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 109 | 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 48.5k ⌀ | 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
240bb6a9305b5b59bd948955fadb7803d1d7fd9f | 1,489 | hpp | C++ | src/metaSMT/concurrent/concurrent_queue.hpp | finnhaedicke/metaSMT | 949245da0bf0f3c042cb589aaea5d015e2ed9e9a | [
"MIT"
] | 33 | 2015-04-09T14:14:25.000Z | 2022-03-27T08:55:58.000Z | src/metaSMT/concurrent/concurrent_queue.hpp | finnhaedicke/metaSMT | 949245da0bf0f3c042cb589aaea5d015e2ed9e9a | [
"MIT"
] | 28 | 2015-03-13T14:21:33.000Z | 2019-04-02T07:59:34.000Z | src/metaSMT/concurrent/concurrent_queue.hpp | finnhaedicke/metaSMT | 949245da0bf0f3c042cb589aaea5d015e2ed9e9a | [
"MIT"
] | 9 | 2015-04-22T18:10:51.000Z | 2021-08-06T12:44:12.000Z | #pragma once
#include "../support/disable_warnings.hpp"
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>
#include "../support/enable_warnings.hpp"
#include <queue>
namespace metaSMT {
namespace concurrent {
/* taken from http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html */
template<typename Data>
class concurrent_queue
{
private:
std::queue<Data> the_queue;
mutable boost::mutex the_mutex;
boost::condition_variable the_condition_variable;
public:
void push(Data const& data)
{
boost::mutex::scoped_lock lock(the_mutex);
the_queue.push(data);
lock.unlock();
the_condition_variable.notify_one();
}
bool empty() const
{
boost::mutex::scoped_lock lock(the_mutex);
return the_queue.empty();
}
bool try_pop(Data& popped_value)
{
boost::mutex::scoped_lock lock(the_mutex);
if(the_queue.empty())
{
return false;
}
popped_value=the_queue.front();
the_queue.pop();
return true;
}
void wait_and_pop(Data& popped_value)
{
boost::mutex::scoped_lock lock(the_mutex);
while(the_queue.empty())
{
the_condition_variable.wait(lock);
}
popped_value=the_queue.front();
the_queue.pop();
}
};
} /* namespace concurrent */
} /* namespace metaSMT */
| 22.560606 | 129 | 0.633983 | finnhaedicke |
2413c53aa208f6a5f0febc24109a1915cf7cfd2c | 1,549 | hpp | C++ | stan/math/prim/fun/simplex_free.hpp | bayesmix-dev/math | 3616f7195adc95ef8e719a2af845d61102bc9272 | [
"BSD-3-Clause"
] | 1 | 2020-06-14T14:33:37.000Z | 2020-06-14T14:33:37.000Z | stan/math/prim/fun/simplex_free.hpp | bayesmix-dev/math | 3616f7195adc95ef8e719a2af845d61102bc9272 | [
"BSD-3-Clause"
] | null | null | null | stan/math/prim/fun/simplex_free.hpp | bayesmix-dev/math | 3616f7195adc95ef8e719a2af845d61102bc9272 | [
"BSD-3-Clause"
] | 1 | 2020-05-10T12:55:07.000Z | 2020-05-10T12:55:07.000Z | #ifndef STAN_MATH_PRIM_FUN_SIMPLEX_FREE_HPP
#define STAN_MATH_PRIM_FUN_SIMPLEX_FREE_HPP
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/err.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/fun/log.hpp>
#include <stan/math/prim/fun/logit.hpp>
#include <stan/math/prim/fun/to_ref.hpp>
#include <cmath>
namespace stan {
namespace math {
/**
* Return an unconstrained vector that when transformed produces
* the specified simplex. It applies to a simplex of dimensionality
* K and produces an unconstrained vector of dimensionality (K-1).
*
* <p>The simplex transform is defined through a centered
* stick-breaking process.
*
* @tparam ColVec type of the simplex (must be a column vector)
* @param x Simplex of dimensionality K.
* @return Free vector of dimensionality (K-1) that transforms to
* the simplex.
* @throw std::domain_error if x is not a valid simplex
*/
template <typename Vec, require_eigen_col_vector_t<Vec>* = nullptr>
auto simplex_free(const Vec& x) {
using std::log;
using T = value_type_t<Vec>;
const auto& x_ref = to_ref(x);
check_simplex("stan::math::simplex_free", "Simplex variable", x_ref);
int Km1 = x_ref.size() - 1;
plain_type_t<Vec> y(Km1);
T stick_len = x_ref.coeff(Km1);
for (Eigen::Index k = Km1; --k >= 0;) {
stick_len += x_ref.coeff(k);
T z_k = x_ref.coeff(k) / stick_len;
y.coeffRef(k) = logit(z_k) + log(Km1 - k);
// note: log(Km1 - k) = logit(1.0 / (Km1 + 1 - k));
}
return y;
}
} // namespace math
} // namespace stan
#endif
| 29.788462 | 71 | 0.700452 | bayesmix-dev |
2416890ad0b7f5eb96d1b99de8d9ea950ddae211 | 242 | cpp | C++ | ContainerShape.cpp | wnsgml972/MFC-InteriorProgram | d37a7d084414ad727555936d5eba3a5d757e9d78 | [
"MIT"
] | 7 | 2019-05-03T01:15:42.000Z | 2021-08-31T06:38:11.000Z | ContainerShape.cpp | wnsgml972/MFC-InteriorProgram | d37a7d084414ad727555936d5eba3a5d757e9d78 | [
"MIT"
] | 14 | 2018-09-11T10:11:34.000Z | 2019-05-21T07:07:31.000Z | ContainerShape.cpp | wnsgml972/MFC-InteriorProgram | d37a7d084414ad727555936d5eba3a5d757e9d78 | [
"MIT"
] | null | null | null | #include "stdafx.h"
#include "ContainerShape.h"
CContainerShape::CContainerShape(int nId, int nX, int nY, int nWidth, int nHeight)
: CShape(nId, nX, nY, nWidth, nHeight)
{
m_nType = TYPE_DEFAULT;
}
CContainerShape::~CContainerShape()
{
} | 18.615385 | 82 | 0.727273 | wnsgml972 |
24181414823811739d99a328f1d8485761f4d6a0 | 476 | cpp | C++ | src/main.cpp | egomeh/floaty-boaty-go-go | a011db6f1f8712bf3caa85becc1fd83ac5bf1996 | [
"MIT"
] | 2 | 2018-01-12T10:26:07.000Z | 2018-02-02T19:03:00.000Z | src/main.cpp | egomeh/floaty-boaty-go-go | a011db6f1f8712bf3caa85becc1fd83ac5bf1996 | [
"MIT"
] | null | null | null | src/main.cpp | egomeh/floaty-boaty-go-go | a011db6f1f8712bf3caa85becc1fd83ac5bf1996 | [
"MIT"
] | null | null | null | #include "definitions.hpp"
#include <string>
#include <sstream>
#include <iostream>
#include <thread>
#include "util.hpp"
#include "application.hpp"
#ifdef GUIONLY
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, int nCmdShow)
#else
int main(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR lpCmdLine, int nCmdShow)
#endif
{
Application application(hInstance);
application.Initialize();
application.Run();
return 0;
}
| 19.833333 | 96 | 0.754202 | egomeh |
24183812b751ea25101cefa9fa1937ced6f15175 | 1,530 | cpp | C++ | src/bwt.cpp | pdinklag/stash | b9e4b1754a521c118b3054af0087b1ae6c9463a1 | [
"MIT"
] | null | null | null | src/bwt.cpp | pdinklag/stash | b9e4b1754a521c118b3054af0087b1ae6c9463a1 | [
"MIT"
] | null | null | null | src/bwt.cpp | pdinklag/stash | b9e4b1754a521c118b3054af0087b1ae6c9463a1 | [
"MIT"
] | 1 | 2020-05-13T11:36:45.000Z | 2020-05-13T11:36:45.000Z | #include <iostream>
#include <fstream>
#include <vector>
#include <stash/util/file_size.hpp>
#include <divsufsort64.h>
#include <tlx/cmdline_parser.hpp>
int main(int argc, char** argv) {
// params
std::string input_filename; // required
sauchar_t sentinel;
{
std::string sentinel_str("\0", 1);
tlx::CmdlineParser cp;
cp.add_param_string("file", input_filename, "The input file.");
cp.add_string('s', "sentinel", sentinel_str, "How to print the sentinel character.");
if (!cp.process(argc, argv)) {
return -1;
}
sentinel = sentinel_str[0];
}
// read input file
const size_t input_filesize = stash::file_size(input_filename);
const size_t n = input_filesize + 1;
sauchar_t* input = new sauchar_t[n];
{
std::ifstream f(input_filename);
f.read((char*)input, input_filesize);
// verify
for(size_t i = 0; i < input_filesize; i++) {
if(input[i] == sentinel) {
std::cerr << "input must not contain sentinel" << std::endl;
return -2;
}
}
}
input[n-1] = 0; // sentinel
// construct suffix array
saidx64_t* sa = new saidx64_t[n];
divsufsort64(input, sa, n);
// print BWT
for(size_t i = 0; i < n; i++) {
const auto s = sa[i];
const auto c = input[s ? s-1 : n-1];
std::cout << (c ? c : sentinel);
}
// clean up
delete[] sa;
delete[] input;
}
| 24.285714 | 93 | 0.549673 | pdinklag |
2419b94e666e844b7a0077134703d7703da4e382 | 634 | cpp | C++ | src/Engine/GUI/GUI_Main.cpp | slajerek/MTEngineSDL | 19b5295d875c197ec03bc20ddacd48c228920365 | [
"MIT"
] | 4 | 2021-12-16T11:22:30.000Z | 2022-01-05T11:20:32.000Z | src/Engine/GUI/GUI_Main.cpp | slajerek/MTEngineSDL | 19b5295d875c197ec03bc20ddacd48c228920365 | [
"MIT"
] | 1 | 2022-01-07T10:41:38.000Z | 2022-01-09T12:04:03.000Z | src/Engine/GUI/GUI_Main.cpp | slajerek/MTEngineSDL | 19b5295d875c197ec03bc20ddacd48c228920365 | [
"MIT"
] | null | null | null | #include "GUI_Main.h"
#include "CGuiMain.h"
#include "MT_API.h"
#include "CConfigStorage.h"
CGuiMain *guiMain = NULL;
CConfigStorage *globalConfig = NULL;
void GUI_Init()
{
MT_GuiPreInit();
guiMain = new CGuiMain();
}
void GUI_Render()
{
// LOGD("GUI_Render");
guiMain->RenderImGui();
MT_Render();
}
void GUI_PostRenderEndFrame()
{
guiMain->PostRenderEndFrame();
MT_PostRenderEndFrame();
}
// TODO me:
void GUI_ShowVirtualKeyboard() {}
void GUI_HideVirtualKeyboard() {}
void GUI_SetPressConsumed(bool isConsumed) {}
void GUI_LockMutex()
{
VID_LockRenderMutex();
}
void GUI_UnlockMutex()
{
VID_UnlockRenderMutex();
}
| 14.088889 | 45 | 0.727129 | slajerek |
241a99feb862404273344a53f699a62033ea0be4 | 8,032 | cpp | C++ | Samples/FileListTransfer/main.cpp | RichardRanft/RakNet | 1a169895a900c9fc4841c556e16514182b75faf8 | [
"BSD-2-Clause"
] | 1,255 | 2015-01-01T12:16:18.000Z | 2017-05-24T20:56:12.000Z | Samples/FileListTransfer/main.cpp | RichardRanft/RakNet | 1a169895a900c9fc4841c556e16514182b75faf8 | [
"BSD-2-Clause"
] | 76 | 2017-06-07T21:05:41.000Z | 2021-12-14T21:15:49.000Z | Samples/FileListTransfer/main.cpp | RichardRanft/RakNet | 1a169895a900c9fc4841c556e16514182b75faf8 | [
"BSD-2-Clause"
] | 535 | 2015-01-05T01:09:02.000Z | 2017-05-17T00:58:03.000Z | /*
* Copyright (c) 2014, Oculus VR, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "RakPeerInterface.h"
#include "FileListTransfer.h"
#include "RakSleep.h"
#include "MessageIdentifiers.h"
#include "FileListTransferCBInterface.h"
#include "FileOperations.h"
#include "SuperFastHash.h"
#include "RakAssert.h"
#include "BitStream.h"
#include "IncrementalReadInterface.h"
#include "PacketizedTCP.h"
#include "SocketLayer.h"
#include <stdio.h>
#include "Gets.h"
RakNet::RakString file;
RakNet::RakString fileCopy;
//const char *file = "c:/temp/unittest.vcproj";
//const char *fileCopy = "c:/temp/unittest_copy.vcproj";
#define USE_TCP
class TestCB : public RakNet::FileListTransferCBInterface
{
public:
bool OnFile(
OnFileStruct *onFileStruct)
{
printf("OnFile: %i. (100%%) %i/%i %s %ib / %ib\n",
onFileStruct->setID,
onFileStruct->fileIndex+1,
onFileStruct->numberOfFilesInThisSet,
onFileStruct->fileName,
onFileStruct->byteLengthOfThisFile,
onFileStruct->byteLengthOfThisSet);
FILE *fp = fopen(fileCopy.C_String(), "wb");
fwrite(onFileStruct->fileData, onFileStruct->byteLengthOfThisFile, 1, fp);
fclose(fp);
// Make sure it worked
unsigned int hash1 = SuperFastHashFile(file.C_String());
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash1, sizeof(hash1));
unsigned int hash2 = SuperFastHashFile(fileCopy.C_String());
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash2, sizeof(hash2));
RakAssert(hash1==hash2);
// Return true to have RakNet delete the memory allocated to hold this file.
// False if you hold onto the memory, and plan to delete it yourself later
return true;
}
virtual void OnFileProgress(FileProgressStruct *fps)
{
printf("OnFileProgress: %i partCount=%i partTotal=%i (%i%%) %i/%i %s %ib/%ib %ib/%ib total\n",
fps->onFileStruct->setID,
fps->partCount, fps->partTotal, (int) (100.0*(double)fps->onFileStruct->bytesDownloadedForThisFile/(double)fps->onFileStruct->byteLengthOfThisFile),
fps->onFileStruct->fileIndex+1,
fps->onFileStruct->numberOfFilesInThisSet,
fps->onFileStruct->fileName,
fps->onFileStruct->bytesDownloadedForThisFile,
fps->onFileStruct->byteLengthOfThisFile,
fps->onFileStruct->bytesDownloadedForThisSet,
fps->onFileStruct->byteLengthOfThisSet,
fps->firstDataChunk);
}
virtual bool OnDownloadComplete(DownloadCompleteStruct *dcs)
{
printf("Download complete.\n");
// Returning false automatically deallocates the automatically allocated handler that was created by DirectoryDeltaTransfer
return false;
}
} transferCallback;
// Sender progress notification
class TestFileListProgress : public RakNet::FileListProgress
{
virtual void OnFilePush(const char *fileName, unsigned int fileLengthBytes, unsigned int offset, unsigned int bytesBeingSent, bool done, RakNet::SystemAddress targetSystem, unsigned short setID)
{
printf("Sending %s bytes=%i offset=%i\n", fileName, bytesBeingSent, offset);
}
virtual void OnFilePushesComplete( RakNet::SystemAddress systemAddress, unsigned short setID )
{
char str[32];
systemAddress.ToString(true, (char*) str);
RAKNET_DEBUG_PRINTF("File pushes complete to %s\n", str);
}
virtual void OnSendAborted( RakNet::SystemAddress systemAddress )
{
char str[32];
systemAddress.ToString(true, (char*) str);
RAKNET_DEBUG_PRINTF("Send aborted to %s\n", str);
}
} testFileListProgress;
int main()
{
printf("This sample demonstrates incrementally sending a file with\n");
printf("the FileListTransferPlugin. Incremental sends will read and send the.\n");
printf("file only as needed, rather than putting the whole file in memory.\n");
printf("This is to support sending large files to many users at the same time.\n");
printf("Difficulty: Intermediate\n\n");
TestCB testCB;
RakNet::FileListTransfer flt1, flt2;
#ifdef USE_TCP
RakNet::PacketizedTCP tcp1, tcp2;
#if RAKNET_SUPPORT_IPV6==1
const bool testInet6=true;
#else
const bool testInet6=false;
#endif
if (testInet6)
{
tcp1.Start(60000,1,-99999,AF_INET6);
tcp2.Start(60001,1,-99999,AF_INET6);
tcp2.Connect("::1",60000,false,AF_INET6);
}
else
{
tcp1.Start(60000,1,-99999,AF_INET);
tcp2.Start(60001,1,-99999,AF_INET);
tcp2.Connect("127.0.0.1",60000,false,AF_INET);
}
tcp1.AttachPlugin(&flt1);
tcp2.AttachPlugin(&flt2);
#else
RakNet::RakPeerInterface *peer1 = RakNet::RakPeerInterface::GetInstance();
RakNet::RakPeerInterface *peer2 = RakNet::RakPeerInterface::GetInstance();
RakNet::SocketDescriptor sd1(60000,0),sd2(60001,0);
peer1->Startup(1,&sd1,1);
peer2->Startup(1,&sd2,1);
peer1->SetMaximumIncomingConnections(1);
peer2->Connect("127.0.0.1",60000,0,0,0);
peer1->AttachPlugin(&flt1);
peer2->AttachPlugin(&flt2);
peer1->SetSplitMessageProgressInterval(9);
peer2->SetSplitMessageProgressInterval(9);
#endif
// Print sending progress notifications
flt1.AddCallback(&testFileListProgress);
// Run incremental reads in a thread so the read does not block the main thread
flt1.StartIncrementalReadThreads(1);
RakNet::FileList fileList;
RakNet::IncrementalReadInterface incrementalReadInterface;
printf("Enter complete filename with path to test:\n");
char str[256];
Gets(str, sizeof(str));
if (str[0]==0)
strcpy(str, "D:\\RakNet\\Lib\\RakNetLibStaticDebug.lib");
file=str;
fileCopy=file+"_copy";
// Reference this file, rather than add it in memory. Will send 1000 byte chunks. The reason to do this is so the whole file does not have to be in memory at once
unsigned int fileLength = GetFileLength(file.C_String());
if (fileLength==0)
{
printf("Test file %s not found.\n", file.C_String());
#ifdef USE_TCP
#else
RakNet::RakPeerInterface::DestroyInstance(peer1);
RakNet::RakPeerInterface::DestroyInstance(peer2);
#endif
return 1;
}
fileList.AddFile(file.C_String(), file.C_String(), 0, fileLength, fileLength, FileListNodeContext(0,0,0,0), true);
// Wait for the connection
printf("File added.\n");
RakSleep(100);
RakNet::Packet *packet1, *packet2;
while (1)
{
#ifdef USE_TCP
RakNet::SystemAddress sa;
sa=tcp2.HasCompletedConnectionAttempt();
if (sa!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
{
flt2.SetupReceive(&testCB, false, sa);
break;
}
#else
// Wait for the connection request to be accepted
packet2=peer2->Receive();
if (packet2 && packet2->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
flt2.SetupReceive(&testCB, false, packet2->systemAddress);
peer2->DeallocatePacket(packet2);
break;
}
peer2->DeallocatePacket(packet2);
#endif
RakSleep(30);
}
// When connected, send the file. Since the file is a reference, it will be sent incrementally
while (1)
{
#ifdef USE_TCP
packet1=tcp1.Receive();
packet2=tcp2.Receive();
RakNet::SystemAddress sa;
sa = tcp1.HasNewIncomingConnection();
if (sa!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
flt1.Send(&fileList,0,sa,0,HIGH_PRIORITY,0, &incrementalReadInterface, 2000 * 1024);
tcp1.DeallocatePacket(packet1);
tcp2.DeallocatePacket(packet2);
#else
packet1=peer1->Receive();
packet2=peer2->Receive();
if (packet1 && packet1->data[0]==ID_NEW_INCOMING_CONNECTION)
flt1.Send(&fileList,peer1,packet1->systemAddress,0,HIGH_PRIORITY,0, &incrementalReadInterface, 2000000);
peer1->DeallocatePacket(packet1);
peer2->DeallocatePacket(packet2);
#endif
RakSleep(0);
}
#ifdef USE_TCP
#else
RakNet::RakPeerInterface::DestroyInstance(peer1);
RakNet::RakPeerInterface::DestroyInstance(peer1);
#endif
return 0;
}
| 32.257028 | 199 | 0.718127 | RichardRanft |
241aa650f8d498bd8f5bbc615306ebb01d7cb773 | 7,235 | cpp | C++ | oceanus/src/v20190422/model/RunJobDescription.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | null | null | null | oceanus/src/v20190422/model/RunJobDescription.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | null | null | null | oceanus/src/v20190422/model/RunJobDescription.cpp | suluner/tencentcloud-sdk-cpp | a56c73cc3f488c4d1e10755704107bb15c5e000d | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. 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 <tencentcloud/oceanus/v20190422/model/RunJobDescription.h>
using TencentCloud::CoreInternalOutcome;
using namespace TencentCloud::Oceanus::V20190422::Model;
using namespace std;
RunJobDescription::RunJobDescription() :
m_jobIdHasBeenSet(false),
m_runTypeHasBeenSet(false),
m_startModeHasBeenSet(false),
m_jobConfigVersionHasBeenSet(false),
m_savepointPathHasBeenSet(false),
m_savepointIdHasBeenSet(false)
{
}
CoreInternalOutcome RunJobDescription::Deserialize(const rapidjson::Value &value)
{
string requestId = "";
if (value.HasMember("JobId") && !value["JobId"].IsNull())
{
if (!value["JobId"].IsString())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.JobId` IsString=false incorrectly").SetRequestId(requestId));
}
m_jobId = string(value["JobId"].GetString());
m_jobIdHasBeenSet = true;
}
if (value.HasMember("RunType") && !value["RunType"].IsNull())
{
if (!value["RunType"].IsInt64())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.RunType` IsInt64=false incorrectly").SetRequestId(requestId));
}
m_runType = value["RunType"].GetInt64();
m_runTypeHasBeenSet = true;
}
if (value.HasMember("StartMode") && !value["StartMode"].IsNull())
{
if (!value["StartMode"].IsString())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.StartMode` IsString=false incorrectly").SetRequestId(requestId));
}
m_startMode = string(value["StartMode"].GetString());
m_startModeHasBeenSet = true;
}
if (value.HasMember("JobConfigVersion") && !value["JobConfigVersion"].IsNull())
{
if (!value["JobConfigVersion"].IsUint64())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.JobConfigVersion` IsUint64=false incorrectly").SetRequestId(requestId));
}
m_jobConfigVersion = value["JobConfigVersion"].GetUint64();
m_jobConfigVersionHasBeenSet = true;
}
if (value.HasMember("SavepointPath") && !value["SavepointPath"].IsNull())
{
if (!value["SavepointPath"].IsString())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.SavepointPath` IsString=false incorrectly").SetRequestId(requestId));
}
m_savepointPath = string(value["SavepointPath"].GetString());
m_savepointPathHasBeenSet = true;
}
if (value.HasMember("SavepointId") && !value["SavepointId"].IsNull())
{
if (!value["SavepointId"].IsString())
{
return CoreInternalOutcome(Core::Error("response `RunJobDescription.SavepointId` IsString=false incorrectly").SetRequestId(requestId));
}
m_savepointId = string(value["SavepointId"].GetString());
m_savepointIdHasBeenSet = true;
}
return CoreInternalOutcome(true);
}
void RunJobDescription::ToJsonObject(rapidjson::Value &value, rapidjson::Document::AllocatorType& allocator) const
{
if (m_jobIdHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "JobId";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_jobId.c_str(), allocator).Move(), allocator);
}
if (m_runTypeHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "RunType";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, m_runType, allocator);
}
if (m_startModeHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "StartMode";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_startMode.c_str(), allocator).Move(), allocator);
}
if (m_jobConfigVersionHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "JobConfigVersion";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, m_jobConfigVersion, allocator);
}
if (m_savepointPathHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "SavepointPath";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_savepointPath.c_str(), allocator).Move(), allocator);
}
if (m_savepointIdHasBeenSet)
{
rapidjson::Value iKey(rapidjson::kStringType);
string key = "SavepointId";
iKey.SetString(key.c_str(), allocator);
value.AddMember(iKey, rapidjson::Value(m_savepointId.c_str(), allocator).Move(), allocator);
}
}
string RunJobDescription::GetJobId() const
{
return m_jobId;
}
void RunJobDescription::SetJobId(const string& _jobId)
{
m_jobId = _jobId;
m_jobIdHasBeenSet = true;
}
bool RunJobDescription::JobIdHasBeenSet() const
{
return m_jobIdHasBeenSet;
}
int64_t RunJobDescription::GetRunType() const
{
return m_runType;
}
void RunJobDescription::SetRunType(const int64_t& _runType)
{
m_runType = _runType;
m_runTypeHasBeenSet = true;
}
bool RunJobDescription::RunTypeHasBeenSet() const
{
return m_runTypeHasBeenSet;
}
string RunJobDescription::GetStartMode() const
{
return m_startMode;
}
void RunJobDescription::SetStartMode(const string& _startMode)
{
m_startMode = _startMode;
m_startModeHasBeenSet = true;
}
bool RunJobDescription::StartModeHasBeenSet() const
{
return m_startModeHasBeenSet;
}
uint64_t RunJobDescription::GetJobConfigVersion() const
{
return m_jobConfigVersion;
}
void RunJobDescription::SetJobConfigVersion(const uint64_t& _jobConfigVersion)
{
m_jobConfigVersion = _jobConfigVersion;
m_jobConfigVersionHasBeenSet = true;
}
bool RunJobDescription::JobConfigVersionHasBeenSet() const
{
return m_jobConfigVersionHasBeenSet;
}
string RunJobDescription::GetSavepointPath() const
{
return m_savepointPath;
}
void RunJobDescription::SetSavepointPath(const string& _savepointPath)
{
m_savepointPath = _savepointPath;
m_savepointPathHasBeenSet = true;
}
bool RunJobDescription::SavepointPathHasBeenSet() const
{
return m_savepointPathHasBeenSet;
}
string RunJobDescription::GetSavepointId() const
{
return m_savepointId;
}
void RunJobDescription::SetSavepointId(const string& _savepointId)
{
m_savepointId = _savepointId;
m_savepointIdHasBeenSet = true;
}
bool RunJobDescription::SavepointIdHasBeenSet() const
{
return m_savepointIdHasBeenSet;
}
| 28.710317 | 152 | 0.695923 | suluner |
241d02e7aa8c2d91440ae4c8dbbd5b28f7dd5c3f | 703 | cpp | C++ | mygfx/examples/00-helloworld/helloworld.cpp | miztook/milan | 45b4b3a7ac665642b76b7461ab629072e767e563 | [
"MIT"
] | 1 | 2018-11-08T23:19:36.000Z | 2018-11-08T23:19:36.000Z | mygfx/examples/00-helloworld/helloworld.cpp | miztook/milan | 45b4b3a7ac665642b76b7461ab629072e767e563 | [
"MIT"
] | null | null | null | mygfx/examples/00-helloworld/helloworld.cpp | miztook/milan | 45b4b3a7ac665642b76b7461ab629072e767e563 | [
"MIT"
] | null | null | null | #include "mygfx/mygfx.h"
#pragma comment(lib, "mygfx.lib")
#pragma comment(lib, "example-common.lib")
#include <bx/uint32_t.h>
#include "common.h"
#include "bgfx_utils.h"
class ExampleHelloWorld : public entry::AppI
{
public:
ExampleHelloWorld(const char* _name, const char* _description)
: entry::AppI(_name, _description)
{
}
void init(int32_t _argc, const char* const* _argv, uint32_t _width, uint32_t _height) override
{
}
virtual int shutdown() override
{
return 0;
}
bool update() override
{
return false;
}
};
int _main_(int _argc, char** _argv)
{
ExampleHelloWorld app("00-helloworld", "Initialization and debug text.");
return entry::runApp(&app, _argc, _argv);
}
| 17.575 | 95 | 0.70697 | miztook |
241df3d7cd84c7d4532df3e8c3f2450278af51a5 | 4,290 | cpp | C++ | src-plugins/itkDataTensorImageWriter/itkDataTensorImageWriterBase.cpp | ocommowi/medInria-public | 9074e40c886881666e7a52c53309d8d28e35c0e6 | [
"BSD-4-Clause"
] | null | null | null | src-plugins/itkDataTensorImageWriter/itkDataTensorImageWriterBase.cpp | ocommowi/medInria-public | 9074e40c886881666e7a52c53309d8d28e35c0e6 | [
"BSD-4-Clause"
] | null | null | null | src-plugins/itkDataTensorImageWriter/itkDataTensorImageWriterBase.cpp | ocommowi/medInria-public | 9074e40c886881666e7a52c53309d8d28e35c0e6 | [
"BSD-4-Clause"
] | null | null | null | /*=========================================================================
medInria
Copyright (c) INRIA 2013. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.
=========================================================================*/
#include "itkDataTensorImageWriterBase.h"
#include <dtkCore/dtkAbstractData.h>
#include <dtkCore/dtkAbstractDataFactory.h>
#include <itkTensor.h>
#include <itkImageFileWriter.h>
#include <itkImage.h>
#include <itkImageRegionConstIterator.h>
#include <itkImageRegionIteratorWithIndex.h>
#include <itkVectorImage.h>
#include <itkVector.h>
itkDataTensorImageWriterBase::itkDataTensorImageWriterBase() : dtkAbstractDataWriter()
{
this->io = 0;
}
itkDataTensorImageWriterBase::~itkDataTensorImageWriterBase()
{
}
QStringList itkDataTensorImageWriterBase::handled() const
{
return QStringList() << "itkDataTensorImageDouble3"
<< "itkDataTensorImageFloat3";
}
QStringList itkDataTensorImageWriterBase::s_handled()
{
return QStringList() << "itkDataTensorImageDouble3"
<< "itkDataTensorImageFloat3";
}
bool itkDataTensorImageWriterBase::canWrite(const QString& path)
{
if (this->io.IsNull())
return false;
return this->io->CanWriteFile ( path.toAscii().constData() );
}
bool itkDataTensorImageWriterBase::write(const QString& path)
{
if (!this->data())
return false;
if (this->io.IsNull())
return false;
if (dtkAbstractData *dtkdata = this->data() ) {
if(dtkdata->identifier()=="itkDataTensorImageFloat3") {
float dummy = 0;
write(path, dummy);
}
else if(dtkdata->identifier()=="itkDataTensorImageDouble3") {
double dummy = 0;
write(path, dummy);
}
else {
qWarning() << "Unrecognized pixel type";
return false;
}
}
return true;
}
template <class PixelType>
bool itkDataTensorImageWriterBase::write(const QString& path, PixelType dummyArgument)
{
typedef typename itk::Vector<PixelType, 6> VectorType;
typedef typename itk::Image<VectorType, 3> VectorImageType;
typedef typename itk::Tensor<PixelType, 3> TensorType;
typedef typename itk::Image<TensorType, 3> TensorImageType;
typedef typename VectorImageType::Pointer VectorImageTypePointer;
VectorImageTypePointer myTensorImage = VectorImageType::New();
typedef typename TensorImageType::Pointer TensorImageTypePointer;
TensorImageTypePointer image = dynamic_cast< TensorImageType* >( (itk::Object*)(this->data()->output()) );
typedef typename TensorImageType::RegionType TensorImageTypeRegionType;
TensorImageTypeRegionType region = image->GetLargestPossibleRegion();
myTensorImage->SetRegions (region);
myTensorImage->SetSpacing (image->GetSpacing());
myTensorImage->SetOrigin (image->GetOrigin());
myTensorImage->SetDirection (image->GetDirection());
try {
myTensorImage->Allocate();
}
catch (itk::ExceptionObject &e) {
std::cerr << e;
throw itk::ExceptionObject (__FILE__,__LINE__,"Error during memory allocation.");
}
typedef itk::ImageRegionConstIterator<TensorImageType> IteratorType;
IteratorType it (image, image->GetLargestPossibleRegion());
itk::ImageRegionIteratorWithIndex<VectorImageType> itOut(myTensorImage, myTensorImage->GetLargestPossibleRegion());
while( !it.IsAtEnd() )
{
TensorType tensor = it.Get();
VectorType vec;
for( unsigned int i=0; i<6; i++) {
vec[i] = static_cast<float>(tensor[i]);
}
itOut.Set (vec);
++it;
++itOut;
}
typedef typename itk::ImageFileWriter<VectorImageType>::Pointer ImageFileWriterPointer;
ImageFileWriterPointer myWriter = itk::ImageFileWriter<VectorImageType>::New();
myWriter->SetFileName(path.toAscii().constData());
myWriter->SetInput(myTensorImage);
try {
myWriter->Write();
}
catch(itk::ExceptionObject &e) {
qDebug() << e.GetDescription();
return false;
}
return true;
}
| 28.791946 | 119 | 0.657809 | ocommowi |
241fa680efd263f8a719e2394c0420c0d4d15a87 | 156 | cpp | C++ | src/goto-instrument/accelerate/linearize.cpp | dan-blank/yogar-cbmc | 05b4f056b585b65828acf39546c866379dca6549 | [
"MIT"
] | 1 | 2021-08-17T08:41:12.000Z | 2021-08-17T08:41:12.000Z | src/goto-instrument/accelerate/linearize.cpp | dan-blank/yogar-cbmc | 05b4f056b585b65828acf39546c866379dca6549 | [
"MIT"
] | 6 | 2017-12-03T22:02:14.000Z | 2018-04-10T09:42:20.000Z | src/goto-instrument/accelerate/linearize.cpp | dan-blank/yogar-cbmc | 05b4f056b585b65828acf39546c866379dca6549 | [
"MIT"
] | 4 | 2019-01-19T03:32:21.000Z | 2021-12-20T14:25:19.000Z | #include "linearize.h"
#include <goto-symex/symex_target_equation.h>
bool linearize(symex_target_equationt &equation, linear_recurrencet &recurrence) {
}
| 22.285714 | 82 | 0.807692 | dan-blank |
2420fba5644995b832bb7bc0f6dbb1fb7d26a0df | 3,036 | cpp | C++ | Sources/Applications/Raytracer/Mesh.cpp | jdelezenne/Sonata | fb1b1b64a78874a0ab2809995be4b6f14f9e4d56 | [
"MIT"
] | null | null | null | Sources/Applications/Raytracer/Mesh.cpp | jdelezenne/Sonata | fb1b1b64a78874a0ab2809995be4b6f14f9e4d56 | [
"MIT"
] | null | null | null | Sources/Applications/Raytracer/Mesh.cpp | jdelezenne/Sonata | fb1b1b64a78874a0ab2809995be4b6f14f9e4d56 | [
"MIT"
] | null | null | null | /*=============================================================================
Mesh.cpp
Project: Sonata Engine
Copyright �by7
Julien Delezenne
=============================================================================*/
#include "Mesh.h"
#include "TriangleShape.h"
namespace Raytracer
{
SE_IMPLEMENT_CLASS(RTMesh);
SE_IMPLEMENT_REFLECTION(RTMesh);
RTMesh::RTMesh() :
RTSceneObject()
{
_LastTriangle = 0;
}
RTMesh::~RTMesh()
{
}
AABB RTMesh::GetAABB()
{
return _BoundingBox;
}
void RTMesh::Intersect(RenderState& state, const Ray3& ray, TraceResult& result)
{
int i;
int count;
bool indexed;
if (_Indices.Count() == 0)
{
count = _Vertices.Count() / 3;
indexed = false;
}
else
{
count = _Indices.Count() / 3;
indexed = true;
}
TraceResult tr;
int32 minTriangle = -1;
real32 minDistance = SE_MAX_R32;
result._Hit = false;
for (i = 0; i < count; ++i)
{
const Vector3& v0 = (indexed ? _Vertices[i*3] : _Vertices[_Indices[i*3]]);
const Vector3& v1 = (indexed ? _Vertices[i*3+1] : _Vertices[_Indices[i*3+1]]);
const Vector3& v2 = (indexed ? _Vertices[i*3+2] : _Vertices[_Indices[i*3+2]]);
RTTriangleShape triangle;
triangle.SetVertices(v0, v1, v2);
triangle.Intersect(state, state._Ray, tr);
if (tr._Hit && tr._Distance < minDistance)
{
minDistance = tr._Distance;
minTriangle = i;
}
}
if (minTriangle != -1)
{
result._Distance = minDistance;
result._Hit = true;
_LastTriangle = minTriangle;
}
}
Vector3 RTMesh::GetNormal(const Vector3& p)
{
return _Normals[_LastTriangle*3];
}
Vector2 RTMesh::GetUV(const Vector3& p)
{
if (_TexCoords.Count() > 0)
return _TexCoords[_LastTriangle*3];
else
return Vector2::Zero;
}
void RTMesh::GenerateNormals()
{
int i;
int count;
bool indexed;
if (_Indices.Count() == 0)
{
count = _Vertices.Count() / 3;
indexed = false;
}
else
{
count = _Indices.Count() / 3;
indexed = true;
}
_Normals.Clear();
_Normals.SetSize(count*3);
for (i = 0; i < count; ++i)
{
const Vector3& v0 = (indexed ? _Vertices[i*3] : _Vertices[_Indices[i*3]]);
const Vector3& v1 = (indexed ? _Vertices[i*3+1] : _Vertices[_Indices[i*3+1]]);
const Vector3& v2 = (indexed ? _Vertices[i*3+2] : _Vertices[_Indices[i*3+2]]);
Vector3 normal = Vector3::Cross(v1 - v0, v2 - v1);
normal = Vector3::Normalize(normal);
_Normals[i*3] = _Normals[i*3+1] = _Normals[i*3+2] = normal;
}
}
void RTMesh::UpdateBoundingBox()
{
int count = _Vertices.Count();
// If there are no vertices, the AABB is invalid
_BoundingBox = AABB::Empty;
// Take the first vertex
VertexArray::Iterator it = _Vertices.GetIterator();
if (it.Next())
{
_BoundingBox.Minimum = _BoundingBox.Maximum = it.Current();
}
// Iterate all the vertices
while (it.Next())
{
const Vector3& v = it.Current();
_BoundingBox.Minimum = Vector3::Min(_BoundingBox.Minimum, v);
_BoundingBox.Maximum = Vector3::Max(_BoundingBox.Maximum, v);
}
}
}
| 20.513514 | 81 | 0.607049 | jdelezenne |
24258878e838da031d16e946cad6d32f1b883411 | 10,463 | cc | C++ | extras/geometry_utils.cc | dch0ph/pNMRsim | 2420e618c7bff9b38b43e7c2ac684c5c28b61787 | [
"MIT"
] | null | null | null | extras/geometry_utils.cc | dch0ph/pNMRsim | 2420e618c7bff9b38b43e7c2ac684c5c28b61787 | [
"MIT"
] | null | null | null | extras/geometry_utils.cc | dch0ph/pNMRsim | 2420e618c7bff9b38b43e7c2ac684c5c28b61787 | [
"MIT"
] | null | null | null |
#include "BaseList.h"
#include "geometry.h"
#include "basespin_system.h"
#include "ListList.h"
#include "NMR.h"
using namespace libcmatrix;
#include "geometry_utils.h"
struct default_spin_t {
const char* elementname;
size_t massnumber;
};
#define NMRSIM_DEFAULT_SPINS 57
const default_spin_t default_spin_table[NMRSIM_DEFAULT_SPINS] = {
{"H",1},
{"C", 13},
{"F", 19},
{"He", 3},
{"Be", 9},
{"B", 11},
{"O", 17},
{"Ne", 21},
{"Na", 23},
{"Mg", 25},
{"Al", 27},
{"Si", 29},
{"P", 31},
{"S", 33},
{"K", 39},
{"Ca", 43},
{"Sc", 45},
{"V", 51},
{"Cr", 53},
{"Mn", 55},
{"Fe", 57},
{"Co", 59},
{"Ni", 61},
{"Zn", 67},
{"Ga", 71},
{"Ge", 73},
{"As", 75},
{"Se", 77},
{"Br", 81},
{"Kr", 83},
{"Rb", 87},
{"Sr", 87},
{"Y", 89},
{"Zr", 91},
{"Nb", 93},
{"Mo", 95},
{"Tc", 99},
{"Rh", 103},
{"Pd", 105},
{"Cd", 113},
{"In", 115},
{"Sb", 121},
{"I", 127},
{"Sn", 119},
{"Te", 125},
{"Cs", 133},
{"Ba", 137},
{"La", 139},
{"Ta", 181},
{"W", 183},
{"Re", 187},
{"Ir", 193},
{"Pt", 195},
{"Au", 197},
{"Tl", 205},
{"Pb", 207},
{"Bi", 209}
};
void fill(double d[3], const vector3& a)
{
d[0]=a.x;
d[1]=a.y;
d[2]=a.z;
}
void transformation_matrix(rmatrix3& dest, const vector3& x, const vector3& y, const vector3& z)
{
fill(dest[0],x);
fill(dest[1],y);
fill(dest[2],z);
}
void write_PDB_comment(FILE* fp, const char* str)
{
fprintf(fp,"REMARK 99 %s\n",str);
}
void write_PDB_atom(FILE* fp, size_t serial, const char totlabel[8], const vector3& coords, size_t seq)
{
fprintf(fp,"HETATM%5" LCM_PRI_SIZE_T_MODIFIER "u %-4s UNK 0 %3" LCM_PRI_SIZE_T_MODIFIER "u %8.3f%8.3f%8.3f 1.00 0.00\n",serial,totlabel,seq,coords.x,coords.y,coords.z);
}
bool testsame(const Matrix<double>& An, const Matrix<double>& A, const char* head, int verbose)
{
const double normdiff=norm(An-A);
const bool fail=(normdiff>1e-6);
if (verbose || fail)
std::cout << head << '\n' << An << '\n';
if (fail)
std::cout << "FAILED (" << normdiff << ")\n";
else
std::cout << "SUCCESS\n";
return fail;
}
size_t default_nucleus(const char* name)
{
char buf[10];
for (size_t i=0;i<NMRSIM_DEFAULT_SPINS;i++) {
const default_spin_t& curspin(default_spin_table[i]);
if (strcmp(name,curspin.elementname)==0) {
sprintf(buf,"%zu%s",curspin.massnumber,name);
return labeltonuc(buf);
}
}
return NULL_NUCLEUS;
}
//check that subsel fits exactly within sel
bool checkoverlap(const BaseList<size_t>& sel, const BaseList<size_t>& subsel)
{
for (size_t i=subsel.size();i--;) {
if (!ismember(sel,subsel(i))) {
std::cerr << "Methyl group " << subsel << " not entirely within selection " << sel << ": results will be bogus\n";
return false;
}
}
return true;
}
bool BaseDipolarAverager::check_nooverlap(const BaseList<size_t>& second) const
{
for (size_t j=second.size();j--;) {
const int which=which_set(second(j));
if (which>=0) {
if (!checkoverlap(second,groups_(which)))
return false;
}
}
return true;
}
int BaseDipolarAverager::validate_set(const BaseList<size_t>& which) const
{
if (which.size()==1)
return -1;
const int whichset=which_set_(which.front());
const size_t n=which.size();
if ((whichset>=0) && (groups_(whichset).size()==n)) {
bool ok=true;
for (size_t i=1;i<n;i++) {
if (which_set_(which(i))!=whichset) {
ok=false;
break;
}
}
if (ok)
return whichset;
}
throw InvalidParameter("DipolarAverager: atom group does not match an averaging set");
}
BaseDipolarAverager::BaseDipolarAverager(const BaseList<vector3>& positionsv, double gammaval, const ListList<size_t>& groupsv, int verbosev)
: natoms_(positionsv.size()),
positions_(positionsv),
groups_(groupsv),
verbose_(verbosev)
{
gammavals_.create(natoms_,gammaval);
initialise();
}
BaseDipolarAverager::BaseDipolarAverager(const BaseList<vector3>& positionsv, const BaseList<double>& gammavalsv, const ListList<size_t>& groupsv, int verbosev)
: natoms_(positionsv.size()),
positions_(positionsv),
groups_(groupsv),
gammavals_(gammavalsv),
verbose_(verbosev)
{
initialise();
}
BaseDipolarAverager::BaseDipolarAverager(const BaseList<vector3>& positionsv, double gammaval, const BaseList< Matrix<size_t> >& groupsv, int verbosev)
: natoms_(positionsv.size()),
positions_(positionsv),
verbose_(verbosev)
{
makegroups(groupsv);
gammavals_.create(natoms_,gammaval);
initialise();
}
BaseDipolarAverager::BaseDipolarAverager(const BaseList<vector3>& positionsv, const BaseList<double>& gammavalsv, const BaseList< Matrix<size_t> >& groupsv, int verbosev)
: natoms_(positionsv.size()),
positions_(positionsv),
gammavals_(gammavalsv),
verbose_(verbosev)
{
if (gammavals_.size()!=natoms_)
throw Mismatch("DipolarAverager:: number of gamma values doesn't match number of atoms",gammavals_.size(),natoms_);
makegroups(groupsv);
initialise();
}
void BaseDipolarAverager::makegroups(const BaseList< Matrix<size_t> >& groupsv)
{
size_t items=0;
size_t blks=0;
for (size_t i=groupsv.size();i--;) {
const Matrix<size_t>& curm(groupsv(i));
blks+=curm.rows();
items+=curm.size();
}
groups_.reserve(blks,items);
for (size_t i=0;i<groupsv.size();i++) {
const Matrix<size_t>& curm(groupsv(i));
for (size_t r=0;r<curm.rows();r++)
groups_.push_back(curm.row(r));
}
}
void BaseDipolarAverager::initialise()
{
which_set_.create(natoms_,-1);
for (size_t ng=0;ng<groups_.size();ng++) {
const BaseList<size_t> curgroup(groups_(ng));
if (curgroup.size()<2)
throw InvalidParameter("DipolarAverager: group of atoms with <2 members");
for (size_t na=curgroup.size();na--;) {
const size_t curi=curgroup(na);
validate_index(curi);
if (which_set_(curi)!=-1)
throw InvalidParameter("DipolarAverager: groups of atoms overlap");
which_set_(curi)=ng;
}
}
}
std::pair<int,int> BaseDipolarAverager::validate_sets(const BaseList<size_t>& whichi, const BaseList<size_t>& whichj) const
{
const int seti=validate_set(whichi);
const int setj=validate_set(whichj);
if (seti>=0) {
if (seti==setj)
throw Failed("DipolarAverager: not appropriate for couplings within the same averaging set");
}
else {
if (setj<0)
throw Failed("DipolarAverager: not appropriate for couplings between non-averaged nuclei");
}
return std::pair<int,int>(seti,setj);
}
void TensorDipolarAverager::initialise_tensor()
{
const size_t nsets=groups_.size();
// avposition.create(nsets);
perpunitvector_.create(nsets);
for (size_t i=0;i<nsets;i++) {
const BaseList<size_t> curset(groups_(i));
const size_t nsites=curset.size();
if (nsites!=3)
throw Failed("TensorDipolarAverager: only implemented for 3 site exchange");
const vector3 planevec1(positions_(curset(size_t(0))) - positions_(curset(size_t(1))) );
const vector3 planevec2(positions_(curset(size_t(1))) - positions_(curset(size_t(2))) );
vector3 perp(cross(planevec1,planevec2));
perp/=perp.length();
// vector3 meanpos(0,0,0);
// for (size_t c=nsites;c--;)
// meanpos+=positions_(curset(c));
// meanpos/=nsites;
// avposition(i)=meanpos;
const spherical sphco(perp);
perpunitvector_(i)=sphco;
if (verbose_)
// std::cout << "For averaging group " << (i+1) << " Mean position: " << meanpos << " Perp unit vector (spherical polar coords): " << sphco << '\n';
std::cout << "For averaging group " << (i+1) << ": Perp unit vector (spherical polar coords): " << sphco << '\n';
}
}
void TensorDipolarAverager::d_and_Euler(double& d, double& asym, Euler& euler, const BaseList<size_t>& whichi, const BaseList<size_t>& whichj) const
{
const std::pair<int,int> setij=validate_sets(whichi,whichj);
const int seti=setij.first;
const int setj=setij.second;
const bool inavseti=(seti>=0);
const bool inavsetj=(setj>=0);
//vector3 locpositioni,locpositionj;
size_t source;
BaseList<size_t> curset;
if (inavseti) { //!< NB doesn't treat the case of both i and j being averaged (gives dubious results)
// locpositioni=avposition(size_t(seti));
source=whichj.front();
curset.create(groups_(size_t(seti)));
}
else {
if (!inavsetj)
throw InternalError("notinavsetj");
// locpositionj=avposition(size_t(setj));
source=whichi.front();
curset.create(groups_(size_t(setj)));
}
Matrix<double> Dav_MF,Dtmp;
const size_t n=curset.size();
const vector3& sourcepos(positions_(source));
const double gammasource=unsafe_gamma(source);
for (size_t k=n;k--;) {
const size_t curind=curset(k);
const vector3 ivec(positions_(curind) - sourcepos);
const spherical sphco(ivec);
const double d=dipolar_coupling(gammasource,unsafe_gamma(curind),sphco.r*1e-10);
const space_T D_PAS(spatial_tensor(d));
const Euler leuler(vector_to_Euler(sphco));
const space_T D_MF(rotate(D_PAS,leuler));
if (verbose_>1)
std::cout << "Built tensor with coupling " << d << " Hz, orientation " << leuler << '\n' << D_MF << '\n';
tensor_to_matrix(Dtmp,D_MF);
Dav_MF+=Dtmp;
}
Dav_MF*=1.0/n;
if (verbose_>1)
std::cout << "Averaged tensor\n" << Dav_MF << '\n';
double iso;
cartesian_to_PAS_symmetric(iso,d,asym,euler,Dav_MF);
static const double sqrt2thrd=sqrt(2.0/3.0);
// iso/=-sqrt3rd;
d/=sqrt2thrd; //!< should still be needed
if (verbose_>1)
std::cout << "Final d=" << d << " Hz, orientation: " << euler << '\n';
}
double TensorDipolarAverager::dss(const BaseList<size_t>& whichi, const BaseList<size_t>& whichj) const
{
Euler junk;
double d,asym;
d_and_Euler(d,asym,junk,whichi,whichj);
return d*d;
}
| 28.98338 | 175 | 0.605467 | dch0ph |
242a2a6abe2a98089712fefc87ca05df5f408196 | 84 | hpp | C++ | main/RK.hpp | likeblood/Algorithms-parallel-calculator | 1f7273d319944c6b9123927e363cd5c5fccac7c3 | [
"MIT"
] | null | null | null | main/RK.hpp | likeblood/Algorithms-parallel-calculator | 1f7273d319944c6b9123927e363cd5c5fccac7c3 | [
"MIT"
] | 7 | 2020-05-19T02:52:25.000Z | 2020-05-31T23:20:54.000Z | main/RK.hpp | likeblood/cpp_microproject_2020 | 1f7273d319944c6b9123927e363cd5c5fccac7c3 | [
"MIT"
] | 1 | 2021-02-25T15:23:13.000Z | 2021-02-25T15:23:13.000Z | #pragma once
#include "RKMethod.hpp"
#include "RKIntegrator.hpp"
#include "ODE.hpp" | 16.8 | 27 | 0.75 | likeblood |
242ce98cf1db305edce90ae00c23d7a8bbb65fbf | 2,860 | hpp | C++ | include/cppurses/painter/brush.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | include/cppurses/painter/brush.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | include/cppurses/painter/brush.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | #ifndef CPPURSES_PAINTER_BRUSH_HPP
#define CPPURSES_PAINTER_BRUSH_HPP
#include <bitset>
#include <utility>
#include <optional/optional.hpp>
#include <cppurses/painter/attribute.hpp>
#include <cppurses/painter/color.hpp>
namespace cppurses {
/// Holds the look of any paintable object with Attributes and Colors.
class Brush {
public:
/// Construct a Brush with given Attributes and Colors.
template <typename... Attributes>
explicit Brush(Attributes... attrs);
// Base Case
void add_attributes() {}
/// Add a variable number of Attributes or Colors to the brush.
/** Use the (back/fore)ground_color(Color c) functions to add colors to the
* list. */
template <typename T, typename... Others>
void add_attributes(T attr, Others... others);
/// Set the background color of this brush.
void set_background(Color color) { background_color_ = color; }
/// Set the foreground color of this brush.
void set_foreground(Color color) { foreground_color_ = color; }
/// Remove a specific Attribute, if it is set, otherwise no-op.
void remove_attribute(Attribute attr);
/// Sets the background to not have a color, the default state.
void remove_background();
/// Sets the foreground to not have a color, the default state.
void remove_foreground();
/// Removes all of the set Attributes from the brush, not including colors.
void clear_attributes();
/// Provides a check if the brush has the provided Attribute \p attr.
bool has_attribute(Attribute attr) const;
/// Returns the current background as an opt::Optional object.
opt::Optional<Color> background_color() const;
/// Returns the current foreground as an opt::Optional object.
opt::Optional<Color> foreground_color() const;
friend bool operator==(const Brush& lhs, const Brush& rhs);
private:
/// Used by add_attributes() to set a deail::BackgroundColor.
void set_attr(detail::BackgroundColor bc);
/// Used by add_attributes() to set a deail::ForegroundColor.
void set_attr(detail::ForegroundColor fc);
/// Used by add_attributes() to set an Attribute.
void set_attr(Attribute attr);
// Data Members
std::bitset<8> attributes_;
opt::Optional<Color> background_color_;
opt::Optional<Color> foreground_color_;
};
/// Compares if the held attributes and back/foreground colors are equal.
bool operator==(const Brush& lhs, const Brush& rhs);
// TEMPLATE IMPLEMENTATIONS
template <typename... Attributes>
Brush::Brush(Attributes... attrs) {
this->add_attributes(std::forward<Attributes>(attrs)...);
}
template <typename T, typename... Others>
void Brush::add_attributes(T attr, Others... others) {
this->set_attr(attr);
this->add_attributes(others...);
}
} // namespace cppurses
#endif // CPPURSES_PAINTER_BRUSH_HPP
| 31.428571 | 79 | 0.708042 | jktjkt |
242da28b91e2bffe757f64398f675465dfa35eab | 797 | hpp | C++ | pythran/pythonic/include/numpy/digitize.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | null | null | null | pythran/pythonic/include/numpy/digitize.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | null | null | null | pythran/pythonic/include/numpy/digitize.hpp | xmar/pythran | dbf2e8b70ed1e4d4ac6b5f26ead4add940a72592 | [
"BSD-3-Clause"
] | null | null | null | #ifndef PYTHONIC_INCLUDE_NUMPY_DIGITIZE_HPP
#define PYTHONIC_INCLUDE_NUMPY_DIGITIZE_HPP
#include "pythonic/include/numpy/asarray.hpp"
#include "pythonic/include/__builtin__/None.hpp"
#include "pythonic/include/operator_/gt.hpp"
#include "pythonic/include/operator_/lt.hpp"
namespace pythonic
{
namespace numpy
{
template <class I, class O, class B, class Op>
void _digitize(I begin, I end, O &out, B &bins, Op const &op,
utils::int_<1>);
template <class I, class O, class B, class Op, size_t N>
void _digitize(I begin, I end, O &out, B &bins, Op const &op,
utils::int_<N>);
template <class E, class F>
types::ndarray<long, 1> digitize(E const &expr, F const &b);
DECLARE_FUNCTOR(pythonic::numpy, digitize);
}
}
#endif
| 26.566667 | 65 | 0.677541 | xmar |
242eec34b064e0858bb56bb737d91c085b328bcf | 9,239 | cpp | C++ | engine/hash_table.cpp | BaronStack/kvdk | 50fdd226b88ac614ba04109053c529af989c083a | [
"BSD-3-Clause"
] | 1 | 2022-03-01T03:46:02.000Z | 2022-03-01T03:46:02.000Z | engine/hash_table.cpp | KVKIT/kvdk | 809b64058146308fa089859ba4abcb4135333425 | [
"BSD-3-Clause"
] | null | null | null | engine/hash_table.cpp | KVKIT/kvdk | 809b64058146308fa089859ba4abcb4135333425 | [
"BSD-3-Clause"
] | null | null | null | /* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2021 Intel Corporation
*/
#include "hash_table.hpp"
#include "skiplist.hpp"
#include "thread_manager.hpp"
#include "unordered_collection.hpp"
namespace KVDK_NAMESPACE {
HashTable *
HashTable::NewHashTable(uint64_t hash_bucket_num, uint32_t hash_bucket_size,
uint32_t num_buckets_per_slot,
const std::shared_ptr<PMEMAllocator> &pmem_allocator,
uint32_t write_threads) {
HashTable *table = new (std::nothrow)
HashTable(hash_bucket_num, hash_bucket_size, num_buckets_per_slot,
pmem_allocator, write_threads);
if (table) {
auto main_buckets_space =
table->dram_allocator_.Allocate(hash_bucket_size * hash_bucket_num);
if (main_buckets_space.size == 0) {
GlobalLogger.Error("No enough dram to create global hash table\n");
delete table;
table = nullptr;
} else {
table->main_buckets_ = table->dram_allocator_.offset2addr(
main_buckets_space.space_entry.offset);
}
}
return table;
}
bool HashTable::MatchHashEntry(const pmem::obj::string_view &key,
uint32_t hash_k_prefix, uint16_t target_type,
const HashEntry *hash_entry,
DataEntry *data_entry_metadata) {
if (hash_entry->header.status == HashEntryStatus::Empty) {
return false;
}
if ((target_type & hash_entry->header.data_type) &&
hash_k_prefix == hash_entry->header.key_prefix) {
void *pmem_record;
pmem::obj::string_view data_entry_key;
switch (hash_entry->header.offset_type) {
case HashOffsetType::StringRecord: {
pmem_record = pmem_allocator_->offset2addr(hash_entry->offset);
data_entry_key = static_cast<StringRecord *>(pmem_record)->Key();
break;
}
case HashOffsetType::UnorderedCollectionElement:
case HashOffsetType::DLRecord: {
pmem_record = pmem_allocator_->offset2addr(hash_entry->offset);
data_entry_key = static_cast<DLRecord *>(pmem_record)->Key();
break;
}
case HashOffsetType::UnorderedCollection: {
UnorderedCollection *p_collection = hash_entry->p_unordered_collection;
data_entry_key = p_collection->Name();
break;
}
case HashOffsetType::SkiplistNode: {
SkiplistNode *dram_node = (SkiplistNode *)hash_entry->offset;
pmem_record = dram_node->record;
data_entry_key = static_cast<DLRecord *>(pmem_record)->Key();
break;
}
case HashOffsetType::Skiplist: {
Skiplist *skiplist = (Skiplist *)hash_entry->offset;
pmem_record = skiplist->header()->record;
data_entry_key = skiplist->name();
break;
}
default: {
GlobalLogger.Error("Not supported hash offset type: %u\n",
hash_entry->header.offset_type);
assert(false && "Trying to use invalid HashOffsetType!");
return false;
}
}
if (__glibc_likely(data_entry_metadata != nullptr)) {
memcpy(data_entry_metadata, pmem_record, sizeof(DataEntry));
}
if (equal_string_view(key, data_entry_key)) {
return true;
}
}
return false;
}
Status HashTable::SearchForWrite(const KeyHashHint &hint,
const pmem::obj::string_view &key,
uint16_t type_mask, HashEntry **entry_ptr,
HashEntry *hash_entry_snap,
DataEntry *data_entry_meta, bool in_recovery) {
assert(entry_ptr);
assert((*entry_ptr) == nullptr);
HashEntry *reusable_entry = nullptr;
char *bucket_ptr =
(char *)main_buckets_ + (uint64_t)hint.bucket * hash_bucket_size_;
_mm_prefetch(bucket_ptr, _MM_HINT_T0);
uint32_t key_hash_prefix = hint.key_hash_value >> 32;
uint64_t entries = hash_bucket_entries_[hint.bucket];
bool found = false;
// search cache
*entry_ptr = slots_[hint.slot].hash_cache.entry_ptr;
if (*entry_ptr != nullptr) {
memcpy_16(hash_entry_snap, *entry_ptr);
if (MatchHashEntry(key, key_hash_prefix, type_mask, hash_entry_snap,
data_entry_meta)) {
(*entry_ptr)->header.status = HashEntryStatus::Updating;
found = true;
}
}
if (!found) {
// iterate hash entries
*entry_ptr = (HashEntry *)bucket_ptr;
uint64_t i = 0;
for (i = 0; i < entries; i++) {
if (i > 0 && i % num_entries_per_bucket_ == 0) {
// next bucket
memcpy_8(&bucket_ptr, bucket_ptr + hash_bucket_size_ - 8);
_mm_prefetch(bucket_ptr, _MM_HINT_T0);
}
*entry_ptr = (HashEntry *)bucket_ptr + (i % num_entries_per_bucket_);
memcpy_16(hash_entry_snap, *entry_ptr);
if (MatchHashEntry(key, key_hash_prefix, type_mask, hash_entry_snap,
data_entry_meta)) {
slots_[hint.slot].hash_cache.entry_ptr = *entry_ptr;
found = true;
break;
}
if (!in_recovery /* we don't reused hash entry in
recovering */
&& (*entry_ptr)->Reusable()) {
reusable_entry = *entry_ptr;
}
}
if (!found) {
// reach end of buckets, reuse entry or allocate a new bucket
if (i > 0 && i % num_entries_per_bucket_ == 0) {
if (reusable_entry != nullptr) {
if (data_entry_meta && !reusable_entry->Empty()) {
memcpy(data_entry_meta,
pmem_allocator_->offset2addr(reusable_entry->offset),
sizeof(DataEntry));
}
*entry_ptr = reusable_entry;
} else {
auto space = dram_allocator_.Allocate(hash_bucket_size_);
if (space.size == 0) {
GlobalLogger.Error("Memory overflow!\n");
return Status::MemoryOverflow;
}
void *next_off =
dram_allocator_.offset2addr(space.space_entry.offset);
memset(next_off, 0, space.size);
memcpy_8(bucket_ptr + hash_bucket_size_ - 8, &next_off);
*entry_ptr = (HashEntry *)next_off;
}
} else {
*entry_ptr = (HashEntry *)bucket_ptr + (i % num_entries_per_bucket_);
}
}
}
// set status of writing position, see comments of HashEntryStatus
if (found) {
(*entry_ptr)->header.status = HashEntryStatus::Updating;
} else {
if ((*entry_ptr) == reusable_entry) {
if ((*entry_ptr)->header.status == HashEntryStatus::CleanReusable) {
(*entry_ptr)->header.status = HashEntryStatus::Updating;
}
} else {
(*entry_ptr)->header.status = HashEntryStatus::Initializing;
}
}
return found ? Status::Ok : Status::NotFound;
}
Status HashTable::SearchForRead(const KeyHashHint &hint,
const pmem::obj::string_view &key,
uint16_t type_mask, HashEntry **entry_ptr,
HashEntry *hash_entry_snap,
DataEntry *data_entry_meta) {
assert(entry_ptr);
assert((*entry_ptr) == nullptr);
char *bucket_ptr =
(char *)main_buckets_ + (uint64_t)hint.bucket * hash_bucket_size_;
_mm_prefetch(bucket_ptr, _MM_HINT_T0);
uint32_t key_hash_prefix = hint.key_hash_value >> 32;
uint64_t entries = hash_bucket_entries_[hint.bucket];
// search cache
*entry_ptr = slots_[hint.slot].hash_cache.entry_ptr;
if (*entry_ptr != nullptr) {
memcpy_16(hash_entry_snap, *entry_ptr);
if (MatchHashEntry(key, key_hash_prefix, type_mask, hash_entry_snap,
data_entry_meta)) {
return Status::Ok;
}
}
// iterate hash entrys
for (uint64_t i = 0; i < entries; i++) {
if (i > 0 && i % num_entries_per_bucket_ == 0) {
// next bucket
memcpy_8(&bucket_ptr, bucket_ptr + hash_bucket_size_ - 8);
_mm_prefetch(bucket_ptr, _MM_HINT_T0);
}
*entry_ptr = (HashEntry *)bucket_ptr + (i % num_entries_per_bucket_);
while (1) {
memcpy_16(hash_entry_snap, *entry_ptr);
if (MatchHashEntry(key, key_hash_prefix, type_mask, hash_entry_snap,
data_entry_meta)) {
slots_[hint.slot].hash_cache.entry_ptr = *entry_ptr;
return Status::Ok;
} else {
// check if hash entry modified by another write thread during
// MatchHashEntry
if (memcmp(hash_entry_snap, *(entry_ptr), sizeof(HashEntry)) == 0) {
break;
}
}
}
}
return Status::NotFound;
}
void HashTable::Insert(const KeyHashHint &hint, HashEntry *entry_ptr,
uint16_t type, uint64_t offset,
HashOffsetType offset_type) {
assert(write_thread.id >= 0);
HashEntry new_hash_entry(hint.key_hash_value >> 32, type, offset,
(type == StringDeleteRecord)
? HashEntryStatus::DirtyReusable
: HashEntryStatus::Normal,
offset_type);
bool new_entry = entry_ptr->header.status == HashEntryStatus::Initializing;
memcpy_16(entry_ptr, &new_hash_entry);
if (new_entry) { // new allocated
hash_bucket_entries_[hint.bucket]++;
}
}
} // namespace KVDK_NAMESPACE
| 35.263359 | 80 | 0.617599 | BaronStack |
24308c5522b87577de35faec37e57053f5a05f76 | 779 | cpp | C++ | c++/test/test_matmul_upper.cpp | jacksonloper/celerite2 | e413e28dc43ba33e67960b51a9cbbac43c2f58df | [
"MIT"
] | 38 | 2020-10-10T02:43:53.000Z | 2022-03-30T09:59:21.000Z | c++/test/test_matmul_upper.cpp | jacksonloper/celerite2 | e413e28dc43ba33e67960b51a9cbbac43c2f58df | [
"MIT"
] | 34 | 2020-10-06T18:50:47.000Z | 2022-01-28T10:33:04.000Z | c++/test/test_matmul_upper.cpp | jacksonloper/celerite2 | e413e28dc43ba33e67960b51a9cbbac43c2f58df | [
"MIT"
] | 6 | 2020-11-09T18:12:54.000Z | 2022-02-03T20:20:59.000Z | #define CATCH_CONFIG_MAIN
#include "catch.hpp"
#include "helpers.hpp"
#include <celerite2/celerite2.h>
using namespace celerite2::test;
using namespace celerite2::core;
TEMPLATE_LIST_TEST_CASE("check the results of matmul_upper", "[matmul_upper]", TestKernels) {
SETUP_TEST(50);
double max_resid;
Matrix K, Z(Y.rows(), Y.cols()), F;
to_dense(x, c, a, U, V, K);
Matrix expect = K.triangularView<Eigen::StrictlyUpper>() * Y;
SECTION("general") {
Z.setZero();
matmul_upper(x, c, U, V, Y, Z, F);
max_resid = (expect - Z).array().abs().maxCoeff();
REQUIRE(max_resid < 1e-12);
}
SECTION("no grad") {
Z.setZero();
matmul_upper(x, c, U, V, Y, Z);
max_resid = (expect - Z).array().abs().maxCoeff();
REQUIRE(max_resid < 1e-12);
}
}
| 23.606061 | 93 | 0.641849 | jacksonloper |
2432b0701313618b67db0de4d19fd1b2ad2daed7 | 2,287 | cpp | C++ | demo/main.cpp | MatthiasKillat/lockfree-stack | 2f51495b6775887df2e4efc9d7174bfb9eb50afb | [
"MIT"
] | null | null | null | demo/main.cpp | MatthiasKillat/lockfree-stack | 2f51495b6775887df2e4efc9d7174bfb9eb50afb | [
"MIT"
] | null | null | null | demo/main.cpp | MatthiasKillat/lockfree-stack | 2f51495b6775887df2e4efc9d7174bfb9eb50afb | [
"MIT"
] | null | null | null | #include <iostream>
#include "index_stack.hpp"
#include "lockfree_stack.hpp"
//playground, work in progress
int main(void)
{
{
IndexStack<4> stack;
stack.push(0);
stack.push(1);
stack.push(2);
uint32_t value;
if (stack.pop(value))
{
std::cout << "popped " << value << std::endl;
}
else
{
std::cout << "popped nothing" << std::endl;
}
if (stack.pop(value))
{
std::cout << "popped " << value << std::endl;
}
else
{
std::cout << "popped nothing" << std::endl;
}
if (stack.pop(value))
{
std::cout << "popped " << value << std::endl;
}
else
{
std::cout << "popped nothing" << std::endl;
}
}
{
std::cout << "**************" << std::endl;
IndexStack<4> stack(IndexStack<4>::ConstructFull::Policy);
uint32_t value;
while (stack.pop(value))
{
std::cout << "popped " << value << std::endl;
}
}
{
std::cout << "**************" << std::endl;
LockFreeStack<int, 4> stack;
stack.try_push(1);
stack.try_push(2);
stack.try_push(3);
while (true)
{
auto popped = stack.pop();
if (!popped)
break;
std::cout << "popped " << *popped << std::endl;
}
}
{
std::cout << "**************" << std::endl;
LockFreeStack<int, 8> stack;
for (int i = 1; i <= 8; ++i)
{
stack.try_push(i);
}
auto popped = stack.multipop(3);
std::cout << "\nmultipop 3 elements: ";
for (auto &element : popped)
{
std::cout << element << " ";
}
popped = stack.multipop(3);
std::cout << "\nmultipop 3 elements: ";
for (auto &element : popped)
{
std::cout << element << " ";
}
popped = stack.multipop(3);
std::cout << "\nmultipop 3 elements: ";
for (auto &element : popped)
{
std::cout << element << " ";
}
std::cout << std::endl;
}
return 0;
} | 22.203883 | 66 | 0.415391 | MatthiasKillat |
243396ce973d06445dbdd4d96631f4d62bf037e4 | 320 | cpp | C++ | codeforces/random/PetyaAndSquares.cpp | skmorningstar/Competitive-Programming | 05ba602d0fe1492d5c36267237980a9ac2f124d6 | [
"Apache-2.0"
] | null | null | null | codeforces/random/PetyaAndSquares.cpp | skmorningstar/Competitive-Programming | 05ba602d0fe1492d5c36267237980a9ac2f124d6 | [
"Apache-2.0"
] | null | null | null | codeforces/random/PetyaAndSquares.cpp | skmorningstar/Competitive-Programming | 05ba602d0fe1492d5c36267237980a9ac2f124d6 | [
"Apache-2.0"
] | null | null | null | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define MOD 1000000007
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,x,y;
cin>>n>>x>>y;
n=n/2;
if((x==n || x==n+1) && (y==n||y==n+1))
cout<<"NO"<<endl;
else
cout<<"YES"<<endl;
return 0;
} | 14.545455 | 39 | 0.6 | skmorningstar |
24349d600b9df7c5add7fc5fd97c8ac1b859df89 | 8,718 | cpp | C++ | methods/src/utils/utils.cpp | erinaceous/shadows | 43c86c18936f6af4c0c54f30419e8f7bfb244e9a | [
"MIT"
] | 3 | 2015-11-22T07:04:07.000Z | 2017-11-19T13:03:27.000Z | methods/src/utils/utils.cpp | erinaceous/shadows | 43c86c18936f6af4c0c54f30419e8f7bfb244e9a | [
"MIT"
] | null | null | null | methods/src/utils/utils.cpp | erinaceous/shadows | 43c86c18936f6af4c0c54f30419e8f7bfb244e9a | [
"MIT"
] | null | null | null | /**
* @file utils.cpp
* @brief Utility functions and macros shared between my programs. Including
* this file makes a bunch of global variables available, which command line
* arguments are copied to.
* It also defines some helpful macros to reduce 'boiler plate' code. I don't
* know if this is a good idea or bad C++ practise since I'm still a newbie to
* C/C++ style programming. It's certainly made it easier for me to read my own
* files.
*
* Since this initializes things for you, the main() function for a program is
* as simple as:
*
* void main(int argc, char** argv) {
* utils_init();
* add_parameter(int, example_parameter_1);
* add_parameter(int, example_parameter_2);
* add_parameter_multi(vector<string>, multi_token_option);
* parse_commands();
* init_timers();
*
* for_each_input_file_as(input_path) {
* Mat input = imread(*input_path);
* string output_path = to_png_filename(*input_path, output_dir);
* if(!input.data) {
* cerr << "Failed to load " << *input_path << endl;
* continue;
* }
* Mat output = image_processing_function(
* input, example_parameter_1, example_parameter_2
* );
* timing_file_log();
* imwrite_png(output_path, output);
* show_gui(); // if "--gui yes" specified on command line, show input
* // and output images
* }
* timing_file_end();
* return 0;
* }
*
*
* @author Owain Jones <odj@aber.ac.uk>
* @version 0.1
* @date 2014-03-12
*/
#include "shadows.hpp"
#include <opencv2/opencv.hpp>
#include <iostream>
#include <sstream>
#include <fstream>
#include <chrono>
#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
using namespace std;
namespace fs = boost::filesystem;
namespace ch = std::chrono;
namespace po = boost::program_options;
po::options_description desc("Options");
bool gui = false;
bool gui_loop = false;
bool gui_wait = false;
bool test_mode = false;
string output_dir;
string info_image_set;
string info_chain;
string info_parameters;
vector<string> inputs;
bool verbose = false;
/** All my programs are going to be run in parallel - and that's handled by
* the external Python script. Having 8 threads per program trips over the
* 8 programs running at a time and generally doesn't help; on my laptop at
* least, timing tests suggest that 8 processes are better than 8 threads --
* I'm guessing due to waiting on IO or something.
* So all the programs that run this function will have their OpenCV code
* ran on a single thread only. **/
#define utils_init() cv::setNumThreads(0)
/**
* @brief Creates an output stream for a file. If that file exists, then
* simply returns it. If it doesn't exist yet, opens the file, and if
* you've specified anything in the header argument, appends that to
* the file, then returns it.
* Always opens files in output + append mode.
*
* @param path Path to file to be opened
* @param header Optional header string to append to file if it is new
*
* @return Pointer to an output stream that can be written to.
*/
ofstream* get_file(const char* path, const char* header=NULL) {
if(fs::exists(path)) {
ofstream* got_file =
new ofstream(path, ofstream::out | ofstream::app);
return got_file;
}
ofstream* got_file = new ofstream(path, ofstream::out | ofstream::app);
if(header != NULL) {
*got_file << header << endl;
}
return got_file;
}
/**
* @brief Uses the get_file function to access a file / open a new one,
* appends a header suitable for a timing.csv file if the file is new.
*
* @param path Path to the file
*
* @return Pointer to an output stream that can be written to.
*/
ofstream* get_timing_file(const char* path) {
return get_file(
path,
"Chain, Image Set, Parameters, Program, Input, Time"
);
}
// Macros for timing information
#define get_timing_file(path) \
get_file(path, "Chain, Image Set, Parameters, Program, Input, Time")
// Put this at the start of your main()
#define init_timers() \
std::stringstream timing_path; \
timing_path << output_dir.c_str() << "/timing.csv"; \
ofstream* timing = get_timing_file(timing_path.str().c_str()); \
chrono::steady_clock::time_point time_curr = std::chrono::steady_clock::now(); \
chrono::steady_clock::time_point time_end = std::chrono::steady_clock::now();
#define timing_file_write(output_path, time_last, time_now) \
*timing << info_chain.c_str() << ", " << info_image_set.c_str() << ", "; \
*timing << info_parameters.c_str() << ", "; \
*timing << PROGRAM_NAME << ", " << output_path << ", "; \
*timing << chrono::duration_cast<chrono::microseconds>(time_now - time_last).count(); \
*timing << endl;
// Put this somewhere in your image processing loop -- after you've processed an
// image is probably a good place
#define timing_file_log() \
time_end = std::chrono::steady_clock::now(); \
timing_file_write(output_path, time_curr, time_end) \
time_curr = std::chrono::steady_clock::now()
// Put this after your loop
#define timing_file_end() \
/*timing_file_write("total", time_start, time_end);*/ \
timing->close()
// Shortcuts for adding parameters to a Boost program_options::options_description
#define add_parameter(type, name)\
desc.add_options()(#name, po::value<type>(&name))
#define add_parameter_multi(type, name)\
desc.add_options()(#name, po::value<type>(&name)->multitoken())
#define parse_commands() \
po::variables_map options = parse_command_line(desc, argc, argv);
/**
* @brief Parses command line using options_description passed by user, adding
* default options used by all programs along the way.
*
* @param desc An initialized options_description containing the extra arguments
* your program requires
* @param argc
* @param argv
*
* @return A variables_map with the parsed command line
*/
po::variables_map parse_command_line(po::options_description desc,
int argc, char** argv) {
desc.add_options()("help", "Print help message");
add_parameter(bool, test_mode);
add_parameter(bool, verbose);
add_parameter(bool, gui);
add_parameter(bool, gui_loop);
add_parameter(bool, gui_wait);
add_parameter(string, info_image_set);
add_parameter(string, info_chain);
add_parameter(string, info_parameters);
add_parameter(string, output_dir);
add_parameter_multi(vector<string>, inputs);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc)
.allow_unregistered().run(), vm);
if(vm.count("help")) {
cout << desc << endl;
}
if(vm.count("test_mode")) {
verbose = true;
gui = true;
gui_loop = true;
gui_wait = true;
stringstream sb;
sb << "/tmp/" << PROGRAM_NAME;
output_dir = sb.str();
}
po::notify(vm);
return vm;
}
/**
* @brief Take a filename from anywhere and replace its extension with .png and
* say that it's in the directory specified by output_dir.
*
* @param input_path Path to input file
* @param output_dir Directory to prepend filename with
*
* @return
*/
string to_png_filename(string input_path, string output_dir) {
stringstream output_path;
fs::path filepath(input_path);
output_path << output_dir << '/' << fs::basename(input_path) << ".png";
return output_path.str();
}
/**
* @brief Write a file to output_dir/ with the .png extension.
* Uses opencv's imwrite function internally, configured to use the best PNG
* compression available.
*
* @param input_path Path to input file (used for base filename)
* @param output_dir Directory in which to save file
* @param output Mat containing image data
*/
void imwrite_png(string path, cv::Mat output) {
vector<int> imwrite_params;
imwrite_params.push_back(CV_IMWRITE_PNG_COMPRESSION);
imwrite_params.push_back(9);
cv::imwrite(path, output, imwrite_params);
}
#define show_gui(input, output, file_list, current_input_path) \
if(gui) { \
imshow("input", input); \
imshow("output", output); \
if(gui_wait) { \
waitKey(0); \
} else { \
waitKey(1); \
} \
if(gui_loop) { \
if(current_input_path >= file_list.end() - 1) { \
current_input_path = file_list.begin() - 1; \
} \
} \
}
#define for_each_string_in_list(l, i) \
for(std::vector<std::string>::iterator i = l.begin(); i < l.end(); i++)
#define _log(os, msg)\
if(verbose) {\
os << msg;\
os.flush();\
}
#define log_v(msg)\
_log(std::cout, msg)
#define log_e(msg)\
_log(std::cerr, msg)
| 30.482517 | 87 | 0.670567 | erinaceous |
0f8744d82e0ffdd7a2c540cc0ce787dd9568d12b | 233 | cpp | C++ | RequiredRemainder.cpp | seikhchilli/codeforces-problemset | 7b64c91ef9eb9e36b2931335ae131648de0de285 | [
"MIT"
] | 3 | 2021-09-01T13:27:29.000Z | 2021-09-24T12:35:37.000Z | RequiredRemainder.cpp | seikhchilli/codeforces-problemset | 7b64c91ef9eb9e36b2931335ae131648de0de285 | [
"MIT"
] | null | null | null | RequiredRemainder.cpp | seikhchilli/codeforces-problemset | 7b64c91ef9eb9e36b2931335ae131648de0de285 | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int x, y, n;
cin>>x>>y>>n;
int k = (n % x) - y >= 0 ? (n - (((n % x) - y))) : (n - (x + ((n % x) - y)));
cout<<k<<endl;
}
}
| 16.642857 | 81 | 0.39485 | seikhchilli |
0f877b9bbac658e6cbee3177273dd52e71371e7b | 4,600 | cpp | C++ | event_handles/Translate3dEventHandle.cpp | dolphin-li/ClothDesigner | 82b186d6db320b645ac67a4d32d7746cc9bdd391 | [
"MIT"
] | 32 | 2016-12-13T05:49:12.000Z | 2022-02-04T06:15:47.000Z | event_handles/Translate3dEventHandle.cpp | dolphin-li/ClothDesigner | 82b186d6db320b645ac67a4d32d7746cc9bdd391 | [
"MIT"
] | 2 | 2019-07-30T02:01:16.000Z | 2020-03-12T15:06:51.000Z | event_handles/Translate3dEventHandle.cpp | dolphin-li/ClothDesigner | 82b186d6db320b645ac67a4d32d7746cc9bdd391 | [
"MIT"
] | 18 | 2017-11-16T13:37:06.000Z | 2022-03-11T08:13:46.000Z | #include <QEvent>
#include <GL\glew.h>
#include "Viewer3d.h"
#include "Renderable\ObjMesh.h"
#include "Translate3dEventHandle.h"
#include "../clothdesigner.h"
#include "../Viewer2d.h"
#include "cloth\clothPiece.h"
#include "cloth\TransformInfo.h"
Translate3dEventHandle::Translate3dEventHandle(Viewer3d* v) : Abstract3dEventHandle(v)
{
m_cursor = QCursor(Qt::CursorShape::SizeAllCursor);
m_iconFile = "icons/translation.png";
m_inactiveIconFile = "icons/translation_inactive.png";
m_toolTips = "translate handle";
m_axisScale = 0.3;
}
Translate3dEventHandle::~Translate3dEventHandle()
{
}
void Translate3dEventHandle::handleEnter()
{
Abstract3dEventHandle::handleEnter();
if (m_viewer->getManager())
m_viewer->getManager()->simulationDestroy();
if (m_pickInfo.mesh)
{
auto box = m_pickInfo.mesh->boundingBox;
m_viewer->beginTrackBall(Viewer3d::TrackBall_Trans, m_pickInfo.pickPos,
ldp::Mat3d().eye(), (box[1] - box[0]).length()* m_axisScale);
}
m_transformed = false;
}
void Translate3dEventHandle::handleLeave()
{
m_viewer->endTrackBall();
Abstract3dEventHandle::handleLeave();
}
void Translate3dEventHandle::mousePressEvent(QMouseEvent *ev)
{
Abstract3dEventHandle::mousePressEvent(ev);
if (m_viewer->buttons() == Qt::LeftButton)
{
int sid = m_viewer->fboRenderedIndex(ev->pos());
m_viewer->setHoverTrackBallAxis(sid);
if (sid >= Viewer3d::TrackBallIndex_X && sid <= Viewer3d::TrackBallIndex_Z)
m_viewer->setActiveTrackBallAxis(sid);
} // end if initial_location and left button
}
void Translate3dEventHandle::mouseReleaseEvent(QMouseEvent *ev)
{
Abstract3dEventHandle::mouseReleaseEvent(ev);
if (m_transformed)
{
if (m_viewer->getMainUI())
m_viewer->getMainUI()->pushHistory("translate piece", ldp::HistoryStack::Type3dTransform);
m_transformed = false;
}
if (m_viewer->buttons() == Qt::LeftButton)
{
if (m_viewer->getActiveTrackBallAxis() > 0)
{
m_viewer->setActiveTrackBallAxis(-1);
} // end if track ball axis active
else
{
if (ev->pos() == m_mouse_press_pt)
{
pick(ev->pos());
if (m_pickInfo.mesh)
{
auto box = m_pickInfo.mesh->boundingBox;
m_viewer->beginTrackBall(Viewer3d::TrackBall_Trans, m_pickInfo.pickPos,
ldp::Mat3d().eye(), (box[1] - box[0]).length()* m_axisScale);
}
}
} // end else
} // end if left button and initial_cloth
}
void Translate3dEventHandle::mouseDoubleClickEvent(QMouseEvent *ev)
{
Abstract3dEventHandle::mouseDoubleClickEvent(ev);
}
void Translate3dEventHandle::mouseMoveEvent(QMouseEvent *ev)
{
bool valid_op = false;
int sid = m_viewer->getActiveTrackBallAxis();
if (sid < Viewer3d::TrackBallIndex_X || sid > Viewer3d::TrackBallIndex_Z)
{
int hid = m_viewer->fboRenderedIndex(ev->pos());
if (hid >= Viewer3d::TrackBallIndex_X && hid <= Viewer3d::TrackBallIndex_Z)
m_viewer->setHoverTrackBallAxis(hid);
else
m_viewer->setHoverTrackBallAxis(0);
}
else if (m_viewer->buttons() == Qt::LeftButton)
{
const ldp::Camera& cam = m_viewer->camera();
if (m_pickInfo.mesh)
{
QPoint lp = m_viewer->lastMousePos();
ldp::Float3 axis = 0;
switch (sid)
{
default:
break;
case (int)Viewer3d::TrackBallIndex_X:
axis[0] = 1;
break;
case (int)Viewer3d::TrackBallIndex_Y:
axis[1] = 1;
break;
case (int)Viewer3d::TrackBallIndex_Z:
axis[2] = 1;
break;
}
ldp::Double3 wp = cam.getWorldCoords(ldp::Float3(ev->x(), m_viewer->height() - 1 - ev->y(), m_pickInfo.screenPos[2]));
ldp::Double3 wlp = cam.getWorldCoords(ldp::Float3(lp.x(), m_viewer->height() - 1 - lp.y(), m_pickInfo.screenPos[2]));
ldp::Double3 dir = (wp - wlp)*axis;
if (m_pickInfo.piece) // cloth mesh
{
m_pickInfo.piece->transformInfo().translate(dir);
m_viewer->getManager()->updateCloths3dMeshBy2d();
}
else // body mesh
{
auto tr = m_viewer->getManager()->getBodyMeshTransform();
tr.translate(dir);
m_viewer->getManager()->setBodyMeshTransform(tr);
}
m_transformed = true;
m_viewer->translateTrackBall(dir);
if (m_viewer->getMainUI())
m_viewer->getMainUI()->viewer2d()->updateGL();
valid_op = true;
} // end if getPickedMeshFrameInfo
} // end if initial_cloth and left button
if (!valid_op)
Abstract3dEventHandle::mouseMoveEvent(ev);
}
void Translate3dEventHandle::wheelEvent(QWheelEvent *ev)
{
Abstract3dEventHandle::wheelEvent(ev);
}
void Translate3dEventHandle::keyPressEvent(QKeyEvent *ev)
{
Abstract3dEventHandle::keyPressEvent(ev);
}
void Translate3dEventHandle::keyReleaseEvent(QKeyEvent *ev)
{
Abstract3dEventHandle::keyReleaseEvent(ev);
}
| 27.058824 | 121 | 0.709565 | dolphin-li |
0f8c362ee5d5db8341721a132787eb0235a1e472 | 16,372 | cpp | C++ | src/FHEContext.cpp | patrick-schwarz/HElib | cd267e2ddc6e92886b89f3aa51c416d5c1d2dc59 | [
"Apache-2.0"
] | 1 | 2020-12-01T07:18:47.000Z | 2020-12-01T07:18:47.000Z | src/FHEContext.cpp | wangjinglin0721/HElib | cd267e2ddc6e92886b89f3aa51c416d5c1d2dc59 | [
"Apache-2.0"
] | null | null | null | src/FHEContext.cpp | wangjinglin0721/HElib | cd267e2ddc6e92886b89f3aa51c416d5c1d2dc59 | [
"Apache-2.0"
] | null | null | null | /* Copyright (C) 2012-2019 IBM Corp.
* This program is 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. See accompanying LICENSE file.
*/
#include <cstring>
#include <algorithm>
#include "FHEContext.h"
#include "EvalMap.h"
#include "powerful.h"
#include "binio.h"
#include "sample.h"
#include "EncryptedArray.h"
namespace helib {
long FindM(long k, long nBits, long c, long p, long d, long s, long chosen_m, bool verbose)
{
// get a lower-bound on the parameter N=phi(m):
// 1. Each level in the modulus chain corresponds to pSize=p2Size/2
// bits (where we have one prime of this size, and all the others are of
// size p2Size).
// When using DoubleCRT, we need 2m to divide q-1 for every prime q.
// 2. With nBits of ctxt primes,
// the largest modulus for "fresh ciphertexts" has size
// Q0 ~ 2^{nBits}
// 3. We break each ciphertext into upto c digits, do each digit is as large
// as D=2^{nBits/c}
// 4. The added noise variance term from the key-switching operation is
// c*N*sigma^2*D^2, and this must be mod-switched down to w*N (so it is
// on par with the added noise from modulus-switching). Hence the ratio
// P that we use for mod-switching must satisfy c*N*sigma^2*D^2/P^2<w*N,
// or P > sqrt(c/w) * sigma * 2^{(L+1)*pSize/c}
// 5. With this extra P factor, the key-switching matrices are defined
// relative to a modulus of size
// Q0 = q0*P ~ sqrt{c/w} sigma 2^{nBits*(1+1/c)}
// 6. To get k-bit security we need N>log(Q0/sigma)(k+110)/7.2, i.e. roughly
// N > nBits*(1+1/c)(k+110) / 7.2
// Compute a bound on m, and make sure that it is not too large
double cc = 1.0+(1.0/(double)c);
double dN = ceil(nBits*cc*(k+110)/7.2);
// FIXME: the bound for dN is not conservative enough...
// this should be re-worked.
long N = NTL_SP_BOUND;
if (N > dN) N = dN;
else {
std::stringstream ss;
ss << "Cannot support a bound of " << dN;
throw helib::RuntimeError(ss.str());
}
long m = 0;
size_t i=0;
// find the first m satisfying phi(m)>=N and d | ord(p) in Z_m^*
// and phi(m)/ord(p) >= s
if (chosen_m) {
if (NTL::GCD(p, chosen_m) == 1) {
long ordP = multOrd(p, chosen_m);
if (d == 0 || ordP % d == 0) {
// chosen_m is OK
m = chosen_m;
}
}
}
else if (p==2) { // use pre-computed table, divisors of 2^n-1 for some n's
static long ms[][4] = { // pre-computed values of [phi(m),m,d]
//phi(m), m, ord(2),c_m*1000 (not used anymore)
{ 1176, 1247, 28, 3736}, // gens=5(42)
{ 2880, 3133, 24, 3254}, // gens=6(60), 7(!2)
{ 4050, 4051, 50, 0}, // gens=130(81)
{ 4096, 4369, 16, 3422}, // gens=129(16),3(!16)
{ 4704, 4859, 28, 0}, // gens=7(42),3(!4)
{ 5292, 5461, 14, 4160}, // gens=3(126),509(3)
{ 5760, 8435, 24, 8935}, // gens=58(60),1686(2),11(!2)
{ 7500, 7781, 50, 0}, // gens=353(30),3(!5)
{ 8190, 8191, 13, 1273}, // gens=39(630)
{ 9900, 10261, 30, 0}, // gens=3(330)
{10752, 11441, 48, 3607}, // gens=7(112),5(!2)
{10800, 11023, 45, 0}, // gens=270(24),2264(2),3(!5)
{12000, 13981, 20, 2467}, // gens=10(30),23(10),3(!2)
{11520, 15665, 24, 14916}, // gens=6(60),177(4),7(!2)
{14112, 14351, 18, 0}, // gens=7(126),3(!4)
{15004, 15709, 22, 3867}, // gens=5(682)
{18000, 18631, 25, 4208}, // gens=17(120),1177(6)
{15360, 20485, 24, 12767}, // gens=6(80),242(4),7(2)
{16384, 21845, 16, 12798}, // gens=129(16),273(4),3(!16)
{17280 ,21931, 24, 18387}, // gens=6(60),467(6),11(!2)
{19200, 21607, 40, 35633}, // gens=13(120),2789(2),3(!2)
{21168, 27305, 28, 15407}, // gens=6(126),781(6)
{23040, 23377, 48, 5292}, // gens=35(240),5(!2)
{23310, 23311, 45, 0}, // gens=489(518)
{24576, 24929, 48, 5612}, // gens=12(256),5(!2)
{27000, 32767, 15, 20021}, // gens=3(150),873(6),6945(2)
{31104, 31609, 72, 5149}, // gens=11(216),5(!2)
{43690, 43691, 34, 0}, // gens=69(1285)
{49500, 49981, 30, 0}, // gens=3(1650)
{46080, 53261, 24, 33409}, // gens=3(240),242(4),7(!2)
{54000, 55831, 25, 0}, // gens=22(360),3529(6)
{49140, 57337, 39, 2608}, // gens=39(630),40956(2)
{51840, 59527, 72, 21128}, // gens=58(60),1912(6),7(!2)
{61680, 61681, 40, 1273}, // gens=33(771),17(!2)
{65536, 65537, 32, 1273}, // gens=2(32),3(!2048)
{75264, 82603, 56, 36484}, // gens=3(336),24294(2),7(!2)
{84672, 92837, 56, 38520} // gens=18(126),1886(6),3(!2)
};
for (i=0; i<sizeof(ms)/sizeof(long[4]); i++) {
if (ms[i][0] < N || NTL::GCD(p, ms[i][1]) != 1) continue;
long ordP = multOrd(p, ms[i][1]);
long nSlots = ms[i][0]/ordP;
if (d != 0 && ordP % d != 0) continue;
if (nSlots < s) continue;
m = ms[i][1];
break;
}
}
// If m is not set yet, just set it close to N. This may be a lousy
// choice of m for this p, since you will get a small number of slots.
if (m==0) {
// search only for odd values of m, to make phi(m) a little closer to m
for (long candidate=N|1; candidate<10*N; candidate+=2) {
if (NTL::GCD(p,candidate)!=1) continue;
long ordP = multOrd(p,candidate); // the multiplicative order of p mod m
if (d>1 && ordP%d!=0 ) continue;
if (ordP > 100) continue; // order too big, we will get very few slots
long n = phi_N(candidate); // compute phi(m)
if (n < N) continue; // phi(m) too small
m = candidate; // all tests passed, return this value of m
break;
}
}
if (verbose) {
std::cerr << "*** Bound N="<<N<<", choosing m="<<m <<", phi(m)="<< phi_N(m)
<< std::endl;
}
return m;
}
// A global variable, pointing to the "current" context
FHEcontext* activeContext = nullptr;
void FHEcontext::productOfPrimes(NTL::ZZ& p, const IndexSet& s) const
{
p = 1;
for (long i: s)
p *= ithPrime(i);
}
bool FHEcontext::operator==(const FHEcontext& other) const
{
if (zMStar != other.zMStar) return false;
if (alMod != other.alMod) return false;
if (moduli.size() != other.moduli.size()) return false;
for (size_t i=0; i<moduli.size(); i++) {
const Cmodulus& m1 = moduli[i];
const Cmodulus& m2 = other.moduli[i];
if (m1.getQ() != m2.getQ()) return false;
}
if (smallPrimes != other.smallPrimes) return false;
if (ctxtPrimes != other.ctxtPrimes) return false;
if (specialPrimes != other.specialPrimes) return false;
if (digits.size() != other.digits.size()) return false;
for (size_t i=0; i<digits.size(); i++)
if (digits[i] != other.digits[i]) return false;
if (stdev != other.stdev) return false;
if (scale != other.scale) return false;
if (rcData != other.rcData) return false;
return true;
}
void writeContextBaseBinary(std::ostream& str, const FHEcontext& context)
{
writeEyeCatcher(str, BINIO_EYE_CONTEXTBASE_BEGIN);
write_raw_int(str, context.zMStar.getP());
write_raw_int(str, context.alMod.getR());
write_raw_int(str, context.zMStar.getM());
write_raw_int(str, context.zMStar.numOfGens());
// There aren't simple getters to get the gens and ords vectors
for(long i=0; i<context.zMStar.numOfGens(); i++) {
write_raw_int(str, context.zMStar.ZmStarGen(i));
}
write_raw_int(str, context.zMStar.numOfGens());
// Copying the way it is done in ASCII IO.
// Bad dimensions are represented as a negated ord
for(long i=0; i<context.zMStar.numOfGens(); i++) {
if(context.zMStar.SameOrd(i))
write_raw_int(str, context.zMStar.OrderOf(i));
else
write_raw_int(str, -context.zMStar.OrderOf(i));
}
writeEyeCatcher(str, BINIO_EYE_CONTEXTBASE_END);
}
void readContextBaseBinary(std::istream& str, unsigned long& m,
unsigned long& p, unsigned long& r,
std::vector<long>& gens, std::vector<long>& ords)
{
int eyeCatcherFound = readEyeCatcher(str, BINIO_EYE_CONTEXTBASE_BEGIN);
//OLD: assert(eyeCatcherFound == 0);
helib::assertEq(eyeCatcherFound, 0, "Could not find pre-context-base eye catcher");
p = read_raw_int(str);
r = read_raw_int(str);
m = read_raw_int(str);
// Number of gens and ords saved in front of vectors
read_raw_vector(str, gens);
read_raw_vector(str, ords);
eyeCatcherFound = readEyeCatcher(str, BINIO_EYE_CONTEXTBASE_END);
//OLD: assert(eyeCatcherFound == 0);
helib::assertEq(eyeCatcherFound, 0, "Could not find post-context-base eye catcher");
}
std::unique_ptr<FHEcontext> buildContextFromBinary(std::istream& str)
{
unsigned long m, p, r;
std::vector<long> gens, ords;
readContextBaseBinary(str, m, p, r, gens, ords);
return std::unique_ptr<FHEcontext>(new FHEcontext(m,p,r,gens,ords));
}
void writeContextBinary(std::ostream& str, const FHEcontext& context)
{
writeEyeCatcher(str, BINIO_EYE_CONTEXT_BEGIN);
// standard-deviation
write_raw_xdouble(str, context.stdev);
// scale
write_raw_double(str, context.scale);
// the "small" index
write_raw_int(str, context.smallPrimes.card());
for(long tmp: context.smallPrimes) {;
write_raw_int(str, tmp);
}
// the "special" index
write_raw_int(str, context.specialPrimes.card());
for(long tmp: context.specialPrimes) {
write_raw_int(str, tmp);
}
// output the primes in the chain
write_raw_int(str, context.moduli.size());
for (long i=0; i<(long)context.moduli.size(); i++){
write_raw_int(str, context.moduli[i].getQ());
}
// output the digits
write_raw_int(str, context.digits.size());
for(long i=0; i<(long)context.digits.size(); i++){
write_raw_int(str, context.digits[i].card());
for(long tmp: context.digits[i]) {
write_raw_int(str, tmp);
}
}
write_ntl_vec_long(str, context.rcData.mvec);
write_raw_int(str, context.rcData.skHwt);
writeEyeCatcher(str, BINIO_EYE_CONTEXT_END);
}
void readContextBinary(std::istream& str, FHEcontext& context)
{
int eyeCatcherFound = readEyeCatcher(str, BINIO_EYE_CONTEXT_BEGIN);
//OLD: assert(eyeCatcherFound == 0);
helib::assertEq(eyeCatcherFound, 0, "Could not find pre-context eye catcher");
// Get the standard deviation
context.stdev = read_raw_xdouble(str);
// Get the scale
context.scale = read_raw_double(str);
IndexSet smallPrimes;
long smallPrimes_sz = read_raw_int(str);
for(long tmp, i=0; i<smallPrimes_sz; i++){
tmp = read_raw_int(str);
smallPrimes.insert(tmp);
}
IndexSet specialPrimes;
long specialPrimes_sz = read_raw_int(str);
for(long tmp, i=0; i<specialPrimes_sz; i++){
tmp = read_raw_int(str);
specialPrimes.insert(tmp);
}
context.moduli.clear();
context.smallPrimes.clear();
context.specialPrimes.clear();
context.ctxtPrimes.clear();
long nPrimes = read_raw_int(str);
for (long p,i=0; i<nPrimes; i++) {
p = read_raw_int(str);
context.moduli.push_back(Cmodulus(context.zMStar,p,0));
if (smallPrimes.contains(i))
context.smallPrimes.insert(i); // small prime
else if (specialPrimes.contains(i))
context.specialPrimes.insert(i); // special prime
else
context.ctxtPrimes.insert(i); // ciphertext prime
}
long nDigits = read_raw_int(str);
context.digits.resize(nDigits);
for(long i=0; i<(long)context.digits.size(); i++){
long sizeOfS = read_raw_int(str);
for(long tmp, n=0; n<sizeOfS; n++){
tmp = read_raw_int(str);
context.digits[i].insert(tmp);
}
}
// Read in the partition of m into co-prime factors (if bootstrappable)
NTL::Vec<long> mv;
read_ntl_vec_long(str, mv);
long t = read_raw_int(str);
if (mv.length()>0) {
context.makeBootstrappable(mv, t);
}
context.setModSizeTable();
eyeCatcherFound = readEyeCatcher(str, BINIO_EYE_CONTEXT_END);
//OLD: assert(eyeCatcherFound == 0);
helib::assertEq(eyeCatcherFound, 0, "Could not find post-context eye catcher");
}
void writeContextBase(std::ostream& str, const FHEcontext& context)
{
str << "[" << context.zMStar.getM()
<< " " << context.zMStar.getP()
<< " " << context.alMod.getR()
<< " [";
for (long i=0; i<(long) context.zMStar.numOfGens(); i++) {
str << context.zMStar.ZmStarGen(i)
<< ((i==(long)context.zMStar.numOfGens()-1)? "]" : " ");
}
str << " [";
for (long i=0; i<(long) context.zMStar.numOfGens(); i++) {
long ord = context.zMStar.OrderOf(i);
if (context.zMStar.SameOrd(i)) str << ord;
else str << (-ord);
if (i<(long)context.zMStar.numOfGens()-1) str << ' ';
}
str << "]]";
}
std::ostream& operator<< (std::ostream &str, const FHEcontext& context)
{
str << "[\n";
// standard-deviation
str << context.stdev << "\n";
// scale
str << context.scale << "\n";
// the "small" index
str << context.smallPrimes << "\n ";
// the "special" index
str << context.specialPrimes << "\n ";
// output the primes in the chain
str << context.moduli.size() << "\n";
for (long i=0; i<(long)context.moduli.size(); i++)
str << context.moduli[i].getQ() << " ";
str << "\n ";
// output the digits
str << context.digits.size() << "\n";
for (long i=0; i<(long)context.digits.size(); i++)
str << context.digits[i] << " ";
str <<"\n";
str << context.rcData.mvec;
str << " " << context.rcData.skHwt;
str << " " << context.rcData.build_cache;
str << "]\n";
return str;
}
void readContextBase(std::istream& str, unsigned long& m, unsigned long& p,
unsigned long& r, std::vector<long>& gens, std::vector<long>& ords)
{
// Advance str beyond first '['
seekPastChar(str, '['); // this function is defined in NumbTh.cpp
str >> m >> p >> r;
str >> gens;
str >> ords;
seekPastChar(str, ']');
}
std::unique_ptr<FHEcontext> buildContextFromAscii(std::istream& str)
{
unsigned long m, p, r;
std::vector<long> gens, ords;
readContextBase(str, m, p, r, gens, ords);
return std::unique_ptr<FHEcontext>(new FHEcontext(m,p,r,gens,ords));
}
std::istream& operator>> (std::istream &str, FHEcontext& context)
{
seekPastChar(str, '['); // this function is defined in NumbTh.cpp
// Get the standard deviation
str >> context.stdev;
// Get the scale
str >> context.scale;
IndexSet smallPrimes;
str >> smallPrimes;
IndexSet specialPrimes;
str >> specialPrimes;
context.moduli.clear();
context.smallPrimes.clear();
context.specialPrimes.clear();
context.ctxtPrimes.clear();
long nPrimes;
str >> nPrimes;
for (long i=0; i<nPrimes; i++) {
long p;
str >> p;
context.moduli.push_back(Cmodulus(context.zMStar,p,0));
if (smallPrimes.contains(i))
context.smallPrimes.insert(i); // small prime
else if (specialPrimes.contains(i))
context.specialPrimes.insert(i); // special prime
else
context.ctxtPrimes.insert(i); // ciphertext prime
}
// read in the partition to digits
long nDigits;
str >> nDigits;
context.digits.resize(nDigits);
for (long i=0; i<(long)context.digits.size(); i++)
str >> context.digits[i];
// Read in the partition of m into co-prime factors (if bootstrappable)
NTL::Vec<long> mv;
long t;
int build_cache;
str >> mv;
str >> t;
str >> build_cache;
if (mv.length()>0) {
context.makeBootstrappable(mv, t, build_cache);
}
context.setModSizeTable();
seekPastChar(str, ']');
return str;
}
FHEcontext::~FHEcontext()
{
delete ea;
}
// Constructors must ensure that alMod points to zMStar, and
// rcEA (if set) points to rcAlmod which points to zMStar
FHEcontext::FHEcontext(unsigned long m, unsigned long p, unsigned long r,
const std::vector<long>& gens, const std::vector<long>& ords):
stdev(3.2), scale(10.0), zMStar(m, p, gens, ords), alMod(zMStar, r)
{
ea = new EncryptedArray(*this, alMod);
}
}
| 30.94896 | 91 | 0.62216 | patrick-schwarz |
0f8f36ba108e40d79d1baeb6fce8b6fca28e5166 | 421 | cc | C++ | kattis/acm2.cc | Ashindustry007/competitive-programming | 2eabd3975c029d235abb7854569593d334acae2f | [
"WTFPL"
] | 506 | 2018-08-22T10:30:38.000Z | 2022-03-31T10:01:49.000Z | kattis/acm2.cc | Ashindustry007/competitive-programming | 2eabd3975c029d235abb7854569593d334acae2f | [
"WTFPL"
] | 13 | 2019-08-07T18:31:18.000Z | 2020-12-15T21:54:41.000Z | kattis/acm2.cc | Ashindustry007/competitive-programming | 2eabd3975c029d235abb7854569593d334acae2f | [
"WTFPL"
] | 234 | 2018-08-06T17:11:41.000Z | 2022-03-26T10:56:42.000Z | // https://open.kattis.com/problems/acm2
#include <bits/stdc++.h>
using namespace std;
using vi=vector<int>;
int main(){
int n,p,b,c;
cin>>n>>p;
vi a(n);
for(int i=0;i<n;i++)cin>>a[i];
if(a[p]>300){
cout<<"0 0\n";
return 0;
}
b=c=a[p];
swap(a[p],a[n-1]);
a.pop_back();
sort(a.begin(),a.end());
int i=0;
for(;i<n-1&&b+a[i]<=300;i++){
b+=a[i];
c+=b;
}
cout<<i+1<<" "<<c<<endl;
}
| 16.84 | 40 | 0.496437 | Ashindustry007 |
0f906b861a78494bc89ea5b353550ee601f47bb8 | 2,489 | hpp | C++ | Examples/NMocha/src/OutputDebugStringBuf.hpp | garymathews/titanium_mobile_windows | ff2a02d096984c6cad08f498e1227adf496f84df | [
"Apache-2.0"
] | 20 | 2015-04-02T06:55:30.000Z | 2022-03-29T04:27:30.000Z | Examples/NMocha/src/OutputDebugStringBuf.hpp | garymathews/titanium_mobile_windows | ff2a02d096984c6cad08f498e1227adf496f84df | [
"Apache-2.0"
] | 692 | 2015-04-01T21:05:49.000Z | 2020-03-10T10:11:57.000Z | Examples/NMocha/src/OutputDebugStringBuf.hpp | garymathews/titanium_mobile_windows | ff2a02d096984c6cad08f498e1227adf496f84df | [
"Apache-2.0"
] | 22 | 2015-04-01T20:57:51.000Z | 2022-01-18T17:33:15.000Z | /**
* Util
*
* Copyright (c) 2014 by Appcelerator, Inc. All Rights Reserved.
* Licensed under the terms of the Apache Public License.
* Please see the LICENSE included with this distribution for details.
*/
#ifndef _TITANIUM_MOBILE_WINDOWS_UTIL_OUTPUTDEBUGSTRINGBUF_HPP_
#define _TITANIUM_MOBILE_WINDOWS_UTIL_OUTPUTDEBUGSTRINGBUF_HPP_
#if defined(_DEBUG)
#include <ostream>
#include <sstream>
#include <vector>
#include <Windows.h>
namespace TitaniumWindows {
// This class is a derivate of basic_stringbuf which will output
// all the written data using the OutputDebugString function.
template<typename TChar, typename TTraits = std::char_traits<TChar>>
class OutputDebugStringBuf final : public std::basic_stringbuf < TChar, TTraits > {
public:
explicit OutputDebugStringBuf() : buffer_(256) {
setg(nullptr, nullptr, nullptr);
setp(buffer_.data(), buffer_.data(), buffer_.data() + buffer_.size());
}
~OutputDebugStringBuf() {
}
static_assert(std::is_same<TChar, char>::value || std::is_same<TChar, wchar_t>::value, "OutputDebugStringBuf only supports char and wchar_t types");
int sync() try {
MessageOutputer<TChar, TTraits>()(pbase(), pptr());
setp(buffer_.data(), buffer_.data(), buffer_.data() + buffer_.size());
return 0;
}
catch (...) {
return -1;
}
int overflow(int c = TTraits::eof()) {
auto syncRet = sync();
if (c != TTraits::eof()) {
buffer_[0] = c;
setp(buffer_.data(), buffer_.data() + 1, buffer_.data() + buffer_.size());
}
return syncRet == -1 ? TTraits::eof() : 0;
}
private:
std::vector<TChar> buffer_;
template<typename TChar, typename TTraits>
struct MessageOutputer;
template<>
struct MessageOutputer < char, std::char_traits<char> > {
template<typename TIterator>
void operator()(TIterator begin, TIterator end) const {
std::string s(begin, end);
OutputDebugStringA(s.c_str());
}
};
template<>
struct MessageOutputer < wchar_t, std::char_traits<wchar_t> > {
template<typename TIterator>
void operator()(TIterator begin, TIterator end) const {
std::wstring s(begin, end);
OutputDebugStringW(s.c_str());
}
};
};
} // namespace TitaniumWindows {
#endif
#endif // _TITANIUM_MOBILE_WINDOWS_UTIL_OUTPUTDEBUGSTRINGBUF_HPP_
| 28.94186 | 153 | 0.642025 | garymathews |
0f944d0aeab70f52d46c424d2a0cdbfa9c7ede1f | 2,316 | cpp | C++ | modules/skparagraph/src/FontArguments.cpp | twinsunllc/skia | 8318cc9928ef12577f249f49250dd94ee2bc1d28 | [
"BSD-3-Clause"
] | null | null | null | modules/skparagraph/src/FontArguments.cpp | twinsunllc/skia | 8318cc9928ef12577f249f49250dd94ee2bc1d28 | [
"BSD-3-Clause"
] | null | null | null | modules/skparagraph/src/FontArguments.cpp | twinsunllc/skia | 8318cc9928ef12577f249f49250dd94ee2bc1d28 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2019 Google LLC.
#include "modules/skparagraph/src/FontArguments.h"
bool operator==(const SkFontArguments& a, const SkFontArguments& b) {
if (a.getCollectionIndex() != b.getCollectionIndex()) {
return false;
}
const SkFontArguments::VariationPosition posA = a.getVariationDesignPosition();
const SkFontArguments::VariationPosition posB = b.getVariationDesignPosition();
if (posA.coordinateCount != posB.coordinateCount) {
return false;
}
for (int i = 0; i < posA.coordinateCount; ++i) {
const SkFontArguments::VariationPosition::Coordinate& coordA = posA.coordinates[i];
const SkFontArguments::VariationPosition::Coordinate& coordB = posB.coordinates[i];
if (coordA.axis != coordB.axis || coordA.value != coordB.value) {
return false;
}
}
const SkFontArguments::Palette palA = a.getPalette();
const SkFontArguments::Palette palB = b.getPalette();
if (palA.index != palB.index || palA.overrideCount != palB.overrideCount) {
return false;
}
for (int i = 0; i < palA.overrideCount; ++i) {
const SkFontArguments::Palette::Override& overA = palA.overrides[i];
const SkFontArguments::Palette::Override& overB = palB.overrides[i];
if (overA.index != overB.index || overA.color != overB.color) {
return false;
}
}
return true;
}
bool operator!=(const SkFontArguments& a, const SkFontArguments& b) {
return !(a == b);
}
namespace std {
size_t hash<SkFontArguments>::operator()(const SkFontArguments& args) const {
size_t hash = 0;
hash ^= std::hash<int>()(args.getCollectionIndex());
const SkFontArguments::VariationPosition pos = args.getVariationDesignPosition();
for (int i = 0; i < pos.coordinateCount; ++i) {
hash ^= std::hash<SkFourByteTag>()(pos.coordinates[i].axis);
hash ^= std::hash<float>()(pos.coordinates[i].value);
}
const SkFontArguments::Palette pal = args.getPalette();
hash ^= std::hash<int>()(pal.index);
for (int i = 0; i < pal.overrideCount; ++i) {
hash ^= std::hash<int>()(pal.overrides[i].index);
hash ^= std::hash<SkColor>()(pal.overrides[i].color);
}
return hash;
}
}
| 37.967213 | 91 | 0.628238 | twinsunllc |
0f95fecd925c7ab349450e2a97123219698430fa | 570 | cpp | C++ | Array as a parameter.cpp | AtharvK9/Cpp-Fundamentals | 827e367e113adc81c7e22e5e8d3c6eb4afb71b4d | [
"MIT"
] | null | null | null | Array as a parameter.cpp | AtharvK9/Cpp-Fundamentals | 827e367e113adc81c7e22e5e8d3c6eb4afb71b4d | [
"MIT"
] | null | null | null | Array as a parameter.cpp | AtharvK9/Cpp-Fundamentals | 827e367e113adc81c7e22e5e8d3c6eb4afb71b4d | [
"MIT"
] | null | null | null | #include<iostream>
using namespace std;
//Array can't be passed by value.
void fun(int A[], int n){//Pointer to an Array.
cout << sizeof(A)/sizeof(int) << "\n";//It's taking size of a pointer.
A[0]=12;
for(int i = 0;i<6;i++){
cout << A[i] << " ";
}
}
int main(){
int A[]={1,2,3,4,5,6};//Array is Declared & initialised.
int n = 6;
fun(A,n);
cout << sizeof(A)/sizeof(int) << "\n";//It's taking size of actual Array.
for(int x:A){
cout << x << " ";//For each loop works lonly in main function.
}
return 0;
} | 23.75 | 77 | 0.538596 | AtharvK9 |
0f9670386171b1db7d06f4d730ced5467ec79b1e | 5,370 | cpp | C++ | apps/RAMDanceToolkit/src/scenes/Laban/Laban.cpp | YCAMInterlab/RAMDanceToolkit | 5db15135f4ad6f6a9116610b909df99036f74797 | [
"Apache-2.0"
] | 52 | 2015-01-13T05:17:23.000Z | 2021-05-09T14:09:39.000Z | apps/RAMDanceToolkit/src/scenes/Laban/Laban.cpp | YCAMInterlab/RAMDanceToolkit | 5db15135f4ad6f6a9116610b909df99036f74797 | [
"Apache-2.0"
] | 7 | 2015-01-12T10:25:14.000Z | 2018-09-18T12:34:15.000Z | apps/RAMDanceToolkit/src/scenes/Laban/Laban.cpp | YCAMInterlab/RAMDanceToolkit | 5db15135f4ad6f6a9116610b909df99036f74797 | [
"Apache-2.0"
] | 31 | 2015-01-12T06:39:15.000Z | 2020-04-06T07:05:08.000Z | //
// Laban.cpp - RAMDanceToolkit
//
// Copyright 2012-2013 YCAM InterLab, Yoshito Onishi, Satoru Higa, Motoi Shimizu, and Kyle McDonald
//
// 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 "Laban.h"
static bool LabanMomentIsDead(LabanMoment& moment)
{
return moment.isDead();
}
void Laban::setupControlPanel()
{
maxLabanMomentLife = 1.0f;
threshold = .2;
lineWidth = 3;
scale = 20;
ticks = 3;
lineLength = 300;
showLines = true;
showPlanes = false;
onlyLimbs = true;
ofxUICanvas* panel = ramGetGUI().getCurrentUIContext();
panel->addSlider("Fade out", 0, 2, &maxLabanMomentLife, 300, 20);
panel->addToggle("Only Limbs", &onlyLimbs, 20, 20);
panel->addSlider("Threshold", 0, .5, &threshold, 300, 20);
panel->addToggle("Show lines", &showLines, 20, 20);
panel->addSlider("Line width", 0, 10, &lineWidth, 300, 20);
panel->addSlider("Line length", 0, 1000, &lineLength, 300, 20);
panel->addToggle("Show planes", &showPlanes, 20, 20);
panel->addSlider("Scale", 0, 1000, &scale, 300, 20);
panel->addSlider("Ticks", 0, 10, &ticks, 300, 20);
}
void Laban::setup()
{
for(int x = -1; x <= +1; x++)
{
for(int y = -1; y <= +1; y++)
{
for(int z = -1; z <= +1; z++)
{
if(!(x == 0 && y == 0 && z == 0))
{
ofVec3f cur(x, y, z);
cur.normalize();
labanDirections.push_back(cur);
float red = ofMap(x, -1, 1, 64, 255);
float green = ofMap(y, -1, 1, 64, 255);
float blue = ofMap(z, -1, 1, 64, 255);
labanColors.push_back(ofColor(red, green, blue));
}
}
}
}
}
void Laban::update()
{
moments.erase(remove_if(moments.begin(), moments.end(), LabanMomentIsDead), moments.end());
}
void Laban::draw()
{
ramBeginCamera();
ofEnableAlphaBlending();
glDisable(GL_DEPTH_TEST);
list<LabanMoment>::iterator itr;
for(itr = moments.begin(); itr != moments.end(); itr++)
{
LabanMoment& cur = *itr;
ofPushStyle();
float alpha = cur.getLife(maxLabanMomentLife);
ofSetColor(255, 64 * alpha);
ofLine(cur.start, cur.start + cur.direction * lineLength);
ofSetColor(labanColors[cur.choice], 255 * alpha);
ofLine(cur.start, cur.start + labanDirections[cur.choice] * lineLength);
ofPopStyle();
}
ramEndCamera();
}
void Laban::drawActor(const ramActor &actor)
{
for (int i=0; i<actor.getNumNode(); i++)
{
if(onlyLimbs)
{
if(i != ramActor::JOINT_LEFT_ANKLE &&
i != ramActor::JOINT_RIGHT_ANKLE &&
i != ramActor::JOINT_LEFT_WRIST &&
i != ramActor::JOINT_RIGHT_WRIST)
{
continue;
}
}
const ramNode &node = actor.getNode(i);
ofSetColor(255);
ofSetLineWidth(lineWidth);
if(node.hasParent())
{
ofVec3f start = node.getGlobalPosition();
ofVec3f end = node.getParent()->getGlobalPosition();
ofVec3f direction = (start - end);
direction.normalize();
if(showLines)
{
int nearestChoice;
float nearestDistance;
for(int i = 0; i < labanDirections.size(); i++)
{
float distance = direction.distance(labanDirections[i]);
if(i == 0 || distance < nearestDistance)
{
nearestChoice = i;
nearestDistance = distance;
}
}
if(nearestDistance < threshold)
{
moments.push_back(LabanMoment(start, direction, nearestChoice));
}
}
if(showPlanes)
{
if(abs(direction.x) < threshold)
{
ofPushMatrix();
ofTranslate(start);
ofDrawGrid(scale, ticks, false, true, false, false);
ofPopMatrix();
}
if(abs(direction.y) < threshold)
{
ofPushMatrix();
ofTranslate(start);
ofDrawGrid(scale, ticks, false, false, true, false);
ofPopMatrix();
}
if(abs(direction.z) < threshold)
{
ofPushMatrix();
ofTranslate(start);
ofDrawGrid(scale, ticks, false, false, false, true);
ofPopMatrix();
}
}
}
}
}
void Laban::drawRigid(ramRigidBody &rigid)
{
}
| 31.964286 | 99 | 0.518994 | YCAMInterlab |
0f9906a238d593017d767ee71cb1750f5d95827f | 1,324 | hpp | C++ | inc/sexpr-quote.hpp | ryanvbissell/dslang | 65379ca7bbefff0161d11343b742ac58452d37e7 | [
"BSD-2-Clause"
] | null | null | null | inc/sexpr-quote.hpp | ryanvbissell/dslang | 65379ca7bbefff0161d11343b742ac58452d37e7 | [
"BSD-2-Clause"
] | null | null | null | inc/sexpr-quote.hpp | ryanvbissell/dslang | 65379ca7bbefff0161d11343b742ac58452d37e7 | [
"BSD-2-Clause"
] | null | null | null | // vim: set tabstop=2 softtabstop=2 shiftwidth=2 expandtab :
/*
* Copyright (c) 2014-2017, Ryan V. Bissell
* All rights reserved.
*
* SPDX-License-Identifier: BSD-2-Clause
* See the enclosed "LICENSE" file for exact license terms.
*/
#ifndef DSLANG_SEXPR_QUOTE_HPP
#define DSLANG_SEXPR_QUOTE_HPP
#include "sexpr.hpp"
#include <string.h>
namespace DSL
{
namespace detail
{
class SexprQuote CX_FINAL : public Sexpr
{
public:
SexprQuote(Context* sc, char const** input);
std::string Write() const;
/*
static bool Match(Dialect const& dialect, char const* text);
static Sexpr::Type Skip(Dialect const& dialect, char const** input);
static SEXPR Parse(Dialect const& dialect, char const** input);
*/
protected:
Type type() const override { return Sexpr::Type::QUOTE; }
Sexpr const* transmute(char const** input) const override;
Sexpr const* eval(SexprEnv const* env) const override;
private:
Sexpr::Type type_;
std::string text_;
virtual ~SexprQuote();
};
bool SexprQuote__Match(char const* text);
Sexpr::Type SexprQuote__Skip(char const** input);
Sexpr const* SexprQuote__Parse(Context* sc, char const** input);
} // namespace detail
using SexprQUOTE = CX::IntrusivePtr<detail::SexprQuote>;
} // namespace DSL
#endif // DSLANG_SEXPR_QUOTE_HPP
| 22.066667 | 72 | 0.705438 | ryanvbissell |
0f9d5384f9407a460db0945869cace6ba23cb323 | 3,140 | hpp | C++ | tests/Unit/Helpers/Evolution/EventsAndDenseTriggers/DenseTriggers/TestTrigger.hpp | macedo22/spectre | 97b2b7ae356cf86830258cb5f689f1191fdb6ddd | [
"MIT"
] | 1 | 2018-10-01T06:07:16.000Z | 2018-10-01T06:07:16.000Z | tests/Unit/Helpers/Evolution/EventsAndDenseTriggers/DenseTriggers/TestTrigger.hpp | macedo22/spectre | 97b2b7ae356cf86830258cb5f689f1191fdb6ddd | [
"MIT"
] | 4 | 2018-06-04T20:26:40.000Z | 2018-07-27T14:54:55.000Z | tests/Unit/Helpers/Evolution/EventsAndDenseTriggers/DenseTriggers/TestTrigger.hpp | macedo22/spectre | 97b2b7ae356cf86830258cb5f689f1191fdb6ddd | [
"MIT"
] | null | null | null | // Distributed under the MIT License.
// See LICENSE.txt for details.
#pragma once
#include "Framework/TestingFramework.hpp"
#include <pup.h>
#include <string>
#include "DataStructures/DataBox/Tag.hpp"
#include "Evolution/EventsAndDenseTriggers/DenseTrigger.hpp"
#include "Options/Options.hpp"
#include "Parallel/CharmPupable.hpp"
#include "Utilities/TMPL.hpp"
namespace TestHelpers::DenseTriggers {
class TestTrigger : public DenseTrigger {
public:
/// \cond
TestTrigger() = default;
explicit TestTrigger(CkMigrateMessage* const msg) noexcept
: DenseTrigger(msg) {}
using PUP::able::register_constructor;
WRAPPED_PUPable_decl_template(TestTrigger); // NOLINT
/// \endcond
struct IsReady {
using type = bool;
constexpr static Options::String help = "IsReady";
};
struct IsTriggered {
using type = bool;
constexpr static Options::String help = "IsTriggered";
};
struct NextCheck {
using type = double;
constexpr static Options::String help = "NextCheck";
};
using options = tmpl::list<IsReady, IsTriggered, NextCheck>;
constexpr static Options::String help = "help";
TestTrigger(const bool is_ready, const bool is_triggered,
const double next_check) noexcept
: is_ready_(is_ready),
is_triggered_(is_triggered),
next_check_(next_check) {}
using is_triggered_argument_tags = tmpl::list<>;
Result is_triggered() const noexcept {
CHECK(is_ready_);
return {is_triggered_, next_check_};
}
using is_ready_argument_tags = tmpl::list<>;
bool is_ready() const noexcept { return is_ready_; }
// NOLINTNEXTLINE(google-runtime-references)
void pup(PUP::er& p) noexcept override {
DenseTrigger::pup(p);
p | is_ready_;
p | is_triggered_;
p | next_check_;
}
private:
bool is_ready_;
bool is_triggered_;
double next_check_;
};
template <typename Label>
class BoxTrigger : public DenseTrigger {
public:
/// \cond
BoxTrigger() = default;
explicit BoxTrigger(CkMigrateMessage* const msg) noexcept
: DenseTrigger(msg) {}
using PUP::able::register_constructor;
WRAPPED_PUPable_decl_template(BoxTrigger); // NOLINT
/// \endcond
static std::string name() noexcept {
return "BoxTrigger<" + Options::name<Label>() + ">";
}
using options = tmpl::list<>;
constexpr static Options::String help = "help";
struct IsTriggered : db::SimpleTag {
using type = bool;
};
struct NextCheck : db::SimpleTag {
using type = double;
};
struct IsReady : db::SimpleTag {
using type = bool;
};
using is_triggered_argument_tags =
tmpl::list<IsReady, IsTriggered, NextCheck>;
Result is_triggered(const bool is_ready, const bool is_triggered,
const double next_check) const noexcept {
CHECK(is_ready);
return {is_triggered, next_check};
}
using is_ready_argument_tags = tmpl::list<IsReady>;
bool is_ready(const bool is_ready) const noexcept { return is_ready; }
};
/// \cond
template <typename Label>
PUP::able::PUP_ID BoxTrigger<Label>::my_PUP_ID = 0; // NOLINT
/// \endcond
} // namespace TestHelpers::DenseTriggers
| 25.737705 | 72 | 0.698408 | macedo22 |
0fa087c7c41a6a86d79991214d027c733eace0d4 | 2,265 | cpp | C++ | Codeforces/1606E/solution.cpp | caando/Competitive-Programming-Archive | 589781a23bda39aedf5fc437bf9b97c264fd3736 | [
"MIT"
] | 5 | 2021-09-09T09:16:29.000Z | 2022-01-08T11:28:12.000Z | Codeforces/1606E/solution.cpp | zjk2606/Competitive-Programming-Archive | 589781a23bda39aedf5fc437bf9b97c264fd3736 | [
"MIT"
] | 1 | 2021-09-09T09:16:26.000Z | 2021-09-11T04:00:36.000Z | Codeforces/1606E/solution.cpp | zjk2606/Competitive-Programming-Archive | 589781a23bda39aedf5fc437bf9b97c264fd3736 | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
#define fi first
#define se second
#define sz(c) ((int)(c).size())
#define all(c) (c).begin(), (c).end()
#define forn(i, m, n) for (int i = m, nnnn = (n); i < nnnn; ++i)
#define pb push_back
#define mp make_pair
#define NIL 0
#define INF INT_MAX
#define int128 __int128_t
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long double eps = 1e-9;
const long long mod = 998244353;
const int MAXN = 200000;
vector<ll> fact;
void calc_fact(ll n, ll P){
if (fact.size() < 1) fact.pb(1);
forn(i, fact.size(), n+1) fact.pb(fact[i-1] * i % P);
}
vector<ll> fact_inv;
void calc_fact_inv(ll n, ll P){
if (fact_inv.size() < 1) fact_inv.pb(1);
forn(i, fact_inv.size(), n+1) fact_inv.pb(fact_inv[i-1] * inv_mod(i, P) % P);
}
ll nCr(ll n, ll r, ll P){
if (r > n) return 0;
calc_fact(n, P);
calc_fact_inv(n, P);
return (fact[n] * fact_inv[r] % P) * fact_inv[n-r] % P;
}
void solve(){
ll n, x;
cin >> n >> x;
ll dp[n+1][x+1];
memset(dp, 0, sizeof dp);
ll p[501][501];
memset(p, 0, sizeof p);
forn(i, 1, 501){
p[i][0] = 1;
forn(j, 1, 501){
p[i][j] = p[i][j-1] * i % mod;
}
}
forn(i, 0, x+1) dp[0][i] = 1;
for(int i = 2; i <= n; i++){
for(int j = 1; j <= x; j++){
if (j < i) dp[i][j] = p[j][i];
else {
forn(k, 0, i+1){
dp[i][j] += p[i-1][k] * nCr(i, k, mod) % mod * dp[i-k][j+1-i] % mod;
dp[i][j] %= mod;
}
}
}
}
cout << dp[n][x] << '\n';
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(12) << fixed;
solve();
} | 24.354839 | 88 | 0.516556 | caando |
0fa556061ac91a3c234396d72c1de6621353a050 | 42,514 | cpp | C++ | plugins/src/natives/iter.cpp | AGraber/PawnPlus | 8f1a06fc6a88293ccbfca549742db636470d2e4b | [
"MIT"
] | 79 | 2018-03-07T22:49:20.000Z | 2022-03-31T04:55:30.000Z | plugins/src/natives/iter.cpp | AGraber/PawnPlus | 8f1a06fc6a88293ccbfca549742db636470d2e4b | [
"MIT"
] | 45 | 2018-07-13T20:57:40.000Z | 2022-02-01T17:55:34.000Z | plugins/src/natives/iter.cpp | AGraber/PawnPlus | 8f1a06fc6a88293ccbfca549742db636470d2e4b | [
"MIT"
] | 29 | 2018-03-23T08:22:02.000Z | 2022-02-13T22:59:50.000Z | #include "natives.h"
#include "errors.h"
#include "modules/containers.h"
#include "modules/variants.h"
#include "modules/strings.h"
#include "modules/expressions.h"
#include "modules/iterators.h"
#include "objects/dyn_object.h"
#include "fixes/linux.h"
#include <cstring>
template <class Func>
auto value_write(cell arg, Func f) -> typename std::result_of<Func(dyn_object&)>::type
{
dyn_iterator *iter;
if(iter_pool.get_by_id(arg, iter))
{
return value_write(iter, f);
}
amx_LogicError(errors::pointer_invalid, "iterator", arg);
dyn_object tmp;
return f(tmp);
}
template <class Func>
auto value_modify(cell arg, Func f) -> typename std::result_of<Func(dyn_object&)>::type
{
dyn_iterator *iter;
if(iter_pool.get_by_id(arg, iter))
{
return value_modify(iter, f);
}
amx_LogicError(errors::pointer_invalid, "iterator", arg);
dyn_object tmp;
return f(tmp);
}
template <class Func>
auto value_read(cell arg, Func f) -> typename std::result_of<Func(const dyn_object&)>::type
{
dyn_iterator *iter;
if(iter_pool.get_by_id(arg, iter))
{
return value_read(iter, f);
}
amx_LogicError(errors::pointer_invalid, "iterator", arg);
dyn_object tmp;
return f(tmp);
}
template <class Func>
auto key_read(cell arg, Func f) -> typename std::result_of<Func(const dyn_object&)>::type
{
dyn_iterator *iter;
if(iter_pool.get_by_id(arg, iter))
{
return key_read(iter, f);
}
amx_LogicError(errors::pointer_invalid, "iterator", arg);
dyn_object tmp;
return f(tmp);
}
template <class Func>
auto key_value_access(cell arg, dyn_iterator *&iter, Func f) -> typename std::result_of<Func(const dyn_object&)>::type
{
if(iter_pool.get_by_id(arg, iter))
{
return key_value_access(iter, f);
}
amx_LogicError(errors::pointer_invalid, "iterator", arg);
dyn_object tmp;
return f(tmp);
}
template <size_t... Indices>
class value_at
{
using value_ftype = typename dyn_factory<Indices...>::type;
using result_ftype = typename dyn_result<Indices...>::type;
public:
// native iter_set(IterTag:iter, ...);
template <value_ftype Factory>
static cell AMX_NATIVE_CALL iter_set(AMX *amx, cell *params)
{
return value_write(params[1], [&](dyn_object &obj)
{
obj = Factory(amx, params[Indices]...);
return 1;
});
}
// native iter_get(IterTag:iter, ...);
template <result_ftype Factory>
static cell AMX_NATIVE_CALL iter_get(AMX *amx, cell *params)
{
return value_read(params[1], [&](const dyn_object &obj)
{
return Factory(amx, obj, params[Indices]...);
});
}
// native Iter:iter_insert(IterTag:iter, ...);
template <value_ftype Factory>
static cell AMX_NATIVE_CALL iter_insert(AMX *amx, cell *params)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(!iter->insert(Factory(amx, params[Indices]...))) amx_LogicError(errors::operation_not_supported, "iterator");
return params[1];
}
// native iter_get_key(IterTag:iter, ...);
template <result_ftype Factory>
static cell AMX_NATIVE_CALL iter_get_key(AMX *amx, cell *params)
{
return key_read(params[1], [&](const dyn_object &obj)
{
return Factory(amx, obj, params[Indices]...);
});
}
// native Iter:iter_range(AnyTag:start, count, skip=1, ...);
template <value_ftype Factory>
static cell AMX_NATIVE_CALL iter_range(AMX *amx, cell *params)
{
if(params[2] < 0) amx_LogicError(errors::out_of_range, "count");
auto &iter = iter_pool.emplace_derived<range_iterator>(Factory(amx, params[Indices]...), params[2], optparam(3, 1));
iter->set_to_first();
return iter_pool.get_id(iter);
}
// native Iter:iter_repeat(AnyTag:value, count, ...);
template <value_ftype Factory>
static cell AMX_NATIVE_CALL iter_repeat(AMX *amx, cell *params)
{
if(params[2] < 0) amx_LogicError(errors::out_of_range, "count");
auto &iter = iter_pool.emplace_derived<repeat_iterator>(Factory(amx, params[Indices]...), params[2]);
iter->set_to_first();
return iter_pool.get_id(iter);
}
};
template <size_t... KeyIndices>
class key_at
{
using key_ftype = typename dyn_factory<KeyIndices...>::type;
public:
// native Iter:map_iter_at(Map:map, key, ...);
template <key_ftype KeyFactory>
static cell AMX_NATIVE_CALL map_iter_at(AMX *amx, cell *params)
{
std::shared_ptr<map_t> ptr;
if(!map_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "map", params[1]);
auto &iter = iter_pool.add(std::make_unique<map_iterator_t>(ptr, ptr->find(KeyFactory(amx, params[KeyIndices]...))));
return iter_pool.get_id(iter);
}
};
// native bool:iter_set_cell(IterTag:iter, offset, AnyTag:value, ...);
template <size_t TagIndex = 0>
static cell AMX_NATIVE_CALL iter_set_cell(AMX *amx, cell *params)
{
if(params[2] < 0) amx_LogicError(errors::out_of_range, "array offset");
return value_modify(params[1], [&](dyn_object &obj)
{
if(TagIndex && !obj.tag_assignable(amx, params[TagIndex])) return 0;
obj.set_cell(params[2], params[3]);
return 1;
});
}
// native iter_set_cells(IterTag:iter, offset, AnyTag:values[], size=sizeof(values), ...);
template <size_t TagIndex = 0>
static cell AMX_NATIVE_CALL iter_set_cells(AMX *amx, cell *params)
{
if(params[2] < 0) amx_LogicError(errors::out_of_range, "array offset");
return value_modify(params[1], [&](dyn_object &obj)
{
if(TagIndex && !obj.tag_assignable(amx, params[TagIndex])) return 0;
cell *addr = amx_GetAddrSafe(amx, params[3]);
return obj.set_cells(params[2], addr, params[4]);
});
}
// native bool:iter_set_cell_md(IterTag:iter, const offsets[], AnyTag:value, offsets_size=sizeof(offsets), ...);
template <size_t TagIndex = 0>
static cell AMX_NATIVE_CALL iter_set_cell_md(AMX *amx, cell *params)
{
return value_modify(params[1], [&](dyn_object &obj)
{
if(TagIndex && !obj.tag_assignable(amx, params[TagIndex])) return 0;
cell offsets_size = params[4];
cell *offsets_addr = get_offsets(amx, params[2], offsets_size);
obj.set_cell(offsets_addr, offsets_size, params[3]);
return 1;
});
}
// native iter_set_cells_md(IterTag:iter, const offsets[], AnyTag:values[], offsets_size=sizeof(offsets), size=sizeof(values), ...);
template <size_t TagIndex = 0>
static cell AMX_NATIVE_CALL iter_set_cells_md(AMX *amx, cell *params)
{
return value_modify(params[1], [&](dyn_object &obj)
{
if(TagIndex && !obj.tag_assignable(amx, params[TagIndex])) return 0;
cell offsets_size = params[4];
cell *offsets_addr = get_offsets(amx, params[2], offsets_size);
cell *addr = amx_GetAddrSafe(amx, params[3]);
return obj.set_cells(offsets_addr, offsets_size, addr, params[5]);
});
}
namespace Natives
{
// native Iter:list_iter(List:list, index=0);
AMX_DEFINE_NATIVE_TAG(list_iter, 1, iter)
{
std::shared_ptr<list_t> ptr;
if(!list_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "list", params[1]);
auto &iter = iter_pool.emplace_derived<list_iterator_t>(ptr);
cell index = optparam(2, 0);
if(index < 0)
{
iter->reset();
}else{
for(cell i = 0; i < index; i++)
{
if(!iter->move_next())
{
break;
}
}
}
return iter_pool.get_id(iter);
}
// native list_add_iter(List:list, Iter:iter, index=-1);
AMX_DEFINE_NATIVE_TAG(list_add_iter, 2, cell)
{
cell index = optparam(3, -1);
if(index < -1) amx_LogicError(errors::out_of_range, "list index");
list_t *ptr;
if(!list_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "list", params[1]);
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[2], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[2]);
auto pos = ptr->end();
if(index == -1)
{
index = ptr->size();
}else if(static_cast<ucell>(index) > ptr->size())
{
amx_LogicError(errors::out_of_range, "list index");
}else if(index != ptr->size())
{
pos = ptr->begin() + index;
}
while(iter->valid())
{
value_read(iter, [&](const dyn_object &obj)
{
pos = ptr->insert(pos, obj);
++pos;
});
if(!iter->move_next())
{
break;
}
}
return index;
}
// native Iter:map_iter(Map:map, index=0);
AMX_DEFINE_NATIVE_TAG(map_iter, 1, iter)
{
std::shared_ptr<map_t> ptr;
if(!map_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "map", params[1]);
auto &iter = iter_pool.emplace_derived<map_iterator_t>(ptr);
cell index = optparam(2, 0);
if(index < 0)
{
iter->reset();
}else{
for(cell i = 0; i < index; i++)
{
if(!iter->move_next())
{
break;
}
}
}
return iter_pool.get_id(iter);
}
// native Iter:map_iter_at(Map:map, AnyTag:key, TagTag:key_tag_id=tagof(key));
AMX_DEFINE_NATIVE_TAG(map_iter_at, 3, iter)
{
return key_at<2, 3>::map_iter_at<dyn_func>(amx, params);
}
// native Iter:map_iter_at_arr(Map:map, const AnyTag:key[], key_size=sizeof(key), TagTag:key_tag_id=tagof(key));
AMX_DEFINE_NATIVE_TAG(map_iter_at_arr, 4, iter)
{
return key_at<2, 3, 4>::map_iter_at<dyn_func_arr>(amx, params);
}
// native Iter:map_iter_at_str(Map:map, const key[]);
AMX_DEFINE_NATIVE_TAG(map_iter_at_str, 2, iter)
{
return key_at<2>::map_iter_at<dyn_func_str>(amx, params);
}
// native Iter:map_iter_at_str_s(Map:map, ConstStringTag:key);
AMX_DEFINE_NATIVE_TAG(map_iter_at_str_s, 2, iter)
{
return key_at<2>::map_iter_at<dyn_func_str_s>(amx, params);
}
// native Iter:map_iter_at_var(Map:map, ConstVariantTag:key);
AMX_DEFINE_NATIVE_TAG(map_iter_at_var, 2, iter)
{
return key_at<2>::map_iter_at<dyn_func_var>(amx, params);
}
// native Iter:linked_list_iter(LinkedList:linked_list, index=0);
AMX_DEFINE_NATIVE_TAG(linked_list_iter, 1, iter)
{
std::shared_ptr<linked_list_t> ptr;
if(!linked_list_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "linked list", params[1]);
auto &iter = iter_pool.emplace_derived<linked_list_iterator_t>(ptr);
cell index = optparam(2, 0);
if(index < 0)
{
iter->reset();
}else{
for(cell i = 0; i < index; i++)
{
if(!iter->move_next())
{
break;
}
}
}
return iter_pool.get_id(iter);
}
// native linked_list_add_iter(LinkedList:linked_list, Iter:iter, index=-1);
AMX_DEFINE_NATIVE_TAG(linked_list_add_iter, 2, cell)
{
cell index = optparam(3, -1);
if(index < -1) amx_LogicError(errors::out_of_range, "linked list index");
linked_list_t *ptr;
if(!linked_list_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "linked list", params[1]);
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[2], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[2]);
auto pos = ptr->end();
if(index == -1)
{
index = ptr->size();
}else if(static_cast<ucell>(index) > ptr->size())
{
amx_LogicError(errors::out_of_range, "linked list index");
}else if(index != ptr->size())
{
pos = ptr->begin();
std::advance(pos, index);
}
while(iter->valid())
{
value_read(iter, [&](const dyn_object &obj)
{
pos = ptr->insert(pos, obj);
++pos;
});
if(!iter->move_next())
{
break;
}
}
return index;
}
// native Iter:var_iter(VariantTag:var, count=1);
AMX_DEFINE_NATIVE_TAG(var_iter, 1, iter)
{
cell count = optparam(2, 1);
if(count < 0) amx_LogicError(errors::out_of_range, "count");
std::shared_ptr<dyn_object> ptr;
if(!variants::pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "variant", params[1]);
auto &iter = iter_pool.emplace_derived<variant_iterator>(ptr, count);
iter->set_to_first();
return iter_pool.get_id(iter);
}
// native Iter:handle_iter(HandleTag:handle, count=1);
AMX_DEFINE_NATIVE_TAG(handle_iter, 1, iter)
{
cell count = optparam(2, 1);
if(count < 0) amx_LogicError(errors::out_of_range, "count");
std::shared_ptr<handle_t> handle;
if(!handle_pool.get_by_id(params[1], handle)) amx_LogicError(errors::pointer_invalid, "handle", params[1]);
auto &iter = iter_pool.emplace_derived<handle_iterator>(handle, count);
iter->set_to_first();
return iter_pool.get_id(iter);
}
// native Iter:pool_iter(Pool:pool, index=0);
AMX_DEFINE_NATIVE_TAG(pool_iter, 1, iter)
{
std::shared_ptr<pool_t> ptr;
if(!pool_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "pool", params[1]);
auto &iter = iter_pool.emplace_derived<pool_iterator_t>(ptr);
cell index = optparam(2, 0);
if(index < 0)
{
iter->reset();
}else{
for(cell i = 0; i < index; i++)
{
if(!iter->move_next())
{
break;
}
}
}
return iter_pool.get_id(iter);
}
// native Iter:pool_iter_at(Pool:pool, index);
AMX_DEFINE_NATIVE_TAG(pool_iter_at, 2, iter)
{
cell index = params[2];
if(index < 0) amx_LogicError(errors::out_of_range, "pool index");
std::shared_ptr<pool_t> ptr;
if(!pool_pool.get_by_id(params[1], ptr)) amx_LogicError(errors::pointer_invalid, "pool", params[1]);
auto &iter = iter_pool.emplace_derived<pool_iterator_t>(ptr, ptr->find(index));
return iter_pool.get_id(iter);
}
// native bool:iter_valid(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_valid, 1, bool)
{
dyn_iterator *iter;
return iter_pool.get_by_id(params[1], iter);
}
// native Iter:iter_acquire(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_acquire, 1, iter)
{
decltype(iter_pool)::ref_container *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(!iter_pool.acquire_ref(*iter)) amx_LogicError(errors::cannot_acquire, "iterator", params[1]);
return params[1];
}
// native Iter:iter_release(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_release, 1, iter)
{
decltype(iter_pool)::ref_container *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(!iter_pool.release_ref(*iter)) amx_LogicError(errors::cannot_release, "iterator", params[1]);
return params[1];
}
// native iter_delete(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_delete, 1, cell)
{
if(!iter_pool.remove_by_id(params[1])) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
return 1;
}
// native bool:iter_linked(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_linked, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter == nullptr)
{
return false;
}
return !iter->expired();
}
// native bool:iter_inside(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_inside, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter == nullptr)
{
return false;
}
return iter->valid();
}
// native bool:iter_empty(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_empty, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter == nullptr)
{
return true;
}
return iter->empty();
}
// native iter_type(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_type, 1, cell)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter == nullptr)
{
return 0;
}
return reinterpret_cast<cell>(&typeid(*iter));
}
// native iter_type_str(IterTag:iter, type[], size=sizeof(type));
AMX_DEFINE_NATIVE_TAG(iter_type_str, 3, cell)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
cell *addr = amx_GetAddrSafe(amx, params[2]);
if(iter == nullptr)
{
return 0;
}
auto str = typeid(*iter).name();
amx_SetString(addr, str, false, false, params[3]);
return std::strlen(str);
}
// native String:iter_type_str_s(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_type_str_s, 1, string)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter == nullptr)
{
return strings::pool.get_id(strings::pool.add());
}
return strings::create(typeid(*iter).name());
}
// native Iter:iter_erase(IterTag:iter, bool:stay=false);
AMX_DEFINE_NATIVE_TAG(iter_erase, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(!iter->erase(optparam(2, 0))) amx_LogicError(errors::operation_not_supported, "iterator", params[1]);
return params[1];
}
// native Iter:iter_erase_deep(IterTag:iter, bool:stay=false);
AMX_DEFINE_NATIVE_TAG(iter_erase_deep, 1, iter)
{
dyn_iterator *iter;
key_value_access(params[1], iter, [&](const dyn_object &obj)
{
obj.release();
});
if(!iter->erase(optparam(2, 0))) amx_LogicError(errors::operation_not_supported, "iterator", params[1]);
return params[1];
}
// native Iter:iter_reset(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_reset, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter)
{
if(!iter->reset()) amx_LogicError(errors::operation_not_supported, "iterator", params[1]);
}
return params[1];
}
// native bool:iter_can_reset(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_can_reset, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter)
{
return iter->can_insert();
}
return true;
}
// native bool:iter_can_insert(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_can_insert, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter)
{
return iter->can_insert();
}
return false;
}
// native bool:iter_can_erase(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_can_erase, 1, bool)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter) && iter != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
if(iter)
{
return iter->can_erase();
}
return false;
}
// native Iter:iter_clone(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_clone, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
return iter_pool.get_id(iter_pool.add(std::dynamic_pointer_cast<object_pool<dyn_iterator>::ref_container>(iter->clone_shared())));
}
// native iter_swap(IterTag:iter1, IterTag:iter2);
AMX_DEFINE_NATIVE_TAG(iter_swap, 2, cell)
{
return value_write(params[1], [&](dyn_object &obj1)
{
return value_write(params[2], [&](dyn_object &obj2)
{
std::swap(obj1, obj2);
return 1;
});
});
}
// native bool:iter_eq(IterTag:iter1, IterTag:iter2);
AMX_DEFINE_NATIVE_TAG(iter_eq, 2, bool)
{
dyn_iterator *iter1;
if(!iter_pool.get_by_id(params[1], iter1) && iter1 != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
dyn_iterator *iter2;
if(!iter_pool.get_by_id(params[2], iter2) && iter2 != nullptr) amx_LogicError(errors::pointer_invalid, "iterator", params[2]);
if(iter1 == nullptr)
{
return iter2 == nullptr;
}else if(iter2 == nullptr)
{
return false;
}
return *iter1 == *iter2;
}
// native Iter:iter_range(AnyTag:start, count, skip=1, TagTag:tag_id=tagof(start));
AMX_DEFINE_NATIVE_TAG(iter_range, 4, iter)
{
return value_at<1, 4>::iter_range<dyn_func>(amx, params);
}
// native Iter:iter_range_arr(const AnyTag:start[], count, skip=1, size=sizeof(start), TagTag:tag_id=tagof(start));
AMX_DEFINE_NATIVE_TAG(iter_range_arr, 5, iter)
{
return value_at<1, 4, 5>::iter_range<dyn_func_arr>(amx, params);
}
// native Iter:iter_range_str(const start[], count, skip=1);
AMX_DEFINE_NATIVE_TAG(iter_range_str, 3, iter)
{
return value_at<1>::iter_range<dyn_func_str>(amx, params);
}
// native Iter:iter_range_str_s(ConstStringTag:start, count, skip=1);
AMX_DEFINE_NATIVE_TAG(iter_range_str_s, 3, iter)
{
return value_at<1>::iter_range<dyn_func_str_s>(amx, params);
}
// native Iter:iter_range_var(ConstVariantTag:start, count, skip=1);
AMX_DEFINE_NATIVE_TAG(iter_range_var, 3, iter)
{
return value_at<1>::iter_range<dyn_func_var>(amx, params);
}
// native Iter:iter_repeat(AnyTag:value, count, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_repeat, 3, iter)
{
return value_at<1, 3>::iter_repeat<dyn_func>(amx, params);
}
// native Iter:iter_repeat_arr(const AnyTag:value[], count, size=sizeof(value), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_repeat_arr, 4, iter)
{
return value_at<1, 3, 4>::iter_repeat<dyn_func_arr>(amx, params);
}
// native Iter:iter_repeat_str(const value[], count);
AMX_DEFINE_NATIVE_TAG(iter_repeat_str, 2, iter)
{
return value_at<1>::iter_repeat<dyn_func_str>(amx, params);
}
// native Iter:iter_repeat_str_s(ConstStringTag:value, count);
AMX_DEFINE_NATIVE_TAG(iter_repeat_str_s, 2, iter)
{
return value_at<1>::iter_repeat<dyn_func_str_s>(amx, params);
}
// native Iter:iter_repeat_var(ConstVariantTag:value, count);
AMX_DEFINE_NATIVE_TAG(iter_repeat_var, 2, iter)
{
return value_at<1>::iter_repeat<dyn_func_var>(amx, params);
}
// native Iter:iter_filter(IterTag:iter, Expression:expr);
AMX_DEFINE_NATIVE_TAG(iter_filter, 2, iter)
{
std::shared_ptr<dyn_iterator> iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
expression_ptr expr;
if(!expression_pool.get_by_id(params[2], expr)) amx_LogicError(errors::pointer_invalid, "expression", params[2]);
return iter_pool.get_id(iter_pool.emplace_derived<filter_iterator>(std::move(iter), std::move(expr)));
}
// native Iter:iter_project(IterTag:iter, Expression:expr);
AMX_DEFINE_NATIVE_TAG(iter_project, 2, iter)
{
std::shared_ptr<dyn_iterator> iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
expression_ptr expr;
if(!expression_pool.get_by_id(params[2], expr)) amx_LogicError(errors::pointer_invalid, "expression", params[2]);
return iter_pool.get_id(iter_pool.emplace_derived<project_iterator>(std::move(iter), std::move(expr)));
}
// native Iter:iter_move_next(IterTag:iter, steps=1);
AMX_DEFINE_NATIVE_TAG(iter_move_next, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
bool success = true;
cell steps = optparam(2, 1);
if(steps < 0)
{
for(cell i = steps; i < 0; i++)
{
if(!iter->move_previous())
{
success = false;
break;
}
}
}else{
for(cell i = 0; i < steps; i++)
{
if(!iter->move_next())
{
success = false;
break;
}
}
}
return success ? params[1] : 0;
}
// native Iter:iter_move_previous(IterTag:iter, steps=1);
AMX_DEFINE_NATIVE_TAG(iter_move_previous, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
bool success = true;
cell steps = optparam(2, 1);
if(steps < 0)
{
for(cell i = steps; i < 0; i++)
{
if(!iter->move_next())
{
success = false;
break;
}
}
}else{
for(cell i = 0; i < steps; i++)
{
if(!iter->move_previous())
{
success = false;
break;
}
}
}
return success ? params[1] : 0;
}
// native Iter:iter_to_first(IterTag:iter, index=0);
AMX_DEFINE_NATIVE_TAG(iter_to_first, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
cell index = optparam(2, 0);
if(index < 0)
{
amx_LogicError(errors::out_of_range, "index");
}
bool success = iter->set_to_first();
if(success)
{
for(cell i = 0; i < index; i++)
{
if(!iter->move_next())
{
success = false;
break;
}
}
}
return success ? params[1] : 0;
}
// native Iter:iter_to_last(IterTag:iter, index=0);
AMX_DEFINE_NATIVE_TAG(iter_to_last, 1, iter)
{
dyn_iterator *iter;
if(!iter_pool.get_by_id(params[1], iter)) amx_LogicError(errors::pointer_invalid, "iterator", params[1]);
cell index = optparam(2, 0);
if(index < 0)
{
amx_LogicError(errors::out_of_range, "index");
}
bool success = iter->set_to_last();
if(success)
{
for(cell i = 0; i < index; i++)
{
if(!iter->move_previous())
{
success = false;
break;
}
}
}
return success ? params[1] : 0;
}
// native iter_get(IterTag:iter, offset=0);
AMX_DEFINE_NATIVE(iter_get, 2)
{
return value_at<2>::iter_get<dyn_func>(amx, params);
}
// native iter_get_arr(IterTag:iter, AnyTag:value[], size=sizeof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_arr, 3, cell)
{
return value_at<2, 3>::iter_get<dyn_func_arr>(amx, params);
}
// native String:iter_get_str_s(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_get_str_s, 1, string)
{
return value_at<>::iter_get<dyn_func_str_s>(amx, params);
}
// native Variant:iter_get_var(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_get_var, 1, variant)
{
return value_at<>::iter_get<dyn_func_var>(amx, params);
}
// native bool:iter_get_safe(IterTag:iter, &AnyTag:value, offset=0, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_safe, 4, bool)
{
return value_at<2, 3, 4>::iter_get<dyn_func>(amx, params);
}
// native iter_get_arr_safe(IterTag:iter, AnyTag:value[], size=sizeof(value), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_arr_safe, 4, cell)
{
return value_at<2, 3, 4>::iter_get<dyn_func_arr>(amx, params);
}
// native iter_get_str_safe(IterTag:iter, value[], size=sizeof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_str_safe, 3, cell)
{
return value_at<2, 3>::iter_get<dyn_func_str>(amx, params);
}
// native String:iter_get_str_safe_s(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_get_str_safe_s, 1, string)
{
return value_at<0>::iter_get<dyn_func_str_s>(amx, params);
}
// native iter_set(IterTag:iter, AnyTag:value, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set, 3, cell)
{
return value_at<2, 3>::iter_set<dyn_func>(amx, params);
}
// native iter_set_arr(IterTag:iter, const AnyTag:value[], size=sizeof(value), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set_arr, 4, cell)
{
return value_at<2, 3, 4>::iter_set<dyn_func_arr>(amx, params);
}
// native iter_set_arr_2d(IterTag:iter, const AnyTag:value[][], size=sizeof(value), size2=sizeof(value[]), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set_arr_2d, 5, cell)
{
return value_at<2, 3, 4, 5>::iter_set<dyn_func_arr>(amx, params);
}
// native iter_set_arr_3d(IterTag:iter, const AnyTag:value[][][], size=sizeof(value), size2=sizeof(value[]), size3=sizeof(value[][]), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set_arr_3d, 6, cell)
{
return value_at<2, 3, 4, 5, 6>::iter_set<dyn_func_arr>(amx, params);
}
// native iter_set_str(IterTag:iter, const value[]);
AMX_DEFINE_NATIVE_TAG(iter_set_str, 2, cell)
{
return value_at<2>::iter_set<dyn_func_str>(amx, params);
}
// native iter_set_str_s(IterTag:iter, ConstStringTag:value);
AMX_DEFINE_NATIVE_TAG(iter_set_str_s, 2, cell)
{
return value_at<2>::iter_set<dyn_func_str_s>(amx, params);
}
// native iter_set_var(IterTag:iter, VariantTag:value);
AMX_DEFINE_NATIVE_TAG(iter_set_var, 2, cell)
{
return value_at<2>::iter_set<dyn_func_var>(amx, params);
}
// native iter_set_cell(IterTag:iter, offset, AnyTag:value);
AMX_DEFINE_NATIVE_TAG(iter_set_cell, 3, cell)
{
return ::iter_set_cell(amx, params);
}
// native bool:iter_set_cell_safe(IterTag:iter, offset, AnyTag:value, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set_cell_safe, 4, bool)
{
return ::iter_set_cell<4>(amx, params);
}
// native iter_set_cells(IterTag:iter, offset, AnyTag:values[], size=sizeof(values));
AMX_DEFINE_NATIVE_TAG(iter_set_cells, 4, cell)
{
return ::iter_set_cells(amx, params);
}
// native iter_set_cells_safe(IterTag:iter, offset, AnyTag:values[], size=sizeof(values), TagTag:tag_id=tagof(values));
AMX_DEFINE_NATIVE_TAG(iter_set_cells_safe, 5, cell)
{
return ::iter_set_cells<5>(amx, params);
}
// native iter_get_md(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE(iter_get_md, 3)
{
return value_at<2, 3>::iter_get<dyn_func>(amx, params);
}
// native iter_get_md_arr(IterTag:iter, const offsets[], AnyTag:value[], size=sizeof(value), offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_md_arr, 5, cell)
{
return value_at<3, 2, 4, 5>::iter_get<dyn_func_arr>(amx, params);
}
// native String:iter_get_md_str_s(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_md_str_s, 3, string)
{
return value_at<2, 3>::iter_get<dyn_func_str_s>(amx, params);
}
// native bool:iter_get_md_safe(IterTag:iter, const offsets[], &AnyTag:value, offsets_size=sizeof(offsets), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_md_safe, 5, bool)
{
return value_at<3, 2, 4, 5>::iter_get<dyn_func>(amx, params);
}
// native iter_get_md_arr_safe(IterTag:iter, const offsets[], AnyTag:value[], size=sizeof(value), offsets_size=sizeof(offsets), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_md_arr_safe, 6, cell)
{
return value_at<3, 2, 4, 5, 6>::iter_get<dyn_func_arr>(amx, params);
}
// native iter_get_md_str_safe(IterTag:iter, const offsets[], value[], size=sizeof(value), offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_md_str_safe, 5, cell)
{
return value_at<3, 2, 4, 5>::iter_get<dyn_func_str>(amx, params);
}
// native String:iter_get_md_str_safe_s(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_md_str_safe_s, 3, string)
{
return value_at<2, 3, 0>::iter_get<dyn_func_str_s>(amx, params);
}
// native iter_set_cell_md(IterTag:iter, const offsets[], AnyTag:value, offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_set_cell_md, 4, cell)
{
return ::iter_set_cell_md(amx, params);
}
// native bool:iter_set_cell_md_safe(IterTag:iter, const offsets[], AnyTag:value, offsets_size=sizeof(offsets), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_set_cell_md_safe, 5, bool)
{
return ::iter_set_cell_md<5>(amx, params);
}
// native iter_set_cells_md(IterTag:iter, const offsets[], AnyTag:values[], offsets_size=sizeof(offsets), size=sizeof(values));
AMX_DEFINE_NATIVE_TAG(iter_set_cells_md, 5, cell)
{
return ::iter_set_cells_md(amx, params);
}
// native iter_set_cells_md_safe(IterTag:iter, const offsets[], AnyTag:values[], offsets_size=sizeof(offsets), size=sizeof(values), TagTag:tag_id=tagof(values));
AMX_DEFINE_NATIVE_TAG(iter_set_cells_md_safe, 6, cell)
{
return ::iter_set_cells_md<6>(amx, params);
}
// native Iter:iter_insert(IterTag:iter, AnyTag:value, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_insert, 3, iter)
{
return value_at<2, 3>::iter_insert<dyn_func>(amx, params);
}
// native Iter:iter_insert_arr(IterTag:iter, const AnyTag:value[], size=sizeof(value), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_insert_arr, 4, iter)
{
return value_at<2, 3, 4>::iter_insert<dyn_func_arr>(amx, params);
}
// native Iter:iter_insert_arr_2d(IterTag:iter, const AnyTag:value[][], size=sizeof(value), size2=sizeof(value[]), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_insert_arr_2d, 5, iter)
{
return value_at<2, 3, 4, 5>::iter_insert<dyn_func_arr>(amx, params);
}
// native Iter:iter_insert_arr_3d(IterTag:iter, const AnyTag:value[][][], size=sizeof(value), size2=sizeof(value[]), size3=sizeof(value[][]), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_insert_arr_3d, 6, iter)
{
return value_at<2, 3, 4, 5, 6>::iter_insert<dyn_func_arr>(amx, params);
}
// native Iter:iter_insert_str(IterTag:iter, const value[]);
AMX_DEFINE_NATIVE_TAG(iter_insert_str, 2, iter)
{
return value_at<2>::iter_insert<dyn_func_str>(amx, params);
}
// native Iter:iter_insert_str_s(IterTag:iter, ConstStringTag:value);
AMX_DEFINE_NATIVE_TAG(iter_insert_str_s, 2, iter)
{
return value_at<2>::iter_insert<dyn_func_str_s>(amx, params);
}
// native Iter:iter_insert_var(IterTag:iter, VariantTag:value);
AMX_DEFINE_NATIVE_TAG(iter_insert_var, 2, iter)
{
return value_at<2>::iter_insert<dyn_func_var>(amx, params);
}
// native iter_get_key(IterTag:iter, offset=0);
AMX_DEFINE_NATIVE(iter_get_key, 2)
{
return value_at<2>::iter_get_key<dyn_func>(amx, params);
}
// native iter_get_key_arr(IterTag:iter, AnyTag:value[], size=sizeof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_arr, 3, cell)
{
return value_at<2, 3>::iter_get_key<dyn_func_arr>(amx, params);
}
// native String:iter_get_key_str_s(IterTag:iter));
AMX_DEFINE_NATIVE_TAG(iter_get_key_str_s, 1, string)
{
return value_at<>::iter_get_key<dyn_func_str_s>(amx, params);
}
// native Variant:iter_get_key_var(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_get_key_var, 1, variant)
{
return value_at<>::iter_get_key<dyn_func_var>(amx, params);
}
// native bool:iter_get_key_safe(IterTag:iter, &AnyTag:value, offset=0, TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_safe, 4, bool)
{
return value_at<2, 3, 4>::iter_get_key<dyn_func>(amx, params);
}
// native iter_get_key_arr_safe(IterTag:iter, AnyTag:value[], size=sizeof(value), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_arr_safe, 4, cell)
{
return value_at<2, 3, 4>::iter_get_key<dyn_func_arr>(amx, params);
}
// native iter_get_key_str_safe(IterTag:iter, value[], size=sizeof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_str_safe, 3, cell)
{
return value_at<2, 3>::iter_get_key<dyn_func_str>(amx, params);
}
// native String:iter_get_key_str_safe_s(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_get_key_str_safe_s, 1, string)
{
return value_at<0>::iter_get_key<dyn_func_str_s>(amx, params);
}
// native iter_get_key_md(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE(iter_get_key_md, 3)
{
return value_at<2, 3>::iter_get_key<dyn_func>(amx, params);
}
// native iter_get_key_md_arr(IterTag:iter, const offsets[], AnyTag:value[], size=sizeof(value), offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_arr, 5, cell)
{
return value_at<3, 2, 4, 5>::iter_get_key<dyn_func_arr>(amx, params);
}
// native String:iter_get_key_md_str_s(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_str_s, 3, string)
{
return value_at<2, 3>::iter_get_key<dyn_func_str_s>(amx, params);
}
// native bool:iter_get_key_md_safe(IterTag:iter, const offsets[], &AnyTag:value, offsets_size=sizeof(offsets), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_safe, 5, bool)
{
return value_at<3, 2, 4, 5>::iter_get_key<dyn_func>(amx, params);
}
// native iter_get_key_md_arr_safe(IterTag:iter, const offsets[], AnyTag:value[], size=sizeof(value), offsets_size=sizeof(offsets), TagTag:tag_id=tagof(value));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_arr_safe, 6, cell)
{
return value_at<3, 2, 4, 5, 6>::iter_get_key<dyn_func_arr>(amx, params);
}
// native iter_get_key_md_str_safe(IterTag:iter, const offsets[], value[], size=sizeof(value), offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_str_safe, 5, cell)
{
return value_at<3, 2, 4, 5>::iter_get_key<dyn_func_str>(amx, params);
}
// native String:iter_get_key_md_str_safe_s(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_get_key_md_str_safe_s, 3, string)
{
return value_at<2, 3, 0>::iter_get_key<dyn_func_str_s>(amx, params);
}
// native iter_tagof(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_tagof, 1, cell)
{
return value_read(params[1], [&](const dyn_object &obj)
{
return obj.get_tag(amx);
});
}
// native tag_uid:iter_tag_uid(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_tag_uid, 1, cell)
{
return value_read(params[1], [&](const dyn_object &obj)
{
return obj.get_tag()->uid;
});
}
// native iter_sizeof(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_sizeof, 1, cell)
{
return value_read(params[1], [&](const dyn_object &obj)
{
return obj.get_size();
});
}
// native iter_sizeof_md(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_sizeof_md, 3, cell)
{
return value_read(params[1], [&](const dyn_object &obj)
{
cell offsets_size = params[3];
cell *offsets_addr = get_offsets(amx, params[2], offsets_size);
return obj.get_size(offsets_addr, offsets_size);
});
}
// native iter_rank(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_rank, 1, cell)
{
return value_read(params[1], [&](const dyn_object &obj)
{
return obj.get_rank();
});
}
// native iter_tagof_key(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_tagof_key, 1, cell)
{
return key_read(params[1], [&](const dyn_object &obj)
{
return obj.get_tag(amx);
});
}
// native tag_uid:iter_key_tag_uid(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_key_tag_uid, 1, cell)
{
return key_read(params[1], [&](const dyn_object &obj)
{
return obj.get_tag()->uid;
});
}
// native iter_sizeof_key(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_sizeof_key, 1, cell)
{
return key_read(params[1], [&](const dyn_object &obj)
{
return obj.get_size();
});
}
// native iter_sizeof_key_md(IterTag:iter, const offsets[], offsets_size=sizeof(offsets));
AMX_DEFINE_NATIVE_TAG(iter_sizeof_key_md, 3, cell)
{
return key_read(params[1], [&](const dyn_object &obj)
{
cell offsets_size = params[3];
cell *offsets_addr = get_offsets(amx, params[2], offsets_size);
return obj.get_size(offsets_addr, offsets_size);
});
}
// native iter_key_rank(IterTag:iter);
AMX_DEFINE_NATIVE_TAG(iter_key_rank, 1, cell)
{
return key_read(params[1], [&](const dyn_object &obj)
{
return obj.get_rank();
});
}
}
static AMX_NATIVE_INFO native_list[] =
{
AMX_DECLARE_NATIVE(list_iter),
AMX_DECLARE_NATIVE(list_add_iter),
AMX_DECLARE_NATIVE(linked_list_add_iter),
AMX_DECLARE_NATIVE(map_iter),
AMX_DECLARE_NATIVE(map_iter_at),
AMX_DECLARE_NATIVE(map_iter_at_arr),
AMX_DECLARE_NATIVE(map_iter_at_str),
AMX_DECLARE_NATIVE(map_iter_at_str_s),
AMX_DECLARE_NATIVE(map_iter_at_var),
AMX_DECLARE_NATIVE(linked_list_iter),
AMX_DECLARE_NATIVE(var_iter),
AMX_DECLARE_NATIVE(handle_iter),
AMX_DECLARE_NATIVE(pool_iter),
AMX_DECLARE_NATIVE(pool_iter_at),
AMX_DECLARE_NATIVE(iter_valid),
AMX_DECLARE_NATIVE(iter_acquire),
AMX_DECLARE_NATIVE(iter_release),
AMX_DECLARE_NATIVE(iter_delete),
AMX_DECLARE_NATIVE(iter_linked),
AMX_DECLARE_NATIVE(iter_inside),
AMX_DECLARE_NATIVE(iter_empty),
AMX_DECLARE_NATIVE(iter_type),
AMX_DECLARE_NATIVE(iter_type_str),
AMX_DECLARE_NATIVE(iter_type_str_s),
AMX_DECLARE_NATIVE(iter_erase),
AMX_DECLARE_NATIVE(iter_erase_deep),
AMX_DECLARE_NATIVE(iter_reset),
AMX_DECLARE_NATIVE(iter_can_reset),
AMX_DECLARE_NATIVE(iter_can_insert),
AMX_DECLARE_NATIVE(iter_can_erase),
AMX_DECLARE_NATIVE(iter_clone),
AMX_DECLARE_NATIVE(iter_swap),
AMX_DECLARE_NATIVE(iter_eq),
AMX_DECLARE_NATIVE(iter_range),
AMX_DECLARE_NATIVE(iter_range_arr),
AMX_DECLARE_NATIVE(iter_range_str),
AMX_DECLARE_NATIVE(iter_range_str_s),
AMX_DECLARE_NATIVE(iter_range_var),
AMX_DECLARE_NATIVE(iter_repeat),
AMX_DECLARE_NATIVE(iter_repeat_arr),
AMX_DECLARE_NATIVE(iter_repeat_str),
AMX_DECLARE_NATIVE(iter_repeat_str_s),
AMX_DECLARE_NATIVE(iter_repeat_var),
AMX_DECLARE_NATIVE(iter_filter),
AMX_DECLARE_NATIVE(iter_project),
AMX_DECLARE_NATIVE(iter_move_next),
AMX_DECLARE_NATIVE(iter_move_previous),
AMX_DECLARE_NATIVE(iter_to_first),
AMX_DECLARE_NATIVE(iter_to_last),
AMX_DECLARE_NATIVE(iter_get),
AMX_DECLARE_NATIVE(iter_get_arr),
AMX_DECLARE_NATIVE(iter_get_str_s),
AMX_DECLARE_NATIVE(iter_get_var),
AMX_DECLARE_NATIVE(iter_get_safe),
AMX_DECLARE_NATIVE(iter_get_arr_safe),
AMX_DECLARE_NATIVE(iter_get_str_safe),
AMX_DECLARE_NATIVE(iter_get_str_safe_s),
AMX_DECLARE_NATIVE(iter_set),
AMX_DECLARE_NATIVE(iter_set_arr),
AMX_DECLARE_NATIVE(iter_set_arr_2d),
AMX_DECLARE_NATIVE(iter_set_arr_3d),
AMX_DECLARE_NATIVE(iter_set_str),
AMX_DECLARE_NATIVE(iter_set_str_s),
AMX_DECLARE_NATIVE(iter_set_var),
AMX_DECLARE_NATIVE(iter_set_cell),
AMX_DECLARE_NATIVE(iter_set_cell_safe),
AMX_DECLARE_NATIVE(iter_set_cells),
AMX_DECLARE_NATIVE(iter_set_cells_safe),
AMX_DECLARE_NATIVE(iter_get_md),
AMX_DECLARE_NATIVE(iter_get_md_arr),
AMX_DECLARE_NATIVE(iter_get_md_str_s),
AMX_DECLARE_NATIVE(iter_get_md_safe),
AMX_DECLARE_NATIVE(iter_get_md_arr_safe),
AMX_DECLARE_NATIVE(iter_get_md_str_safe),
AMX_DECLARE_NATIVE(iter_get_md_str_safe_s),
AMX_DECLARE_NATIVE(iter_set_cell_md),
AMX_DECLARE_NATIVE(iter_set_cell_md_safe),
AMX_DECLARE_NATIVE(iter_set_cells_md),
AMX_DECLARE_NATIVE(iter_set_cells_md_safe),
AMX_DECLARE_NATIVE(iter_insert),
AMX_DECLARE_NATIVE(iter_insert_arr),
AMX_DECLARE_NATIVE(iter_insert_arr_2d),
AMX_DECLARE_NATIVE(iter_insert_arr_3d),
AMX_DECLARE_NATIVE(iter_insert_str),
AMX_DECLARE_NATIVE(iter_insert_str_s),
AMX_DECLARE_NATIVE(iter_insert_var),
AMX_DECLARE_NATIVE(iter_get_key),
AMX_DECLARE_NATIVE(iter_get_key_arr),
AMX_DECLARE_NATIVE(iter_get_key_str_s),
AMX_DECLARE_NATIVE(iter_get_key_var),
AMX_DECLARE_NATIVE(iter_get_key_safe),
AMX_DECLARE_NATIVE(iter_get_key_arr_safe),
AMX_DECLARE_NATIVE(iter_get_key_str_safe),
AMX_DECLARE_NATIVE(iter_get_key_str_safe_s),
AMX_DECLARE_NATIVE(iter_get_key_md),
AMX_DECLARE_NATIVE(iter_get_key_md_arr),
AMX_DECLARE_NATIVE(iter_get_key_md_str_s),
AMX_DECLARE_NATIVE(iter_get_key_md_safe),
AMX_DECLARE_NATIVE(iter_get_key_md_arr_safe),
AMX_DECLARE_NATIVE(iter_get_key_md_str_safe),
AMX_DECLARE_NATIVE(iter_get_key_md_str_safe_s),
AMX_DECLARE_NATIVE(iter_tagof),
AMX_DECLARE_NATIVE(iter_tag_uid),
AMX_DECLARE_NATIVE(iter_sizeof),
AMX_DECLARE_NATIVE(iter_sizeof_md),
AMX_DECLARE_NATIVE(iter_rank),
AMX_DECLARE_NATIVE(iter_tagof_key),
AMX_DECLARE_NATIVE(iter_sizeof_key),
AMX_DECLARE_NATIVE(iter_sizeof_key_md),
AMX_DECLARE_NATIVE(iter_key_rank),
};
int RegisterIterNatives(AMX *amx)
{
return amx_Register(amx, native_list, sizeof(native_list) / sizeof(*native_list));
}
| 30.323823 | 171 | 0.724303 | AGraber |
0fab90e4cfdd5b570bab49c06c107030941d1c7f | 5,924 | hpp | C++ | src/elona/draw.hpp | XrosFade/ElonaFoobar | c33880080e0b475103ae3ea7d546335f9d4abd02 | [
"MIT"
] | null | null | null | src/elona/draw.hpp | XrosFade/ElonaFoobar | c33880080e0b475103ae3ea7d546335f9d4abd02 | [
"MIT"
] | null | null | null | src/elona/draw.hpp | XrosFade/ElonaFoobar | c33880080e0b475103ae3ea7d546335f9d4abd02 | [
"MIT"
] | null | null | null | #pragma once
#include <string>
#include <vector>
#include "../snail/color.hpp"
#include "optional.hpp"
#include "pic_loader/extent.hpp"
#include "shared_id.hpp"
namespace elona
{
class CharaChipDB;
class ItemChipDB;
class PortraitDB;
class MapChipDB;
struct Item;
struct ItemChip
{
// NOTE: fully qualified to avoid ID collisions in pic_loader
SharedId key; // core.item_chip#core.putitoro
int offset_y;
int stack_height;
int shadow;
int animation;
};
extern std::vector<ItemChip> item_chips;
struct CharaChip
{
// NOTE: fully qualified to avoid ID collisions in pic_loader
SharedId key; // core.chara_chip#core.putit
int offset_y;
};
extern std::vector<CharaChip> chara_chips;
optional_ref<const Extent> draw_get_rect_chara(int);
optional_ref<const Extent> draw_get_rect_item(int);
optional_ref<const Extent> draw_get_rect_portrait(const std::string&);
optional_ref<const Extent> draw_get_rect(const std::string&);
optional_ref<const Extent> prepare_item_image(int id, int color);
optional_ref<const Extent>
prepare_item_image(int id, int color, int character_image);
void set_color_mod(int r, int g, int b, int window_id = -1);
enum class HPBarSide
{
left_side,
right_side,
};
void show_hp_bar(HPBarSide side, int inf_clocky);
void initialize_damage_popups();
void add_damage_popup(
const std::string& text,
int character,
const snail::Color& color);
void clear_damage_popups();
void show_damage_popups();
void draw_emo(int = 0, int = 0, int = 0);
void load_pcc_part(int cc, int body_part, const char* body_part_str);
void set_pcc_depending_on_equipments(int cc, int ci);
struct Character;
optional_ref<const Extent> chara_preparepic(const Character& cc);
optional_ref<const Extent> chara_preparepic(int image_id);
void create_pcpic(int cc, bool with_equipments = true);
void initialize_map_chips(const MapChipDB&);
void initialize_chara_chips(const CharaChipDB&);
void initialize_item_chips(const ItemChipDB&);
void initialize_portraits(const PortraitDB&);
void initialize_all_chips();
void draw_prepare_map_chips();
void draw_clear_loaded_chips();
void draw_init_key_select_buffer();
void draw_select_key(const std::string& key, int x, int y);
void bmes(
const std::string& message,
int x,
int y,
const snail::Color& text_color = {255, 255, 255, 255},
const snail::Color& shadow_color = {0, 0, 0, 255});
void draw_chara(
const Character& chara,
int x,
int y,
int scale = 1,
int alpha = 0);
void draw_chara(int image_id, int x, int y, int scale = 1, int alpha = 0);
void draw_chara_scale_height(const Character& chara, int x, int y);
void draw_chara_scale_height(int image_id, int x, int y);
void draw_item_material(int mat_id, int x, int y);
void draw_item_with_portrait(const Item& item, int x, int y);
void draw_item_with_portrait(
int image_id,
int color,
optional<int> chara_chip_id,
int x,
int y);
void draw_item_with_portrait_scale_height(const Item& item, int x, int y);
void draw_item_with_portrait_scale_height(
int image_id,
int color,
optional<int> chara_chip_id,
int x,
int y);
// Asset-related functions
struct AssetData;
const AssetData& asset_load(const std::string& key);
const AssetData& asset_load(const std::string& key, int window_id);
void init_assets();
void draw(const std::string& key, int x, int y);
void draw(const std::string& key, int x, int y, int width, int height);
void draw_centered(const std::string& key, int x, int y, int width, int height);
void draw_rotated(
const std::string& key,
int center_x,
int center_y,
double angle);
void draw_rotated(
const std::string& key,
int center_x,
int center_y,
int width,
int height,
double angle);
void draw_indexed(const std::string& key, int x, int y, int index);
void draw_indexed(
const std::string& key,
int x,
int y,
int index_x,
int index_y);
void draw_indexed_rotated(
const std::string& key,
int x,
int y,
int index_x,
int index_y,
double angle);
void draw_region(const std::string& key, int x, int y, int width);
void draw_region(const std::string& key, int x, int y, int width, int height);
void draw_region(
const std::string& key,
int x,
int y,
int offset_x,
int offset_y,
int width,
int height);
void draw_region(
const std::string& key,
int x,
int y,
int offset_x,
int offset_y,
int width,
int height,
int dst_width,
int dst_height);
void draw_region_centered(
const std::string& key,
int x,
int y,
int offset_x,
int offset_y,
int width,
int height,
int dst_width,
int dst_height);
void draw_region_rotated(
const std::string& key,
int x,
int y,
int offset_x,
int offset_y,
int width,
int height,
double angle);
void draw_bar(
const std::string& key,
int x,
int y,
int dst_width,
int dst_height,
int width);
void draw_bar_vert(
const std::string& key,
int x,
int y,
int dst_width,
int dst_height,
int height);
void draw_indexed_region(
const std::string& key,
int x,
int y,
int index_x,
int index_y,
int count_x,
int count_y);
void draw_bg(const std::string& key);
void asset_copy_from(int window_id, int x, int y, const std::string& key);
void asset_copy_from(
int window_id,
int x,
int y,
int width,
int height,
const std::string& key);
void draw_map_tile(int id, int x, int y, int anim_frame = 0);
void draw_map_tile(
int id,
int x,
int y,
int width,
int height,
int anim_frame = 0);
void draw_map_tile(
int id,
int x,
int y,
int width,
int height,
int dst_width,
int dst_height,
int anim_frame = 0);
const AssetData& get_image_info(const std::string& key);
} // namespace elona
| 22.610687 | 80 | 0.694294 | XrosFade |
0fb6c6780fb5016b303f4b481515aa57ec029273 | 1,388 | cpp | C++ | projects/pinguin_warfare/mapselectionmenuscene.cpp | MBakels/Centauri_Framework | eaca476af5ef8c7679e9026605868e8db2af014f | [
"MIT"
] | null | null | null | projects/pinguin_warfare/mapselectionmenuscene.cpp | MBakels/Centauri_Framework | eaca476af5ef8c7679e9026605868e8db2af014f | [
"MIT"
] | null | null | null | projects/pinguin_warfare/mapselectionmenuscene.cpp | MBakels/Centauri_Framework | eaca476af5ef8c7679e9026605868e8db2af014f | [
"MIT"
] | null | null | null | #include "mapselectionmenuscene.h"
#include "scenemanager.h"
#include "map.h"
MapSelectionMenuScene::MapSelectionMenuScene() {
// Initial button position
int xPos = 200, yPos = 100;
// Add a button for each MapData element in maps
for each(std::pair<std::string, MapData*> map in Map::maps) {
// Create and add button
Button* mapButton = new Button(Point3(xPos, yPos, 0), "assets/WhiteSquare.png", BLACK);
mapButton->GetSprite()->size = Point2(300, 100);
mapButton->AddButtonText(map.first, 0, 0, 62);
AddChild(mapButton);
// Add button to buttons vector
mapButtons.push_back(mapButton);
// Set position for next button
xPos += 350;
if (xPos >= SWIDTH - 175) {
yPos += 150;
xPos = 200;
}
}
}
MapSelectionMenuScene::~MapSelectionMenuScene() {
// Remove all buttons
std::vector<Button*>::iterator buttonsIt;
for (buttonsIt = mapButtons.begin(); buttonsIt != mapButtons.end(); buttonsIt++) {
RemoveChild((*buttonsIt));
delete (*buttonsIt);
}
mapButtons.clear();
}
void MapSelectionMenuScene::Update() {
// Check button input for each button
for each(Button* button in mapButtons) {
if (button->CheckPressed(Point2(GetInput()->GetMouseX(), GetInput()->GetMouseY()))) {
// If the button is pressed create a new map and load it
SceneMaganger::AddScene(new Map(button->buttonText->GetText()->text));
SceneMaganger::LoadScene(5);
}
}
} | 30.844444 | 89 | 0.695965 | MBakels |
0fb7e65bd2ac657c475a6b748f880e7b1245f613 | 2,150 | cpp | C++ | src/sources/ProgressWin.cpp | waddlesplash/Photon | a93eeed8c156bde5f3721f74ebe7c21aa7e12459 | [
"BSD-3-Clause"
] | 4 | 2017-06-13T22:51:50.000Z | 2019-04-19T20:02:27.000Z | src/sources/ProgressWin.cpp | waddlesplash/Photon | a93eeed8c156bde5f3721f74ebe7c21aa7e12459 | [
"BSD-3-Clause"
] | null | null | null | src/sources/ProgressWin.cpp | waddlesplash/Photon | a93eeed8c156bde5f3721f74ebe7c21aa7e12459 | [
"BSD-3-Clause"
] | 1 | 2020-10-26T09:00:17.000Z | 2020-10-26T09:00:17.000Z | #include "ProgressWin.h"
ProgressView::ProgressView(BRect r) :
BView(r, "ProgressView", B_FOLLOW_ALL, B_WILL_DRAW)
{
BRect re =Bounds();
re.InsetBy(4,4);
progress = new BStatusBar(re,"aa","bb","cc");
//progress->SetBarHeight(7);
rgb_color colx ={200,0,0};
progress->SetBarColor(colx);
SetViewColor(216,216,216);
progress->SetViewColor(216,216,216);
progress->SetMaxValue(100);
AddChild(progress);
util.progress_exists=true;
}
ProgressWindow::ProgressWindow(BRect frame, char *title)
: BWindow(frame, title, B_FLOATING_WINDOW,B_NOT_MINIMIZABLE | B_NOT_ZOOMABLE|
B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS | B_AVOID_FOCUS)
{
progress_view = new ProgressView(Bounds());
AddChild(progress_view);
}
ProgressWindow::~ProgressWindow()
{
util.progress_exists=false;
}
void ProgressWindow::MessageReceived(BMessage *msg)
{
int32 val=0;
float percent;
char str[255];
const char *name = str;
switch (msg->what)
{
case UPDATE_PROGRESS:
msg->FindInt32("value",&val);
//percent = 100 * (progress_view->progress->CurrentValue() / progress_view->progress->CurrentValue());
//if (floor(val)!=floor (percent))
//{
progress_view->progress->Update(val);
//sprintf(str,"%g %%",percent);
sprintf(str,"%g %%",progress_view->progress->CurrentValue());
progress_view->progress->SetTrailingText(str);
//}
break;
case SET_PROGRESS_NAME:
msg->FindString("text",&name);
progress_view->progress->SetText(str);
break;
case RESET_PROGRESS:
progress_view->progress->Reset();
break;
case SET_PROGRESS_COLOR_FILTER:
progress_view->progress->SetBarColor(ThePrefs.color_filter);
break;
case SET_PROGRESS_COLOR_MEMORIZE:
progress_view->progress->SetBarColor(ThePrefs.color_memorize);
break;
case SET_PROGRESS_COLOR_UNDO:
progress_view->progress->SetBarColor(ThePrefs.color_undo);
break;
case SET_PROGRESS_COLOR_LOAD:
progress_view->progress->SetBarColor(ThePrefs.color_load);
break;
case SET_PROGRESS_COLOR_SAVE:
progress_view->progress->SetBarColor(ThePrefs.color_save);
break;
default:
BWindow::MessageReceived( msg );
}
}
| 20.873786 | 104 | 0.71814 | waddlesplash |
0fbabdbd42759024d8c4c976d134c6796fad6a57 | 6,402 | cc | C++ | game/src/gui/app/deploy_view.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | 1 | 2018-03-02T03:36:59.000Z | 2018-03-02T03:36:59.000Z | game/src/gui/app/deploy_view.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | 1 | 2018-04-17T01:43:02.000Z | 2018-04-17T01:43:02.000Z | game/src/gui/app/deploy_view.cc | chunseoklee/mengde | 7261e45dab9e02d4bf18b4542767f4b50a5616a0 | [
"MIT"
] | null | null | null | #include "deploy_view.h"
#include <algorithm>
#include "core/assets.h"
#include "core/equipment.h"
#include "core/force.h"
#include "core/hero.h"
#include "core/i_deploy_helper.h"
#include "core/unit.h"
#include "deploy_director.h"
#include "equipment_select_view.h"
#include "equipment_set_view.h"
#include "game_view.h"
#include "gui/uifw/button_view.h"
#include "gui/uifw/image_view.h"
#include "gui/uifw/text_view.h"
#include "resource_path.h"
#include "unit_over_view.h"
#include "unit_view.h"
namespace mengde {
namespace gui {
namespace app {
HeroModelView::HeroModelView(const Rect& frame, const core::Hero* hero, core::IDeployHelper* deploy_helper)
: CallbackView(frame), hero_(hero), deploy_no_(0), required_unselectable_(false), tv_no_(nullptr) {
padding(4);
Rect img_src_rect(0, 0, 48, 48);
Rect iv_frame = LayoutHelper::CalcPosition(GetActualFrameSize(), img_src_rect.GetSize(), LayoutHelper::kAlignCenter);
iv_frame.SetY(iv_frame.GetY() - 8);
ImageView* iv_hero = new ImageView(iv_frame, rcpath::UnitModelPath(hero->GetModelId(), kSpriteStand).ToString());
iv_hero->SetSourceRect(img_src_rect);
AddChild(iv_hero);
Rect tv_hero_frame = GetActualFrame();
TextView* tv_hero = new TextView(&tv_hero_frame, hero_->GetId(), COLOR("white"), 14, LayoutHelper::kAlignMidBot);
AddChild(tv_hero);
Rect tv_no_frame = GetActualFrame();
tv_no_frame.SetW(tv_no_frame.GetW() - 8);
tv_no_ = new TextView(&tv_no_frame, "", COLOR("orange"), 20, LayoutHelper::kAlignRgtTop);
AddChild(tv_no_);
deploy_no_ = deploy_helper->FindDeploy(hero);
required_unselectable_ = (deploy_no_ != 0); // Assume unselectable if already deployed at this point(construction)
UpdateViews();
}
void HeroModelView::UpdateViews() {
if (required_unselectable_) {
ASSERT(IsSelected());
bg_color(COLOR("black"));
tv_no_->SetText("");
} else if (IsSelected()) {
bg_color(COLOR("gray"));
tv_no_->SetText(std::to_string(deploy_no_));
} else {
bg_color(COLOR("transparent"));
tv_no_->SetText("");
}
}
HeroModelListView::HeroModelListView(const Rect& frame, const vector<const core::Hero*>& hero_list,
core::IDeployHelper* deploy_helper, DeployDirector* director)
: CompositeView(frame) {
bg_color(COLOR("navy"));
static const Vec2D kHeroModelSize = {96, 80};
Rect hero_model_frame({0, 0}, kHeroModelSize);
for (auto hero : hero_list) {
HeroModelView* model_view = new HeroModelView(hero_model_frame, hero, deploy_helper);
model_view->SetMouseButtonHandler(
[model_view, hero, deploy_helper, director](const foundation::MouseButtonEvent e) -> bool {
if (e.IsLeftButtonUp()) {
int deploy_no = 0;
if (model_view->IsSelected()) {
deploy_no = deploy_helper->UnassignDeploy(hero);
} else {
deploy_no = deploy_helper->AssignDeploy(hero);
}
director->OnDeployNoChanged(model_view, deploy_no);
director->OnHeroChosen(hero);
}
return true;
});
AddChild(model_view);
hero_model_frame.SetX(hero_model_frame.GetX() + kHeroModelSize.x);
if (hero_model_frame.GetRight() > GetActualFrameSize().x) {
hero_model_frame.SetX(0);
hero_model_frame.SetY(hero_model_frame.GetY() + kHeroModelSize.y);
}
}
}
DeployView::DeployView(const Rect& frame, core::Assets* assets, core::IDeployHelper* deploy_helper, GameView* gv)
: CompositeView(frame), gv_(gv) {
padding(8);
bg_color(COLOR("darkgray"));
director_ = new DeployDirector();
Rect unit_view_frame = LayoutHelper::CalcPosition(GetActualFrameSize(), {204, 320}, LayoutHelper::kAlignRgtTop);
UnitView* unit_view = new UnitView(unit_view_frame);
unit_view->padding(0);
AddChild(unit_view);
EquipmentSetView* equipment_set_view = unit_view->equipment_set_view();
Rect equipment_select_frame = GetActualFrame();
equipment_select_frame.SetW(4 * 96);
equipment_select_view_ = new EquipmentSelectView(equipment_select_frame, equipment_set_view);
equipment_select_view_->visible(false);
{ // Initialize equipment_set_view
EquipmentSelectView* select_view = equipment_select_view_;
auto mouse_handler_gen = [select_view, assets](core::Equipment::Type type) {
return [select_view, assets, type](const foundation::MouseButtonEvent e) {
if (e.IsLeftButtonUp()) {
if (select_view->visible()) {
select_view->visible(false);
} else {
vector<core::EquipmentWithAmount> equipments = assets->GetEquipmentsWithAmount();
vector<core::EquipmentWithAmount> equipments_filtered;
std::copy_if(equipments.begin(), equipments.end(), std::back_inserter(equipments_filtered),
[type](const core::EquipmentWithAmount& eq) { return eq.object->GetType() == type; });
select_view->SetEquipments(equipments_filtered, assets);
select_view->visible(true);
}
}
return true;
};
};
equipment_set_view->SetWeaponMouseButtonHandler(mouse_handler_gen(core::Equipment::Type::kWeapon));
equipment_set_view->SetArmorMouseButtonHandler(mouse_handler_gen(core::Equipment::Type::kArmor));
equipment_set_view->SetAidMouseButtonHandler(mouse_handler_gen(core::Equipment::Type::kAid));
}
HeroModelListView* hero_model_list_view;
{
Rect hero_model_list_frame = GetActualFrame();
hero_model_list_frame.SetW(4 * 96);
hero_model_list_view = new HeroModelListView(hero_model_list_frame, assets->GetHeroes(), deploy_helper, director_);
AddChild(hero_model_list_view);
}
Rect btn_ok_frame = LayoutHelper::CalcPosition(GetActualFrameSize(), {100, 50}, LayoutHelper::kAlignRgtBot);
ButtonView* btn_ok = new ButtonView(&btn_ok_frame, "To Battle");
btn_ok->SetMouseButtonHandler([&, deploy_helper](foundation::MouseButtonEvent e) {
if (e.IsLeftButtonUp()) {
if (deploy_helper->SubmitDeploy()) {
this->visible(false);
gv_->InitUIStateMachine();
}
}
return true;
});
AddChild(equipment_select_view_);
AddChild(btn_ok);
director_->Init(hero_model_list_view, unit_view->unit_over_view(), equipment_set_view, equipment_select_view_);
}
} // namespace app
} // namespace gui
} // namespace mengde
| 37.881657 | 119 | 0.69572 | chunseoklee |
0fbb27736d46f8a25cc494234e9cb5cec198e326 | 6,074 | cpp | C++ | image/src/KTXImage.cpp | Arthapz/StormKit | 7c8dead874734d04b97776287b25bf2ebe9be617 | [
"MIT"
] | 17 | 2019-02-12T14:40:06.000Z | 2021-12-21T12:54:17.000Z | image/src/KTXImage.cpp | Arthapz/StormKit | 7c8dead874734d04b97776287b25bf2ebe9be617 | [
"MIT"
] | null | null | null | image/src/KTXImage.cpp | Arthapz/StormKit | 7c8dead874734d04b97776287b25bf2ebe9be617 | [
"MIT"
] | 2 | 2019-02-21T10:07:42.000Z | 2020-05-08T19:49:10.000Z | /////////// - StormKit::image - ///////////
#include <storm/core/Ranges.hpp>
/////////// - StormKit::image - ///////////
#include <storm/image/Image.hpp>
/////////// - STL - ///////////
#include <csetjmp>
#include <cstring>
/////////// - libJPEG - ///////////
#include <gli/gli.hpp>
using namespace storm;
using namespace storm::image;
namespace storm::image {
constexpr auto toStormFormat(gli::format format) noexcept {
switch (format) {
case gli::FORMAT_R8_SNORM_PACK8: return Image::Format::R8_SNorm;
case gli::FORMAT_R8_UNORM_PACK8: return Image::Format::R8_UNorm;
case gli::FORMAT_R16_SNORM_PACK16: return Image::Format::R16_SNorm;
case gli::FORMAT_R16_UNORM_PACK16: return Image::Format::R16_UNorm;
case gli::FORMAT_R8_SINT_PACK8: return Image::Format::R8I;
case gli::FORMAT_R8_UINT_PACK8: return Image::Format::R8U;
case gli::FORMAT_R16_SINT_PACK16: return Image::Format::R16I;
case gli::FORMAT_R16_UINT_PACK16: return Image::Format::R16U;
case gli::FORMAT_R32_SINT_PACK32: return Image::Format::R32I;
case gli::FORMAT_R32_UINT_PACK32: return Image::Format::R32U;
case gli::FORMAT_R16_SFLOAT_PACK16: return Image::Format::R16F;
case gli::FORMAT_R32_SFLOAT_PACK32: return Image::Format::R32F;
case gli::FORMAT_RG8_SNORM_PACK8: return Image::Format::RG8_SNorm;
case gli::FORMAT_RG8_UNORM_PACK8: return Image::Format::RG8_UNorm;
case gli::FORMAT_RG16_SNORM_PACK16: return Image::Format::RG16_SNorm;
case gli::FORMAT_RG16_UNORM_PACK16: return Image::Format::RG16_UNorm;
case gli::FORMAT_RG8_SINT_PACK8: return Image::Format::RG8I;
case gli::FORMAT_RG8_UINT_PACK8: return Image::Format::RG8U;
case gli::FORMAT_RG16_SINT_PACK16: return Image::Format::RG16I;
case gli::FORMAT_RG16_UINT_PACK16: return Image::Format::RG16U;
case gli::FORMAT_RG32_SINT_PACK32: return Image::Format::RG32I;
case gli::FORMAT_RG32_UINT_PACK32: return Image::Format::RG32U;
case gli::FORMAT_RG16_SFLOAT_PACK16: return Image::Format::RG16F;
case gli::FORMAT_RG32_SFLOAT_PACK32: return Image::Format::RG32F;
case gli::FORMAT_RGB8_SNORM_PACK8: return Image::Format::RGB8_SNorm;
case gli::FORMAT_RGB8_UNORM_PACK8: return Image::Format::RGB8_UNorm;
case gli::FORMAT_RGB16_SNORM_PACK16: return Image::Format::RGB16_SNorm;
case gli::FORMAT_RGB16_UNORM_PACK16: return Image::Format::RGB16_UNorm;
case gli::FORMAT_BGR8_UNORM_PACK8: return Image::Format::RGB16_UNorm;
case gli::FORMAT_RGB8_SINT_PACK8: return Image::Format::RGB8I;
case gli::FORMAT_RGB8_UINT_PACK8: return Image::Format::RGB8U;
case gli::FORMAT_RGB16_SINT_PACK16: return Image::Format::RGB16I;
case gli::FORMAT_RGB16_UINT_PACK16: return Image::Format::RGB16U;
case gli::FORMAT_RGB32_SINT_PACK32: return Image::Format::RGB32I;
case gli::FORMAT_RGB32_UINT_PACK32: return Image::Format::RGB32U;
case gli::FORMAT_RGB16_SFLOAT_PACK16: return Image::Format::RGB16F;
case gli::FORMAT_RGB32_SFLOAT_PACK32: return Image::Format::RGB32F;
case gli::FORMAT_RGB8_SRGB_PACK8: return Image::Format::sRGB8;
case gli::FORMAT_BGR8_SRGB_PACK8: return Image::Format::sBGR8;
case gli::FORMAT_RGBA8_SNORM_PACK8: return Image::Format::RGBA8_SNorm;
case gli::FORMAT_RGBA8_UNORM_PACK8: return Image::Format::RGBA8_UNorm;
case gli::FORMAT_RGBA16_SNORM_PACK16: return Image::Format::RGBA16_SNorm;
case gli::FORMAT_RGBA16_UNORM_PACK16: return Image::Format::RGBA16_UNorm;
case gli::FORMAT_BGRA8_UNORM_PACK8: return Image::Format::RGBA16_UNorm;
case gli::FORMAT_RGBA8_SINT_PACK8: return Image::Format::RGBA8I;
case gli::FORMAT_RGBA8_UINT_PACK8: return Image::Format::RGBA8U;
case gli::FORMAT_RGBA16_SINT_PACK16: return Image::Format::RGBA16I;
case gli::FORMAT_RGBA16_UINT_PACK16: return Image::Format::RGBA16U;
case gli::FORMAT_RGBA32_SINT_PACK32: return Image::Format::RGBA32I;
case gli::FORMAT_RGBA32_UINT_PACK32: return Image::Format::RGBA32U;
case gli::FORMAT_RGBA16_SFLOAT_PACK16: return Image::Format::RGBA16F;
case gli::FORMAT_RGBA32_SFLOAT_PACK32: return Image::Format::RGBA32F;
case gli::FORMAT_RGBA8_SRGB_PACK8: return Image::Format::sRGBA8;
case gli::FORMAT_BGRA8_SRGB_PACK8: return Image::Format::sBGRA8;
default: return Image::Format::Undefined;
}
return Image::Format::Undefined;
}
} // namespace storm::image
std::optional<std::string> Image::loadKTX(core::ByteConstSpan data) noexcept {
auto image = gli::load_ktx(reinterpret_cast<const char *>(std::data(data)), std::size(data));
const auto faces = static_cast<core::UInt32>(image.faces());
const auto layers = static_cast<core::UInt32>(image.layers());
const auto mip_levels = static_cast<core::UInt32>(image.levels());
const auto format = toStormFormat(image.format());
if (format == Image::Format::Undefined) return "Unsupported pixel format";
auto _data = core::ByteArray {};
_data.resize(image.size());
core::ranges::copy(core::toConstByteSpan(image.data(), image.size()), std::begin(_data));
m_extent = core::Extenti { image.extent().x, image.extent().y, image.extent().z };
m_channel_count = getChannelCountFor(format);
m_bytes_per_channel = getArraySizeByChannelFor(format);
m_mip_levels = mip_levels;
m_faces = faces;
m_layers = layers;
m_data = std::move(_data);
m_format = format;
return std::nullopt;
}
std::optional<std::string> Image::saveKTX(const std::filesystem::path &filepath) const noexcept {
return std::nullopt;
}
| 53.280702 | 97 | 0.669575 | Arthapz |
0fbbc01bfef9c81727ff0e3bd9af2ee944cd2ec3 | 6,620 | cpp | C++ | ClientLourd/Tuto/Commun/Externe/FTGL/include/FTGlyph/FTGlyphGlue.cpp | samirov78/MultiplayerRobotSimulator | bd8b2741e310b027f0746c838b717e436802c402 | [
"MIT"
] | 110 | 2016-06-23T23:07:23.000Z | 2022-03-25T03:18:16.000Z | ClientLourd/Tuto/Commun/Externe/FTGL/include/FTGlyph/FTGlyphGlue.cpp | samirov78/MultiplayerRobotSimulator | bd8b2741e310b027f0746c838b717e436802c402 | [
"MIT"
] | 9 | 2016-06-24T13:20:01.000Z | 2020-05-05T18:43:46.000Z | ClientLourd/Tuto/Commun/Externe/FTGL/include/FTGlyph/FTGlyphGlue.cpp | samirov78/MultiplayerRobotSimulator | bd8b2741e310b027f0746c838b717e436802c402 | [
"MIT"
] | 23 | 2016-04-26T23:37:13.000Z | 2021-09-27T07:10:08.000Z | /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
* Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
*
* 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 "config.h"
#include "FTGL/ftgl.h"
#include "FTInternals.h"
static const FTPoint static_ftpoint;
static const FTBBox static_ftbbox;
FTGL_BEGIN_C_DECLS
#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \
FTGLglyph* cname cargs \
{ \
cxxname *g = new cxxname cxxarg; \
if(g->Error()) \
{ \
delete g; \
return NULL; \
} \
FTGLglyph *ftgl = (FTGLglyph *)malloc(sizeof(FTGLglyph)); \
ftgl->ptr = g; \
ftgl->type = cxxtype; \
return ftgl; \
}
// FTBitmapGlyph::FTBitmapGlyph();
C_TOR(ftglCreateBitmapGlyph, (FT_GlyphSlot glyph),
FTBitmapGlyph, (glyph), GLYPH_BITMAP);
// FTBufferGlyph::FTBufferGlyph();
// FIXME: not implemented
// FTExtrudeGlyph::FTExtrudeGlyph();
C_TOR(ftglCreateExtrudeGlyph, (FT_GlyphSlot glyph, float depth,
float frontOutset, float backOutset, int useDisplayList),
FTExtrudeGlyph, (glyph, depth, frontOutset, backOutset, (useDisplayList != 0)),
GLYPH_EXTRUDE);
// FTOutlineGlyph::FTOutlineGlyph();
C_TOR(ftglCreateOutlineGlyph, (FT_GlyphSlot glyph, float outset,
int useDisplayList),
FTOutlineGlyph, (glyph, outset, (useDisplayList != 0)), GLYPH_OUTLINE);
// FTPixmapGlyph::FTPixmapGlyph();
C_TOR(ftglCreatePixmapGlyph, (FT_GlyphSlot glyph),
FTPixmapGlyph, (glyph), GLYPH_PIXMAP);
// FTPolygonGlyph::FTPolygonGlyph();
C_TOR(ftglCreatePolygonGlyph, (FT_GlyphSlot glyph, float outset,
int useDisplayList),
FTPolygonGlyph, (glyph, outset, (useDisplayList != 0)), GLYPH_POLYGON);
// FTTextureGlyph::FTTextureGlyph();
C_TOR(ftglCreateTextureGlyph, (FT_GlyphSlot glyph, int id, int xOffset,
int yOffset, int width, int height),
FTTextureGlyph, (glyph, id, xOffset, yOffset, width, height),
GLYPH_TEXTURE);
// FTCustomGlyph::FTCustomGlyph();
class FTCustomGlyph : public FTGlyph
{
public:
FTCustomGlyph(FTGLglyph *base, void *p,
void (*render) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
int, FTGL_DOUBLE *, FTGL_DOUBLE *),
void (*destroy) (FTGLglyph *, void *))
: FTGlyph((FT_GlyphSlot)0),
baseGlyph(base),
data(p),
renderCallback(render),
destroyCallback(destroy)
{}
~FTCustomGlyph()
{
destroyCallback(baseGlyph, data);
}
float Advance() const { return baseGlyph->ptr->Advance(); }
const FTPoint& Render(const FTPoint& pen, int renderMode)
{
FTGL_DOUBLE advancex, advancey;
renderCallback(baseGlyph, data, pen.X(), pen.Y(), renderMode,
&advancex, &advancey);
advance = FTPoint(advancex, advancey);
return advance;
}
const FTBBox& BBox() const { return baseGlyph->ptr->BBox(); }
FT_Error Error() const { return baseGlyph->ptr->Error(); }
private:
FTPoint advance;
FTGLglyph *baseGlyph;
void *data;
void (*renderCallback) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
int, FTGL_DOUBLE *, FTGL_DOUBLE *);
void (*destroyCallback) (FTGLglyph *, void *);
};
C_TOR(ftglCreateCustomGlyph, (FTGLglyph *base, void *data,
void (*renderCallback) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
int, FTGL_DOUBLE *, FTGL_DOUBLE *),
void (*destroyCallback) (FTGLglyph *, void *)),
FTCustomGlyph, (base, data, renderCallback, destroyCallback),
GLYPH_CUSTOM);
#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
cret cname cargs \
{ \
if(!g || !g->ptr) \
{ \
fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
cxxerr; \
} \
return g->ptr->cxxname cxxarg; \
}
// FTGlyph::~FTGlyph();
void ftglDestroyGlyph(FTGLglyph *g)
{
if(!g || !g->ptr)
{
fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
return;
}
delete g->ptr;
free(g);
}
// const FTPoint& FTGlyph::Render(const FTPoint& pen, int renderMode);
extern "C++" {
C_FUN(static const FTPoint&, _ftglRenderGlyph, (FTGLglyph *g,
const FTPoint& pen, int renderMode),
return static_ftpoint, Render, (pen, renderMode));
}
void ftglRenderGlyph(FTGLglyph *g, FTGL_DOUBLE penx, FTGL_DOUBLE peny,
int renderMode, FTGL_DOUBLE *advancex,
FTGL_DOUBLE *advancey)
{
FTPoint pen(penx, peny);
FTPoint ret = _ftglRenderGlyph(g, pen, renderMode);
*advancex = ret.X();
*advancey = ret.Y();
}
// float FTGlyph::Advance() const;
C_FUN(float, ftglGetGlyphAdvance, (FTGLglyph *g), return 0.0, Advance, ());
// const FTBBox& FTGlyph::BBox() const;
extern "C++" {
C_FUN(static const FTBBox&, _ftglGetGlyphBBox, (FTGLglyph *g),
return static_ftbbox, BBox, ());
}
void ftglGetGlyphBBox(FTGLglyph *g, float bounds[6])
{
FTBBox ret = _ftglGetGlyphBBox(g);
FTPoint lower = ret.Lower(), upper = ret.Upper();
bounds[0] = lower.Xf(); bounds[1] = lower.Yf(); bounds[2] = lower.Zf();
bounds[3] = upper.Xf(); bounds[4] = upper.Yf(); bounds[5] = upper.Zf();
}
// FT_Error FTGlyph::Error() const;
C_FUN(FT_Error, ftglGetGlyphError, (FTGLglyph *g), return -1, Error, ());
FTGL_END_C_DECLS
| 33.266332 | 85 | 0.641239 | samirov78 |
0fbc0db6e99387859e836424e5575d95d6b69a6f | 3,930 | cpp | C++ | mpags-cipher.cpp | tomlatham/mpags-c-course-day-2-ejones21 | fe749511e23f422977c558b7fee5bfea636ec626 | [
"MIT"
] | null | null | null | mpags-cipher.cpp | tomlatham/mpags-c-course-day-2-ejones21 | fe749511e23f422977c558b7fee5bfea636ec626 | [
"MIT"
] | null | null | null | mpags-cipher.cpp | tomlatham/mpags-c-course-day-2-ejones21 | fe749511e23f422977c558b7fee5bfea636ec626 | [
"MIT"
] | null | null | null | // Standard Library includes
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
// Our project headers
#include "TransformChar.hpp"
#include "processCommandLine.hpp"
#include "runCaesarCipher.hpp"
// For std::isalpha and std::isupper
#include <cctype>
// Main function of the mpags-cipher program
int main(int argc, char* argv[])
{
// Convert the command-line arguments into a more easily usable form
const std::vector<std::string> cmdLineArgs {argv, argv+argc};
// Options that might be set by the command-line arguments
bool helpRequested {false};
bool versionRequested {false};
std::string inputFile {""};
std::string outputFile {""};
bool encrypt {true};
size_t key {0};
if(processCommandLine(
cmdLineArgs,
helpRequested,
versionRequested,
inputFile,
outputFile,
encrypt,
key))
{return 1;}
// Handle help, if requested
if (helpRequested) {
// Line splitting for readability
std::cout
<< "Usage: mpags-cipher [-i <file>] [-o <file>]\n\n"
<< "Encrypts/Decrypts input alphanumeric text using classical ciphers\n\n"
<< "Available options:\n\n"
<< " -h|--help Print this help message and exit\n\n"
<< " --version Print version information\n\n"
<< " -i FILE Read text to be processed from FILE\n"
<< " Stdin will be used if not supplied\n\n"
<< " -o FILE Write processed text to FILE\n"
<< " Stdout will be used if not supplied\n\n"
<< " -k KEY Specify the cipher KEY\n"
<< " A null key, i.e. no encryption, is used if not supplied\n\n"
<< " -e Will use the cipher to encrypt the input text (default behaviour)\n\n"
<< " -d Will use the cipher to decrypt the input text\n\n";
// Help requires no further action, so return from main
// with 0 used to indicate success
return 0;
}
// Handle version, if requested
// Like help, requires no further action,
// so return from main with zero to indicate success
if (versionRequested) {
std::cout << "0.2.0" << std::endl;
return 0;
}
// Initialise variables for processing input text
char inputChar {'x'};
std::string outputText {""};
std::string encryptedCode{""};
// Read in user input from stdin/file
if (!inputFile.empty()) {
std::ifstream in_file{inputFile};
bool ok_to_read = in_file.good();
if(ok_to_read){
while(in_file>>inputChar)
{
outputText += transformChar(inputChar);
}
}
else{
// Loop over each character from user input
// (until Return then CTRL-D (EOF) pressed)
std::cerr << "[error] failed to create istream on file '" << inputFile << "'" << std::endl;
std::cout<<"Type the input and press ctrl-D to exit"<<std::endl;
while(std::cin >> inputChar)
{
outputText += transformChar(inputChar);
}
}
} else {
// Loop over each character from user input
// (until Return then CTRL-D (EOF) pressed)
std::cout<<"Type the input and press ctrl-D to exit"<<std::endl;
while(std::cin >> inputChar)
{
outputText += transformChar(inputChar);
}
}
// Run the encryption code
encryptedCode = runCaesarCipher(outputText, key, encrypt);
// Output the transliterated text
if (!outputFile.empty()) {
std::ofstream out_file {outputFile};
bool ok_to_write = out_file.good();
if(ok_to_write){
out_file <<encryptedCode<< std::endl;
}
else{
std::cerr << "[error] failed to open file for output: '" << outputFile << "'" << std::endl;
std::cout << encryptedCode << std::endl;
}
} else {
std::cout << encryptedCode << std::endl;
}
// No requirement to return from main, but we do so for clarity
// and for consistency with other functions
return 0;
}
| 30.465116 | 99 | 0.616031 | tomlatham |
0fbf56ffba91b321fa2641386cb5d1c5c7ec9b33 | 2,865 | cpp | C++ | code archive/hpcodewar2018/19.cpp | brianbbsu/program | c4505f2b8c0b91010e157db914a63c49638516bc | [
"MIT"
] | 4 | 2018-04-08T08:07:58.000Z | 2021-06-07T14:55:24.000Z | code archive/hpcodewar2018/19.cpp | brianbbsu/program | c4505f2b8c0b91010e157db914a63c49638516bc | [
"MIT"
] | null | null | null | code archive/hpcodewar2018/19.cpp | brianbbsu/program | c4505f2b8c0b91010e157db914a63c49638516bc | [
"MIT"
] | 1 | 2018-10-29T12:37:25.000Z | 2018-10-29T12:37:25.000Z | //{
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#include<sstream>
#include<cmath>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<ll,ll> ii;
#define REP(i,n) for(ll i=0;i<n;i++)
#define REP1(i,n) for(ll i=1;i<=n;i++)
#define FILL(i,n) memset(i,n,sizeof i)
#define MEM(i,n) memset(i,n,sizeof i)
#define X first
#define Y second
#define SZ(_a) (int)_a.size()
#define ALL(_a) _a.begin(),_a.end()
#define pb push_back
#define eb emplace_back
#ifdef brian
#define debug(...) do{\
fprintf(stderr,"%s - %d (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
_do(__VA_ARGS__);\
}while(0)
template<typename T>void _do(T &&_x){cerr<<_x<<endl;}
template<typename T,typename ...S> void _do(T &&_x,S &&..._t){cerr<<_x<<" ,";_do(_t...);}
template<typename _a,typename _b> ostream& operator << (ostream &_s,const pair<_a,_b> &_p){return _s<<"("<<_p.X<<","<<_p.Y<<")";}
template<typename It> ostream& _OUTC(ostream &_s,It _ita,It _itb)
{
_s<<"{";
for(It _it=_ita;_it!=_itb;_it++)
{
_s<<(_it==_ita?"":",")<<*_it;
}
_s<<"}";
return _s;
}
template<typename _a> ostream &operator << (ostream &_s,vector<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,set<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a,typename _b> ostream &operator << (ostream &_s,map<_a,_b> &_c){return _OUTC(_s,ALL(_c));}
template<typename _t> void pary(_t _a,_t _b){_OUTC(cerr,_a,_b);cerr<<endl;}
#define IOS()
#else
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() ios_base::sync_with_stdio(0);cin.tie(0);
#endif // brian
//}
#define MAXN MAXn
const ll MAXn=1e5+5,MAXlg=__lg(MAXn)+2;
const ll MOD=1000000007;
const ll INF=ll(1e15);
ll mat[6][6] = {
{-2,1,-2,3,2,1},
{-5,-2,5,2,5,-4},
{-5,-5,0,5,-1,-1},
{-3,-2,-5,0,1,2},
{5,-3,-2,-1,-3,1},
{-5,-4,-5,2,4,-1}
};
const ll N = 6;
set<ii> st[MAXn];
int main()
{
IOS();
ll n,m;
cin>>n>>m;
st[0].insert(ii(n,m));
queue<pair<ll,ii> > q;
q.push({0,{n,m}});
while(SZ(q))
{
ll ite = q.front().X;
ll tp = q.front().Y.X;
ll p = q.front().Y.Y;
q.pop();
ite ++;
REP(i,N)
{
ll np = p + mat[tp][i];
if(ite % 2 == 0)
{
np -= abs(np % 10) + ite;
}
if(np < 0)np += ite * ite % 30;
if(np < 0)continue;
else if(np == 0)
{
cout<<ite<<endl;
return 0;
}
else if(!st[ite].count(ii(i,np)))
{
st[ite].insert(ii(i,np));
q.push({ite,{i,np}});
}
}
}
}
| 24.279661 | 129 | 0.539616 | brianbbsu |
0fbf98a4c023316af3e8062a5bc946de9cc3e486 | 196 | hpp | C++ | MeetingCodes/Meeting4/Nelli_Square.hpp | knelli2/spectre-cpp-basics | 9ac3f192a3673e708e8cd33efce0b3eba13f46fc | [
"MIT"
] | null | null | null | MeetingCodes/Meeting4/Nelli_Square.hpp | knelli2/spectre-cpp-basics | 9ac3f192a3673e708e8cd33efce0b3eba13f46fc | [
"MIT"
] | null | null | null | MeetingCodes/Meeting4/Nelli_Square.hpp | knelli2/spectre-cpp-basics | 9ac3f192a3673e708e8cd33efce0b3eba13f46fc | [
"MIT"
] | null | null | null | #pragma once
#include "Nelli_Rectangle.hpp"
class Square : public Rectangle {
public:
Square(double length) noexcept;
double Perimeter() const noexcept;
double Area() const noexcept;
};
| 16.333333 | 36 | 0.734694 | knelli2 |
0fc0f095d26eeaffb1541a6076e828efb11390b7 | 5,254 | cpp | C++ | src/Entities/ArrowEntity.cpp | wbrbr/MCServer | a7bbca30c560c581127f7b6c49ca427c3e96a1da | [
"Apache-2.0"
] | 1 | 2021-03-20T01:23:29.000Z | 2021-03-20T01:23:29.000Z | src/Entities/ArrowEntity.cpp | wbrbr/MCServer | a7bbca30c560c581127f7b6c49ca427c3e96a1da | [
"Apache-2.0"
] | null | null | null | src/Entities/ArrowEntity.cpp | wbrbr/MCServer | a7bbca30c560c581127f7b6c49ca427c3e96a1da | [
"Apache-2.0"
] | 1 | 2018-09-16T04:44:56.000Z | 2018-09-16T04:44:56.000Z | #include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "Player.h"
#include "ArrowEntity.h"
#include "../Chunk.h"
cArrowEntity::cArrowEntity(cEntity * a_Creator, double a_X, double a_Y, double a_Z, const Vector3d & a_Speed) :
super(pkArrow, a_Creator, a_X, a_Y, a_Z, 0.5, 0.5),
m_PickupState(psNoPickup),
m_DamageCoeff(2),
m_IsCritical(false),
m_Timer(0),
m_HitGroundTimer(0),
m_HasTeleported(false),
m_bIsCollected(false),
m_HitBlockPos(Vector3i(0, 0, 0))
{
SetSpeed(a_Speed);
SetMass(0.1);
SetGravity(-20.0f);
SetAirDrag(0.2f);
SetYawFromSpeed();
SetPitchFromSpeed();
FLOGD("Created arrow {0} with speed {1:.02f} and rot {{{2:.02f}, {3:.02f}}}",
m_UniqueID, GetSpeed(), GetYaw(), GetPitch()
);
}
cArrowEntity::cArrowEntity(cPlayer & a_Player, double a_Force) :
super(pkArrow, &a_Player, a_Player.GetThrowStartPos(), a_Player.GetThrowSpeed(a_Force * 1.5 * 20), 0.5, 0.5),
m_PickupState(psInSurvivalOrCreative),
m_DamageCoeff(2),
m_IsCritical((a_Force >= 1)),
m_Timer(0),
m_HitGroundTimer(0),
m_HasTeleported(false),
m_bIsCollected(false),
m_HitBlockPos(0, 0, 0)
{
if (a_Player.IsGameModeCreative())
{
m_PickupState = psInCreative;
}
SetGravity(-20.0f);
SetAirDrag(0.01f);
}
bool cArrowEntity::CanPickup(const cPlayer & a_Player) const
{
switch (m_PickupState)
{
case psNoPickup: return false;
case psInSurvivalOrCreative: return (a_Player.IsGameModeSurvival() || a_Player.IsGameModeCreative());
case psInCreative: return a_Player.IsGameModeCreative();
}
UNREACHABLE("Unsupported arrow pickup state");
}
void cArrowEntity::OnHitSolidBlock(Vector3d a_HitPos, eBlockFace a_HitFace)
{
Vector3d Hit = a_HitPos;
Hit += GetSpeed().NormalizeCopy() / 100000; // Make arrow sink into block a bit so it lodges (TODO: investigate how to stop them going so far so that they become black clientside)
super::OnHitSolidBlock(Hit, a_HitFace);
Vector3i BlockHit = Hit.Floor();
int X = BlockHit.x, Y = BlockHit.y, Z = BlockHit.z;
m_HitBlockPos = Vector3i(X, Y, Z);
// Broadcast arrow hit sound
m_World->BroadcastSoundEffect("entity.arrow.hit", BlockHit, 0.5f, static_cast<float>(0.75 + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
if ((m_World->GetBlock(Hit) == E_BLOCK_TNT) && IsOnFire())
{
m_World->SetBlock(X, Y, Z, E_BLOCK_AIR, 0);
m_World->SpawnPrimedTNT(Vector3d(BlockHit));
}
}
void cArrowEntity::OnHitEntity(cEntity & a_EntityHit, Vector3d a_HitPos)
{
super::OnHitEntity(a_EntityHit, a_HitPos);
int Damage = static_cast<int>(GetSpeed().Length() / 20 * m_DamageCoeff + 0.5);
if (m_IsCritical)
{
Damage += m_World->GetTickRandomNumber(Damage / 2 + 2);
}
unsigned int PowerLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPower);
if (PowerLevel > 0)
{
int ExtraDamage = static_cast<int>(ceil(0.25 * (PowerLevel + 1)));
Damage += ExtraDamage;
}
unsigned int PunchLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPunch);
double KnockbackAmount = 11 + 10 * PunchLevel;
a_EntityHit.TakeDamage(dtRangedAttack, GetCreatorUniqueID(), Damage, KnockbackAmount);
if (IsOnFire() && !a_EntityHit.IsInWater())
{
a_EntityHit.StartBurning(100);
}
// Broadcast successful hit sound
GetWorld()->BroadcastSoundEffect("entity.arrow.hit_player", GetPosition(), 0.5, static_cast<float>(0.75 + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
Destroy();
}
void cArrowEntity::CollectedBy(cPlayer & a_Dest)
{
if (m_IsInGround && !m_bIsCollected && CanPickup(a_Dest))
{
// Do not add the arrow to the inventory when the player is in creative:
if (!a_Dest.IsGameModeCreative())
{
int NumAdded = a_Dest.GetInventory().AddItem(E_ITEM_ARROW);
if (NumAdded == 0)
{
// No space in the inventory
return;
}
}
GetWorld()->BroadcastCollectEntity(*this, a_Dest, 1);
GetWorld()->BroadcastSoundEffect("entity.item.pickup", GetPosition(), 0.5, static_cast<float>(0.75 + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
m_bIsCollected = true;
}
}
void cArrowEntity::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
{
super::Tick(a_Dt, a_Chunk);
if (!IsTicking())
{
// The base class tick destroyed us
return;
}
m_Timer += a_Dt;
if (m_bIsCollected)
{
if (m_Timer > std::chrono::milliseconds(500))
{
Destroy();
return;
}
}
else if (m_Timer > std::chrono::minutes(5))
{
Destroy();
return;
}
if (m_IsInGround)
{
if (!m_HasTeleported) // Sent a teleport already, don't do again
{
if (m_HitGroundTimer > std::chrono::milliseconds(500))
{
m_World->BroadcastTeleportEntity(*this);
m_HasTeleported = true;
}
else
{
m_HitGroundTimer += a_Dt;
}
}
int RelPosX = m_HitBlockPos.x - a_Chunk.GetPosX() * cChunkDef::Width;
int RelPosZ = m_HitBlockPos.z - a_Chunk.GetPosZ() * cChunkDef::Width;
cChunk * Chunk = a_Chunk.GetRelNeighborChunkAdjustCoords(RelPosX, RelPosZ);
if (Chunk == nullptr)
{
// Inside an unloaded chunk, abort
return;
}
if (Chunk->GetBlock(RelPosX, m_HitBlockPos.y, RelPosZ) == E_BLOCK_AIR) // Block attached to was destroyed?
{
m_IsInGround = false; // Yes, begin simulating physics again
}
}
}
| 24.211982 | 181 | 0.696422 | wbrbr |
0fc31a4f51e9b466f53c6f9db2da11ed596a6165 | 2,678 | cpp | C++ | addons/80s_tanoa_vehicles/gendarmerie/bo105/config.cpp | maxmconrad/80sTanoaDev | 68fbc5712d97308b67777aeb0444dbc46ea03eab | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | null | null | null | addons/80s_tanoa_vehicles/gendarmerie/bo105/config.cpp | maxmconrad/80sTanoaDev | 68fbc5712d97308b67777aeb0444dbc46ea03eab | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | null | null | null | addons/80s_tanoa_vehicles/gendarmerie/bo105/config.cpp | maxmconrad/80sTanoaDev | 68fbc5712d97308b67777aeb0444dbc46ea03eab | [
"Naumen",
"Condor-1.1",
"MS-PL"
] | null | null | null | class CfgPatches
{
class 80s_tanoa_vehicles_gendarmerie_bo105
{
units[]=
{
"80s_tanoa_gendarmerie_bo105"
};
weapons[]=
{
};
requiredAddons[]=
{
"gm_core_vehicles",
};
};
};
/////////////////////////
// BO-105 /
/////////////////////////
class gm_texturesource_base;
class CfgVehicles
{
class gm_bo105m_base;
class gm_bo105m_vbh_base: gm_bo105m_base
{
class TextureSources
{
class 80s_tanoa_gendarmerie_blk: gm_texturesource_base
{
factions[]=
{
"80s_tanoa_gendarmerie"
};
displayname="Gendarmerie (Black)";
textures[]=
{
"",
"\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\80s_tanoa_bo105_ext_01_co.paa",
"\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\80s_tanoa_bo105_ext_01_co.paa"
};
};
};
};
class 80s_tanoa_gendarmerie_bo105_base: gm_bo105m_vbh_base
{
side=1;
faction="80s_tanoa_gendarmerie";
gm_InsigniasDefaultNation="80s_tanoa_insignia_hi_civ_01";
gm_LicensePlate="80s_tanoa_licenseplate";
gm_LicensePlateSelectionsDigits[]=
{
//"LicensePlate_01",
//"LicensePlate_02",
"LicensePlate_03",
"LicensePlate_04",
"LicensePlate_05",
"LicensePlate_06",
"LicensePlate_07",
"LicensePlate_08"
};
gm_TacticalSignsDefaultIcon="";
gm_TacticalNumbersFontNumbers="";
gm_TacticalNumbersDefaultNumber="##";
gm_LicensePlateDefaultDigits="######";
crew="80s_tanoa_gendarme_pilot_p1";
editorPreview="\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\editorpreview\80s_tanoa_gendarmerie_bo105.jpg";
};
class 80s_tanoa_gendarmerie_bo105: 80s_tanoa_gendarmerie_bo105_base
{
displayName="Bo-105";
scope=2;
scopeCurator=2;
scopeArsenal=2;
author="quarren";
editorPreview="\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\editorpreview\80s_tanoa_gendarmerie_bo105.jpg";
class TransportItems
{
class _xx_burnBandage
{
name="gm_ge_army_burnBandage";
count=4;
};
class _xx_gauzeBandage
{
name="gm_ge_army_gauzeBandage";
count=4;
};
class _xx_gm_repairkit_01
{
name="gm_repairkit_01";
count=2;
};
};
hiddenSelectionsTextures[]=
{
"",
"\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\80s_tanoa_bo105_ext_01_co.paa",
"\80s_tanoa\80s_tanoa_vehicles\gendarmerie\bo105\data\80s_tanoa_bo105_ext_01_co.paa"
};
}
}; | 26 | 123 | 0.622106 | maxmconrad |
0fc4b0a1e39e6b71c08ceee191725933b0640af4 | 30 | cpp | C++ | src/render/raytracer/raytracer_uniform.cpp | reneruhr/kipod | 5860f1730049a7901d4825be9af00d99aa99b8fa | [
"Apache-2.0",
"MIT"
] | null | null | null | src/render/raytracer/raytracer_uniform.cpp | reneruhr/kipod | 5860f1730049a7901d4825be9af00d99aa99b8fa | [
"Apache-2.0",
"MIT"
] | null | null | null | src/render/raytracer/raytracer_uniform.cpp | reneruhr/kipod | 5860f1730049a7901d4825be9af00d99aa99b8fa | [
"Apache-2.0",
"MIT"
] | null | null | null | #include "raytracer_uniform.h" | 30 | 30 | 0.833333 | reneruhr |
0fcaf7c3b0c822e20cb038673d225b1f21bc11d9 | 347 | cpp | C++ | CodeForces/Codeforces Round #775/b.cpp | ajidow/Answers_of_OJ | 70e0c02d9367c3a154b83a277edbf158f32484a3 | [
"MIT"
] | null | null | null | CodeForces/Codeforces Round #775/b.cpp | ajidow/Answers_of_OJ | 70e0c02d9367c3a154b83a277edbf158f32484a3 | [
"MIT"
] | null | null | null | CodeForces/Codeforces Round #775/b.cpp | ajidow/Answers_of_OJ | 70e0c02d9367c3a154b83a277edbf158f32484a3 | [
"MIT"
] | null | null | null | #include <iostream>
#include <algorithm>
using namespace std;
int a[100010];
int main(int argc, char const *argv[])
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
{
cin >> a[i];
}
sort(a + 1, a + 1 + n);
int ans = 0;
}
return 0;
} | 11.965517 | 38 | 0.530259 | ajidow |
0fcd240a6389f7dabadce2ec2aa90172eef34b3e | 1,267 | hh | C++ | include/point2D.hh | Nixsm/space-invaders | 3b771b7bc37f380716f22d0515d4e8a0d9f04f50 | [
"MIT"
] | null | null | null | include/point2D.hh | Nixsm/space-invaders | 3b771b7bc37f380716f22d0515d4e8a0d9f04f50 | [
"MIT"
] | null | null | null | include/point2D.hh | Nixsm/space-invaders | 3b771b7bc37f380716f22d0515d4e8a0d9f04f50 | [
"MIT"
] | null | null | null | #ifndef MATH_POINT2D_HH
#define MATH_POINT2D_HH
#include <iostream>
namespace Math {
class Point2D {
public:
Point2D() { }
Point2D(float x, float y)
:_x(x), _y(y)
{ }
float getX() {
return _x;
}
void setX(float x) {
_x = x;
}
float getY() {
return _y;
}
void setY(float y) {
_y = y;
}
Point2D& operator+(const Point2D& other) {
_y -= other._y;
_x -= other._x;
return *this;
}
Point2D& operator-(const Point2D& other) {
_y += other._y;
_x += other._x;
return *this;
}
Point2D& operator*(const float& constant) {
_x *= constant;
_y *= constant;
return *this;
}
friend std::ostream& operator<<(std::ostream& os, const Point2D& point) {
os << "(X: " << point._x << " Y: " << point._y << ")";
return os;
}
private:
float _x;
float _y;
};
}
#endif //MATH_POINT2D_H | 20.111111 | 81 | 0.38674 | Nixsm |
0fcdf3ca0dbb8b5d246e1ffc4575d5a055737523 | 1,111 | cpp | C++ | src/tracked_types.cpp | zionlang/zion | 6e5adc7529cbed47b1a1c06b56b8a1764cd44bac | [
"MIT"
] | 63 | 2016-06-04T04:04:00.000Z | 2022-03-17T08:38:49.000Z | src/tracked_types.cpp | zionlang/zion | 6e5adc7529cbed47b1a1c06b56b8a1764cd44bac | [
"MIT"
] | 29 | 2017-03-02T03:36:34.000Z | 2021-01-27T03:23:09.000Z | src/tracked_types.cpp | zionlang/zion | 6e5adc7529cbed47b1a1c06b56b8a1764cd44bac | [
"MIT"
] | 3 | 2017-12-26T20:50:38.000Z | 2020-12-23T03:20:06.000Z | #include "tracked_types.h"
#include "ast.h"
#include "dbg.h"
#include "logger_decls.h"
namespace zion {
types::Ref get_tracked_type(const TrackedTypes &tracked_types,
const ast::Expr *e) {
auto iter = tracked_types.find(e);
if (iter == tracked_types.end()) {
log_location(log_error, e->get_location(),
"translation env does not contain a type for %s",
e->str().c_str());
assert(false && !!"missing type for expression");
return {};
} else {
return iter->second;
}
}
void rebind_tracked_types(TrackedTypes &tracked_types,
const types::Map &bindings) {
if (bindings.size() == 0) {
return;
}
for (auto pair : tracked_types) {
if (pair.second->ftv_count() != 0) {
debug_above(7, log("changing tracked_types[%s] from %s to %s",
pair.first->str().c_str(), pair.second->str().c_str(),
pair.second->rebind(bindings)->str().c_str()));
tracked_types[pair.first] = pair.second->rebind(bindings);
}
}
}
} // namespace zion
| 27.775 | 79 | 0.576058 | zionlang |
0fd25ee4f2fa1d776e1c325b422386c5df544017 | 5,826 | c++ | C++ | src/extern/inventor/apps/demos/revo/profile.c++ | OpenXIP/xip-libraries | 9f0fef66038b20ff0c81c089d7dd0038e3126e40 | [
"Apache-2.0"
] | 2 | 2020-05-21T07:06:07.000Z | 2021-06-28T02:14:34.000Z | src/extern/inventor/apps/demos/revo/profile.c++ | OpenXIP/xip-libraries | 9f0fef66038b20ff0c81c089d7dd0038e3126e40 | [
"Apache-2.0"
] | null | null | null | src/extern/inventor/apps/demos/revo/profile.c++ | OpenXIP/xip-libraries | 9f0fef66038b20ff0c81c089d7dd0038e3126e40 | [
"Apache-2.0"
] | 6 | 2016-03-21T19:53:18.000Z | 2021-06-08T18:06:03.000Z | /*
*
* Copyright (C) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*
*/
//
// Some code for setting up and dealing with the profile window.
//
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <stdlib.h>
#include <Inventor/Xt/SoXt.h>
#include <Inventor/SoDB.h>
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoLightModel.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoOrthographicCamera.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <Inventor/sensors/SoSensor.h>
#include <Xm/Text.h>
#include "LineManip.h"
#include "Useful.h"
#include "RevClass.h"
//
// The line manipulator.
//
static LineManip2 *TheLineManip;
//
// The default coordinates for the line manipulator.
//
static float defaultCoords[2][3] =
{
{ 0.5, 0.2, 0.0 },
{ 0.5, -0.2, 0.0 },
};
//
// Grid for window:
//
static char *GridString =
"#Inventor V2.0 ascii\n"
"Separator {"
" PickStyle { style UNPICKABLE }"
" LightModel { model BASE_COLOR }"
" BaseColor { rgb 0.2 0.2 0.2 }"
" Array {"
" numElements1 19"
" separation1 .1 0 0"
" origin CENTER"
" Coordinate3 { point [ 0 -1 0, 0 1 0 ] }"
" LineSet { numVertices [ 2 ] }"
" }"
" Array {"
" numElements1 19"
" separation1 0 .1 0"
" origin CENTER"
" Coordinate3 { point [ -1 0 0, 1 0 0 ] }"
" LineSet { numVertices [ 2 ] }"
" }"
" BaseColor { rgb 0.4 0.0 0.0 }"
" Coordinate3 { point [ -1.0 0.0 0.0, 1.0 0.0 0.0,"
" 0.0 -1.0 0.0, 0.0 1.0 0.0 ]"
" }"
" LineSet { numVertices [ 2, 2 ] }"
"}";
//
// This is called when the mouse leaves the profile window. It turns
// off the line manip's hilights.
//
static void
leaveProfileWindow(Widget, XtPointer mydata, XEvent *, Boolean *cont)
{
((LineManip2 *)mydata)->removeHilights();
*cont = TRUE; // Continue dispatching this event
}
//
// Called to get rid of all the points added so far.
//
void
clearPoints()
{
SoCoordinate3 *coord = TheLineManip->getCoordinate3();
coord->point.deleteValues(0);
}
//
// Called whenever the profile is edited. It tells the surface to
// recalculate itself. Note that this could be more efficient by
// noticing exactly what changed and just recomputing what is
// necessary (e.g. when adding a point to the end, only two sets of
// normals needs to be generated, etc).
//
static void
profileChangedCallback(void *data, SoSensor *)
{
RevolutionSurface *s = (RevolutionSurface *)data;
SoCoordinate3 *coord = TheLineManip->getCoordinate3();
s->createSurface(&coord->point);
}
//
// This creates the profile's scene graph and sets up the callback so
// the line manipulator turns off its hilights when the mouse leaves
// the profile window.
//
SoNode *
createProfileGraph(Widget profileWidget, RevolutionSurface *surface)
{
SoSeparator *result = new SoSeparator;
result->ref();
SoOrthographicCamera *c = new SoOrthographicCamera;
result->addChild(c);
c->position.setValue(0.5, 0.0, 1.0);
c->nearDistance = 0.5;
c->farDistance = 1.5;
c->focalDistance = 1.0;
c->height = 1.0;
// Axes and labels (appear underneath the line manipulator)
SoInput in;
in.setBuffer(GridString, strlen(GridString));
SoNode *node;
SoDB::read(&in, node);
SoSeparator *g1 = (SoSeparator *)node;
if (g1 != NULL)
{
result->addChild(g1);
g1->renderCaching = SoSeparator::ON;
g1->boundingBoxCaching = SoSeparator::ON;
}
SoSeparator *manipGroup = new SoSeparator;
result->addChild(manipGroup);
SoLightModel *lm = new SoLightModel;
manipGroup->addChild(lm);
lm->model = SoLightModel::BASE_COLOR;
SoMaterial *m = new SoMaterial;
m->diffuseColor.setValue(0.0, 0.8, 0.8);
manipGroup->addChild(m);
TheLineManip = new LineManip2;
TheLineManip->setHilightSize(0.02);
manipGroup->addChild(TheLineManip);
SoCoordinate3 *coord = TheLineManip->getCoordinate3();
SoNodeSensor *d = new SoNodeSensor(profileChangedCallback, surface);
d->attach(coord);
coord->point.setValues(0, 2, defaultCoords);
//
// Make sure surface of revolution and line manip both agree on
// the default coordinates
//
surface->createSurface(&coord->point);
XtAddEventHandler(profileWidget, LeaveWindowMask,
FALSE, leaveProfileWindow, (XtPointer)TheLineManip);
result->unrefNoDelete();
return result;
}
| 27.875598 | 77 | 0.688465 | OpenXIP |
0fdb263006642a6a6cd32b6549504a36fff8a3a8 | 4,667 | cpp | C++ | src/ADBViewer/src/App/gui/guiIcon.cpp | ClnViewer/ADB-Android-Viewer | c619fe626ab390b656893974700a0b6379159c03 | [
"MIT"
] | 9 | 2019-05-20T12:06:36.000Z | 2022-03-24T19:11:06.000Z | src/ADBViewer/src/App/gui/guiIcon.cpp | ClnViewer/ADB-Android-Viewer | c619fe626ab390b656893974700a0b6379159c03 | [
"MIT"
] | null | null | null | src/ADBViewer/src/App/gui/guiIcon.cpp | ClnViewer/ADB-Android-Viewer | c619fe626ab390b656893974700a0b6379159c03 | [
"MIT"
] | 3 | 2020-07-06T04:51:33.000Z | 2021-07-26T20:08:02.000Z | /*
MIT License
Android remote Viewer, GUI ADB tools
Android Viewer developed to view and control your android device from a PC.
ADB exchange Android Viewer, support scale view, input tap from mouse,
input swipe from keyboard, save/copy screenshot, etc..
Copyright (c) 2016-2019 PS
GitHub: https://github.com/ClnViewer/ADB-Android-Viewer
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, sub license, 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 "../../ADBViewer.h"
bool guiIcon::init(
App *app,
SDL_Rect & rect,
ResManager::IndexImageResource resid,
std::function<bool(SDL_Event*, SDL_Rect*)> f
)
{
if (!app)
return false;
m_app = app;
m_resid = resid;
m_func = f;
guiBase::gui.rdst = rect;
guiBase::gui.rsrc = nullptr;
guiBase::gui.texture = nullptr;
bool ret = guiBase::initgui(app);
guiBase::ActiveOff();
return ret;
}
bool guiIcon::tinit(SDL_Texture **texture)
{
GuiLock(
if ((texture) && (*texture))
SDL_DestroyTexture(*texture);
*texture = nullptr;
);
return true;
}
bool guiIcon::evresize(SDL_Texture**)
{
Off();
On();
return true;
}
void guiIcon::On()
{
On(nullptr);
}
void guiIcon::On(SDL_Point *p)
{
SDL_Surface *l_image_surface = nullptr;
SDL_Texture *l_texture = nullptr;
do
{
if (!(l_image_surface = ResManager::imageload(m_resid)))
break;
SDL_Rect *r = guiBase::GetGui<SDL_Rect>();
r->w = l_image_surface->w;
r->h = l_image_surface->h;
l_texture = SDL_CreateTexture(
guiBase::GetGui<SDL_Renderer>(),
SDL_PIXELFORMAT_RGB24,
SDL_TEXTUREACCESS_STREAMING,
r->w,
r->h
);
if (!l_texture)
{
SDLErrorMessageQueue();
break;
}
if (p)
{
r->x = p->x;
r->y = p->y;
}
SDL_UpdateTexture(l_texture, nullptr, l_image_surface->pixels, l_image_surface->pitch);
SDL_FreeSurface(l_image_surface);
GuiLock(
std::swap(guiBase::gui.texture, l_texture);
);
if (l_texture)
SDL_DestroyTexture(l_texture);
guiBase::ActiveOn();
return;
}
while (0);
if (l_image_surface)
SDL_FreeSurface(l_image_surface);
if (l_texture)
SDL_DestroyTexture(l_texture);
guiBase::ActiveOff();
}
void guiIcon::Off()
{
guiBase::ActiveOff();
SDL_Texture *l_texture = nullptr;
GuiLock(
std::swap(guiBase::gui.texture, l_texture);
);
if (l_texture)
SDL_DestroyTexture(l_texture);
}
bool guiIcon::event(SDL_Event *ev, const void *instance)
{
bool isreg = false;
guiIcon *gi = static_cast<guiIcon*>(
const_cast<void*>(instance)
);
if ((!gi) || (!gi->m_func))
return false;
switch (ev->type)
{
case SDL_MOUSEMOTION: isreg = true; break;
case SDL_MOUSEBUTTONDOWN: if (ev->button.button == SDL_BUTTON_LEFT) { isreg = true; } break;
default: break;
}
if (isreg)
{
SDL_Rect *r = gi->guiBase::GetGui<SDL_Rect>();
if (gi->guiBase::IsRegion(ev, r))
return gi->m_func(ev, r);
}
return false;
}
| 27.452941 | 100 | 0.573173 | ClnViewer |
0fde9f33c4d275d0d63ff5720a92f555138a52e3 | 9,779 | cc | C++ | cinn/hlir/pe/reduction.cc | hp03/CINN | 2a162037b1665877ce005750691415ddd859d446 | [
"Apache-2.0"
] | null | null | null | cinn/hlir/pe/reduction.cc | hp03/CINN | 2a162037b1665877ce005750691415ddd859d446 | [
"Apache-2.0"
] | null | null | null | cinn/hlir/pe/reduction.cc | hp03/CINN | 2a162037b1665877ce005750691415ddd859d446 | [
"Apache-2.0"
] | null | null | null | // Copyright (c) 2021 CINN 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 "cinn/hlir/pe/reduction.h"
#include <cinn/ir/ir_base.h>
#include <algorithm>
#include "cinn/common/ir_util.h"
#include "cinn/hlir/pe/broadcast.h"
#include "cinn/ir/ir_operators.h"
#include "cinn/ir/tensor.h"
#include "cinn/lang/builtin.h"
#include "cinn/lang/compute.h"
namespace cinn {
namespace hlir {
namespace pe {
using ir::Tensor;
using lang::Compute;
/**
* @brief transform reduction axes which could be empty or have negative elements into real axes with valid dimension
* indices.
*
* @param ndim Number of dimensions of the output tensor.
* @param axes The axes parameter.
* @param real_axes A non-empty sorted array of valid dimension indices, with no duplicates.
*
* @notes If the input axes are empty, the result will be axes including all dimensions. If any input element is
* negative, it will be treated as an offset from the last dimension (same as python indexing rules).
*/
void GetRealAxes(int ndim, const std::vector<int>& axes, std::vector<int>* real_axes) {
CHECK(real_axes);
if (axes.empty()) {
for (int i = 0; i < ndim; ++i) {
real_axes->push_back(i);
}
} else {
for (auto axis : axes) {
if (axis < 0) {
axis += ndim;
}
CHECK_LE(axis, ndim) << "exceeds the maximum dimension: " << ndim << std::endl;
CHECK_GE(axis, 0);
real_axes->push_back(axis);
}
real_axes->resize(std::unique(real_axes->begin(), real_axes->end()) - real_axes->begin());
std::sort(real_axes->begin(), real_axes->end());
}
}
/**
* @brief Calculate the target reduced shape.
*
* @param real_axes A non-empty sorted array of valid dimension indices, with no duplicates.
* @param output_shape The output Tensor shape.
* @param tensor The input tensor.
* @param keep_dims If this is set to true, the reduced axes are kept as dimensions with size one. This enables the
* result to broadcast correctly against the input array.
*/
void GetOutputShape(const std::vector<int>& real_axes,
std::vector<Expr>* output_shape,
const Tensor& tensor,
bool keep_dims) {
CHECK(output_shape);
auto ndim = tensor->shape.size();
if (keep_dims) {
for (size_t i = 0; i < ndim; ++i) {
if (std::find(real_axes.begin(), real_axes.end(), i) != real_axes.end()) {
output_shape->push_back(common::make_one());
} else {
output_shape->push_back(tensor->shape[i]);
}
}
} else {
for (size_t i = 0; i < ndim; ++i) {
if (std::find(real_axes.begin(), real_axes.end(), i) == real_axes.end()) {
output_shape->push_back(tensor->shape[i]);
}
}
}
if (output_shape->empty()) {
output_shape->push_back(common::make_one());
}
}
/*!
* @brief Create a reduction PE.
*
* @param tensor The input tensor.
* @param fn The reduction function eg. ReduceSum
* @param output_shape The output Tensor shape.
* @param real_axes The real axes where the reduction is performed.
* @param squeeze_axes The real axes to squeeze. If unsqueezed, reduced axes will have shape 1 in the output tensor.
* @param initial Starting value for the sum.
* @param output_name The name of the output Tensor.
*
* @return The result tensor.
*/
template <typename FuncOp>
Tensor DoReduce(const Tensor& tensor,
const FuncOp& fn,
const std::vector<Expr>& output_shape,
const std::vector<int>& real_axes,
const std::vector<int>& squeeze_axes,
Expr initial,
const std::string& output_name) {
std::vector<Var> reduce_axes;
for (auto& axis : real_axes) {
std::string name = UniqName("kk");
reduce_axes.push_back(Var(tensor->shape[axis], name));
}
auto compute = [&](const std::vector<Expr>& indices) -> Expr {
std::vector<Expr> eval_indice;
int indice_cnt = 0;
int reduce_cnt = 0;
for (size_t i = 0; i < tensor->shape.size(); ++i) {
bool squeeze_i = std::find(squeeze_axes.begin(), squeeze_axes.end(), i) != squeeze_axes.end();
if (std::find(real_axes.begin(), real_axes.end(), i) != real_axes.end()) {
eval_indice.push_back(reduce_axes[reduce_cnt]);
reduce_cnt++;
indice_cnt += !squeeze_i;
continue;
}
eval_indice.push_back(indices[indice_cnt]);
indice_cnt++;
}
return fn(tensor(eval_indice), reduce_axes, initial);
};
Tensor C = Compute(output_shape, compute, output_name);
return C;
}
/**
* @brief reduction PE
*
* @param tensor The input tensor.
* @param axes The axes along which the reduction are performed.
* @param fn The reduction function eg. ReduceSum
* @param keep_dims If it is set true, the axes which are reduced are left in the result as dimensions with size one.
* @param initial Starting value for the sum.
*
* @return The result tensor.
*/
template <typename FuncOp>
Tensor Reduce(const Tensor& tensor,
const std::vector<int>& axes,
const FuncOp& fn,
bool keep_dims,
ir::Expr initial,
const std::string& output_name) {
auto ndim = tensor->shape.size();
CHECK_GT(ndim, 0) << "Reduce tensor's dim must be more than 0";
std::vector<int> real_axes;
GetRealAxes(static_cast<int>(ndim), axes, &real_axes);
std::vector<Expr> output_shapes;
GetOutputShape(real_axes, &output_shapes, tensor, keep_dims);
return DoReduce(
tensor, fn, output_shapes, real_axes, keep_dims ? std::vector<int>() : real_axes, initial, output_name);
}
Tensor ReduceSum(
const Tensor& A, const std::vector<int>& axes, bool keep_dims, ir::Expr initial, const std::string& output_name) {
if (!initial.defined()) {
initial = common::make_const(A->type(), 0);
}
return Reduce(A, axes, lang::ReduceSum, keep_dims, initial, output_name);
}
Tensor ReduceProd(
const Tensor& A, const std::vector<int>& axes, bool keep_dims, ir::Expr initial, const std::string& output_name) {
if (!initial.defined()) {
initial = common::make_const(A->type(), 1);
}
return Reduce(A, axes, lang::ReduceMul, keep_dims, initial, output_name);
}
Tensor ReduceMax(
const Tensor& A, const std::vector<int>& axes, bool keep_dims, Expr initial, const std::string& output_name) {
return Reduce(A, axes, lang::ReduceMax, keep_dims, Expr(), output_name);
}
Tensor ReduceMin(
const Tensor& A, const std::vector<int>& axes, bool keep_dims, Expr initial, const std::string& output_name) {
return Reduce(A, axes, lang::ReduceMin, keep_dims, Expr(), output_name);
}
std::vector<Tensor> WarpReduce(const ir::Tensor& A,
int last_reduce_dim_num,
const std::string& reduce_type,
const std::string& output_name) {
Expr lane(1);
for (int idx = A->shape.size() - 1; idx >= (A->shape.size() - last_reduce_dim_num); --idx) {
lane = lane * A->shape[idx].as_int32();
}
std::vector<Expr> tmp_shape(A->shape.begin(), A->shape.begin() + A->shape.size() - last_reduce_dim_num);
tmp_shape.push_back(Expr(32));
auto tmp_out = Compute(
tmp_shape,
[=](const std::vector<Expr>& indexs) -> Expr {
std::vector<Expr> tmp_indexs(indexs.begin(), indexs.begin() + indexs.size() - 1);
for (int idx = 0; idx < last_reduce_dim_num; ++idx) {
tmp_indexs.push_back(Expr(0));
}
CHECK_EQ(A->shape.size(), tmp_indexs.size());
Expr offset = common::IndiceToAbsOffset(A->shape, tmp_indexs);
return lang::CallExtern(reduce_type, {A, offset, lane});
},
UniqName(output_name + "_" + reduce_type));
std::vector<Expr> out_shape(A->shape.begin(), A->shape.begin() + A->shape.size() - last_reduce_dim_num);
auto out = Compute(
out_shape,
[=](const std::vector<Expr>& indexs) -> Expr {
std::vector<Expr> tmp_indexs(indexs);
tmp_indexs.push_back(Expr(0));
return tmp_out(tmp_indexs);
},
UniqName(output_name));
return {out, tmp_out};
}
/**
* @brief find the max of array elements over the last dimension
*
* @param A The input Tensor
* @param output_name The name of the output Tensor
*/
std::vector<ir::Tensor> WarpReduceMax(const ir::Tensor& A, int last_reduce_dim_num, const std::string& output_name) {
return WarpReduce(A, last_reduce_dim_num, "cinn_warp_reduce_max", output_name);
}
/**
* @brief compute the sum of array elements over the last dimension
*
* @param A The input Tensor
* @param output_name The name of the output Tensor
*/
std::vector<ir::Tensor> WarpReduceSum(const ir::Tensor& A, int last_reduce_dim_num, const std::string& output_name) {
return WarpReduce(A, last_reduce_dim_num, "cinn_warp_reduce_sum", output_name);
}
/**
* @brief compute the average of array elements over the last dimension
*
* @param A The input Tensor
* @param output_name The name of the output Tensor
*/
std::vector<ir::Tensor> WarpReduceAvg(const ir::Tensor& A, int last_reduce_dim_num, const std::string& output_name) {
return WarpReduce(A, last_reduce_dim_num, "cinn_warp_reduce_avg", output_name);
}
} // namespace pe
} // namespace hlir
} // namespace cinn
| 35.689781 | 118 | 0.661008 | hp03 |
0fea668b97fe0c5de44482de956a2c79a9196fa0 | 34,122 | cpp | C++ | src/armnn/layers/LstmLayer.cpp | tkdhmin/armnn | af2dac50e2581262492af05010a4bf7bb26b690d | [
"MIT"
] | 856 | 2018-03-09T17:26:23.000Z | 2022-03-24T21:31:33.000Z | src/armnn/layers/LstmLayer.cpp | tuanhe/armnn | 8a4bd6671d0106dfb788b8c9019f2f9646770f8d | [
"MIT"
] | 623 | 2018-03-13T04:40:42.000Z | 2022-03-31T09:45:17.000Z | src/armnn/layers/LstmLayer.cpp | tuanhe/armnn | 8a4bd6671d0106dfb788b8c9019f2f9646770f8d | [
"MIT"
] | 284 | 2018-03-09T23:05:28.000Z | 2022-03-29T14:42:28.000Z | //
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "LstmLayer.hpp"
#include "LayerCloneBase.hpp"
#include <armnn/LstmParams.hpp>
#include <armnn/TypesUtils.hpp>
#include <backendsCommon/TensorHandle.hpp>
#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
LstmLayer::LstmLayer(const LstmDescriptor& param, const char* name)
: LayerWithParameters(3, 4, LayerType::Lstm, param, name)
{
}
std::unique_ptr<IWorkload> LstmLayer::CreateWorkload(const IWorkloadFactory& factory) const
{
LstmQueueDescriptor descriptor;
// Basic parameters
descriptor.m_InputToForgetWeights = m_BasicParameters.m_InputToForgetWeights.get();
descriptor.m_InputToCellWeights = m_BasicParameters.m_InputToCellWeights.get();
descriptor.m_InputToOutputWeights = m_BasicParameters.m_InputToOutputWeights.get();
descriptor.m_RecurrentToForgetWeights = m_BasicParameters.m_RecurrentToForgetWeights.get();
descriptor.m_RecurrentToCellWeights = m_BasicParameters.m_RecurrentToCellWeights.get();
descriptor.m_RecurrentToOutputWeights = m_BasicParameters.m_RecurrentToOutputWeights.get();
descriptor.m_ForgetGateBias = m_BasicParameters.m_ForgetGateBias.get();
descriptor.m_CellBias = m_BasicParameters.m_CellBias.get();
descriptor.m_OutputGateBias = m_BasicParameters.m_OutputGateBias.get();
// Cifg parameters
if (!m_Param.m_CifgEnabled)
{
descriptor.m_InputToInputWeights = m_CifgParameters.m_InputToInputWeights.get();
descriptor.m_RecurrentToInputWeights = m_CifgParameters.m_RecurrentToInputWeights.get();
descriptor.m_InputGateBias = m_CifgParameters.m_InputGateBias.get();
}
// Projection parameters
if (m_Param.m_ProjectionEnabled)
{
descriptor.m_ProjectionWeights = m_ProjectionParameters.m_ProjectionWeights.get();
descriptor.m_ProjectionBias = m_ProjectionParameters.m_ProjectionBias.get();
}
// Peephole parameters
if (m_Param.m_PeepholeEnabled)
{
if (!m_Param.m_CifgEnabled)
{
descriptor.m_CellToInputWeights = m_PeepholeParameters.m_CellToInputWeights.get();
}
descriptor.m_CellToForgetWeights = m_PeepholeParameters.m_CellToForgetWeights.get();
descriptor.m_CellToOutputWeights = m_PeepholeParameters.m_CellToOutputWeights.get();
}
// Layer normalisation parameters
if(m_Param.m_LayerNormEnabled)
{
if (!m_Param.m_CifgEnabled)
{
descriptor.m_InputLayerNormWeights = m_LayerNormParameters.m_InputLayerNormWeights.get();
}
descriptor.m_ForgetLayerNormWeights = m_LayerNormParameters.m_ForgetLayerNormWeights.get();
descriptor.m_CellLayerNormWeights = m_LayerNormParameters.m_CellLayerNormWeights.get();
descriptor.m_OutputLayerNormWeights = m_LayerNormParameters.m_OutputLayerNormWeights.get();
}
SetAdditionalInfo(descriptor);
return factory.CreateLstm(descriptor, PrepInfoAndDesc(descriptor));
}
LstmLayer* LstmLayer::Clone(Graph& graph) const
{
auto layer = CloneBase<LstmLayer>(graph, m_Param, GetName());
layer->m_BasicParameters.m_InputToForgetWeights = m_BasicParameters.m_InputToForgetWeights ?
m_BasicParameters.m_InputToForgetWeights
: nullptr;
layer->m_BasicParameters.m_InputToCellWeights = m_BasicParameters.m_InputToCellWeights ?
m_BasicParameters.m_InputToCellWeights : nullptr;
layer->m_BasicParameters.m_InputToOutputWeights = m_BasicParameters.m_InputToOutputWeights ?
m_BasicParameters.m_InputToOutputWeights : nullptr;
layer->m_BasicParameters.m_RecurrentToForgetWeights = m_BasicParameters.m_RecurrentToForgetWeights ?
m_BasicParameters.m_RecurrentToForgetWeights : nullptr;
layer->m_BasicParameters.m_RecurrentToCellWeights = m_BasicParameters.m_RecurrentToCellWeights ?
m_BasicParameters.m_RecurrentToCellWeights : nullptr;
layer->m_BasicParameters.m_RecurrentToOutputWeights = m_BasicParameters.m_RecurrentToOutputWeights ?
m_BasicParameters.m_RecurrentToOutputWeights : nullptr;
layer->m_BasicParameters.m_ForgetGateBias = m_BasicParameters.m_ForgetGateBias ?
m_BasicParameters.m_ForgetGateBias : nullptr;
layer->m_BasicParameters.m_CellBias = m_BasicParameters.m_CellBias ?
m_BasicParameters.m_CellBias : nullptr;
layer->m_BasicParameters.m_OutputGateBias = m_BasicParameters.m_OutputGateBias ?
m_BasicParameters.m_OutputGateBias : nullptr;
if (!m_Param.m_CifgEnabled)
{
layer->m_CifgParameters.m_InputToInputWeights = m_CifgParameters.m_InputToInputWeights ?
m_CifgParameters.m_InputToInputWeights : nullptr;
layer->m_CifgParameters.m_RecurrentToInputWeights = m_CifgParameters.m_RecurrentToInputWeights ?
m_CifgParameters.m_RecurrentToInputWeights : nullptr;
layer->m_CifgParameters.m_InputGateBias = m_CifgParameters.m_InputGateBias ?
m_CifgParameters.m_InputGateBias : nullptr;
}
if (m_Param.m_ProjectionEnabled)
{
layer->m_ProjectionParameters.m_ProjectionWeights = m_ProjectionParameters.m_ProjectionWeights ?
m_ProjectionParameters.m_ProjectionWeights : nullptr;
layer->m_ProjectionParameters.m_ProjectionBias = m_ProjectionParameters.m_ProjectionBias ?
m_ProjectionParameters.m_ProjectionBias : nullptr;
}
if (m_Param.m_PeepholeEnabled)
{
if (!m_Param.m_CifgEnabled)
{
layer->m_PeepholeParameters.m_CellToInputWeights = m_PeepholeParameters.m_CellToInputWeights ?
m_PeepholeParameters.m_CellToInputWeights : nullptr;
}
layer->m_PeepholeParameters.m_CellToForgetWeights = m_PeepholeParameters.m_CellToForgetWeights ?
m_PeepholeParameters.m_CellToForgetWeights : nullptr;
layer->m_PeepholeParameters.m_CellToOutputWeights = m_PeepholeParameters.m_CellToOutputWeights ?
m_PeepholeParameters.m_CellToOutputWeights : nullptr;
}
if (m_Param.m_LayerNormEnabled)
{
layer->m_LayerNormParameters.m_InputLayerNormWeights = m_LayerNormParameters.m_InputLayerNormWeights ?
m_LayerNormParameters.m_InputLayerNormWeights : nullptr;
layer->m_LayerNormParameters.m_ForgetLayerNormWeights = m_LayerNormParameters.m_ForgetLayerNormWeights ?
m_LayerNormParameters.m_ForgetLayerNormWeights : nullptr;
layer->m_LayerNormParameters.m_CellLayerNormWeights = m_LayerNormParameters.m_CellLayerNormWeights ?
m_LayerNormParameters.m_CellLayerNormWeights : nullptr;
layer->m_LayerNormParameters.m_OutputLayerNormWeights = m_LayerNormParameters.m_OutputLayerNormWeights ?
m_LayerNormParameters.m_OutputLayerNormWeights : nullptr;
}
return std::move(layer);
}
std::vector<TensorShape> LstmLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
{
ARMNN_ASSERT(inputShapes.size() == 3);
// Get input values for validation
unsigned int batchSize = inputShapes[0][0];
unsigned int outputSize = inputShapes[1][1];
unsigned int numUnits = inputShapes[2][1];
std::vector<TensorShape> outShapes;
outShapes.push_back(TensorShape({batchSize, numUnits * (m_Param.m_CifgEnabled ? 3 : 4)}));
outShapes.push_back(TensorShape({batchSize, outputSize}));
outShapes.push_back(TensorShape({batchSize, numUnits}));
outShapes.push_back(TensorShape({batchSize, outputSize}));
return outShapes;
}
void LstmLayer::ValidateTensorShapesFromInputs()
{
VerifyLayerConnections(3, CHECK_LOCATION());
const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();
VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);
auto inferredShapes = InferOutputShapes( {
GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(),
GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape(),
GetInputSlot(2).GetConnection()->GetTensorInfo().GetShape()
});
ARMNN_ASSERT(inferredShapes.size() == 4);
// Check if the weights are nullptr
ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToForgetWeights != nullptr,
"LstmLayer: m_BasicParameters.m_InputToForgetWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToCellWeights != nullptr,
"LstmLayer: m_BasicParameters.m_InputToCellWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_InputToOutputWeights != nullptr,
"LstmLayer: m_BasicParameters.m_InputToOutputWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToForgetWeights != nullptr,
"LstmLayer: m_BasicParameters.m_RecurrentToForgetWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToCellWeights != nullptr,
"LstmLayer: m_BasicParameters.m_RecurrentToCellWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_RecurrentToOutputWeights != nullptr,
"LstmLayer: m_BasicParameters.m_RecurrentToOutputWeights should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_ForgetGateBias != nullptr,
"LstmLayer: m_BasicParameters.m_ForgetGateBias should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_CellBias != nullptr,
"LstmLayer: m_BasicParameters.m_CellBias should not be null.");
ARMNN_ASSERT_MSG(m_BasicParameters.m_OutputGateBias != nullptr,
"LstmLayer: m_BasicParameters.m_OutputGateBias should not be null.");
if (!m_Param.m_CifgEnabled)
{
ARMNN_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights != nullptr,
"LstmLayer: m_CifgParameters.m_InputToInputWeights should not be null.");
ARMNN_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights != nullptr,
"LstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not be null.");
ARMNN_ASSERT_MSG(m_CifgParameters.m_InputGateBias != nullptr,
"LstmLayer: m_CifgParameters.m_InputGateBias should not be null.");
ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "LstmLayer");
}
else
{
ARMNN_ASSERT_MSG(m_CifgParameters.m_InputToInputWeights == nullptr,
"LstmLayer: m_CifgParameters.m_InputToInputWeights should not have a value when CIFG is enabled.");
ARMNN_ASSERT_MSG(m_CifgParameters.m_RecurrentToInputWeights == nullptr,
"LstmLayer: m_CifgParameters.m_RecurrentToInputWeights should not have a value when CIFG is enabled.");
ARMNN_ASSERT_MSG(m_CifgParameters.m_InputGateBias == nullptr,
"LstmLayer: m_CifgParameters.m_InputGateBias should not have a value when CIFG is enabled.");
ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "LstmLayer");
}
if (m_Param.m_ProjectionEnabled)
{
ARMNN_ASSERT_MSG(m_ProjectionParameters.m_ProjectionWeights != nullptr,
"LstmLayer: m_ProjectionParameters.m_ProjectionWeights should not be null.");
}
if (m_Param.m_PeepholeEnabled)
{
if (!m_Param.m_CifgEnabled)
{
ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToInputWeights != nullptr,
"LstmLayer: m_PeepholeParameters.m_CellToInputWeights should not be null "
"when Peephole is enabled and CIFG is disabled.");
}
ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToForgetWeights != nullptr,
"LstmLayer: m_PeepholeParameters.m_CellToForgetWeights should not be null.");
ARMNN_ASSERT_MSG(m_PeepholeParameters.m_CellToOutputWeights != nullptr,
"LstmLayer: m_PeepholeParameters.m_CellToOutputWeights should not be null.");
}
ValidateAndCopyShape(
GetOutputSlot(1).GetTensorInfo().GetShape(), inferredShapes[1], m_ShapeInferenceMethod, "LstmLayer", 1);
ValidateAndCopyShape(
GetOutputSlot(2).GetTensorInfo().GetShape(), inferredShapes[2], m_ShapeInferenceMethod, "LstmLayer", 2);
ValidateAndCopyShape(
GetOutputSlot(3).GetTensorInfo().GetShape(), inferredShapes[3], m_ShapeInferenceMethod, "LstmLayer", 3);
if (m_Param.m_LayerNormEnabled)
{
if(!m_Param.m_CifgEnabled)
{
ARMNN_ASSERT_MSG(m_LayerNormParameters.m_InputLayerNormWeights != nullptr,
"LstmLayer: m_LayerNormParameters.m_inputLayerNormWeights should not be null.");
}
ARMNN_ASSERT_MSG(m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr,
"LstmLayer: m_LayerNormParameters.m_forgetLayerNormWeights should not be null.");
ARMNN_ASSERT_MSG(m_LayerNormParameters.m_CellLayerNormWeights != nullptr,
"LstmLayer: m_LayerNormParameters.m_cellLayerNormWeights should not be null.");
ARMNN_ASSERT_MSG(m_LayerNormParameters.m_OutputLayerNormWeights != nullptr,
"LstmLayer: m_LayerNormParameters.m_outputLayerNormWeights should not be null.");
}
}
Layer::ConstantTensors LstmLayer::GetConstantTensorsByRef()
{
return {m_BasicParameters.m_InputToForgetWeights,
m_BasicParameters.m_InputToCellWeights,
m_BasicParameters.m_InputToOutputWeights,
m_BasicParameters.m_RecurrentToForgetWeights,
m_BasicParameters.m_RecurrentToCellWeights,
m_BasicParameters.m_RecurrentToOutputWeights,
m_BasicParameters.m_ForgetGateBias,
m_BasicParameters.m_CellBias,
m_BasicParameters.m_OutputGateBias,
// Cifg parameters
m_CifgParameters.m_InputToInputWeights,
m_CifgParameters.m_RecurrentToInputWeights,
m_CifgParameters.m_InputGateBias,
// Projection parameters
m_ProjectionParameters.m_ProjectionWeights,
m_ProjectionParameters.m_ProjectionBias,
// Peephole parameters
m_PeepholeParameters.m_CellToInputWeights,
m_PeepholeParameters.m_CellToForgetWeights,
m_PeepholeParameters.m_CellToOutputWeights,
// Layer normalisation parameters
m_LayerNormParameters.m_InputLayerNormWeights,
m_LayerNormParameters.m_ForgetLayerNormWeights,
m_LayerNormParameters.m_CellLayerNormWeights,
m_LayerNormParameters.m_OutputLayerNormWeights};
}
void LstmLayer::Accept(ILayerVisitor& visitor) const
{
LstmInputParams inputParams;
ManagedConstTensorHandle managedInputToForgetWeights(m_BasicParameters.m_InputToForgetWeights);
ManagedConstTensorHandle managedInputToCellWeights(m_BasicParameters.m_InputToCellWeights);
ManagedConstTensorHandle managedInputToOutputWeights(m_BasicParameters.m_InputToOutputWeights);
ManagedConstTensorHandle managedRecurrentToForgetWeights(m_BasicParameters.m_RecurrentToForgetWeights);
ManagedConstTensorHandle managedRecurrentToCellWeights(m_BasicParameters.m_RecurrentToCellWeights);
ManagedConstTensorHandle managedRecurrentToOutputWeights(m_BasicParameters.m_RecurrentToOutputWeights);
ManagedConstTensorHandle managedForgetGateBias(m_BasicParameters.m_ForgetGateBias);
ManagedConstTensorHandle managedCellBias(m_BasicParameters.m_CellBias);
ManagedConstTensorHandle managedOutputGateBias(m_BasicParameters.m_OutputGateBias);
// Cifg parameters
ManagedConstTensorHandle managedInputToInputWeights(m_CifgParameters.m_InputToInputWeights);
ManagedConstTensorHandle managedRecurrentToInputWeights(m_CifgParameters.m_RecurrentToInputWeights);
ManagedConstTensorHandle managedInputGateBias(m_CifgParameters.m_InputGateBias);
// Projection parameters
ManagedConstTensorHandle managedProjectionWeights(m_ProjectionParameters.m_ProjectionWeights);
ManagedConstTensorHandle managedProjectionBias(m_ProjectionParameters.m_ProjectionBias);
// Peephole parameters
ManagedConstTensorHandle managedCellToInputWeights(m_PeepholeParameters.m_CellToInputWeights);
ManagedConstTensorHandle managedCellToForgetWeights(m_PeepholeParameters.m_CellToForgetWeights);
ManagedConstTensorHandle managedCellToOutputWeights(m_PeepholeParameters.m_CellToOutputWeights);
// Layer normalisation parameters
ManagedConstTensorHandle managedInputLayerNormWeights(m_LayerNormParameters.m_InputLayerNormWeights);
ManagedConstTensorHandle managedForgetLayerNormWeights(m_LayerNormParameters.m_ForgetLayerNormWeights);
ManagedConstTensorHandle managedCellLayerNormWeights(m_LayerNormParameters.m_CellLayerNormWeights);
ManagedConstTensorHandle managedOutputLayerNormWeights(m_LayerNormParameters.m_OutputLayerNormWeights);
ConstTensor inputToInputWeightsTensor;
if (m_CifgParameters.m_InputToInputWeights != nullptr)
{
ConstTensor inputToInputWeightsTensorCopy(managedInputToInputWeights.GetTensorInfo(),
managedInputToInputWeights.Map());
inputToInputWeightsTensor = inputToInputWeightsTensorCopy;
inputParams.m_InputToInputWeights = &inputToInputWeightsTensor;
}
ConstTensor inputToForgetWeightsTensor;
if (m_BasicParameters.m_InputToForgetWeights != nullptr)
{
ConstTensor inputToForgetWeightsTensorCopy(managedInputToForgetWeights.GetTensorInfo(),
managedInputToForgetWeights.Map());
inputToForgetWeightsTensor = inputToForgetWeightsTensorCopy;
inputParams.m_InputToForgetWeights = &inputToForgetWeightsTensor;
}
ConstTensor inputToCellWeightsTensor;
if (m_BasicParameters.m_InputToCellWeights != nullptr)
{
ConstTensor inputToCellWeightsTensorCopy(managedInputToCellWeights.GetTensorInfo(),
managedInputToCellWeights.Map());
inputToCellWeightsTensor = inputToCellWeightsTensorCopy;
inputParams.m_InputToCellWeights = &inputToCellWeightsTensor;
}
ConstTensor inputToOutputWeightsTensor;
if (m_BasicParameters.m_InputToOutputWeights != nullptr)
{
ConstTensor inputToOutputWeightsTensorCopy(managedInputToOutputWeights.GetTensorInfo(),
managedInputToOutputWeights.Map());
inputToOutputWeightsTensor = inputToOutputWeightsTensorCopy;
inputParams.m_InputToOutputWeights = &inputToOutputWeightsTensor;
}
ConstTensor recurrentToInputWeightsTensor;
if (m_CifgParameters.m_RecurrentToInputWeights != nullptr)
{
ConstTensor recurrentToInputWeightsTensorCopy(
managedRecurrentToInputWeights.GetTensorInfo(),
managedRecurrentToInputWeights.Map());
recurrentToInputWeightsTensor = recurrentToInputWeightsTensorCopy;
inputParams.m_RecurrentToInputWeights = &recurrentToInputWeightsTensor;
}
ConstTensor recurrentToForgetWeightsTensor;
if (m_BasicParameters.m_RecurrentToForgetWeights != nullptr)
{
ConstTensor recurrentToForgetWeightsTensorCopy(
managedRecurrentToForgetWeights.GetTensorInfo(),
managedRecurrentToForgetWeights.Map());
recurrentToForgetWeightsTensor = recurrentToForgetWeightsTensorCopy;
inputParams.m_RecurrentToForgetWeights = &recurrentToForgetWeightsTensor;
}
ConstTensor recurrentToCellWeightsTensor;
if (m_BasicParameters.m_RecurrentToCellWeights != nullptr)
{
ConstTensor recurrentToCellWeightsTensorCopy(
managedRecurrentToCellWeights.GetTensorInfo(),
managedRecurrentToCellWeights.Map());
recurrentToCellWeightsTensor = recurrentToCellWeightsTensorCopy;
inputParams.m_RecurrentToCellWeights = &recurrentToCellWeightsTensor;
}
ConstTensor recurrentToOutputWeightsTensor;
if (m_BasicParameters.m_RecurrentToOutputWeights != nullptr)
{
ConstTensor recurrentToOutputWeightsTensorCopy(
managedRecurrentToOutputWeights.GetTensorInfo(),
managedRecurrentToOutputWeights.Map());
recurrentToOutputWeightsTensor = recurrentToOutputWeightsTensorCopy;
inputParams.m_RecurrentToOutputWeights = &recurrentToOutputWeightsTensor;
}
ConstTensor cellToInputWeightsTensor;
if (m_PeepholeParameters.m_CellToInputWeights != nullptr)
{
ConstTensor cellToInputWeightsTensorCopy(managedCellToInputWeights.GetTensorInfo(),
managedCellToInputWeights.Map());
cellToInputWeightsTensor = cellToInputWeightsTensorCopy;
inputParams.m_CellToInputWeights = &cellToInputWeightsTensor;
}
ConstTensor cellToForgetWeightsTensor;
if (m_PeepholeParameters.m_CellToForgetWeights != nullptr)
{
ConstTensor cellToForgetWeightsTensorCopy(managedCellToForgetWeights.GetTensorInfo(),
managedCellToForgetWeights.Map());
cellToForgetWeightsTensor = cellToForgetWeightsTensorCopy;
inputParams.m_CellToForgetWeights = &cellToForgetWeightsTensor;
}
ConstTensor cellToOutputWeightsTensor;
if (m_PeepholeParameters.m_CellToOutputWeights != nullptr)
{
ConstTensor cellToOutputWeightsTensorCopy(managedCellToOutputWeights.GetTensorInfo(),
managedCellToOutputWeights.Map());
cellToOutputWeightsTensor = cellToOutputWeightsTensorCopy;
inputParams.m_CellToOutputWeights = &cellToOutputWeightsTensor;
}
ConstTensor inputGateBiasTensor;
if (m_CifgParameters.m_InputGateBias != nullptr)
{
ConstTensor inputGateBiasTensorCopy(managedInputGateBias.GetTensorInfo(),
managedInputGateBias.Map());
inputGateBiasTensor = inputGateBiasTensorCopy;
inputParams.m_InputGateBias = &inputGateBiasTensor;
}
ConstTensor forgetGateBiasTensor;
if (m_BasicParameters.m_ForgetGateBias != nullptr)
{
ConstTensor forgetGateBiasTensorCopy(managedForgetGateBias.GetTensorInfo(),
managedForgetGateBias.Map());
forgetGateBiasTensor = forgetGateBiasTensorCopy;
inputParams.m_ForgetGateBias = &forgetGateBiasTensor;
}
ConstTensor cellBiasTensor;
if (m_BasicParameters.m_CellBias != nullptr)
{
ConstTensor cellBiasTensorCopy(managedCellBias.GetTensorInfo(),
managedCellBias.Map());
cellBiasTensor = cellBiasTensorCopy;
inputParams.m_CellBias = &cellBiasTensor;
}
ConstTensor outputGateBias;
if (m_BasicParameters.m_OutputGateBias != nullptr)
{
ConstTensor outputGateBiasCopy(managedOutputGateBias.GetTensorInfo(),
managedOutputGateBias.Map());
outputGateBias = outputGateBiasCopy;
inputParams.m_OutputGateBias = &outputGateBias;
}
ConstTensor projectionWeightsTensor;
if (m_ProjectionParameters.m_ProjectionWeights != nullptr)
{
ConstTensor projectionWeightsTensorCopy(managedProjectionWeights.GetTensorInfo(),
managedProjectionWeights.Map());
projectionWeightsTensor = projectionWeightsTensorCopy;
inputParams.m_ProjectionWeights = &projectionWeightsTensor;
}
ConstTensor projectionBiasTensor;
if (m_ProjectionParameters.m_ProjectionBias != nullptr)
{
ConstTensor projectionBiasTensorCopy(managedProjectionBias.GetTensorInfo(),
managedProjectionBias.Map());
projectionBiasTensor = projectionBiasTensorCopy;
inputParams.m_ProjectionBias = &projectionBiasTensor;
}
ConstTensor inputLayerNormTensor;
if (m_LayerNormParameters.m_InputLayerNormWeights != nullptr)
{
ConstTensor inputLayerNormTensorCopy(managedInputLayerNormWeights.GetTensorInfo(),
managedInputLayerNormWeights.Map());
inputLayerNormTensor = inputLayerNormTensorCopy;
inputParams.m_InputLayerNormWeights = &inputLayerNormTensor;
}
ConstTensor forgetLayerNormTensor;
if (m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr)
{
ConstTensor forgetLayerNormTensorCopy(managedForgetLayerNormWeights.GetTensorInfo(),
managedForgetLayerNormWeights.Map());
forgetLayerNormTensor = forgetLayerNormTensorCopy;
inputParams.m_ForgetLayerNormWeights = &forgetLayerNormTensor;
}
ConstTensor cellLayerNormTensor;
if (m_LayerNormParameters.m_CellLayerNormWeights != nullptr)
{
ConstTensor cellLayerNormTensorCopy(managedCellLayerNormWeights.GetTensorInfo(),
managedCellLayerNormWeights.Map());
cellLayerNormTensor = cellLayerNormTensorCopy;
inputParams.m_CellLayerNormWeights = &cellLayerNormTensor;
}
ConstTensor outputLayerNormTensor;
if (m_LayerNormParameters.m_OutputLayerNormWeights != nullptr)
{
ConstTensor outputLayerNormTensorCopy(managedOutputLayerNormWeights.GetTensorInfo(),
managedOutputLayerNormWeights.Map());
outputLayerNormTensor = outputLayerNormTensorCopy;
inputParams.m_OutputLayerNormWeights = &outputLayerNormTensor;
}
visitor.VisitLstmLayer(this, GetParameters(), inputParams, GetName());
}
void LstmLayer::ExecuteStrategy(IStrategy& strategy) const
{
std::vector<ConstTensor> constTensors;
LstmDescriptor descriptor = GetParameters();
ManagedConstTensorHandle managedInputToForgetWeights(m_BasicParameters.m_InputToForgetWeights);
ManagedConstTensorHandle managedInputToCellWeights(m_BasicParameters.m_InputToCellWeights);
ManagedConstTensorHandle managedInputToOutputWeights(m_BasicParameters.m_InputToOutputWeights);
ManagedConstTensorHandle managedRecurrentToForgetWeights(m_BasicParameters.m_RecurrentToForgetWeights);
ManagedConstTensorHandle managedRecurrentToCellWeights(m_BasicParameters.m_RecurrentToCellWeights);
ManagedConstTensorHandle managedRecurrentToOutputWeights(m_BasicParameters.m_RecurrentToOutputWeights);
ManagedConstTensorHandle managedForgetGateBias(m_BasicParameters.m_ForgetGateBias);
ManagedConstTensorHandle managedCellBias(m_BasicParameters.m_CellBias);
ManagedConstTensorHandle managedOutputGateBias(m_BasicParameters.m_OutputGateBias);
// Cifg parameters
ManagedConstTensorHandle managedInputToInputWeights(m_CifgParameters.m_InputToInputWeights);
ManagedConstTensorHandle managedRecurrentToInputWeights(m_CifgParameters.m_RecurrentToInputWeights);
ManagedConstTensorHandle managedInputGateBias(m_CifgParameters.m_InputGateBias);
// Projection parameters
ManagedConstTensorHandle managedProjectionWeights(m_ProjectionParameters.m_ProjectionWeights);
ManagedConstTensorHandle managedProjectionBias(m_ProjectionParameters.m_ProjectionBias);
// Peephole parameters
ManagedConstTensorHandle managedCellToInputWeights(m_PeepholeParameters.m_CellToInputWeights);
ManagedConstTensorHandle managedCellToForgetWeights(m_PeepholeParameters.m_CellToForgetWeights);
ManagedConstTensorHandle managedCellToOutputWeights(m_PeepholeParameters.m_CellToOutputWeights);
// Layer normalisation parameters
ManagedConstTensorHandle managedInputLayerNormWeights(m_LayerNormParameters.m_InputLayerNormWeights);
ManagedConstTensorHandle managedForgetLayerNormWeights(m_LayerNormParameters.m_ForgetLayerNormWeights);
ManagedConstTensorHandle managedCellLayerNormWeights(m_LayerNormParameters.m_CellLayerNormWeights);
ManagedConstTensorHandle managedOutputLayerNormWeights(m_LayerNormParameters.m_OutputLayerNormWeights);
// First add mandatory/basic parameters
if (m_BasicParameters.m_InputToForgetWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputToForgetWeights.GetTensorInfo(),
managedInputToForgetWeights.Map()));
}
if (m_BasicParameters.m_InputToCellWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputToCellWeights.GetTensorInfo(),
managedInputToCellWeights.Map()));
}
if (m_BasicParameters.m_InputToOutputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputToOutputWeights.GetTensorInfo(),
managedInputToOutputWeights.Map()));
}
if (m_BasicParameters.m_RecurrentToForgetWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(
managedRecurrentToForgetWeights.GetTensorInfo(),
managedRecurrentToForgetWeights.Map()));
}
if (m_BasicParameters.m_RecurrentToCellWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(
managedRecurrentToCellWeights.GetTensorInfo(),
managedRecurrentToCellWeights.Map()));
}
if (m_BasicParameters.m_RecurrentToOutputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(
managedRecurrentToOutputWeights.GetTensorInfo(),
managedRecurrentToOutputWeights.Map()));
}
if (m_BasicParameters.m_ForgetGateBias != nullptr)
{
constTensors.emplace_back(ConstTensor(managedForgetGateBias.GetTensorInfo(),
managedForgetGateBias.Map()));
}
if (m_BasicParameters.m_CellBias != nullptr)
{
constTensors.emplace_back(ConstTensor(managedCellBias.GetTensorInfo(),
managedCellBias.Map()));
}
if (m_BasicParameters.m_OutputGateBias != nullptr)
{
constTensors.emplace_back(ConstTensor(managedOutputGateBias.GetTensorInfo(),
managedOutputGateBias.Map()));
}
// Add cifg parameters
if (!descriptor.m_CifgEnabled)
{
if (m_CifgParameters.m_InputToInputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputToInputWeights.GetTensorInfo(),
managedInputToInputWeights.Map()));
}
if (m_CifgParameters.m_RecurrentToInputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(
managedRecurrentToInputWeights.GetTensorInfo(),
managedRecurrentToInputWeights.Map()));
}
if (m_CifgParameters.m_InputGateBias != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputGateBias.GetTensorInfo(),
managedInputGateBias.Map()));
}
}
// Add peephole parameters
if (descriptor.m_PeepholeEnabled)
{
if (!descriptor.m_CifgEnabled)
{
if (m_PeepholeParameters.m_CellToInputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedCellToInputWeights.GetTensorInfo(),
managedCellToInputWeights.Map()));
}
}
if (m_PeepholeParameters.m_CellToForgetWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedCellToForgetWeights.GetTensorInfo(),
managedCellToForgetWeights.Map()));
}
if (m_PeepholeParameters.m_CellToOutputWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedCellToOutputWeights.GetTensorInfo(),
managedCellToOutputWeights.Map()));
}
}
// Add projection parameters
if (descriptor.m_ProjectionEnabled)
{
if (m_ProjectionParameters.m_ProjectionWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedProjectionWeights.GetTensorInfo(),
managedProjectionWeights.Map()));
}
if (m_ProjectionParameters.m_ProjectionBias != nullptr)
{
constTensors.emplace_back(ConstTensor(managedProjectionBias.GetTensorInfo(),
managedProjectionBias.Map()));
}
}
// Add norm parameters
if (descriptor.m_LayerNormEnabled)
{
if (!descriptor.m_CifgEnabled)
{
if (m_LayerNormParameters.m_InputLayerNormWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedInputLayerNormWeights.GetTensorInfo(),
managedInputLayerNormWeights.Map()));
}
}
if (m_LayerNormParameters.m_ForgetLayerNormWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedForgetLayerNormWeights.GetTensorInfo(),
managedForgetLayerNormWeights.Map()));
}
if (m_LayerNormParameters.m_CellLayerNormWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedCellLayerNormWeights.GetTensorInfo(),
managedCellLayerNormWeights.Map()));
}
if (m_LayerNormParameters.m_OutputLayerNormWeights != nullptr)
{
constTensors.emplace_back(ConstTensor(managedOutputLayerNormWeights.GetTensorInfo(),
managedOutputLayerNormWeights.Map()));
}
}
strategy.ExecuteStrategy(this, GetParameters(), constTensors, GetName());
}
} // namespace armnn
| 49.452174 | 116 | 0.718012 | tkdhmin |
0fed7b00aef14ef8708bdd83e27ac887db764eec | 2,911 | cpp | C++ | unidata/gencrng.cpp | leftmike/foment | 3838be87bc78027f3cae93219ed34fb1a17f34b9 | [
"MIT"
] | 63 | 2016-06-02T13:38:18.000Z | 2021-07-22T02:37:52.000Z | unidata/gencrng.cpp | leftmike/foment | 3838be87bc78027f3cae93219ed34fb1a17f34b9 | [
"MIT"
] | 30 | 2016-05-07T23:41:59.000Z | 2021-03-01T00:36:41.000Z | unidata/gencrng.cpp | leftmike/foment | 3838be87bc78027f3cae93219ed34fb1a17f34b9 | [
"MIT"
] | 8 | 2016-08-25T18:42:21.000Z | 2019-08-20T20:12:55.000Z | /*
Generate character ranges for a char-set
gencrng <file> <name> <letter-category> | +<character-code> ...
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_FULL_CHARS 3
int ParseFields(char * s, char ** flds)
{
int nflds = 0;
for (;;)
{
char * f = strchr(s, ';');
while (*s == ' ')
s += 1;
if (*s == 0)
flds[nflds] = 0;
else
flds[nflds] = s;
nflds += 1;
if (f == 0)
break;
*f = 0;
s = f + 1;
}
return(nflds);
}
unsigned int ParseCodePoint(char * fld)
{
char * s = fld;
unsigned int n = 0;
while (*fld)
{
if (*fld >= '0' && *fld <= '9')
n = n * 16 + *fld - '0';
else if (*fld >= 'a' && *fld <= 'f')
n = n * 16 + *fld - 'a' + 10;
else if (*fld >= 'A' && *fld <= 'F')
n = n * 16 + *fld - 'A' + 10;
else
{
fprintf(stderr, "error: gencrng: unable to parse field: %s\n", s);
return(0);
}
fld += 1;
}
return(n);
}
void Usage()
{
fprintf(stderr, "usage: gencrng <file> <name> <letter-category> | <character-code> ...\n");
}
typedef struct
{
unsigned int Start;
unsigned int End; // Inclusive
} CharRange;
CharRange Ranges[0x110000];
unsigned int NumRanges = 0;
void AddCh(unsigned int ch)
{
if (NumRanges == 0 || Ranges[NumRanges - 1].End + 1 < ch)
{
Ranges[NumRanges].Start = ch;
Ranges[NumRanges].End = ch;
NumRanges += 1;
}
else
Ranges[NumRanges-1].End += 1;
}
int main(int argc, char * argv[])
{
char s[256];
if (argc < 4)
{
Usage();
return(1);
}
FILE * fp = fopen(argv[1], "rt");
if (fp == 0)
{
fprintf(stderr, "error: gencrng: unable to open %s\n", argv[1]);
return(1);
}
while (fgets(s, sizeof(s), fp))
{
char * flds[32];
if (*s != '#' && *s != '\n')
{
int nflds = ParseFields(s, flds);
if (nflds < 3)
{
fprintf(stderr, "error: gencrng: not enough fields %s\n", flds[0]);
return(1);
}
for (int adx = 3; adx < argc; adx++)
if (strcmp(argv[adx], flds[2]) == 0 ||
(argv[adx][0] == '+' && strcmp(argv[adx] + 1, flds[0]) == 0))
{
AddCh(ParseCodePoint(flds[0]));
break;
}
}
}
fclose(fp);
printf("\nstatic FCharRange %s[%d] =\n{\n", argv[2], NumRanges);
for (unsigned int ndx = 0; ndx < NumRanges; ndx++)
printf(" {0x%x, 0x%x}, // %d\n", Ranges[ndx].Start, Ranges[ndx].End,
Ranges[ndx].End - Ranges[ndx].Start + 1);
printf("};\n");
return(0);
}
| 20.215278 | 95 | 0.443834 | leftmike |
0fef325b692acb99b5541342af9d80c04162784c | 422 | cpp | C++ | 2021.11.25-Control Work (retake)/Project-10/main.cpp | st091446/programming-Osim-2021-2022 | cf03dcbc1732332adab3ff78704fbd6d4b531887 | [
"Apache-2.0"
] | null | null | null | 2021.11.25-Control Work (retake)/Project-10/main.cpp | st091446/programming-Osim-2021-2022 | cf03dcbc1732332adab3ff78704fbd6d4b531887 | [
"Apache-2.0"
] | null | null | null | 2021.11.25-Control Work (retake)/Project-10/main.cpp | st091446/programming-Osim-2021-2022 | cf03dcbc1732332adab3ff78704fbd6d4b531887 | [
"Apache-2.0"
] | null | null | null | #include <iostream>
#include <windows.h>
using namespace std;
int main(int argc, char* argv[])
{
int a[1000]{0};
int i = 0;
int n = 0;
int s = 0;
cin >> n;
for(i = 0; i < n ; i++)
cin >> a[i];
s= a[0] + a[n-1] + ((a[1] > a[n-2]) ? a[1] : a[n-2]);
for(i = 1;i < n - 1; i++)
{
if( a[i-1] + a[i] + a[i+1] > s) s = a[i-1] + a[i] + a[i+1];
}
cout << s;
cout << endl;
return EXIT_SUCCESS;
}
| 15.071429 | 64 | 0.440758 | st091446 |
0ff035d43c2c59a5239e91703d3c934f76b0c18a | 8,933 | cpp | C++ | src/profiling.cpp | zamaudio/bwa-mem2 | 39d20ef9d729cdbd39b70b8e07933413037f41cb | [
"MIT"
] | null | null | null | src/profiling.cpp | zamaudio/bwa-mem2 | 39d20ef9d729cdbd39b70b8e07933413037f41cb | [
"MIT"
] | null | null | null | src/profiling.cpp | zamaudio/bwa-mem2 | 39d20ef9d729cdbd39b70b8e07933413037f41cb | [
"MIT"
] | null | null | null | /*************************************************************************************
The MIT License
BWA-MEM2 (Sequence alignment using Burrows-Wheeler Transform),
Copyright (C) 2019 Vasimuddin Md, Sanchit Misra, Intel Corporation, Heng Li.
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.
Authors: Vasimuddin Md <vasimuddin.md@intel.com>; Sanchit Misra <sanchit.misra@intel.com>.
*****************************************************************************************/
#include <stdio.h>
#include "macro.h"
#include <stdint.h>
extern uint64_t proc_freq, tprof[LIM_R][LIM_C];
extern int nthreads;
extern int myrank, num_ranks;
int find_opt(uint64_t *a, int len, uint64_t *max, uint64_t *min, double *avg)
{
*max = 0;
*min = 1e15;
*avg = 0;
int i=0;
for (i=0; i<len; i++)
{
if (a[i] > *max) *max = a[i];
if (a[i] < *min) *min = a[i];
*avg += a[i];
}
*avg /= len;
return 1;
}
int display_stats()
{
uint64_t max, min;
double avg;
fprintf(stderr, "No. of OMP threads: %d\n", nthreads);
fprintf(stderr, "Processor is runnig @%lf MHz\n", proc_freq*1.0/1e6);
fprintf(stderr, "Runtime profile:\n");
fprintf(stderr, "\n\t Time taken for main_mem function: %0.2lf Sec\n\n",
tprof[MEM][0]*1.0/proc_freq);
fprintf(stderr, "\tIO times (sec) :\n");
find_opt(tprof[READ_IO], 1, &max, &min, &avg);
fprintf(stderr, "\tReading IO time (reads) avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[SAM_IO], 1, &max, &min, &avg);
fprintf(stderr, "\tWriting IO time (SAM) avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[REF_IO], 1, &max, &min, &avg);
fprintf(stderr, "\tReading IO time (Reference Genome) avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[FMI], 1, &max, &min, &avg);
fprintf(stderr, "\tIndex read time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
fprintf(stderr, "\n\tOverall time (sec) (Excluding Index reading time):\n");
// find_opt(tprof[PROCESS], 1, &max, &min, &avg);
fprintf(stderr, "\tPROCESS() (Total compute time + (read + SAM) IO time) : %0.2lf\n",
tprof[PROCESS][0]*1.0/proc_freq);
find_opt(tprof[MEM_PROCESS2], 1, &max, &min, &avg);
fprintf(stderr, "\tMEM_PROCESS_SEQ() (Total compute time (Kernel + SAM)), avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
fprintf(stderr, "\n\t SAM Processing time (sec):\n");
find_opt(tprof[WORKER20], 1, &max, &min, &avg);
fprintf(stderr, "\t--WORKER_SAM avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#if HIDE
find_opt(tprof[SAM1], 1, &max, &min, &avg);
fprintf(stderr, "\t\tWORKER_SAM1 avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[SAM2], 1, &max, &min, &avg);
fprintf(stderr, "\t\tWORKER_SAM2 avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[ALIGN1], 1, &max, &min, &avg);
fprintf(stderr, "\t\t\tWORKER_ALIGN1 avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[SAM3], 1, &max, &min, &avg);
fprintf(stderr, "\t\tWORKER_SAM3 avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#endif
fprintf(stderr, "\n\tKernels' compute time (sec):\n");
find_opt(tprof[WORKER10], 1, &max, &min, &avg);
fprintf(stderr, "\tTotal kernel (smem+sal+bsw) time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#if HIDE
find_opt(tprof[MEM_ALN_M1], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tMEM_ALN_CHAIN_FLT avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[MEM_ALN_M2], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tMEM_ALN_CHAIN_SEED avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#endif
find_opt(tprof[MEM_COLLECT], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tSMEM compute avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#if HIDE
find_opt(tprof[MEM_CHAIN], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tMEM_CHAIN avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#endif
find_opt(tprof[MEM_SA_BLOCK], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tSAL compute avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#if HIDE
find_opt(tprof[MEM_SA], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\t\t\tMEM_SA avg: %0.2lf, (%0.2lf, %0.2lf)\n\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#endif
// printf("\n\t BSW compute time (sec):\n");
find_opt(tprof[MEM_ALN2], nthreads, &max, &min, &avg);
fprintf(stderr, "\t\tBSW time, avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
int agg1 = 0, agg2 = 0, agg3 = 0;
for (int i=0; i<nthreads; i++) {
agg1 += tprof[PE11][i];
agg2 += tprof[PE12][i];
agg3 += tprof[PE13][i];
}
fprintf(stderr, "\n\tTotal allocs: %d = %d out total requests: %d, Rate: %0.2f\n",
agg1, agg3, agg2, agg1*1.0/agg2);
#if HIDE
fprintf(stderr, "\n BSW Perf.:\n");
find_opt(tprof[MEM_ALN2_B], 1, &max, &min, &avg);
fprintf(stderr, "\tLeft 16-bit time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[MEM_ALN2_D], 1, &max, &min, &avg);
fprintf(stderr, "\tLeft 8-bit time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[MEM_ALN2_C], 1, &max, &min, &avg);
fprintf(stderr, "\tRight 16-bit time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
find_opt(tprof[MEM_ALN2_E], 1, &max, &min, &avg);
fprintf(stderr, "\tRight 8-bit time avg: %0.2lf, (%0.2lf, %0.2lf)\n",
avg*1.0/proc_freq, max*1.0/proc_freq, min*1.0/proc_freq);
#endif
#if HIDE
fprintf(stderr, "\nSTATSV\n");
fprintf(stderr, "%0.2lf\n", tprof[PROCESS][0]*1.0/proc_freq);
find_opt(tprof[MEM_PROCESS2], 1, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
find_opt(tprof[WORKER10], 1, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
find_opt(tprof[MEM_COLLECT], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
find_opt(tprof[MEM_SA_BLOCK], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
find_opt(tprof[MEM_SA], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
double val = 0;
find_opt(tprof[MEM_ALN2_UP], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
val += avg;
find_opt(tprof[CLEFT], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
val += avg;
find_opt(tprof[CRIGHT], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
val += avg;
find_opt(tprof[MEM_ALN2_DOWN], nthreads, &max, &min, &avg);
fprintf(stderr, "%0.2lf\n", avg*1.0/proc_freq);
val += avg;
fprintf(stderr, "%0.2lf\n", val*1.0/proc_freq);
fprintf(stderr, "%0.2lf\n", (tprof[REF_IO][0] + tprof[FMI][0])*1.0/proc_freq);
fprintf(stderr, "%0.2lf\n", tprof[READ_IO][0]*1.0/proc_freq);
#endif
// printf("\tMemory usage (GB):\n");
// printf("\tAvg: %0.2lf, Peak: %0.2lf\n", tprof[PE21][0]*1.0/1e9, tprof[PE22][0]*1.0/1e9);
return 1;
}
| 41.165899 | 109 | 0.627897 | zamaudio |
0ff07b863965774b724969b59cde06245a127324 | 27,736 | cpp | C++ | verilator-4.016/src/V3EmitV.cpp | tcovert2015/fpga_competition | 26b7a72959afbf8315eb962ec597ba14b4a73dbd | [
"BSD-3-Clause"
] | null | null | null | verilator-4.016/src/V3EmitV.cpp | tcovert2015/fpga_competition | 26b7a72959afbf8315eb962ec597ba14b4a73dbd | [
"BSD-3-Clause"
] | null | null | null | verilator-4.016/src/V3EmitV.cpp | tcovert2015/fpga_competition | 26b7a72959afbf8315eb962ec597ba14b4a73dbd | [
"BSD-3-Clause"
] | null | null | null | // -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Emit Verilog from tree
//
// Code available from: http://www.veripool.org/verilator
//
//*************************************************************************
//
// Copyright 2004-2019 by Wilson Snyder. This program is free software; you can
// redistribute it and/or modify it under the terms of either the GNU
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
//
// Verilator 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.
//
//*************************************************************************
#include "config_build.h"
#include "verilatedos.h"
#include "V3Global.h"
#include "V3EmitV.h"
#include "V3EmitCBase.h"
#include <algorithm>
#include <cmath>
#include <cstdarg>
#include <map>
#include <vector>
//######################################################################
// Emit statements and math operators
class EmitVBaseVisitor : public EmitCBaseVisitor {
// MEMBERS
bool m_suppressSemi;
AstSenTree* m_sensesp;
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void puts(const string& str) = 0;
virtual void putbs(const string& str) = 0;
virtual void putfs(AstNode* nodep, const string& str) = 0; // Fileline and node %% mark
virtual void putqs(AstNode* nodep, const string& str) = 0; // Fileline quiet w/o %% mark
virtual void putsNoTracking(const string& str) = 0;
virtual void putsQuoted(const string& str) {
// Quote \ and " for use inside C programs
// Don't use to quote a filename for #include - #include doesn't \ escape.
// Duplicate in V3File - here so we can print to string
putsNoTracking("\"");
putsNoTracking(V3OutFormatter::quoteNameControls(str));
putsNoTracking("\"");
}
// VISITORS
virtual void visit(AstNetlist* nodep) {
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) {
putfs(nodep, nodep->verilogKwd()+" "+modClassName(nodep)+";\n");
iterateChildren(nodep);
putqs(nodep, "end"+nodep->verilogKwd()+"\n");
}
virtual void visit(AstNodeFTask* nodep) {
putfs(nodep, nodep->isFunction() ? "function":"task");
puts(" ");
puts(nodep->prettyName());
puts(";\n");
putqs(nodep, "begin\n"); // Only putfs the first time for each visitor; later for same node is putqs
iterateAndNextNull(nodep->stmtsp());
putqs(nodep, "end\n");
}
virtual void visit(AstBegin* nodep) {
if (nodep->unnamed()) {
putbs("begin\n");
} else {
putbs("begin : "+nodep->name()+"\n");
}
iterateChildren(nodep);
puts("end\n");
}
virtual void visit(AstGenerate* nodep) {
putfs(nodep, "generate\n");
iterateChildren(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstFinal* nodep) {
putfs(nodep, "final begin\n");
iterateChildren(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstInitial* nodep) {
putfs(nodep, "initial begin\n");
iterateChildren(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstAlways* nodep) {
putfs(nodep, "always ");
if (m_sensesp) iterateAndNextNull(m_sensesp); // In active
else iterateAndNextNull(nodep->sensesp());
putbs(" begin\n");
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstAlwaysPublic* nodep) {
putfs(nodep, "/*verilator public_flat_rw ");
if (m_sensesp) iterateAndNextNull(m_sensesp); // In active
else iterateAndNextNull(nodep->sensesp());
putqs(nodep, " ");
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "*/\n");
}
virtual void visit(AstNodeAssign* nodep) {
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " "+nodep->verilogKwd()+" ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignDly* nodep) {
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " <= ");
iterateAndNextNull(nodep->rhsp());
puts(";\n");
}
virtual void visit(AstAssignAlias* nodep) {
putbs("alias ");
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " = ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignW* nodep) {
putfs(nodep, "assign ");
iterateAndNextNull(nodep->lhsp());
putbs(" = ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstBreak* nodep) {
putbs("break");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstSenTree* nodep) {
// AstSenItem is called for dumping in isolation by V3Order
putfs(nodep, "@(");
for (AstNode* expp=nodep->sensesp(); expp; expp = expp->nextp()) {
iterate(expp);
if (expp->nextp()) putqs(expp->nextp(), " or ");
}
puts(")");
}
virtual void visit(AstSenGate* nodep) {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->sensesp(), nodep->rhsp());
}
virtual void visit(AstSenItem* nodep) {
putfs(nodep, "");
puts(nodep->edgeType().verilogKwd());
if (nodep->sensp()) puts(" ");
iterateChildren(nodep);
}
virtual void visit(AstNodeCase* nodep) {
putfs(nodep, "");
if (const AstCase* casep = VN_CAST(nodep, Case)) {
if (casep->priorityPragma()) puts("priority ");
if (casep->uniquePragma()) puts("unique ");
if (casep->unique0Pragma()) puts("unique0 ");
}
puts(nodep->verilogKwd());
puts(" (");
iterateAndNextNull(nodep->exprp());
puts(")\n");
if (const AstCase* casep = VN_CAST(nodep, Case)) {
if (casep->fullPragma() || casep->parallelPragma()) {
puts(" // synopsys");
if (casep->fullPragma()) puts(" full_case");
if (casep->parallelPragma()) puts(" parallel_case");
}
}
iterateAndNextNull(nodep->itemsp());
putqs(nodep, "endcase\n");
}
virtual void visit(AstCaseItem* nodep) {
if (nodep->condsp()) {
iterateAndNextNull(nodep->condsp());
} else putbs("default");
putfs(nodep, ": begin ");
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstComment* nodep) {
puts(string("// ")+nodep->name()+"\n");
iterateChildren(nodep);
}
virtual void visit(AstContinue* nodep) {
putbs("continue");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstCoverDecl*) {} // N/A
virtual void visit(AstCoverInc*) {} // N/A
virtual void visit(AstCoverToggle*) {} // N/A
void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp,
const string& text, AstNode* exprsp) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (fileOrStrgp) { iterateAndNextNull(fileOrStrgp); putbs(","); }
putsQuoted(text);
for (AstNode* expp=exprsp; expp; expp = expp->nextp()) {
puts(",");
iterateAndNextNull(expp);
}
puts(");\n");
}
virtual void visit(AstDisable* nodep) {
putbs("disable "+nodep->name()+";\n");
}
virtual void visit(AstDisplay* nodep) {
visitNodeDisplay(nodep, nodep->filep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstFScanF* nodep) {
visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSScanF* nodep) {
visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSFormat* nodep) {
visitNodeDisplay(nodep, nodep->lhsp(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstSFormatF* nodep) {
visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
}
virtual void visit(AstFOpen* nodep) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filep()) iterateAndNextNull(nodep->filep());
putbs(",");
if (nodep->filenamep()) iterateAndNextNull(nodep->filenamep());
putbs(",");
if (nodep->modep()) iterateAndNextNull(nodep->modep());
puts(");\n");
}
virtual void visit(AstFClose* nodep) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filep()) iterateAndNextNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstFFlush* nodep) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filep()) iterateAndNextNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstJumpGo* nodep) {
putbs("disable "+cvtToHex(nodep->labelp())+";\n");
}
virtual void visit(AstJumpLabel* nodep) {
putbs("begin : "+cvtToHex(nodep)+"\n");
if (nodep->stmtsp()) iterateAndNextNull(nodep->stmtsp());
puts("end\n");
}
virtual void visit(AstNodeReadWriteMem* nodep) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filenamep()) iterateAndNextNull(nodep->filenamep());
putbs(",");
if (nodep->memp()) iterateAndNextNull(nodep->memp());
if (nodep->lsbp()) { putbs(","); iterateAndNextNull(nodep->lsbp()); }
if (nodep->msbp()) { putbs(","); iterateAndNextNull(nodep->msbp()); }
puts(");\n");
}
virtual void visit(AstSysFuncAsTask* nodep) {
iterateAndNextNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstSysIgnore* nodep) {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
iterateAndNextNull(nodep->exprsp());
puts(");\n");
}
virtual void visit(AstNodeFor* nodep) {
putfs(nodep, "for (");
m_suppressSemi = true;
iterateAndNextNull(nodep->initsp());
puts(";");
iterateAndNextNull(nodep->condp());
puts(";");
iterateAndNextNull(nodep->incsp());
m_suppressSemi = false;
puts(") begin\n");
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstRepeat* nodep) {
putfs(nodep, "repeat (");
iterateAndNextNull(nodep->countp());
puts(") begin\n");
iterateAndNextNull(nodep->bodysp());
putfs(nodep, "end\n");
}
virtual void visit(AstWhile* nodep) {
iterateAndNextNull(nodep->precondsp());
putfs(nodep, "while (");
iterateAndNextNull(nodep->condp());
puts(") begin\n");
iterateAndNextNull(nodep->bodysp());
iterateAndNextNull(nodep->incsp());
iterateAndNextNull(nodep->precondsp()); // Need to recompute before next loop
putfs(nodep, "end\n");
}
virtual void visit(AstNodeIf* nodep) {
putfs(nodep, "");
if (const AstIf* ifp = VN_CAST(nodep, If)) {
if (ifp->priorityPragma()) puts("priority ");
if (ifp->uniquePragma()) puts("unique ");
if (ifp->unique0Pragma()) puts("unique0 ");
}
puts("if (");
iterateAndNextNull(nodep->condp());
puts(") begin\n");
iterateAndNextNull(nodep->ifsp());
if (nodep->elsesp()) {
putqs(nodep, "end\n");
putqs(nodep, "else begin\n");
iterateAndNextNull(nodep->elsesp());
}
putqs(nodep, "end\n");
}
virtual void visit(AstPast* nodep) {
putfs(nodep, "$past(");
iterateAndNextNull(nodep->exprp());
if (nodep->ticksp()) {
puts(",");
iterateAndNextNull(nodep->ticksp());
}
puts(")");
}
virtual void visit(AstReturn* nodep) {
putfs(nodep, "return ");
iterateAndNextNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstStop* nodep) {
putfs(nodep, "$stop;\n");
}
virtual void visit(AstFinish* nodep) {
putfs(nodep, "$finish;\n");
}
virtual void visit(AstText* nodep) {
putsNoTracking(nodep->text());
}
virtual void visit(AstScopeName* nodep) {
}
virtual void visit(AstCStmt* nodep) {
putfs(nodep, "$_CSTMT(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstCMath* nodep) {
putfs(nodep, "$_CMATH(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCStmt* nodep) {
putfs(nodep, "$c(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCFunc* nodep) {
putfs(nodep, "$c(");
iterateAndNextNull(nodep->bodysp());
puts(")");
}
// Operators
virtual void emitVerilogFormat(AstNode* nodep, const string& format,
AstNode* lhsp=NULL, AstNode* rhsp=NULL, AstNode* thsp=NULL) {
// Look at emitVerilog() format for term/uni/dual/triops,
// and write out appropriate text.
// %f Potential fileline-if-change and line break
// %l lhsp - if appropriate
// %r rhsp - if appropriate
// %t thsp - if appropriate
// %d dtypep - if appropriate
// %k Potential line break
bool inPct = false;
putbs("");
for (string::const_iterator pos = format.begin(); pos != format.end(); ++pos) {
if (pos[0]=='%') {
inPct = true;
} else if (!inPct) { // Normal text
string s; s+=pos[0]; puts(s);
} else { // Format character
inPct = false;
switch (*pos) {
case '%': puts("%"); break;
case 'f': putfs(nodep, ""); break;
case 'k': putbs(""); break;
case 'l': {
if (!lhsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
else iterateAndNextNull(lhsp);
break;
}
case 'r': {
if (!rhsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
else iterateAndNextNull(rhsp);
break;
}
case 't': {
if (!thsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
else iterateAndNextNull(thsp);
break;
}
case 'd': {
if (!nodep->dtypep()) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
else iterateAndNextNull(nodep->dtypep());
break;
}
default:
nodep->v3fatalSrc("Unknown emitVerilog format code: %"<<pos[0]);
break;
}
}
}
}
virtual void visit(AstNodeTermop* nodep) {
emitVerilogFormat(nodep, nodep->emitVerilog());
}
virtual void visit(AstNodeUniop* nodep) {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp());
}
virtual void visit(AstNodeBiop* nodep) {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp());
}
virtual void visit(AstNodeTriop* nodep) {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp(), nodep->thsp());
}
virtual void visit(AstAttrOf* nodep) {
putfs(nodep, "$_ATTROF(");
iterateAndNextNull(nodep->fromp());
if (nodep->dimp()) {
putbs(",");
iterateAndNextNull(nodep->dimp());
}
puts(")");
}
virtual void visit(AstInitArray* nodep) {
putfs(nodep, "`{");
int pos = 0;
for (AstNode* itemp = nodep->initsp(); itemp; ++pos, itemp=itemp->nextp()) {
int index = nodep->posIndex(pos);
puts(cvtToStr(index));
puts(":");
iterate(itemp);
if (itemp->nextp()) putbs(",");
}
puts("}");
}
virtual void visit(AstNodeCond* nodep) {
putbs("(");
iterateAndNextNull(nodep->condp()); putfs(nodep, " ? ");
iterateAndNextNull(nodep->expr1p()); putbs(" : ");
iterateAndNextNull(nodep->expr2p()); puts(")");
}
virtual void visit(AstRange* nodep) {
puts("[");
if (VN_IS(nodep->msbp(), Const) && VN_IS(nodep->lsbp(), Const)) {
// Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
puts(cvtToStr(VN_CAST(nodep->leftp(), Const)->toSInt())); puts(":");
puts(cvtToStr(VN_CAST(nodep->rightp(), Const)->toSInt())); puts("]");
} else {
iterateAndNextNull(nodep->leftp()); puts(":");
iterateAndNextNull(nodep->rightp()); puts("]");
}
}
virtual void visit(AstSel* nodep) {
iterateAndNextNull(nodep->fromp()); puts("[");
if (VN_IS(nodep->lsbp(), Const)) {
if (nodep->widthp()->isOne()) {
if (VN_IS(nodep->lsbp(), Const)) {
puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()));
} else {
iterateAndNextNull(nodep->lsbp());
}
} else {
puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()
+ VN_CAST(nodep->widthp(), Const)->toSInt()
- 1));
puts(":");
puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()));
}
} else {
iterateAndNextNull(nodep->lsbp()); putfs(nodep, "+:");
iterateAndNextNull(nodep->widthp()); puts("]");
}
puts("]");
}
virtual void visit(AstSliceSel* nodep) {
iterateAndNextNull(nodep->fromp());
puts(cvtToStr(nodep->declRange()));
}
virtual void visit(AstTypedef* nodep) {
putfs(nodep, "typedef ");
iterateAndNextNull(nodep->dtypep()); puts(" ");
puts(nodep->prettyName());
puts(";\n");
}
virtual void visit(AstBasicDType* nodep) {
if (nodep->isSigned()) putfs(nodep, "signed ");
putfs(nodep, nodep->prettyName());
if (nodep->rangep()) { puts(" "); iterateAndNextNull(nodep->rangep()); puts(" "); }
else if (nodep->isRanged()) { puts(" ["); puts(cvtToStr(nodep->msb())); puts(":0] "); }
}
virtual void visit(AstConstDType* nodep) {
putfs(nodep, "const ");
iterate(nodep->subDTypep());
}
virtual void visit(AstNodeArrayDType* nodep) {
iterate(nodep->subDTypep());
iterateAndNextNull(nodep->rangep());
}
virtual void visit(AstNodeClassDType* nodep) {
puts(nodep->verilogKwd()+" ");
if (nodep->packed()) puts("packed ");
puts("\n");
iterateAndNextNull(nodep->membersp());
puts("}");
}
virtual void visit(AstMemberDType* nodep) {
iterate(nodep->subDTypep());
puts(" ");
puts(nodep->name());
puts("}");
}
virtual void visit(AstNodeFTaskRef* nodep) {
if (nodep->dotted()!="") {
putfs(nodep, nodep->dotted()); puts("."); puts(nodep->prettyName());
} else { putfs(nodep, nodep->prettyName()); }
puts("(");
iterateAndNextNull(nodep->pinsp());
puts(")");
}
virtual void visit(AstArg* nodep) {
iterateAndNextNull(nodep->exprp());
}
// Terminals
virtual void visit(AstVarRef* nodep) {
if (nodep->varScopep()) {
putfs(nodep, nodep->varScopep()->prettyName());
} else {
putfs(nodep, nodep->hiername());
puts(nodep->varp()->prettyName());
}
}
virtual void visit(AstVarXRef* nodep) {
putfs(nodep, nodep->dotted());
puts(".");
puts(nodep->varp()->prettyName());
}
virtual void visit(AstConst* nodep) {
putfs(nodep, nodep->num().ascii(true, true));
}
// Just iterate
virtual void visit(AstTopScope* nodep) {
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) {
iterateChildren(nodep);
}
virtual void visit(AstVar* nodep) {
putfs(nodep, nodep->verilogKwd());
puts(" ");
iterate(nodep->dtypep()); puts(" ");
puts(nodep->prettyName());
puts(";\n");
}
virtual void visit(AstActive* nodep) {
m_sensesp = nodep->sensesp();
iterateAndNextNull(nodep->stmtsp());
m_sensesp = NULL;
}
virtual void visit(AstVarScope*) {}
virtual void visit(AstNodeText*) {}
virtual void visit(AstTraceDecl*) {}
virtual void visit(AstTraceInc*) {}
// NOPs
virtual void visit(AstPragma*) {}
virtual void visit(AstCell*) {} // Handled outside the Visit class
// Default
virtual void visit(AstNode* nodep) {
puts(string("\n???? // ")+nodep->prettyTypeName()+"\n");
iterateChildren(nodep);
// Not v3fatalSrc so we keep processing
nodep->v3error("Internal: Unknown node type reached emitter: "<<nodep->prettyTypeName());
}
public:
explicit EmitVBaseVisitor(AstSenTree* domainp=NULL) {
// Domain for printing one a ALWAYS under a ACTIVE
m_suppressSemi = false;
m_sensesp = domainp;
}
virtual ~EmitVBaseVisitor() {}
};
//######################################################################
// Emit to an output file
class EmitVFileVisitor : public EmitVBaseVisitor {
// MEMBERS
V3OutFile* m_ofp;
// METHODS
V3OutFile* ofp() const { return m_ofp; }
virtual void puts(const string& str) { ofp()->puts(str); }
virtual void putbs(const string& str) { ofp()->putbs(str); }
virtual void putfs(AstNode*, const string& str) { putbs(str); }
virtual void putqs(AstNode*, const string& str) { putbs(str); }
virtual void putsNoTracking(const string& str) { ofp()->putsNoTracking(str); }
public:
EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp) {
m_ofp = ofp;
iterate(nodep);
}
virtual ~EmitVFileVisitor() {}
};
//######################################################################
// Emit to a stream (perhaps stringstream)
class EmitVStreamVisitor : public EmitVBaseVisitor {
// MEMBERS
std::ostream& m_os;
// METHODS
virtual void putsNoTracking(const string& str) { m_os<<str; }
virtual void puts(const string& str) { putsNoTracking(str); }
virtual void putbs(const string& str) { puts(str); }
virtual void putfs(AstNode*, const string& str) { putbs(str); }
virtual void putqs(AstNode*, const string& str) { putbs(str); }
public:
EmitVStreamVisitor(AstNode* nodep, std::ostream& os)
: m_os(os) {
iterate(nodep);
}
virtual ~EmitVStreamVisitor() {}
};
//######################################################################
// Emit to a stream (perhaps stringstream)
class EmitVPrefixedFormatter : public V3OutFormatter {
std::ostream& m_os;
string m_prefix; // What to print at beginning of each line
int m_flWidth; // Padding of fileline
int m_column; // Rough location; need just zero or non-zero
FileLine* m_prefixFl;
// METHODS
virtual void putcOutput(char chr) {
if (chr == '\n') {
m_column = 0;
m_os<<chr;
} else {
if (m_column == 0) {
m_column = 10;
m_os<<m_prefixFl->ascii()+":";
m_os<<V3OutFile::indentSpaces(m_flWidth-(m_prefixFl->ascii().length()+1));
m_os<<" ";
m_os<<m_prefix;
}
m_column++;
m_os<<chr;
}
}
public:
void prefixFl(FileLine* fl) { m_prefixFl = fl; }
FileLine* prefixFl() const { return m_prefixFl; }
int column() const { return m_column; }
EmitVPrefixedFormatter(std::ostream& os, const string& prefix, int flWidth)
: V3OutFormatter("__STREAM", V3OutFormatter::LA_VERILOG)
, m_os(os), m_prefix(prefix), m_flWidth(flWidth) {
m_column = 0;
m_prefixFl = v3Global.rootp()->fileline(); // NETLIST's fileline instead of NULL to avoid NULL checks
}
virtual ~EmitVPrefixedFormatter() {
if (m_column) puts("\n");
}
};
class EmitVPrefixedVisitor : public EmitVBaseVisitor {
// MEMBERS
EmitVPrefixedFormatter m_formatter; // Special verilog formatter (Way down the inheritance is another unused V3OutFormatter)
// METHODS
virtual void putsNoTracking(const string& str) { m_formatter.putsNoTracking(str); }
virtual void puts(const string& str) { m_formatter.puts(str); }
// We don't use m_formatter's putbs because the tokens will change filelines
// and insert returns at the proper locations
virtual void putbs(const string& str) { m_formatter.puts(str); }
virtual void putfs(AstNode* nodep, const string& str) { putfsqs(nodep, str, false); }
virtual void putqs(AstNode* nodep, const string& str) { putfsqs(nodep, str, true); }
void putfsqs(AstNode* nodep, const string& str, bool quiet) {
if (m_formatter.prefixFl() != nodep->fileline()) {
m_formatter.prefixFl(nodep->fileline());
if (m_formatter.column()) puts("\n"); // This in turn will print the m_prefixFl
}
if (!quiet && nodep->user3()) puts("%%");
putbs(str);
}
public:
EmitVPrefixedVisitor(AstNode* nodep, std::ostream& os, const string& prefix, int flWidth,
AstSenTree* domainp, bool user3mark)
: EmitVBaseVisitor(domainp), m_formatter(os, prefix, flWidth) {
if (user3mark) { AstUser3InUse::check(); }
iterate(nodep);
}
virtual ~EmitVPrefixedVisitor() {}
};
//######################################################################
// EmitV class functions
void V3EmitV::emitv() {
UINFO(2,__FUNCTION__<<": "<<endl);
if (1) {
// All-in-one file
V3OutVFile of (v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__Vout.v");
of.putsHeader();
of.puts("# DESCR" "IPTION: Verilator output: Verilog representation of internal tree for debug\n");
EmitVFileVisitor visitor (v3Global.rootp(), &of);
} else {
// Process each module in turn
for (AstNodeModule* modp = v3Global.rootp()->modulesp();
modp; modp=VN_CAST(modp->nextp(), NodeModule)) {
V3OutVFile of (v3Global.opt.makeDir()
+"/"+EmitCBaseVisitor::modClassName(modp)+"__Vout.v");
of.putsHeader();
EmitVFileVisitor visitor (modp, &of);
}
}
}
void V3EmitV::verilogForTree(AstNode* nodep, std::ostream& os) {
EmitVStreamVisitor(nodep, os);
}
void V3EmitV::verilogPrefixedTree(AstNode* nodep, std::ostream& os,
const string& prefix, int flWidth,
AstSenTree* domainp, bool user3mark) {
EmitVPrefixedVisitor(nodep, os, prefix, flWidth, domainp, user3mark);
}
| 36.591029 | 129 | 0.546402 | tcovert2015 |
0ff2f19c1a3540c9e686a1ce3051f796f6238fbb | 1,664 | hpp | C++ | include/soralog/util.hpp | igor-egorov/soralog | ac2659044a53fc201c3001914d0d28cbf40e8ee3 | [
"Apache-2.0"
] | 2 | 2022-03-12T14:30:07.000Z | 2022-03-12T21:16:20.000Z | include/soralog/util.hpp | igor-egorov/soralog | ac2659044a53fc201c3001914d0d28cbf40e8ee3 | [
"Apache-2.0"
] | 6 | 2021-03-17T13:24:01.000Z | 2022-03-09T12:52:27.000Z | include/soralog/util.hpp | igor-egorov/soralog | ac2659044a53fc201c3001914d0d28cbf40e8ee3 | [
"Apache-2.0"
] | 4 | 2021-03-15T09:06:43.000Z | 2022-03-12T14:04:42.000Z | /**
* Copyright Soramitsu Co., Ltd. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef SORALOG_UTIL
#define SORALOG_UTIL
#include <pthread.h>
#include <array>
#include <string>
namespace soralog::util {
inline size_t getThreadNumber() {
static std::atomic_size_t tid_counter = 0;
static thread_local size_t tid = ++tid_counter;
return tid;
}
inline void setThreadName(std::string_view name) {
std::array<char, 16> buff{};
memcpy(buff.data(), name.data(), std::min<size_t>(name.size(), 15));
#if defined(__linux__)
pthread_setname_np(pthread_self(), buff.data());
#elif defined(__APPLE__)
pthread_setname_np(buff.data());
#else
#warning \
"Function setThreadName() is not implemented for current platform; An auto-generated name will be used instead"
#endif
}
inline void getThreadName(std::array<char, 16> &name) {
static thread_local std::array<char, 16> thr_name{};
static thread_local bool initialized = [&] {
#if defined(__linux__) or defined(__APPLE__)
pthread_getname_np(pthread_self(), thr_name.data(), thr_name.size());
#else
#warning \
"Function getThreadName() is not implemented for current platform; An auto-generated name will be used instead"
auto generated = "Thread#" + std::to_string(getThreadNumber());
memcpy(thr_name.data(), generated.data(),
std::min(generated.size(), thr_name.size()));
#endif
return true;
}();
name = thr_name;
}
inline std::string getThreadName() {
std::array<char, 16> buff{};
getThreadName(buff);
return buff.data();
}
} // namespace soralog::util
#endif // SORALOG_UTIL
| 27.733333 | 115 | 0.685096 | igor-egorov |
0ff3d54eafaf549ba7dc2bf437e39042b5069ce7 | 3,439 | cpp | C++ | DesktopSharing/codec/avcodec/aac_encoder.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 502 | 2018-06-12T14:48:54.000Z | 2022-03-31T07:33:00.000Z | DesktopSharing/codec/avcodec/aac_encoder.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 37 | 2018-11-23T20:43:27.000Z | 2021-12-24T07:39:17.000Z | DesktopSharing/codec/avcodec/aac_encoder.cpp | JungleZy/DesktopSharing | b8d551a50a3abad8f54db9e5a74d778725422f22 | [
"MIT"
] | 198 | 2018-06-13T13:19:05.000Z | 2022-03-30T07:32:20.000Z | #include "aac_encoder.h"
#include "av_common.h"
using namespace ffmpeg;
AACEncoder::AACEncoder()
{
}
AACEncoder::~AACEncoder()
{
Destroy();
}
bool AACEncoder::Init(AVConfig& audio_config)
{
if (is_initialized_) {
return false;
}
av_config_ = audio_config;
AVCodec *codec = nullptr;
codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
if (!codec) {
LOG("AAC Encoder not found.\n");
Destroy();
return false;
}
codec_context_ = avcodec_alloc_context3(codec);
if (!codec_context_) {
LOG("avcodec_alloc_context3() failed.");
Destroy();
return false;
}
codec_context_->sample_rate = av_config_.audio.samplerate;
codec_context_->sample_fmt = AV_SAMPLE_FMT_FLTP;
codec_context_->channels = av_config_.audio.channels;
codec_context_->channel_layout = av_get_default_channel_layout(av_config_.audio.channels);
codec_context_->bit_rate = av_config_.audio.bitrate;
//codec_context_->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
if (avcodec_open2(codec_context_, codec, NULL) != 0) {
LOG("avcodec_open2() failed.\n");
Destroy();
return false;
}
audio_resampler_.reset(new Resampler());
if (!audio_resampler_->Init(av_config_.audio.samplerate, av_config_.audio.channels,
av_config_.audio.format, av_config_.audio.samplerate,
av_config_.audio.channels, AV_SAMPLE_FMT_FLTP)) {
LOG("Audio resampler init failed.\n");
Destroy();
return false;
}
is_initialized_ = true;
return true;
}
void AACEncoder::Destroy()
{
if (audio_resampler_) {
audio_resampler_->Destroy();
audio_resampler_.reset();
}
if (codec_context_) {
avcodec_close(codec_context_);
avcodec_free_context(&codec_context_);
codec_context_ = nullptr;
}
pts_ = 0;
is_initialized_ = false;
}
uint32_t AACEncoder::GetFrameSamples()
{
if (is_initialized_) {
return codec_context_->frame_size;
}
return 0;
}
AVPacketPtr AACEncoder::Encode(const uint8_t* pcm, int samples)
{
AVFramePtr in_frame(av_frame_alloc(), [](AVFrame* ptr) {
av_frame_free(&ptr);
});
in_frame->sample_rate = codec_context_->sample_rate;
in_frame->format = AV_SAMPLE_FMT_FLT;
in_frame->channels = codec_context_->channels;
in_frame->channel_layout = codec_context_->channel_layout;
in_frame->nb_samples = samples;
in_frame->pts = pts_;
in_frame->pts = av_rescale_q(pts_, { 1, codec_context_->sample_rate }, codec_context_->time_base);
pts_ += in_frame->nb_samples;
if (av_frame_get_buffer(in_frame.get(), 0) < 0) {
LOG("av_frame_get_buffer() failed.\n");
return nullptr;
}
int bytes_per_sample = av_get_bytes_per_sample(av_config_.audio.format);
if (bytes_per_sample == 0) {
return nullptr;
}
memcpy(in_frame->data[0], pcm, bytes_per_sample * in_frame->channels * samples);
AVFramePtr fltp_frame = nullptr;
if (audio_resampler_->Convert(in_frame, fltp_frame) <= 0) {
return nullptr;
}
int ret = avcodec_send_frame(codec_context_, fltp_frame.get());
if (ret != 0) {
return nullptr;
}
AVPacketPtr av_packet(av_packet_alloc(), [](AVPacket* ptr) {av_packet_free(&ptr);});
av_init_packet(av_packet.get());
ret = avcodec_receive_packet(codec_context_, av_packet.get());
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
return nullptr;
}
else if (ret < 0) {
LOG("avcodec_receive_packet() failed.");
return nullptr;
}
return av_packet;
}
| 24.21831 | 100 | 0.697587 | JungleZy |
0ff56926c5d343910d8cf7eb3ef0522185eb6eac | 5,169 | cpp | C++ | src/core/DataSources.cpp | orion-project/spectrum | f7bf34b3670bc6ae3a3829fb9d2b99a82b705eef | [
"Apache-2.0"
] | 4 | 2018-07-05T07:50:26.000Z | 2022-03-21T11:07:02.000Z | src/core/DataSources.cpp | orion-project/spectrum | f7bf34b3670bc6ae3a3829fb9d2b99a82b705eef | [
"Apache-2.0"
] | null | null | null | src/core/DataSources.cpp | orion-project/spectrum | f7bf34b3670bc6ae3a3829fb9d2b99a82b705eef | [
"Apache-2.0"
] | 1 | 2020-01-16T05:11:13.000Z | 2020-01-16T05:11:13.000Z | #include "DataSources.h"
#include "DataReaders.h"
#include "../CustomPrefs.h"
#include <QApplication>
#include <QClipboard>
#include <QFileDialog>
#include <QFileInfo>
#include <QMimeData>
static int __randomSampleIndex = 0;
static int __clipboardCallCount = 0;
//------------------------------------------------------------------------------
// DataSource
//------------------------------------------------------------------------------
DataSource::~DataSource()
{
}
//------------------------------------------------------------------------------
// TextFileDataSource
//------------------------------------------------------------------------------
TextFileDataSource::TextFileDataSource()
{
}
bool TextFileDataSource::configure()
{
auto root = CustomDataHelpers::loadCustomData("datasources");
auto state = root["file"].toObject();
QFileDialog dlg(qApp->activeWindow());
if (_fileName.isEmpty())
{
auto dir = state["dir"].toString();
if (!dir.isEmpty())
dlg.setDirectory(dir);
}
else
dlg.selectFile(_fileName);
if (dlg.exec() == QDialog::Accepted)
{
auto files = dlg.selectedFiles();
if (files.isEmpty()) return false;
auto fileName = files.first();
if (fileName.isEmpty()) return false;
_fileName = fileName;
state["dir"] = dlg.directory().path();
root["file"] = state;
CustomDataHelpers::saveCustomData(root, "datasources");
return true;
}
return false;
}
GraphResult TextFileDataSource::getData()
{
TextReader reader;
reader.fileName = _fileName;
QString res = reader.read();
if (!res.isEmpty())
return GraphResult::fail(res);
_initialData = {reader.xs, reader.ys};
return GraphResult::ok(_initialData);
}
QString TextFileDataSource::makeTitle() const
{
return QFileInfo(_fileName).fileName();
}
//------------------------------------------------------------------------------
// CsvFileMultiDataSource
//------------------------------------------------------------------------------
GraphResult CsvFileDataSource::getData()
{
CsvSingleReader reader;
reader.fileName = _fileName;
reader.params = _params;
QString res = reader.read();
if (!res.isEmpty())
return GraphResult::fail(res);
_initialData = {reader.xs, reader.ys};
return GraphResult::ok(_initialData);
}
QString CsvFileDataSource::makeTitle() const
{
return _params.title;
}
//------------------------------------------------------------------------------
// RandomSampleDataSource
//------------------------------------------------------------------------------
RandomSampleDataSource::RandomSampleDataSource()
{
_index = ++__randomSampleIndex;
}
GraphResult RandomSampleDataSource::getData()
{
const double H = 25;
const int count = 100;
QVector<double> xs(count);
QVector<double> ys(count);
double y = (qrand()%100)*H*0.01;
for (int i = 0; i < count; i++)
{
y = qAbs(y + (qrand()%100)*H*0.01 - H*0.5);
xs[i] = i;
ys[i] = y;
}
_initialData = {xs, ys};
return GraphResult::ok(_initialData);
}
QString RandomSampleDataSource::canRefresh() const
{
return qApp->tr("Refreshing of random graph data is not supported");
}
QString RandomSampleDataSource::makeTitle() const
{
return QString("random-sample (%1)").arg(_index);
}
//------------------------------------------------------------------------------
// ClipboardDataSource
//------------------------------------------------------------------------------
ClipboardDataSource::ClipboardDataSource()
{
if (qApp->clipboard()->mimeData()->hasText())
_index = ++__clipboardCallCount;
}
GraphResult ClipboardDataSource::getData()
{
QString text = qApp->clipboard()->text();
if (text.isEmpty())
return GraphResult::fail(qApp->tr("Clipboard does not contain suitable data"));
TextReader reader;
reader.text = text;
QString res = reader.read();
if (!res.isEmpty())
return GraphResult::fail(res);
_initialData = {reader.xs, reader.ys};
return GraphResult::ok(_initialData);
}
QString ClipboardDataSource::canRefresh() const
{
return qApp->tr("Refreshing of graph data from clipboard is not supported");
}
QString ClipboardDataSource::makeTitle() const
{
return QString("clipboard (%1)").arg(_index);
}
//------------------------------------------------------------------------------
// ClipboardCsvDataSource
//------------------------------------------------------------------------------
GraphResult ClipboardCsvDataSource::getData()
{
return GraphResult::fail("Getting data from Clipboard as CSV must be done via CsvConfigDialog::openClipboard()");
}
QString ClipboardCsvDataSource::canRefresh() const
{
return qApp->tr("Refreshing of graph data from clipboard is not supported");
}
QString ClipboardCsvDataSource::makeTitle() const
{
return _params.title;
}
| 26.372449 | 117 | 0.520604 | orion-project |
0ff9920c44313e9fe0017f591ecaf024ee732689 | 1,728 | cpp | C++ | tests/test_162.cpp | AsmaBALAMANE/tiramisu | 73f9995f1e77e6adbbadda8f7dca1cb349c73eb1 | [
"MIT"
] | null | null | null | tests/test_162.cpp | AsmaBALAMANE/tiramisu | 73f9995f1e77e6adbbadda8f7dca1cb349c73eb1 | [
"MIT"
] | null | null | null | tests/test_162.cpp | AsmaBALAMANE/tiramisu | 73f9995f1e77e6adbbadda8f7dca1cb349c73eb1 | [
"MIT"
] | null | null | null | #include <tiramisu/tiramisu.h>
#include <tiramisu/block.h>
using namespace tiramisu;
int main(int argc, char **argv)
{
tiramisu::init("test_162");
input sizes("sizes", {"s_i"}, {3}, p_int32);
input params("params", {"p_i"}, {2}, p_float32);
constant M("M", sizes(0));
constant N("N", sizes(1));
constant K("K", sizes(2));
constant alpha("alpha", params(0));
constant beta("beta", params(1));
input A("A", {"A_i", "A_j"}, {M, K}, p_float32);
input B("B", {"B_i", "B_j"}, {K, N}, p_float32);
input C("C", {"C_i", "C_j"}, {M, N}, p_float32);
buffer b_A_glb("b_A_glb", {M, K}, p_float32, a_temporary);
buffer b_B_glb("b_B_glb", {K, N}, p_float32, a_temporary);
buffer b_C_glb("b_C_glb", {M, N}, p_float32, a_temporary);
b_A_glb.tag_gpu_global();
b_B_glb.tag_gpu_global();
b_C_glb.tag_gpu_global();
computation copy_A_to_device({}, memcpy(*A.get_buffer(), b_A_glb));
computation copy_B_to_device({}, memcpy(*B.get_buffer(), b_B_glb));
computation copy_C_to_device({}, memcpy(*C.get_buffer(), b_C_glb));
computation copy_C_to_host({}, memcpy(b_C_glb, *C.get_buffer()));
computation gemm({var("dummy", 0, 1)},
cublas_sgemm(b_A_glb, b_B_glb, b_C_glb, M, N, K, alpha, beta));
copy_A_to_device.then(copy_B_to_device, computation::root)
.then(copy_C_to_device, computation::root)
.then(gemm, computation::root)
.then(copy_C_to_host, computation::root);
tiramisu::codegen({sizes.get_buffer(), params.get_buffer(),
A.get_buffer(), B.get_buffer(), C.get_buffer()},
"build/generated_fct_test_162.o", true);
return 0;
}
| 35.265306 | 71 | 0.609954 | AsmaBALAMANE |
ba000edeb1698bfa926a1a969170d966c0d66e77 | 880 | cpp | C++ | src/cpu/arch/cannon_lake_256.cpp | rigred/peakperf | 4055b0a39fa906a7f1658eb530669ce95073e32b | [
"MIT"
] | 32 | 2021-01-09T19:27:01.000Z | 2022-02-26T10:06:59.000Z | src/cpu/arch/cannon_lake_256.cpp | rigred/peakperf | 4055b0a39fa906a7f1658eb530669ce95073e32b | [
"MIT"
] | 11 | 2021-01-01T22:17:15.000Z | 2022-03-14T05:44:59.000Z | src/cpu/arch/cannon_lake_256.cpp | rigred/peakperf | 4055b0a39fa906a7f1658eb530669ce95073e32b | [
"MIT"
] | 3 | 2021-04-10T20:47:32.000Z | 2021-11-12T14:24:17.000Z | #include "cannon_lake_256.hpp"
#define OP_PER_IT B_256_10_OP_IT
TYPE farr_cannon_lake_256[MAX_NUMBER_THREADS][SIZE] __attribute__((aligned(64)));
void compute_cannon_lake_256(TYPE *farr, TYPE mult, int index) {
farr = farr_cannon_lake_256[index];
for(long i=0; i < BENCHMARK_CPU_ITERS; i++) {
farr[0] = _mm256_fmadd_ps(mult, farr[0], farr[1]);
farr[2] = _mm256_fmadd_ps(mult, farr[2], farr[3]);
farr[4] = _mm256_fmadd_ps(mult, farr[4], farr[5]);
farr[6] = _mm256_fmadd_ps(mult, farr[6], farr[7]);
farr[8] = _mm256_fmadd_ps(mult, farr[8], farr[9]);
farr[10] = _mm256_fmadd_ps(mult, farr[10], farr[11]);
farr[12] = _mm256_fmadd_ps(mult, farr[12], farr[13]);
farr[14] = _mm256_fmadd_ps(mult, farr[14], farr[15]);
farr[16] = _mm256_fmadd_ps(mult, farr[16], farr[17]);
farr[18] = _mm256_fmadd_ps(mult, farr[18], farr[19]);
}
}
| 40 | 83 | 0.667045 | rigred |
ba03876c00f89e0d4fdad16f73d7db7b5424e0a2 | 2,305 | cpp | C++ | Il2Native.Logic/NativeImplementations/System.Private.CoreLib/System/Number.cpp | Vinay1705/cs2cpp | d07d3206fb57edb959df8536562909a4d516e359 | [
"MIT"
] | 192 | 2016-03-23T04:33:24.000Z | 2022-03-28T14:41:06.000Z | Il2Native.Logic/NativeImplementations/System.Private.CoreLib/System/Number.cpp | Vinay1705/cs2cpp | d07d3206fb57edb959df8536562909a4d516e359 | [
"MIT"
] | 9 | 2017-03-08T14:45:16.000Z | 2021-09-06T09:28:47.000Z | Il2Native.Logic/NativeImplementations/System.Private.CoreLib/System/Number.cpp | Vinay1705/cs2cpp | d07d3206fb57edb959df8536562909a4d516e359 | [
"MIT"
] | 56 | 2016-03-22T20:37:08.000Z | 2022-03-28T12:20:47.000Z | #include "System.Private.CoreLib.h"
namespace CoreLib { namespace System {
namespace _ = ::CoreLib::System;
// Method : System.Number.FormatDecimal(decimal, string, System.Globalization.NumberFormatInfo)
string* Number::FormatDecimal(_::Decimal value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatDouble(double, string, System.Globalization.NumberFormatInfo)
string* Number::FormatDouble(double value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatInt32(int, string, System.Globalization.NumberFormatInfo)
string* Number::FormatInt32(int32_t value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatUInt32(uint, string, System.Globalization.NumberFormatInfo)
string* Number::FormatUInt32(uint32_t value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatInt64(long, string, System.Globalization.NumberFormatInfo)
string* Number::FormatInt64(int64_t value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatUInt64(ulong, string, System.Globalization.NumberFormatInfo)
string* Number::FormatUInt64(uint64_t value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.FormatSingle(float, string, System.Globalization.NumberFormatInfo)
string* Number::FormatSingle(float value, string* format, _::Globalization::NumberFormatInfo* info)
{
throw 3221274624U;
}
// Method : System.Number.NumberBufferToDecimal(byte*, ref decimal)
bool Number::NumberBufferToDecimal_Ref(uint8_t* number, _::Decimal& value)
{
throw 3221274624U;
}
// Method : System.Number.NumberBufferToDouble(byte*, ref double)
bool Number::NumberBufferToDouble_Ref(uint8_t* number, double& value)
{
throw 3221274624U;
}
}}
namespace CoreLib { namespace System {
namespace _ = ::CoreLib::System;
}}
| 36.015625 | 109 | 0.696746 | Vinay1705 |
ba04c4a79233164bab91b64f55e81d576f931f52 | 2,813 | cpp | C++ | ChannelConneciton/Channel.cpp | qhtLucifer/GaiaConnections | ff4539e05652a815cb19fa2d2da1fa87f76405e5 | [
"MIT"
] | 1 | 2021-12-16T08:14:31.000Z | 2021-12-16T08:14:31.000Z | ChannelConneciton/Channel.cpp | qhtLucifer/GaiaConnections | ff4539e05652a815cb19fa2d2da1fa87f76405e5 | [
"MIT"
] | null | null | null | ChannelConneciton/Channel.cpp | qhtLucifer/GaiaConnections | ff4539e05652a815cb19fa2d2da1fa87f76405e5 | [
"MIT"
] | null | null | null | #include "Channel.hpp"
namespace Gaia::Connections::ChannelConnection{
Channel::Channel(): Socket(Context)
{
}
Channel::Channel(const EndPoint& endPoint): Socket(Context)
{
Socket.connect(endPoint, error_code);
if(!error_code)
{
Connected = true;
}
else
{
throw boost::system::system_error(error_code);
}
}
Channel::Channel(int port):Socket(Context), RemoteEndpoint(boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
{
}
void Channel::Bind(int port)
{
RemoteEndpoint = boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port);
}
void Channel::Bind(boost::asio::ip::tcp::endpoint endpoint_)
{
RemoteEndpoint = std::move(endpoint_);
}
void Channel::DisConnected() {
Socket.close(error_code);
if(!error_code)
{
Connected = false;
}
else
{
throw boost::system::system_error(error_code);
}
}
bool Channel::IsConnected() const
{
return Connected;
}
void Channel::Connect(const Channel::EndPoint& endPoint)
{
Socket.connect(endPoint,error_code);
if(error_code)
{
throw boost::system::system_error(error_code);
}
}
void Channel::Listen()
{
boost::asio::ip::tcp::acceptor acceptor_(Context, RemoteEndpoint);
acceptor_.accept(Socket,error_code);
if(error_code)
{
throw boost::system::system_error(error_code);
}
}
std::vector<unsigned char> Channel::Read()
{
std::vector<unsigned char> data(MaxDataSize);
std::size_t received_size = 0;
while (received_size < MaxDataSize) {
received_size += Socket.read_some(boost::asio::buffer(data), error_code);
if (error_code) {
throw boost::system::system_error(error_code);
}
}
return data;
}
void Channel::SetDataMaxSize(size_t max_data_size)
{
MaxDataSize = max_data_size;
}
std::vector<unsigned char> Channel::Read(size_t length) {
std::vector<unsigned char> data(length);
std::size_t received_size = 0;
while (received_size < length) {
received_size += Socket.read_some(boost::asio::buffer(data), error_code);
if (error_code) {
throw boost::system::system_error(error_code);
}
}
return data;
}
void Channel::Write(std::vector<unsigned char> data) {
Socket.write_some(boost::asio::buffer(data), error_code);
if (error_code) {
throw boost::system::system_error(error_code);
}
}
}; | 23.247934 | 128 | 0.563811 | qhtLucifer |
61321f8d3061ef567112cb2f3630aeec3b314852 | 1,585 | hpp | C++ | shared.hpp | VladX/StreamlabsAssignment | 5135270ee5ce77be869a9606ae07b0db771853f1 | [
"MIT"
] | null | null | null | shared.hpp | VladX/StreamlabsAssignment | 5135270ee5ce77be869a9606ae07b0db771853f1 | [
"MIT"
] | null | null | null | shared.hpp | VladX/StreamlabsAssignment | 5135270ee5ce77be869a9606ae07b0db771853f1 | [
"MIT"
] | null | null | null | #pragma once
#include "streamableobject.hpp"
#include "event.hpp"
#include "argparser.hpp"
#include "asio.hpp"
#include "fmt/include/format.h"
#include <algorithm>
namespace Streamlabs {
class Connection {
protected:
const std::string path_;
HANDLE pipe_;
asio::io_service io_service_;
std::unique_ptr<asio::windows::stream_handle> stream_;
public:
Connection(const std::string &path) : path_(path), pipe_(0) {}
~Connection() { CloseHandle(pipe_); }
void Connect() {}
void SendEvent(const EventHeader &header, const void* data = nullptr) {
asio::write(*stream_, asio::buffer(&header, sizeof(header)));
if (header.length > 0)
asio::write(*stream_, asio::buffer(data, header.length));
}
std::unique_ptr<const uint8_t[]> WaitEvent(EventHeader &header) {
asio::read(*stream_, asio::buffer(&header, sizeof(header)));
uint8_t* data = nullptr;
if (header.length > 0) {
data = new uint8_t[header.length];
asio::read(*stream_, asio::buffer(data, header.length));
}
return std::unique_ptr<const uint8_t[]>(data);
}
void SendObject(const std::unique_ptr<StreamableObject> &object) {
const StreamableObjectType type = object->GetType();
const auto length = object->GetLength();
std::vector<uint8_t> data(sizeof(type) + length);
*reinterpret_cast<StreamableObjectType*>(data.data()) = type;
object->Serialize(data.data() + sizeof(type));
SendEvent({SEND_OBJECT, data.size()}, data.data());
}
};
} | 30.480769 | 75 | 0.641009 | VladX |
6135c9c0285eeabc5192dd0b5d34321acac24e24 | 2,094 | hpp | C++ | src/compressed-sensing/lib/include/Armadillo/armadillo_bits/podarray_bones.hpp | HerrFroehlich/ns3-CompressedSensing | f5e4e56aeea97794695ecef6183bdaa1b72fd1de | [
"MIT"
] | null | null | null | src/compressed-sensing/lib/include/Armadillo/armadillo_bits/podarray_bones.hpp | HerrFroehlich/ns3-CompressedSensing | f5e4e56aeea97794695ecef6183bdaa1b72fd1de | [
"MIT"
] | null | null | null | src/compressed-sensing/lib/include/Armadillo/armadillo_bits/podarray_bones.hpp | HerrFroehlich/ns3-CompressedSensing | f5e4e56aeea97794695ecef6183bdaa1b72fd1de | [
"MIT"
] | null | null | null | // Copyright (C) 2008-2012 NICTA (www.nicta.com.au)
// Copyright (C) 2008-2012 Conrad Sanderson
//
// This file is part of the Armadillo C++ library.
// It is provided without any warranty of fitness
// for any purpose. You can redistribute this file
// and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published
// by the Free Software Foundation, either version 3
// of the License or (at your option) any later version.
// (see http://www.opensource.org/licenses for more info)
//! \addtogroup podarray
//! @{
struct podarray_prealloc_n_elem
{
static const uword val = 16;
};
//! A lightweight array for POD types. If the amount of memory requested is small, the stack is used.
template<typename eT>
class podarray
{
public:
arma_aligned const uword n_elem; //!< number of elements held
arma_aligned const eT* const mem; //!< pointer to memory used by the object
protected:
//! Internal memory, to avoid calling the 'new' operator for small amounts of memory.
arma_aligned eT mem_local[ podarray_prealloc_n_elem::val ];
public:
inline ~podarray();
inline podarray();
inline podarray (const podarray& x);
inline const podarray& operator=(const podarray& x);
arma_inline explicit podarray(const uword new_N);
arma_inline explicit podarray(const eT* X, const uword new_N);
template<typename T1>
inline explicit podarray(const Proxy<T1>& P);
arma_inline eT& operator[] (const uword i);
arma_inline eT operator[] (const uword i) const;
arma_inline eT& operator() (const uword i);
arma_inline eT operator() (const uword i) const;
inline void set_size(const uword new_n_elem);
inline void reset();
inline void fill(const eT val);
inline void zeros();
inline void zeros(const uword new_n_elem);
arma_inline eT* memptr();
arma_inline const eT* memptr() const;
arma_hot inline void copy_row(const Mat<eT>& A, const uword row);
protected:
inline void init(const uword new_n_elem);
};
//! @}
| 24.635294 | 101 | 0.6915 | HerrFroehlich |
6136cf0a92a9633a9c759b8f9ad7a636e1fba498 | 1,070 | hpp | C++ | src/Sbut/lib/ArduinoJson/Object/ObjectImpl.hpp | vanthongxtt/SBUT_SDK | 605937ee30b28e7a96d9f0f236b303c694806f35 | [
"MIT"
] | null | null | null | src/Sbut/lib/ArduinoJson/Object/ObjectImpl.hpp | vanthongxtt/SBUT_SDK | 605937ee30b28e7a96d9f0f236b303c694806f35 | [
"MIT"
] | 8 | 2020-07-07T19:52:46.000Z | 2022-02-26T10:25:52.000Z | examples/esp32/esp32master/libraries/ArduinoJson/src/ArduinoJson/Object/ObjectImpl.hpp | tobievii/Triceratops | eb66c46e4734f05cb5284ebde7234059b839d73b | [
"MIT"
] | 1 | 2020-02-14T21:00:22.000Z | 2020-02-14T21:00:22.000Z | // ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2019
// MIT License
#pragma once
#include "../Array/ArrayRef.hpp"
#include "ObjectRef.hpp"
namespace ARDUINOJSON_NAMESPACE {
template <typename TObject>
template <typename TString>
inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(
const TString& key) const {
return impl()->getOrAddMember(key).template to<ArrayRef>();
}
template <typename TObject>
template <typename TChar>
inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(TChar* key) const {
return impl()->getOrAddMember(key).template to<ArrayRef>();
}
template <typename TObject>
template <typename TString>
inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
const TString& key) const {
return impl()->getOrAddMember(key).template to<ObjectRef>();
}
template <typename TObject>
template <typename TChar>
inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
TChar* key) const {
return impl()->getOrAddMember(key).template to<ObjectRef>();
}
} // namespace ARDUINOJSON_NAMESPACE
| 27.435897 | 79 | 0.768224 | vanthongxtt |
61385cb232da6ac50c090d61faa363de9b798a5f | 79,796 | cpp | C++ | src/LovyanGFX_DentaroUI.cpp | dentaro/LovyanGFX_DentaroUI | b75cb226000b1c7b7845676f550699f67f059baf | [
"MIT"
] | 5 | 2021-11-07T07:49:42.000Z | 2022-02-01T13:31:31.000Z | src/LovyanGFX_DentaroUI.cpp | dentaro/LovyanGFX_DentaroUI | b75cb226000b1c7b7845676f550699f67f059baf | [
"MIT"
] | null | null | null | src/LovyanGFX_DentaroUI.cpp | dentaro/LovyanGFX_DentaroUI | b75cb226000b1c7b7845676f550699f67f059baf | [
"MIT"
] | null | null | null | #include "LovyanGFX_DentaroUI.hpp"
using namespace std;
#define FLICK_DIST 3
// #include <vector>
//LovyanGFX_DentaroUI::LovyanGFX_DentaroUI(LGFX& _lcd)
//{
// lcd = _lcd;
//}
void LovyanGFX_DentaroUI::touchCalibration (bool _calibF){
touchCalibrationF = _calibF;
}
void LovyanGFX_DentaroUI::begin( LGFX* _lcd, String _host, int _shiftNum, int _colBit, int _rotateNo, bool _calibF )
{
host = _host;
SD.end();
// SDカードがマウントされているかの確認
if(!SD.begin(SDCARD_SS_PIN, SDCARD_SPI, 20000000)){
Serial.println("Card Mount Failed");
while (1) {}
}
// カードタイプの取得
uint8_t cardType = SD.cardType();
if(cardType == CARD_NONE)
{
Serial.println("No SD card attached");
// 画面に案内文章を描画します。
_lcd->setTextDatum(textdatum_t::middle_center);
_lcd->drawString("No SD card attached.", _lcd->width()>>1, _lcd->height() >> 1);
_lcd->setTextDatum(textdatum_t::top_left);
while (1) {}
}
// for(int i=0; i<18;i++){
// uiBoxes.push_back(*new UiContainer);
// }
_lcd->init();
_lcd->begin();
_lcd->startWrite();//CSアサート開始
_lcd->setColorDepth( _colBit );
touchCalibrationF = _calibF;
shiftNum = _shiftNum;
for(int i=0; i<shiftNum;i++){
flickPanels[i] = new FlickPanel;
}
use_flickUiSpriteF = true;
// flickUiSprite = _flickUiSprite;
begin(_lcd);
_lcd->setRotation( _rotateNo );
for(int i = 0; i < BUF_PNG_NUM; i++)
{
createLayout( 0, 0, 256, 256, layoutSprite_list[i], MULTI_EVENT );//レイアウト用のスプライトを作る
}
for(int i = 0; i < BUF_PNG_NUM; i++)
{
createTile( layoutSprite_list[i], i, MULTI_EVENT ,i );//スプライト位置とタッチ座標もここでずらす
}
for(int objId = 0; objId < BUF_PNG_NUM; objId++){
preReadXtileNo[objId] = -1;
preReadYtileNo[objId] = -1;
}
}
void LovyanGFX_DentaroUI::begin( LGFX* _lcd)
{
lcdPos.x = 0;
lcdPos.y = 0;
// uiMode = _mode;
if(uiMode == TOUCH_MODE){
}else if(uiMode == PHYSICAL_MODE){
selectBtnID = 0;
}
//btnNum = _btnNum;
// タッチが使用可能な場合のキャリブレーションを行います。（省略可）
if(touchCalibrationF == true){
if (_lcd->touch())
{
//renameFile(SPIFFS, "/config.txt", fileName);
if (_lcd->width() < _lcd->height()) _lcd->setRotation(_lcd->getRotation() ^ 1);
// 画面に案内文章を描画します。
_lcd->setTextDatum(textdatum_t::middle_center);
_lcd->drawString("touch the arrow marker.", _lcd->width()>>1, _lcd->height() >> 1);
_lcd->setTextDatum(textdatum_t::top_left);
// タッチを使用する場合、キャリブレーションを行います。画面の四隅に表示される矢印の先端を順にタッチしてください。
uint16_t fg = TFT_WHITE;
uint16_t bg = TFT_BLACK;
if (_lcd->isEPD()) swap(fg, bg);
_lcd->calibrateTouch(nullptr, fg, bg, max(_lcd->width(), _lcd->height()) >> 3);
_lcd->fillScreen(TFT_BLACK);
_lcd->setColorDepth(TILE_COL_DEPTH);
if(use_flickUiSpriteF){
createFlickBtns(_lcd, flickUiSprite);//フリック用のボタンを生成
}
Serial.printf("heap_caps_get_free_size(MALLOC_CAP_SPIRAM) : %6d\n", heap_caps_get_free_size(MALLOC_CAP_SPIRAM) );
Serial.printf("heap_caps_get_free_size(MALLOC_CAP_DMA):%d\n", heap_caps_get_free_size(MALLOC_CAP_DMA) );
Serial.printf("heap_caps_get_largest_free_block(MALLOC_CAP_DMA):%d\n", heap_caps_get_largest_free_block(MALLOC_CAP_DMA) );
Serial.printf("Width:%d, Height:%d\n", 256, 256);
// void *p = sprite1.createSprite(256, 256);
// if ( p == NULL ) {
// Serial.println("メモリが足りなくて確保できない");
// }
Serial.printf("heap_caps_get_free_size(MALLOC_CAP_DMA):%d\n", heap_caps_get_free_size(MALLOC_CAP_DMA) );
Serial.printf("heap_caps_get_largest_free_block(MALLOC_CAP_DMA):%d\n", heap_caps_get_largest_free_block(MALLOC_CAP_DMA) );
}
}
//9枚分のメモリを確保
for(int i=0; i<9; i++)
{
MapTiles[i] = new MapTile;
getTilePos(35.667995, 139.7532971887966, 15);//適当な座標を入れておく
m_url = "/"+host+"/"+String(ztile)+"/"+String(xtile)+"/"+String(ytile + i)+".png";
MapTiles[i]->begin(i, xtile, ytile, ztile, m_url);
}
Serial.println("");
Serial.println("[UI_ID information]");
}
String LovyanGFX_DentaroUI::getPngUrl(int addNo){
m_url = "/"+host+"/"+String(ztile)+"/"+String(xtile)+"/"+String(ytile + addNo)+".png";
return m_url;
}
void LovyanGFX_DentaroUI::setLatLonPos(double _lat, double _lon){
// _lat = lat;
// _lon = lon;
}
//経緯度からタイル座標を求める
void LovyanGFX_DentaroUI::getTilePos(double _lat, double _lon, int zoom_level)
{
//setLatLonPos(lat, lon);
// _lat = lat;
// _lon = lon;
// //座標を含むタイル番号を計算
// double lat_rad = _lat * (M_PI/180);
// double n = _lcdpow(2, zoom_level);
// xtileNo = int((_lon + 180.0) / 360.0 * n);
// ytileNo = int((1.0 - log(tan(lat_rad) + (1 / cos(lat_rad))) / M_PI) / 2.0 * n);
// ztile = zoom_level;
// 緯度経度からタイル座標に変換
double x = (_lon / 180 + 1) * pow(2, zoom_level) / 2;
xtile = int(x*255);
double y = ((-log(tan((45 + _lat / 2) * M_PI / 180)) + M_PI) * pow(2, zoom_level) / (2 * M_PI));
ytile = int(y*255);
ztile = zoom_level;
// //座標を含むタイル番号を計算
//x = (_lon / 180 + 1) * pow(2, zoom_level-1) / 2;
// xtileNo = int(x);
//y = ((-log(tan((45 + _lat / 2) * M_PI / 180)) + M_PI) * pow(2, zoom_level-1) / (2 * M_PI));
// ytileNo = int(y);
// //現在地を含むタイル番号を計算
double lat_rad = _lat * (M_PI/180);
double n = pow(2, zoom_level);
xtileNo = int((_lon + 180.0) / 360.0 * n);
ytileNo = int((1.0 - log(tan(lat_rad) + (1 / cos(lat_rad))) / M_PI) / 2.0 * n);
}
void LovyanGFX_DentaroUI::update( LGFX* _lcd )
{
preXtile = getXtile();
preYtile = getYtile();
preXtileNo = getXtileNo();
preYtileNo = getYtileNo();
// preDirID = dirID;
_lcd->getTouch(&tp);
for(int i = 0; i < 4; i++)
{
clist[i+1] = clist[i];
}
if(eventState != NO_EVENT) preEventState = eventState;//前のイベント状態を保持
//以下イベント取得処理
eventState = NO_EVENT;//イベント初期化
flickState = NO_EVENT;//-1で初期化
obj_ret.reset();
//1ビット左にシフト
touchState = touchState<<1;
clist[0] = TFT_WHITE;
if ( _lcd->getTouch( &tp ) )
{
bitSet(touchState, 0);//右０ビット目を１（Set）に
}else{
bitClear(touchState, 0);//右０ビット目を0（Clear）に
}
//下位２ビットをみてイベントを振り分け
touchState &= B00000011;
if (touchState == B_TOUCH){
sp = tp; sTime = micros();
eventState = TOUCH;//6
}
else if (touchState == B_MOVE) {
clist[0] = TFT_GREEN;
unsigned long touchedTime = micros() - sTime;
eventState = WAIT;
if(touchedTime > 160000){
clist[0] = TFT_YELLOW;
eventState = MOVE;//8
}
}
else if (touchState == B_RELEASE)
{
clist[0] = TFT_BLUE;
unsigned long touchedTime = micros() - sTime;
float dist = sqrt( pow((tp.x - sp.x),2) + pow((tp.y - sp.y),2) );
if(touchedTime > 120000&&touchedTime <= 160000){
if(dist <= FLICK_DIST){
eventState = WAIT;//5
}
}
else if(touchedTime > 160000)
{
eventState = DRAG;//2
}
else if(dist <= FLICK_DIST){
eventState = TAPPED;//4
float dist2 = sqrt( pow((tp.x - sp2.x),2) + pow((tp.y - sp2.y),2) );
if(sTime - tappedTime < 200000 && dist2 < FLICK_DIST ){//ダブルタップの間の時間調整, 位置判定
eventState = WTAPPED;//5
}
tappedTime = micros();
sp2 = tp;
}
else if(dist > FLICK_DIST)
{
if(touchedTime <= 160000){
float angle = getAngle(sp, tp);
// Serial.println(angle);
if(angle <= 22.5 || angle > 337.5){
eventState = RIGHT_FLICK;//0
flickState = RIGHT_FLICK;//0
}else if(angle <= 67.5 && angle > 22.5){
eventState = R_D_FLICK;//7
flickState = R_D_FLICK;//7
}else if(angle <= 112.5 && angle > 67.5){
eventState = DOWN_FLICK;//6
flickState = DOWN_FLICK;//6
}else if(angle <= 157.5 && angle > 112.5){
eventState = D_L_FLICK;//5
flickState = D_L_FLICK;//5
}else if(angle <= 202.5 && angle > 157.5){
eventState = LEFT_FLICK;//4
flickState = LEFT_FLICK;//4
}else if(angle <= 247.5 && angle > 202.5){
eventState = L_U_FLICK;//3
flickState = L_U_FLICK;//3
}else if(angle <= 292.5 && angle > 247.5){
eventState = UP_FLICK;//2
flickState = UP_FLICK;//2
}else if(angle <= 337.5 && angle > 292.5){
eventState = U_R_FLICK;//1
flickState = U_R_FLICK;//1
}
}
}
eventState = RELEASE;//9
}else if (touchState == B_UNTOUCH) {
clist[0] = TFT_DARKGREEN;
}
for(int i = 0; i < uiBoxes_num; i++){
for(int j = 0; j<uiBoxes[i].b_num; j++){
addHandler(uiBoxes[i].b_sNo + j, j, ret0_DG, uiBoxes[i].eventNo, uiBoxes[i].parentID);
addHandler(uiBoxes[i].b_sNo + j, j, ret1_DG, uiBoxes[i].eventNo, uiBoxes[i].parentID);
}
}
}
void LovyanGFX_DentaroUI::flickSetup(LGFX* _lcd, LGFX_Sprite& _layoutSprite,
LGFX_Sprite& _ui_sprite0, LGFX_Sprite& _ui_sprite1, LGFX_Sprite& _ui_sprite2, LGFX_Sprite& _ui_sprite3, LGFX_Sprite& _flickUiSprite){
createLayout( 0, 80, 240, 240, _layoutSprite, MULTI_EVENT );//LAYOUT_0
createBtns( 0, 18, 240, 30, 1, 1, _ui_sprite3, MULTI_EVENT );//BTN_1
setFlickPanels();//フリックキーボード用プリセット
createFlicks( 48, 48, 144, 192, 3, 4, _ui_sprite0, MULTI_EVENT );//FLICK_2
//ここでフリックパネルのカスタマイズができます。
//引数は(フリックパネル番号、ボタン番号、登録したい５文字、または９文字)になっています。
// setFlickPanel(0, 0, "あいうえおかきくけ");
// setFlickPanel(0, 1, "臨兵闘者皆陣列前行");
_flickUiSprite.createSprite( 144, 144 );
createBtns( 0, 48, 48, 192, 1, 4, _ui_sprite1, MULTI_EVENT );//BTN_3
createBtns( 192, 48, 48, 192, 1, 4, _ui_sprite2, MULTI_EVENT );//BTN_4
setFlick( JP , getUiID("BTN_1"), getUiID("FLICK_2"), getUiID("BTN_3"), getUiID("BTN_4"));//立ち上げ時のパネル指定 JP/EN/NUMERIC
setBtnName( 0, "↓");
}
void LovyanGFX_DentaroUI::flickUpdate( LGFX* _lcd, LGFX_Sprite& _layoutSprite,
LGFX_Sprite& _ui_sprite0, LGFX_Sprite& _ui_sprite1, LGFX_Sprite& _ui_sprite2, LGFX_Sprite& _ui_sprite3, LGFX_Sprite& _flickUiSprite){
if( getEvent() != NO_EVENT){
if( getEvent() == TOUCH ){
if( getTouchBtnID() == uiBoxes[LeftBtnUiID].b_sNo + 2 )//フリックパネルのシフト uiBoxes[LeftBtnUiID].b_sNo+2 = 14
{
fpNo++;
fpNo %= SHIFT_NUM;//フリックパネルのシフト数
if(fpNo==0||fpNo==1)setCharMode(CHAR_3_BYTE);//日本語パネル（３バイト）
else if(fpNo==2||fpNo==3)setCharMode(CHAR_1_BYTE);//英語パネル（１バイト）
setUiLabels( FlickUiID, fpNo);
drawFlicks( FlickUiID, &_layoutSprite, _ui_sprite0 );
}
else if(getTouchBtnID() == uiBoxes[LeftBtnUiID].b_sNo+ 1 )
{ //大小文字モード切替 uiBoxes[LeftBtnUiID].b_sNo+1 = 13
if(fpNo!=2&&fpNo!=3)fpNo=2;//英語モードでなければ切り替える
else if(fpNo==2)fpNo=3;
else if(fpNo==3)fpNo=2;
if(fpNo==2||fpNo==3){
setCharMode( CHAR_1_BYTE );//英語パネル（１バイト）
}
setUiLabels( FlickUiID, fpNo );
drawFlicks( FlickUiID, &_layoutSprite, _ui_sprite0 );
}
_layoutSprite.fillScreen(TFT_BLACK);
drawBtns( TopBtnUiID, &_layoutSprite, _ui_sprite3 );
drawBtns( LeftBtnUiID, &_layoutSprite, _ui_sprite1 );
drawBtns( RightBtnUiID, &_layoutSprite, _ui_sprite2 );
drawFlicks( FlickUiID, &_layoutSprite, _ui_sprite0 );
drawFlickBtns( &_layoutSprite, _flickUiSprite, getTouchBtnID(), getTouchBtnNo(), true, true );
drawLayOut( _layoutSprite );
}
if( getEvent() == RELEASE )
{
_layoutSprite.fillScreen(TFT_BLACK);
// uiBoxes[TopBtnUiID].b_sNo = 0;
// if( getTouchBtnID() == uiBoxes[1].b_sNo)
if( getTouchBtnID() == uiBoxes[TopBtnUiID].b_sNo)
// if( getTouchBtnID() == 0 )
{
if(uiOpenF){
setLayoutPos( 0, 80 );
}
else if(!uiOpenF){setLayoutPos( 0, 290 ); }
_lcd->fillScreen(TFT_BLACK);
uiOpenF = !uiOpenF;
}
// _layoutSprite.fillScreen(TFT_BLACK);
drawBtns( TopBtnUiID, &_layoutSprite, _ui_sprite3 );
drawBtns( LeftBtnUiID, &_layoutSprite, _ui_sprite1 );
drawBtns( RightBtnUiID, &_layoutSprite, _ui_sprite2 );
drawFlicks( FlickUiID, &_layoutSprite, _ui_sprite0 );
if(getTouchBtnID() >= getUiFirstNo(FlickUiID) && getTouchBtnID() < getUiFirstNo(FlickUiID) + 12 ){
curKanaRowNo = getTouchBtnID() - getUiFirstNo(FlickUiID);//押されたボタンを行番号として渡す。
}
if(getTouchBtnID() == uiBoxes[LeftBtnUiID].b_sNo)
{//次へNxt uiBoxes[LeftBtnUiID].b_sNo = 12
selectModeF =false;
if(charMode == CHAR_3_BYTE ){//日本語入力の時
finalChar = "";
curKanaColNo++;
curKanaColNo%=5;
finalChar = getKana( showFlickPanelNo,curKanaRowNo,curKanaColNo,kanaShiftNo);
while(String(" ") == finalChar){
curKanaColNo++;
curKanaColNo%=5;
finalChar = getKana( showFlickPanelNo,curKanaRowNo,curKanaColNo,kanaShiftNo);
}
if(finalChar!="無"){
flickStr = delEndChar(flickStr, 3);
flickStr += finalChar;
flickStrDel += finalChar+"\n";
}
}else if(charMode == CHAR_1_BYTE ){//英語入力の時
finalChar = "";
curKanaColNo++;
curKanaColNo%=5;
finalChar = getKana( showFlickPanelNo,curKanaRowNo,curKanaColNo,0);
while(String(" ") == finalChar){
curKanaColNo++;
curKanaColNo%=5;
finalChar = getKana( showFlickPanelNo,curKanaRowNo,curKanaColNo,0);
}
if(finalChar!="無"){
delChar();
// flickStr = delEndChar(flickStr, 1);
flickStr += finalChar;
flickStrDel += finalChar+"\n";
}
}
}
if( getTouchBtnID() == uiBoxes[LeftBtnUiID].b_sNo + 3 )
{//変換
selectModeF =true;
if( charMode == CHAR_3_BYTE ){
kanaShiftNo++;
kanaShiftNo%=3;
finalChar = getKana( showFlickPanelNo,curKanaRowNo,curKanaColNo,kanaShiftNo);
if(finalChar!="無"){
flickStr = delEndChar(flickStr, 3);
flickStr += finalChar;
flickStrDel += finalChar+"\n";
}
}
}
else if(getTouchBtnID() == uiBoxes[RightBtnUiID].b_sNo)//delete
{
//最後の文字のバイト数を判定する
setlocale(LC_ALL, "");
vector<string> ret = split_mb(flickStrDel.c_str(),"\n");
if(ret.size() >= 1)
{
//バイト数分消去
flickStr = delEndChar(flickStr, ret[ret.size()-1].length());//一字分のバイト数削る
//flickStrDelも更新（最後の字+ "\n"を削除）
flickStrDel = "";
for (size_t i = 0; i < ret.size()-1; i++) {
flickStrDel += String(ret[i].c_str()) + "\n";
}
}
}else if(getTouchBtnID() == uiBoxes[RightBtnUiID].b_sNo+1){
if( charMode == CHAR_3_BYTE ){//全角空白（日本語のとき）
finalChar = " ";
flickStr += finalChar;
}
else if( charMode == CHAR_1_BYTE ){//半角空白
finalChar = " ";
flickStr += finalChar;
}
// flickStrDel = flickStrDel + finalChar + "\n";//通らない
flickStrDel = String(flickStrDel) + finalChar + "\n";//通る
// flickStrDel += finalChar+"\n";//なぜか通らない
}else if(getTouchBtnID() == uiBoxes[RightBtnUiID].b_sNo+2){flickStr = ""; flickStrDel = "";//クリアfinalStr = "";finalStrDel = "";
}else if(flickStr.length() >= 72){flickStr = "";//24文字を超えたらfinalStr = "";
}else
{
if(selectModeF){
kanaShiftNo = 0;
}
finalChar = getFlickStr();
flickStr += finalChar;
flickStrDel += finalChar+"\n";
drawLayOut(_layoutSprite);
}
}
}
}
void LovyanGFX_DentaroUI::delChar(){
//最後の文字のバイト数を判定する
setlocale(LC_ALL, "");
vector<string> ret = split_mb(flickStrDel.c_str(),"\n");
if(ret.size() >= 1){
//バイト数分消去
flickStr = delEndChar(flickStr, ret[ret.size()-1].length());//一字分のバイト数削る
//flickStrDelも更新（最後の字+ "\n"を削除）
flickStrDel = "";
for (size_t i = 0; i < ret.size()-1; i++) {
flickStrDel += String(ret[i].c_str()) + "\n";
}
}
}
String LovyanGFX_DentaroUI::getKana(int _panelID, int _rowID, int _colID, int _transID){
String str="";
string stdstr = "";
stdstr = flickPanels[showFlickPanelNo]->text_list[_rowID].c_str();
if( charMode == CHAR_3_BYTE )
{
String planeStr ="";
planeStr = stdstr.substr(_colID*3, 3).c_str();
str = stdstr.substr(_colID*3, 3).c_str();
if(str != "ま"||planeStr != "な"){
if(_transID == 1||_transID == 2){
int i = 0;
while(planeStr!= getHenkanChar(i, 0)||i>HENKAN_NUM-1){
i++;
if(i>HENKAN_NUM-1)break;
}
if(i < HENKAN_NUM && getHenkanChar(i, _transID).c_str()!=NULL)str = getHenkanChar(i, _transID).c_str();
else str = "無";
}
}
}
else if( charMode == CHAR_1_BYTE )
{
str = stdstr.substr(_colID, 1).c_str();
}
return str;
}
//次のマルチバイト文字へのポインタを取得
const char* LovyanGFX_DentaroUI::next_c_mb(const char* c) {
int L = mblen(c, 10);
return c + L;
}
//マルチバイト文字を一文字取り出す
void LovyanGFX_DentaroUI::ngetc(char* const dst,const char* src) {
int L = mblen(src, 10);
memcpy(dst, src, L);
dst[L] = '\0';
}
//マルチバイト文字を比較する
bool LovyanGFX_DentaroUI::nchr_cmp(const char* c1, const char* c2) {
int K = mblen(c1, 10);
int L = mblen(c2, 10);
if (K != L)
return false;
bool issame = (strncmp(c1, c2, K) == 0);
return issame;
}
vector<string> LovyanGFX_DentaroUI::split_mb(const char* src, const char* del) {
char tmp[10];
vector<string> result;
string tmps;
while (*src) {
//デリミタを飛ばす
// const char* p = src;
while (nchr_cmp(src, del) == true && *src != '\0')
src= next_c_mb(src);
//デリミタに遭遇するまで文字を追加し続ける
while (nchr_cmp(src, del) != true && *src != '\0') {
ngetc(tmp, src);//一文字取り出す
tmps += tmp;
src = next_c_mb(src);
}
if (tmps.size()) {
result.push_back(tmps);
}
tmps.clear();
}
return result;
}
void LovyanGFX_DentaroUI::updateSelectBtnID(int _selectBtnID){
selectBtnID = _selectBtnID;
}
void LovyanGFX_DentaroUI::showTouchEventInfo(LovyanGFX* _lgfx, int _x, int _y){
for(int i = 0; i < 5; i++){
_lgfx->fillRect(_x + 1 + 10*i, _y, 9,9,clist[0]);
}
}
void LovyanGFX_DentaroUI::createToggles(int _x, int _y, int _w,int _h, int _row, int _col, LGFX_Sprite& _uiSprite, int _eventNo){
toggle_mode = true;
createBtns( _x, _y, _w, _h, _row, _col, _uiSprite, _eventNo);
toggle_mode = false;
}
void LovyanGFX_DentaroUI::createFlickBtns(LGFX* _lgfx, LGFX_Sprite& _flickUiSprite)
{
flickPanel.b_sNo = 0;
flickPanel.id = 0;
flickPanel.x = 0;
flickPanel.y = 0;
// flickPanel.w = 144;
// flickPanel.h = 144;
flickPanel.row = 3;
flickPanel.col = 3;
// flickPanel.eventNo = _eventNo;
_flickUiSprite.setPsram( USE_PSRAM );
//_uiSprite.setPsram(false);//UNUSE_PSRAM
_flickUiSprite.setColorDepth( COL_DEPTH );
_flickUiSprite.createSprite( flickPanel.w, flickPanel.h );
//btnNum = _row * _col ;
int b_w = 48;
int b_h = 48;
for(int j= 0; j < 3; j++)
{
for(int i= 0; i < 3; i++)
{
flick_touch_btn_list[ i*flickPanel.col + j ] = NULL;
flick_touch_btn_list[ i*flickPanel.col + j ] = new TouchBtn( _lgfx );
flick_touch_btn_list[ i*flickPanel.col + j ]->initBtn( i * flickPanel.col + j,"a",
i*b_w,
j*b_h,
b_w,
b_h,
String( i*flickPanel.col + j ),
getTouchPoint(0, 0),
getTouchPoint(0, 0),
_flickUiSprite,
TOUCH_FLICK_MODE);
//ベータ版は基本true
flick_touch_btn_list[ i * flickPanel.col + j ]->setVisibleF( true );
flick_touch_btn_list[ i * flickPanel.col + j ]->setAvailableF( true );
}
}
flickPanel.b_num = 9;//UIのボタン数をセット
}
void LovyanGFX_DentaroUI::changeBtnMode(int _uiID, int _btnID, int _btn_mode){
//flick_touch_btn_list[ _btnID ]->btn_mode = _btn_mode;
}
// void LovyanGFX_DentaroUI::setFlickPanel(int _flickPanelID, int _btnID, String _btnsString, int _btn_mode){
// // flick_touch_btn_list[ _btnID ]->btn_mode = _btn_mode;
// // setFlickPanel(_flickPanelID, _btnID, _btnsString);
// }
void LovyanGFX_DentaroUI::setFlickPanel( int _flickPanelID, int _btnID, String _btnsString ){
flickPanels[_flickPanelID]->text_list[_btnID] = _btnsString;
}
String LovyanGFX_DentaroUI::getFlickStr(){
if(getTouchBtnID()!= NO_EVENT)
{
//押されたボタンのモードがFLICKだったら
if(touch_btn_list[getTouchBtnID()]->getBtnMode() == TOUCH_FLICK_MODE){
string gettingText = flickPanels[showFlickPanelNo]->text_list[getTouchBtnID() - getUiFirstNo(FlickUiID)].c_str();
string trimText = "";
flickString ="";
trimText = gettingText;
float angle = getAngle(sp, tp);
// Serial.println(angle);
float dist = getDist(sp, tp);
if(charMode == CHAR_3_BYTE){//日本語3ビットの場合
//５文字の場合
if(dist>24){
if(gettingText.size() == 15)//5文字以下
{
charNumMode = CHAR_3_BYTE_5;//5文字
if(angle <= 22.5 || angle > 337.5){
flickString = trimText.substr(3*3,3).c_str();//え
curKanaColNo = 3;
}else if(angle <= 112.5 && angle > 67.5){
flickString = trimText.substr(4*3,3).c_str();//お
curKanaColNo = 4;
}else if(angle <= 202.5 && angle > 157.5){
flickString = trimText.substr(1*3,3).c_str();//い
curKanaColNo = 1;
}else if(angle <= 292.5 && angle > 247.5){
flickString = trimText.substr(2*3,3).c_str();//う
curKanaColNo = 2;
}
}
else if(gettingText.size() == 27)//9文字
{
charNumMode = CHAR_3_BYTE_9;//9文字
if(angle <= 22.5 || angle > 337.5){
flickString = trimText.substr(5*3,3).c_str();//か
curKanaColNo = 5;
}else if(angle <= 112.5 && angle > 67.5){
flickString = trimText.substr(7*3,3).c_str();//く
curKanaColNo = 7;
}else if(angle <= 202.5 && angle > 157.5){
flickString = trimText.substr(1*3,3).c_str();//い
curKanaColNo = 1;
}else if(angle <= 292.5 && angle > 247.5){
flickString = trimText.substr(3*3,3).c_str();//え
curKanaColNo = 3;
}else if(angle <= 67.5 && angle > 22.5){
flickString = trimText.substr(6*3,3).c_str();//き
curKanaColNo = 6;
}else if(angle <= 157.5 && angle > 112.5){
flickString = trimText.substr(8*3,3).c_str();//け
curKanaColNo = 8;
}else if(angle <= 247.5 && angle > 202.5){
flickString = trimText.substr(2*3,3).c_str();//う
curKanaColNo = 2;
}else if(angle <= 337.5 && angle > 292.5){
flickString = trimText.substr(4*3,3).c_str();//お
curKanaColNo = 4;
}
}
}else if(dist<=24){
flickString = trimText.substr(0,3).c_str();//あ
curKanaColNo = 0;
}
return flickString;
}
else if(charMode == CHAR_1_BYTE){//英数１ビットの場合
if(dist>24){
if(gettingText.size() <= 5)//1バイト文字5文字（英語）以下の場合
{
charNumMode = CHAR_1_BYTE_5;//5文字
flickString = "";
if(angle <= 22.5 || angle > 337.5){
if(trimText.length()>=4)
flickString = trimText.substr(3,1).c_str();//D
}
if(angle <= 112.5 && angle > 67.5&&trimText.length()>=5){
flickString = trimText.substr(4,1).c_str();//E
}
if(angle <= 202.5 && angle > 157.5&&trimText.length()>=2){
flickString = trimText.substr(1,1).c_str();//B
}
if(angle <= 292.5 && angle > 247.5&&trimText.length()>=3){
flickString = trimText.substr(2,1).c_str();//C
}
}
if(gettingText.size() == 9)//1バイト文字5文字（英語）以下の場合
{
charNumMode = CHAR_1_BYTE_9;//9文字
flickString = "";
// if(angle <= 22.5 || angle > 337.5){
// if(trimText.length()>=4)
// flickString = trimText.substr(3,1).c_str();//D
// }
// if(angle <= 112.5 && angle > 67.5&&trimText.length()>=5){
// flickString = trimText.substr(4,1).c_str();//E
// }
// if(angle <= 202.5 && angle > 157.5&&trimText.length()>=2){
// flickString = trimText.substr(1,1).c_str();//B
// }
// if(angle <= 292.5 && angle > 247.5&&trimText.length()>=3){
// flickString = trimText.substr(2,1).c_str();//C
// }
if(angle <= 22.5 || angle > 337.5){
flickString = trimText.substr(5,1).c_str();//かF
// curKanaColNo = 5;
}else if(angle <= 112.5 && angle > 67.5){
flickString = trimText.substr(7,1).c_str();//くH
// curKanaColNo = 7;
}else if(angle <= 202.5 && angle > 157.5){
flickString = trimText.substr(1,1).c_str();//いB
// curKanaColNo = 1;
}else if(angle <= 292.5 && angle > 247.5){
flickString = trimText.substr(3,1).c_str();//えD
// curKanaColNo = 3;
}else if(angle <= 67.5 && angle > 22.5){
flickString = trimText.substr(6,1).c_str();//きG
// curKanaColNo = 6;
}else if(angle <= 157.5 && angle > 112.5){
flickString = trimText.substr(8,1).c_str();//けI
// curKanaColNo = 8;
}else if(angle <= 247.5 && angle > 202.5){
flickString = trimText.substr(2,1).c_str();//うC
// curKanaColNo = 2;
}else if(angle <= 337.5 && angle > 292.5){
flickString = trimText.substr(4,1).c_str();//おE
// curKanaColNo = 4;
}
}
}else if(dist<=24){
flickString = trimText.substr(0,1).c_str();//A
}
return flickString;
}
}
}
return "";
}
void LovyanGFX_DentaroUI::drawFlickBtns( LovyanGFX* _lgfx, LGFX_Sprite& _flickUiSprite, int _btnID, int _btnNo, bool _visible, bool _available )
{
if(_btnID != NO_EVENT)
{
//押されたボタンのモードがFLICKだったら
if(touch_btn_list[getTouchBtnID()]->getBtnMode() == TOUCH_FLICK_MODE)
{
//if(_visible){
_flickUiSprite.setPivot( 0, 0 );//setPivot()で回転する場合の原点を指定します。初期値は左上の(0, 0)だと思います
_flickUiSprite.fillScreen(TFT_RED);
string panelText ="０１２３４５６７８";//デフォルトの文字セット
//string prePanelText ="";
string gettingText = flickPanels[showFlickPanelNo]->text_list[_btnNo].c_str();//ArduinoのString型をc_str()で、string型に直してから、渡す
string trimText = "";
if(gettingText.size() <= 5)//1バイト文字5文字（英語）以下の場合
{
panelText ="";
for(int i=0; i<9; i++){
int swapArray[9] =
{5,2,6,
1,0,3,
8,4,7};
if(swapArray[i] < gettingText.size())
{
trimText = gettingText; panelText += trimText.substr(swapArray[i],1);
panelText += " ";panelText += " ";
}else{
panelText += " ";
}
}
}
else if(gettingText.size() == 9)//1バイト文字9文字（英語）以下の場合
{
panelText ="";
for(int i=0; i<9; i++){
int swapArray[9] =
{2,3,4,
1,0,5,
8,7,6};
if(swapArray[i] < gettingText.size())
{
trimText = gettingText; panelText += trimText.substr(swapArray[i],1);
panelText += " ";panelText += " ";
}else{
panelText += " ";
}
}
}
else if(gettingText.size() == 15)//２バイト文字（日本語）5文字の場合
{
panelText ="";
panelText += " ";//"５";//gettingText.substr(5*3,3).c_str();か
trimText = gettingText; panelText += trimText.substr(2*3,3);//う
panelText += " ";//"８";//gettingText.substr(8*3,3).c_str();け
trimText = gettingText; panelText += trimText.substr(1*3,3);//い
trimText = gettingText; panelText += trimText.substr(0,3);//あ
trimText = gettingText; panelText += trimText.substr(3*3,3);//え
panelText += " ";//"６";//gettingText.substr(6*3,3).c_str();き
trimText = gettingText; panelText += trimText.substr(4*3,3);//お
panelText += " ";//"７";//gettingText.substr(7*3,3).c_str();く
}
else if(gettingText.size() == 27)//9文字の場合
{
panelText ="";
trimText = gettingText; panelText += trimText.substr(2*3,3);//う
trimText = gettingText; panelText += trimText.substr(3*3,3);//え
trimText = gettingText; panelText += trimText.substr(4*3,3);//お
trimText = gettingText; panelText += trimText.substr(1*3,3);//い
trimText = gettingText; panelText += trimText.substr(0,3);//あ
trimText = gettingText; panelText += gettingText.substr(5*3,3);//か
trimText = gettingText; panelText += gettingText.substr(8*3,3);//け
trimText = gettingText; panelText += gettingText.substr(7*3,3);//く
trimText = gettingText; panelText += gettingText.substr(6*3,3);//き
}
//panelText.replace( 0, gettingText.size(), gettingText );// "あああ" がきたら "あああ３４５６７８" のように置き換える
//以下なぜか動かず、、、
// if(panelText.size()<27){//3バイト*9文字以下なら
// panelText.replace(0,gettingText.size(), gettingText);// "あああ" がきたら "あああ３４５６７８" のように置き換える
// }else{
// panelText.substr(0,27);//3バイト*9文字のみ切り出す
// }
//フリックパネルの文字を描画
for(int j = 0; j < 3; j++){
for(int i = 0; i < 3; i++){
_flickUiSprite.setTextSize(1);
flick_touch_btn_list[ j*3+i ]->setBtnName(panelText.substr((j*3+i)*3,3).c_str());//string型の状態で一文字切り出して、Stringに渡す
// String btn_name = flickPanels[showFlickPanelNo]->btn_name.c_str();
String btn_name = flick_touch_btn_list[ j*3+i ]->getBtnName();
//flick_touch_btn_list[i*3+j]->btn_mode = BTN_MODE_FLICK;
flick_touch_btn_list[j*3+i]->flickDraw( _flickUiSprite );
_flickUiSprite.fillRoundRect(
// flick_touch_btn_list[i]->getBtnPos().x,
// flick_touch_btn_list[i]->getBtnPos().y,
48*i,
48*j,
48,//flick_touch_btn_list[i]->getBtnSize().w,
48,//flick_touch_btn_list[i]->getBtnSize().h,
10, TFT_WHITE);
if(btn_name == NULL){
btn_name = String(j*3+i);
}
_flickUiSprite.setTextColor( TFT4_BLACK );
_flickUiSprite.setFont(&lgfxJapanGothicP_20);
int b_hw = 48/2;
int b_hh = 48/2;
float b_str_hw = _flickUiSprite.textWidth( btn_name ) / 2;
_flickUiSprite.drawString( flick_touch_btn_list[ j*3+i ]->getBtnName(), 48*i + b_hw - b_str_hw , 48*j + b_hh - 4 );
}
}
// _flickUiSprite.fillRoundRect(0, 0, 50, 50, 10, TFT_WHITE);
// _flickUiSprite.pushSprite(_lgfx, _x, _y);
// }
// else if(!_visible){
//_flickUiSprite.fillRoundRect(flick_touch_btn_list[i]->, 0, 48, 48, 10, TFT_WHITE);
_flickUiSprite.pushSprite(_lgfx, getBtnPos(_btnID).x, getBtnPos(_btnID).y);
// }
}
}
}
void LovyanGFX_DentaroUI::setLayoutSpritePos(int _LayoutSpritePosx, int _LayoutSpritePosy){
layoutSpritePos = getTouchPoint(_LayoutSpritePosx, _LayoutSpritePosy);
}
void LovyanGFX_DentaroUI::createBtns(//修正中
int _x, int _y,
int _w,int _h,
int _row, int _col,
LGFX_Sprite& _uiSprite, int _eventNo)
{//縦方向に並ぶ
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
uiBoxes[uiID].label = "BTN_" + String(uiID);
Serial.println("BTN_" + String(uiID) + "=[" + String(uiID) + "]" + String(btnID)+"~");
int _startId = btnID;//スタート時のボタンIDをセット
uiBoxes[uiID].b_sNo = btnID;
uiBoxes[uiID].id = uiID;
uiBoxes[uiID].x = _x;
uiBoxes[uiID].y = _y;
uiBoxes[uiID].w = _w;
uiBoxes[uiID].h = _h;
uiBoxes[uiID].row = _row;
uiBoxes[uiID].col = _col;
uiBoxes[uiID].eventNo = _eventNo;
// uiBoxes[uiID].toggle_mode = toggle_mode;
// uiBoxes[uiID].parentID = _parentID;
_uiSprite.setPsram(USE_PSRAM);
//_uiSprite.setPsram(false);//UNUSE_PSRAM
_uiSprite.setColorDepth( COL_DEPTH );
_uiSprite.createSprite( uiBoxes[uiID].w, uiBoxes[uiID].h );
int b_w = int(uiBoxes[uiID].w/uiBoxes[uiID].row);
int b_h = int(uiBoxes[uiID].h/uiBoxes[uiID].col);
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
int p_btnID = _startId + j * uiBoxes[uiID].row + i;//事前に計算
touch_btn_list[p_btnID] = NULL;
touch_btn_list[p_btnID] = new TouchBtn( lcd );
if(toggle_mode == false){
touch_btn_list[p_btnID]->initBtn(p_btnID, String(p_btnID),
i*b_w,
j*b_h,
b_w,
b_h,
String(p_btnID),
layoutSpritePos,
getTouchPoint(_x, _y),
_uiSprite,
TOUCH_BTN_MODE);
}
else if(toggle_mode == true){
touch_btn_list[p_btnID]->initBtn(p_btnID, String(p_btnID),
i*b_w,
j*b_h,
b_w,
b_h,
String(p_btnID),
layoutSpritePos,
getTouchPoint(_x, _y),
_uiSprite,
TOUCH_TOGGLE_MODE);
}
touch_btn_list[ p_btnID ]->setVisibleF( true );
touch_btn_list[ p_btnID ]->setAvailableF( true );
btnID++;//ボタンを更新
}
}
uiBoxes[uiID].b_num = btnID - uiBoxes[uiID].b_sNo;//UIのボタン数をセット
}
void LovyanGFX_DentaroUI::setAvailableF(int uiID, int _btnID, bool _available){
int _startId = uiBoxes[uiID].b_sNo;//スタート時のボタンIDをセット
touch_btn_list[_startId + _btnID]->setAvailableF(_available);
}
void LovyanGFX_DentaroUI::setAllBtnAvailableF(int uiID, bool _available){
int _startId = uiBoxes[uiID].b_sNo;//スタート時のボタンIDをセット
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
touch_btn_list[_startId + j*uiBoxes[uiID].row + i]->setAvailableF(_available);
}
}
}
void LovyanGFX_DentaroUI::setVisibleF(int uiID, int _btnID, bool _visible){
int _startId = uiBoxes[uiID].b_sNo;//スタート時のボタンIDをセット
touch_btn_list[_startId + _btnID]->setVisibleF(_visible);
}
void LovyanGFX_DentaroUI::setAllBtnVisibleF(int uiID, bool _visible){
int _startId = uiBoxes[uiID].b_sNo;//スタート時のボタンIDをセット
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
touch_btn_list[_startId + j*uiBoxes[uiID].row + i]->setVisibleF(_visible);
}
}
}
void LovyanGFX_DentaroUI::createBtns(
int _x, int _y,
int _w,int _h,int
_row, int _col,
LGFX_Sprite& _uiSprite, int _eventNo, bool _colMode)
{//縦方向に並ぶ
if(!_colMode)
{
createBtns( _x, _y, _w, _h, _row, _col, _uiSprite, _eventNo);
}
else if(!_colMode)
{
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
uiBoxes[uiID].label = "BTN_" + String(uiID);
Serial.println("BTN_"+String(uiID) + "=[" + String(uiID) + "]");
int _startId = btnID;//スタート時のボタンIDをセット
uiBoxes[uiID].b_sNo = btnID;
uiBoxes[uiID].id = uiID;
uiBoxes[uiID].x = _x;
uiBoxes[uiID].y = _y;
uiBoxes[uiID].w = _w;
uiBoxes[uiID].h = _h;
uiBoxes[uiID].row = _row;
uiBoxes[uiID].col = _col;
uiBoxes[uiID].eventNo = _eventNo;
// uiBoxes[uiID].parentID = _parentID;
_uiSprite.setPsram( USE_PSRAM );
//_uiSprite.setPsram(false);//UNUSE_PSRAM
_uiSprite.setColorDepth( COL_DEPTH );
_uiSprite.createSprite( uiBoxes[uiID].w, uiBoxes[uiID].h );
//btnNum = _row * _col ;
int b_w = int( uiBoxes[uiID].w / uiBoxes[uiID].row );
int b_h = int( uiBoxes[uiID].h / uiBoxes[uiID].col );
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
//int p_btnID = _startId + j * uiBoxes[uiID].row + i;//事前に計算
int p_btnID = _startId + i * uiBoxes[uiID].col + j;
touch_btn_list[p_btnID] = NULL;
touch_btn_list[p_btnID] = new TouchBtn( lcd );
touch_btn_list[p_btnID]->initBtn( p_btnID, String(p_btnID),
i*b_w,
j*b_h,
b_w,
b_h,
String(_startId),
layoutSpritePos,
getTouchPoint(uiBoxes[uiID].x, uiBoxes[uiID].y),
_uiSprite,
TOUCH_BTN_MODE);
// touch_btn_list[ _startId + i * uiBoxes[uiID].col + j ]->setVisibleF( _btnVisibleF );
// touch_btn_list[ _startId + i * uiBoxes[uiID].col + j ]->setAvailableF( _btnAvailableF );
//ベータ版は基本true
touch_btn_list[ p_btnID ]->setVisibleF( true );
touch_btn_list[ p_btnID ]->setAvailableF( true );
btnID++;
}
}
uiBoxes[uiID].b_num = btnID - uiBoxes[uiID].b_sNo;//UIのボタン数をセット
}
}
void LovyanGFX_DentaroUI::setLayoutPos( int _x, int _y )
{
// uiBoxes[uiID].x = _x;//タッチ座標
// uiBoxes[uiID].y = _y;
layoutSpritePos.x = _x;//表示用レイアウト座標
layoutSpritePos.y = _y;
layoutSprite_w =240;
layoutSprite_h =240;
setLayoutPosToAllBtn(getTouchPoint(_x, _y ));
}
void LovyanGFX_DentaroUI::createLayout( int _x, int _y, int _w, int _h, LGFX_Sprite& _layoutSprite, int _eventNo = MULTI_EVENT){
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
Serial.println("LAYOUT_" + String(uiID) + "=[" + String(uiID) + "]" + String(btnID)+"~");
uiBoxes[uiID].label = "LAYOUT_" + String(uiID);
uiBoxes[uiID].b_sNo = 0;
uiBoxes[uiID].id = uiID;
uiBoxes[uiID].x = _x;
uiBoxes[uiID].y = _y;
uiBoxes[uiID].w = _w;
uiBoxes[uiID].h = _h;
uiBoxes[uiID].eventNo = _eventNo;
// uiBoxes[uiID].parentID = _parentID;
layoutSpritePos.x = _x;
layoutSpritePos.y = _y;
layoutSprite_w = _w;
layoutSprite_h = _h;
// _layoutSprite.setPsram(false);
_layoutSprite.setPsram(true);
_layoutSprite.setColorDepth(TILE_COL_DEPTH);//親スプライトの色深度１６
_layoutSprite.createSprite(layoutSprite_w, layoutSprite_h);
_layoutSprite.setPaletteGrayscale();
}
void LovyanGFX_DentaroUI::createSliders(int _x, int _y, int _w, int _h, int _row, int _col,
LGFX_Sprite& _uiSprite,
int _xy_mode,
int _eventNo)
{
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
uiBoxes[uiID].label = "SLIDER_" + String(uiID);
Serial.println("SLIDER_" + String(uiID) + "=[" + String(uiID) + "]");
int _startId = btnID;
uiBoxes[uiID].b_sNo = btnID;
uiBoxes[uiID].id = uiID;
uiBoxes[uiID].x = _x;
uiBoxes[uiID].y = _y;
uiBoxes[uiID].w = _w;
uiBoxes[uiID].h = _h;
uiBoxes[uiID].row = _row;
uiBoxes[uiID].col = _col;
uiBoxes[uiID].eventNo = _eventNo;
//uiBoxes[uiID].parentID = _parentID;
_uiSprite.setPsram( USE_PSRAM );
// _uiSprite.setPsram(false);//UNUSE_PSRAM
_uiSprite.setColorDepth( COL_DEPTH );
_uiSprite.createSprite( _w, _h );
//sliderNum = _row * _col ;
int s_w = int( _w/_row );
int s_h = int( _h/_col );
for( int i= 0; i < _row; i++ )
{
for( int j= 0; j < _col; j++ )
{
btnID = _startId + j*_row + i;
touch_btn_list[_startId + j*_row + i] = NULL;
touch_btn_list[_startId + j*_row + i] = new TouchBtn( lcd );
touch_btn_list[_startId + j*_row + i]->initSlider( _startId + j*_row + i,
i*s_w,
j*s_h,
s_w,
s_h,
String( _startId + j*_row + i ),
layoutSpritePos,
getTouchPoint(_x, _y),
_uiSprite,
_xy_mode);
btnID++;
}
}
uiBoxes[uiID].b_num = btnID - uiBoxes[uiID].b_sNo;
}
void LovyanGFX_DentaroUI::setQWERTY(int uiID, String _btnsString, LGFX_Sprite& _sprite)
{
int charsNum = _btnsString.length();
const char* btnChars = _btnsString.c_str();
int _id = uiBoxes[uiID].b_sNo;
for(int i=0; i<charsNum; i++){
touch_btn_list[_id + i]->setVisibleF(true);
// touch_btn_list[_id + i]->setAvailableF(true);
touch_btn_list[_id + i]->setBtnName(String(btnChars[i]));
//touch_btn_list[_id + i]->setColor(_bgColIndex);
}
}
void LovyanGFX_DentaroUI::setBtnName( int _btnNo, String _btnName, String _btnNameFalse){
int _btnId = _btnNo;
touch_btn_list[_btnId]->setBtnName(_btnName);
touch_btn_list[_btnId]->setBtnNameFalse(_btnNameFalse);//トグルのfalse状態の時のラベルを設定
}
void LovyanGFX_DentaroUI::setBtnName( int _btnNo, String _btnName)
{
int _btnId = _btnNo;
touch_btn_list[_btnId]->setAvailableF(true);
touch_btn_list[_btnId]->setVisibleF(true);
// touch_btn_list[_btnId]->setAvailableF(true);
touch_btn_list[_btnId]->setBtnName(_btnName);
//touch_btn_list[_btnId]->setColor(_bgColIndex);
}
// void LovyanGFX_DentaroUI::drawBtns(int _uiID, LovyanGFX *_lgfx, LGFX_Sprite& _uiSprite)
// {
// drawBtns(_uiID, _lgfx, _uiSprite, uiBoxes[_uiID].x, uiBoxes[_uiID].y);
// }
void LovyanGFX_DentaroUI::drawBtns( int uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite, int _x, int _y)
{
lgfx = _lgfx;
if( getEvent() != NO_EVENT ){
if(getEvent() == uiBoxes[uiID].eventNo || uiBoxes[uiID].eventNo == MULTI_EVENT)
{
int _id = uiBoxes[uiID].b_sNo;
int _btnNum = uiBoxes[uiID].b_num;
_uiSprite.setPivot( 0, 0 );//setPivot()で回転する場合の原点を指定します。初期値は左上の(0, 0)だと思います
for(int i= _id; i < _id + _btnNum; i++)
{
touch_btn_list[i]->setSelectBtnF(false);
if(selectBtnID == i)touch_btn_list[i]->setSelectBtnF(true);
else touch_btn_list[i]->setSelectBtnF(false);
touch_btn_list[i]->btnDraw(_uiSprite);
// if(_showMethod == SHOW_ALL)
// {
// if(selectBtnID == i)touch_btn_list[i]->setSelectBtnF(true);
// else touch_btn_list[i]->setSelectBtnF(false);
// touch_btn_list[i]->btnDraw(_uiSprite);
// }
// else if(_showMethod == SHOW_NAMED)
// {
// if(touch_btn_list[i]->getAvailableF() == true){
// if(selectBtnID == i)touch_btn_list[i]->setSelectBtnF(true);
// else touch_btn_list[i]->setSelectBtnF(false);
// touch_btn_list[i]->btnDraw(_uiSprite);
// }
// }
}
_uiSprite.pushSprite(_lgfx, uiBoxes[uiID].x, uiBoxes[uiID].y);
}
}
}
void LovyanGFX_DentaroUI::drawSliders(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite)
{
drawSliders( _uiID, _lgfx, _uiSprite, uiBoxes[_uiID].x, uiBoxes[_uiID].y);
}
void LovyanGFX_DentaroUI::drawSliders(int uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite, int _x, int _y)
{
if( getEvent() != NO_EVENT ){
if( getEvent() == uiBoxes[uiID].eventNo || uiBoxes[uiID].eventNo == MULTI_EVENT)
{
int _id = uiBoxes[uiID].b_sNo;
int _btnNum = uiBoxes[uiID].b_num;
_uiSprite.setPivot(0, 0);//setPivot()で回転する場合の原点を指定します。初期値は左上の(0, 0)だと思います
for(int i = _id; i < _id + _btnNum; i++)
{
// touch_btn_list[i].setSelectBtnF(false);
touch_btn_list[i]->sliderDraw(_uiSprite, tp);
// if(_showMethod == SHOW_ALL)
// {
// if(selectBtnID == i)touch_btn_list[i].setSelectBtnF(true);
// else touch_btn_list[i].setSelectBtnF(false);
// touch_btn_list[i].sliderDraw(_uiSprite);
// }
// else if(_showMethod == SHOW_NAMED)
// {
// if(touch_btn_list[i].getAvailableF()==true){
// if(selectBtnID == i)touch_btn_list[i].setSelectBtnF(true);
// else touch_btn_list[i].setSelectBtnF(false);
// touch_btn_list[i].sliderDraw(_uiSprite);
// }
// }
}
_uiSprite.pushSprite(_lgfx, _x, _y);
}
}
//_layoutSprite.pushSprite(layoutSpritePos.x, layoutSpritePos.y);//最終的な出力
}
void LovyanGFX_DentaroUI::drawBtns(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite){
toggle_mode = false;
drawBtns( _uiID, _lgfx, _uiSprite, uiBoxes[_uiID].x, uiBoxes[_uiID].y);
}
// void LovyanGFX_DentaroUI::drawBtns(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite, int _x, int _y){
// toggle_mode = false;
// drawBtns( _uiID, _lgfx, _uiSprite, _x, _y);
// }
void LovyanGFX_DentaroUI::drawToggles(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite){
drawToggles(_uiID, _lgfx, _uiSprite, uiBoxes[_uiID].x, uiBoxes[_uiID].y);
}
void LovyanGFX_DentaroUI::drawToggles(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite, int _x, int _y){
toggle_mode = true;
drawBtns(_uiID, _lgfx, _uiSprite, _x, _y);
toggle_mode = false;
}
void LovyanGFX_DentaroUI::createTile( LGFX_Sprite& _layoutSprite, int _layoutUiID, int _eventNo, int _spriteNo ){//横方向に並ぶ
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
Serial.println("TILE_" + String(uiID) + "=[" + String(uiID) + "]");
int _startId = btnID;
uiBoxes[uiID].b_sNo = btnID;
uiBoxes[uiID].id = uiID;//いる？
uiBoxes[uiID].x = uiBoxes[_layoutUiID].x;
uiBoxes[uiID].y = uiBoxes[_layoutUiID].y;
uiBoxes[uiID].w = uiBoxes[_layoutUiID].w;
uiBoxes[uiID].h = uiBoxes[_layoutUiID].h;
uiBoxes[uiID].row = 1;
uiBoxes[uiID].col = 1;
uiBoxes[uiID].eventNo = _eventNo;
// uiBoxes[uiID].parentID = _parentID;
touch_btn_list[_spriteNo] = NULL;
touch_btn_list[_spriteNo] = new TouchBtn(lcd);
touch_btn_list[_spriteNo] -> initTile(
_startId,
String(_startId),
getTouchPoint(uiBoxes[uiID].x, uiBoxes[uiID].y),
uiBoxes[uiID].w,
uiBoxes[uiID].h,
_layoutSprite,
*MapTiles[_spriteNo]->getSpritePtr());
// g_basic_sprite_list[_spriteNo]);
uiBoxes[uiID].b_num = 1;
}
void LovyanGFX_DentaroUI::createFlicks(int _x, int _y, int _w,int _h,int _row, int _col, LGFX_Sprite& _uiSprite, int _eventNo){//縦方向に並ぶ
uiBoxes.push_back(*new UiContainer);
uiBoxes_num++;
uiID++;
uiBoxes[uiID].label = "FLICK_" + String(uiID);
Serial.println("FLICK_" + String(uiID) + "=[" + String(uiID) + "]" + String(btnID)+"~");
int _startId = btnID;//スタート時のボタンIDをセット
uiBoxes[uiID].b_sNo = btnID;
uiBoxes[uiID].id = uiID;
uiBoxes[uiID].x = _x;
uiBoxes[uiID].y = _y;
uiBoxes[uiID].w = _w;
uiBoxes[uiID].h = _h;
uiBoxes[uiID].row = _row;
uiBoxes[uiID].col = _col;
uiBoxes[uiID].eventNo = _eventNo;
// uiBoxes[uiID].toggle_mode = toggle_mode;
// uiBoxes[uiID].parentID = _parentID;
_uiSprite.setPsram(USE_PSRAM);
//_uiSprite.setPsram(false);//UNUSE_PSRAM
_uiSprite.setColorDepth( COL_DEPTH );
_uiSprite.createSprite( uiBoxes[uiID].w, uiBoxes[uiID].h );
int b_w = int(uiBoxes[uiID].w/uiBoxes[uiID].row);
int b_h = int(uiBoxes[uiID].h/uiBoxes[uiID].col);
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
int p_btnID = _startId + j * uiBoxes[uiID].row + i;
string stdstr = flickPanels[showFlickPanelNo]->text_list[j * uiBoxes[uiID].row + i].c_str();
String str = stdstr.substr(0,3).c_str();//先頭文字をラベルにする
touch_btn_list[p_btnID] = NULL;
touch_btn_list[p_btnID] = new TouchBtn( lcd );
touch_btn_list[p_btnID]->initBtn(p_btnID, String(p_btnID),
i*b_w,
j*b_h,
b_w,
b_h,
str, //先頭文字をラベルにする
layoutSpritePos,
getTouchPoint(_x, _y),
_uiSprite,
TOUCH_FLICK_MODE);
// touch_btn_list[ p_btnID ]->setVisibleF( _btnVisibleF );
// touch_btn_list[ p_btnID ]->setAvailableF( _btnAvailableF );
//ベータ版は基本true
touch_btn_list[ p_btnID ]->setVisibleF( true );
touch_btn_list[ p_btnID ]->setAvailableF( true );
btnID++;//ボタンを更新
}
}
uiBoxes[uiID].b_num = btnID - uiBoxes[uiID].b_sNo;//UIのボタン数をセット
}
void LovyanGFX_DentaroUI::drawFlicks(int _uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite){
toggle_mode = false;
drawFlicks( _uiID, _lgfx, _uiSprite, uiBoxes[_uiID].x, uiBoxes[_uiID].y);
}
void LovyanGFX_DentaroUI::drawFlicks( int uiID, LovyanGFX* _lgfx, LGFX_Sprite& _uiSprite, int _x, int _y)
{
lgfx = _lgfx;
if( getEvent() != NO_EVENT ){
if(getEvent() == uiBoxes[uiID].eventNo || uiBoxes[uiID].eventNo == MULTI_EVENT)
{
int _id = uiBoxes[uiID].b_sNo;
int _btnNum = uiBoxes[uiID].b_num;
_uiSprite.setPivot( 0, 0 );//setPivot()で回転する場合の原点を指定します。初期値は左上の(0, 0)だと思います
for(int i= _id; i < _id + _btnNum; i++)
{
touch_btn_list[i]->setSelectBtnF(false);
if(selectBtnID == i)touch_btn_list[i]->setSelectBtnF(true);
else touch_btn_list[i]->setSelectBtnF(false);
touch_btn_list[i]->btnDraw(_uiSprite);
}
_uiSprite.pushSprite(lgfx, uiBoxes[uiID].x, uiBoxes[uiID].y);
}
}
}
void LovyanGFX_DentaroUI::setupMaps(LGFX* _lcd)
{
}
void LovyanGFX_DentaroUI::setPngTile( fs::FS &fs, String _m_url, int _spriteNo )
{
MapTiles[_spriteNo]->getSpritePtr()->drawPngFile(fs, _m_url,
0, 0,
256, 256,
0, 0, 1.0, 1.0,
datum_t::top_left);
// this->g_basic_sprite_list[_spriteNo].drawPngFile(fs, _m_url,
// 0, 0,
// 256, 256,
// 0, 0, 1.0, 1.0,
// datum_t::top_left);
}
void LovyanGFX_DentaroUI::drawTile(int uiID, LovyanGFX* _lgfx, LGFX_Sprite& _layoutSprite, uint8_t _bgColIndex, int _spriteNo )//スプライトに格納
{
if( getEvent() != NO_EVENT )
{
if( getEvent() == uiBoxes[uiID].eventNo || uiBoxes[uiID].eventNo == MULTI_EVENT)
{
int _id = uiBoxes[uiID].b_sNo;
touch_btn_list[_id]->setVisibleF(true);
touch_btn_list[_id]->tileDraw( _lgfx, _layoutSprite, layoutSpritePos, sp, _bgColIndex, *MapTiles[_spriteNo]->getSpritePtr());
}
}
}
void LovyanGFX_DentaroUI::drawTileAuto(int uiID, LovyanGFX* _lgfx, LGFX_Sprite& _layoutSprite, int _bgColIndex, int _spriteNo )//スプライトに格納
{
int _id = uiBoxes[uiID].b_sNo;
// touch_btn_list[_id]->setVisibleF(false);
touch_btn_list[_id]->setVisibleF(true);
touch_btn_list[_id]->setDrawFinishF(false);
touch_btn_list[_id]->tileDraw( _lgfx, _layoutSprite, layoutSpritePos, sp, _bgColIndex, *MapTiles[_spriteNo]->getSpritePtr());
while(touch_btn_list[_id]->getDrawFinishF() == false)
{
//読み込み完了を待つだけ
delay(1);
}
touch_btn_list[_id]->setDrawFinishF(true);
}
void LovyanGFX_DentaroUI::drawLayOut(LGFX_Sprite& _layoutSprite){
// if(getEvent() == uiBoxes[uiID].eventNo)
// {
_layoutSprite.pushSprite(layoutSpritePos.x, layoutSpritePos.y);//最終的な出力
// }
}
bool LovyanGFX_DentaroUI::isAvailable( int _btnID ){
return touch_btn_list[_btnID]->getAvailableF();
}
void LovyanGFX_DentaroUI::addHandler( int _btnID, int _btnNo, DelegateBase2* _func, uint16_t _runEventNo, int _parentID){
runEventNo = _runEventNo;
//btnID = _btnID;
_parentID = 0;//ベータ版ではとりあえず強制的にLCDのみのイベントをとる
touch_btn_list[_btnID]->addHandler(_func);
if( parentID == PARENT_LCD ) touch_btn_list[_btnID]->run2( _btnID, _btnNo, sp, tp, eventState, runEventNo);//ボタン内のイベントかチェック
else if( parentID == PARENT_SPRITE ) touch_btn_list[_btnID]->run2( _btnID, _btnNo, sp, tp, eventState, runEventNo);//ボタン内のイベントかチェック
touch_btn_list[_btnID]->delHandlers2();
}
float LovyanGFX_DentaroUI::getAngle(lgfx::v1::touch_point_t a, lgfx::v1::touch_point_t b ){
float r = atan2( b.y - a.y, b.x - a.x );
if (r < 0) {
r = r + 2 * M_PI;
}
return r * 360 / (2 * M_PI);
}
float LovyanGFX_DentaroUI::getDist(lgfx::v1::touch_point_t a, lgfx::v1::touch_point_t b ){
float d = sqrt((b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y));
return d;
}
int LovyanGFX_DentaroUI::getPreEvent()
{
return preEventState;
}
void LovyanGFX_DentaroUI::circle(LovyanGFX* _lgfx, uint16_t c, int fillF)
{
if(fillF){
_lgfx->fillCircle(tp.x, tp.y, 10, c);
_lgfx->fillCircle(tp.x, tp.y, 10, c);
}else{
_lgfx->drawCircle(tp.x, tp.y, 10, c);
_lgfx->drawCircle(tp.x, tp.y, 10, c);
}
}
void LovyanGFX_DentaroUI::rect(LovyanGFX* _lgfx, uint16_t c, int fillF)
{
if(fillF){
_lgfx->fillRect(tp.x, tp.y, 10, 10, c);
_lgfx->fillRect(tp.x, tp.y, 10, 10, c);
}else{
_lgfx->drawRect(tp.x, tp.y, 10, 10, c);
_lgfx->drawRect(tp.x, tp.y, 10, 10, c);
}
}
void LovyanGFX_DentaroUI::nowLoc(LovyanGFX* _lgfx){
_lgfx->fillTriangle(110, 106, 130, 106, 120, 120, TFT_RED);
_lgfx->fillCircle(120, 120 - 18, 10, TFT_RED);
_lgfx->fillCircle(120, 120 - 18, 6, TFT_WHITE);
}
lgfx::v1::touch_point_t LovyanGFX_DentaroUI::getPos()
{
return tp;
}
lgfx::v1::touch_point_t LovyanGFX_DentaroUI::getStartPos()
{
return sp;
}
void LovyanGFX_DentaroUI::setPos(int _x, int _y){
tp.x = _x;
tp.y = _y;
}
void LovyanGFX_DentaroUI::setStartPos(int _x, int _y){
sp.x = _x;
sp.y = _y;
}
int LovyanGFX_DentaroUI::getTouchBtnID(){
return obj_ret.btnID;
}
int LovyanGFX_DentaroUI::getTouchBtnNo(){
return getTouchBtnID() - getUiFirstNo(FlickUiID);
}
int LovyanGFX_DentaroUI::getEvent(){
return eventState;
}
int LovyanGFX_DentaroUI::getFlickEvent(){
return flickState;
}
// LGFX_Sprite LovyanGFX_DentaroUI::getTileSprite(int _btnID)
// {
// return g_basic_sprite;
// }
void LovyanGFX_DentaroUI::setTilePos(int _id, int _x, int _y)
{
touch_btn_list[_id]->setTilePos(getTouchPoint(_x - layoutSpritePos.x, _y - layoutSpritePos.y));
}
lgfx::v1::touch_point_t LovyanGFX_DentaroUI::getTouchPoint(int _x, int _y){
lgfx::v1::touch_point_t tp;
tp.x = _x;
tp.y = _y;
return tp;
}
float LovyanGFX_DentaroUI::getSliderVal(int uiID, int _btnNo){
float retVal = 1.0;
int _btnID = uiBoxes[uiID].b_sNo + _btnNo;
if(touch_btn_list[_btnID]->get_xy_mode() == X_VAL){retVal = touch_btn_list[_btnID]->getSliderValx();}
else if(touch_btn_list[_btnID]->get_xy_mode() == Y_VAL){retVal = touch_btn_list[_btnID]->getSliderValy();}
return retVal;
}
float LovyanGFX_DentaroUI::getSliderVal(int uiID,int _btnNo, int _xy){
float retVal = 1.0;
int _btnID = uiBoxes[uiID].b_sNo + _btnNo;
if(_xy == X_VAL){retVal = touch_btn_list[_btnID]->getSliderValx();}
else if(_xy == Y_VAL){retVal = touch_btn_list[_btnID]->getSliderValy();}
return retVal;
}
Vec2 LovyanGFX_DentaroUI::getSliderVec2(int uiID, int _btnNo){//XYを一気に取得
Vec2 retPos;
int _btnID = uiBoxes[uiID].b_sNo + _btnNo;
if(touch_btn_list[_btnID]->get_xy_mode() == XY_VAL){
retPos.x = touch_btn_list[_btnID]->getSliderValx();
retPos.y = touch_btn_list[_btnID]->getSliderValy();
}
return retPos;
}
void LovyanGFX_DentaroUI::setSliderVal(int uiID, int _btnNo, float _x, float _y){
int _btnID = uiBoxes[uiID].b_sNo + _btnNo;
touch_btn_list[_btnID]->setSliderVal(_x, _y);
}
void LovyanGFX_DentaroUI::setCharMode(int _charMode){
charMode = _charMode;
}
int LovyanGFX_DentaroUI::getCharMode(){
return charMode;
}
bool LovyanGFX_DentaroUI::getToggleVal(int _uiID, int _btnNo){
int _btnID = uiBoxes[uiID].b_sNo + _btnNo;
return touch_btn_list[_btnID]->getToggleVal();
}
int LovyanGFX_DentaroUI::getUiFirstNo(int uiID){
return uiBoxes[uiID].b_sNo;
}
int LovyanGFX_DentaroUI::getflickPanelBtnNo(int uiID){
return flickPanels[uiID]->b_No;
}
int LovyanGFX_DentaroUI::getUiBtnNum(int uiID){
return uiBoxes[uiID].b_num;
}
int LovyanGFX_DentaroUI::getUiBoxNum(){
// return uiBoxes.size();
return uiBoxes_num;
}
int LovyanGFX_DentaroUI::getAllBtnNum(){
return btnID;
}
int LovyanGFX_DentaroUI::getParentID(){
return parentID;
}
int LovyanGFX_DentaroUI::getUiID( const char* _uiLabel){
int i = 0;
while(uiBoxes[i].label != String(_uiLabel)){
i++;
}
return i;
}
lgfx::v1::touch_point_t LovyanGFX_DentaroUI::getBtnPos(int _btnID){
return getTouchPoint(touch_btn_list[_btnID]->getBtnPos().x, touch_btn_list[_btnID]->getBtnPos().y);
}
void LovyanGFX_DentaroUI::setUiLabels(int uiID, int _showFlickPanelNo)
{
showFlickPanelNo = _showFlickPanelNo;
for(int i= 0; i < uiBoxes[uiID].row; i++)
{
for(int j= 0; j < uiBoxes[uiID].col; j++)
{
// int p_btnID = uiBoxes[uiID].b_sNo + j * uiBoxes[uiID].row + i;
int p_btnID = uiBoxes[uiID].b_sNo + j * uiBoxes[ uiID ].row + i;
string stdstr = flickPanels[ showFlickPanelNo ]->text_list[ j * uiBoxes[uiID].row + i ].c_str();
String str = stdstr.substr( 0, 3 ).c_str();//先頭文字をラベルにする
touch_btn_list[ p_btnID ]->setBtnName( str );
}
}
}
void LovyanGFX_DentaroUI::showInfo(LGFX& _lgfx , int _infox, int _infoy){
//showTouchEventInfo( _lgfx, _lgfx.width() - 100, 0 );//タッチイベントを視覚化する
//フレームレート情報などを表示します。
_lgfx.fillRect( _infox, _infoy, 100, 10, TFT_BLACK );
_lgfx.setTextSize(2);
_lgfx.setTextColor( TFT_WHITE );
_lgfx.setCursor( _infox + 1, _infoy + 1 );
_lgfx.print( fps );
_lgfx.print( ":" );
_lgfx.print( String( getEvent() ) );
_lgfx.print( "[" );
_lgfx.print( String( getPreEvent() ) );
_lgfx.print( "]:BTN" );
_lgfx.println( String( getTouchBtnID() ) );
++frame_count;sec = millis() / 1000;
if ( psec != sec ) {
psec = sec; fps = frame_count;
frame_count = 0;
_lgfx.setAddrWindow( 0, 0, _lgfx.width(), _lgfx.height() );
//_lgfx.setAddrWindow( 0, 0, 240, 320 );
}
}
void LovyanGFX_DentaroUI::showInfo(LovyanGFX* _lgfx , int _infox, int _infoy){
//フレームレート情報などを表示します。
_lgfx->setTextSize(1);
_lgfx->setFont(&lgfxJapanGothicP_8);
_lgfx->fillRect( 0, 0, 150, 10, TFT_BLACK );
_lgfx->setTextColor( TFT_WHITE );
_lgfx->setCursor( 1,1 );
_lgfx->print( fps );
_lgfx->print( ":" );
_lgfx->print( String( getEvent() ) );
_lgfx->print( "[" );
_lgfx->print( String( getPreEvent() ) );
_lgfx->print( "]:BTN" );
_lgfx->print( "[" );
_lgfx->print( String( getFlickEvent() ) );
_lgfx->print( "]:BTN" );
_lgfx->println( String( getTouchBtnID() ) );
++frame_count;sec = millis() / 1000;
if ( psec != sec ) {
psec = sec; fps = frame_count;
frame_count = 0;
_lgfx->setAddrWindow( 0, 0, _lgfx->width(), _lgfx->height() );
}
}
String LovyanGFX_DentaroUI::getHenkanChar(int _henkanListNo, int _kanaShiftNo){
return kanalist[_henkanListNo][_kanaShiftNo];
}
void LovyanGFX_DentaroUI::setFlickPanels(){
//パネル番号、ボタン番号、表示文字９個
//setFlickPanel(0, 0, "あいうえおかきくけ");//9文字はいまのところ未対応
int _b_sNo = uiBoxes[FlickUiID].b_sNo;
setCharMode(CHAR_3_BYTE);
//全角5文字になるように空白を入れて文字を登録
setFlickPanel(0, _b_sNo, "あいうえお");//第一引数はSHIFT_ID
setFlickPanel(0, _b_sNo+1, "かきくけこ");
setFlickPanel(0, _b_sNo+2, "さしすせそ");
setFlickPanel(0, _b_sNo+3, "たちつてと");
setFlickPanel(0, _b_sNo+4, "なにぬねの");
setFlickPanel(0, _b_sNo+5, "はひふへほ");
setFlickPanel(0, _b_sNo+6, "まみむめも");
setFlickPanel(0, _b_sNo+7, "や「ゆ」よ");
setFlickPanel(0, _b_sNo+8, "らりるれろ");
setFlickPanel(0, _b_sNo+9, "～（・） ");
setFlickPanel(0, _b_sNo+10, "わをんー ");
setFlickPanel(0, _b_sNo+11, "、。？！ ");
setFlickPanel(1, _b_sNo+0, "アイウエオ");
setFlickPanel(1, _b_sNo+1, "カキクケコ");
setFlickPanel(1, _b_sNo+2, "サシスセソ");
setFlickPanel(1, _b_sNo+3, "タチツテト");
setFlickPanel(1, _b_sNo+4, "ナニヌネノ");
setFlickPanel(1, _b_sNo+5, "ハヒフヘホ");
setFlickPanel(1, _b_sNo+6, "マミムメモ");
setFlickPanel(1, _b_sNo+7, "ヤ「ユ」ヨ");
setFlickPanel(1, _b_sNo+8, "ラリルレロ");
setFlickPanel(1, _b_sNo+9, "％＆￥― ");
setFlickPanel(1, _b_sNo+10, "ワヲンー ");
setFlickPanel(1, _b_sNo+11, "、。？！ ");
setCharMode(CHAR_1_BYTE);
//半角5文字になるように空白を入れて文字を登録
setFlickPanel(2, _b_sNo+0, "@#|&_");
setFlickPanel(2, _b_sNo+1, "ABC ");
setFlickPanel(2, _b_sNo+2, "DEF ");
setFlickPanel(2, _b_sNo+3, "GHI ");
setFlickPanel(2, _b_sNo+4, "JKL ");
setFlickPanel(2, _b_sNo+5, "MNO ");
setFlickPanel(2, _b_sNo+6, "PQRS ");
setFlickPanel(2, _b_sNo+7, "TUV ");
setFlickPanel(2, _b_sNo+8, "WXYZ ");
setFlickPanel(2, _b_sNo+9, "^[$] ");//toggleボタンに
setFlickPanel(2, _b_sNo+10, "'<\"> ");
setFlickPanel(2, _b_sNo+11, ".,?! ");
setFlickPanel(3, _b_sNo+0, "@#%&_");
setFlickPanel(3, _b_sNo+1, "abc");
setFlickPanel(3, _b_sNo+2, "def ");
setFlickPanel(3, _b_sNo+3, "ghi ");
setFlickPanel(3, _b_sNo+4, "jkl ");
setFlickPanel(3, _b_sNo+5, "mno ");
setFlickPanel(3, _b_sNo+6, "pqrs ");
setFlickPanel(3, _b_sNo+7, "tuv ");
setFlickPanel(3, _b_sNo+8, "wxyz ");
setFlickPanel(3, _b_sNo+9, "-(/) ");
setFlickPanel(3, _b_sNo+10, ":;'\" ");
setFlickPanel(3, _b_sNo+11, ".,?! ");
setFlickPanel(4, _b_sNo+0, "0 ");
setFlickPanel(4, _b_sNo+1, "1 ");
setFlickPanel(4, _b_sNo+2, "2 ");
setFlickPanel(4, _b_sNo+3, "3 ");
setFlickPanel(4, _b_sNo+4, "4 ");
setFlickPanel(4, _b_sNo+5, "5 ");
setFlickPanel(4, _b_sNo+6, "6 ");
setFlickPanel(4, _b_sNo+7, "7 ");
setFlickPanel(4, _b_sNo+8, "8 ");
setFlickPanel(4, _b_sNo+9, "9 ");
setFlickPanel(4, _b_sNo+10, "+-*/ ");
setFlickPanel(4, _b_sNo+11, ".(=) ");
}
void LovyanGFX_DentaroUI::setFlick( int _TopBtnUiID, int _FlickUiID, int _LeftBtnUiID, int _RightBtnUiID )
{
setFlick( CHAR_3_BYTE, _TopBtnUiID, _FlickUiID, _LeftBtnUiID, _RightBtnUiID );
}
void LovyanGFX_DentaroUI::setFlick( int _charMode, int _TopBtnUiID, int _FlickUiID, int _LeftBtnUiID, int _RightBtnUiID )
{
TopBtnUiID = _TopBtnUiID;
FlickUiID = _FlickUiID;
LeftBtnUiID = _LeftBtnUiID;
RightBtnUiID = _RightBtnUiID;
setBtnName( uiBoxes[LeftBtnUiID].b_sNo, "Nxt" );
setBtnName( uiBoxes[LeftBtnUiID].b_sNo+1, "a/A" );
setBtnName( uiBoxes[LeftBtnUiID].b_sNo+2, "SFT" );
setBtnName( uiBoxes[LeftBtnUiID].b_sNo+3, "゛小" );
setBtnName( uiBoxes[RightBtnUiID].b_sNo, "del" );
setBtnName( uiBoxes[RightBtnUiID].b_sNo+1, "_" );
setBtnName( uiBoxes[RightBtnUiID].b_sNo+2, "Clr" );
setBtnName( uiBoxes[RightBtnUiID].b_sNo+3, "Ret" );
if(_charMode == CHAR_1_BYTE){
fpNo=2;//英語モードに切り替える
}else if(_charMode == NUMERIC){
fpNo=4;//数値モードに切り替える
}else{
setCharMode(_charMode);//指定のパネルモードに切り替える
}
setUiLabels( FlickUiID, fpNo );
// drawFlicks( getUiID("FLICK_1"), &_layoutSprite, _ui_sprite0 );
}
String LovyanGFX_DentaroUI::getInvisibleFlickStrings(){
String invisibleStr = "";
//最後の文字のバイト数を判定する
setlocale(LC_ALL, "");
vector<string> ret = split_mb(flickStrDel.c_str(),"\n");
if(ret.size() >= 1){
for (size_t i = 0; i < ret.size()-1; i++) {
invisibleStr += "*";
}
invisibleStr += String(ret[ret.size()-1].c_str());
}
return invisibleStr;
}
String LovyanGFX_DentaroUI::getFlickString(bool _visibleMode){
if(_visibleMode == INVISIBLE)return getInvisibleFlickStrings();
else return flickStr;
}
String LovyanGFX_DentaroUI::getFlickString(){
return flickStr;
}
String LovyanGFX_DentaroUI::getFlickChar(){
String RetChar = "";
if(!selectModeF){
RetChar = preFlickChar;
}else if(selectModeF){
RetChar = previewFlickChar;
}
return RetChar;
}
String LovyanGFX_DentaroUI::delEndChar(String _str, int _ByteNum){
string stdFlickStr = _str.c_str();
for( int i = 0; i < _ByteNum; i++ ){
stdFlickStr.erase( --stdFlickStr.end() );
}
return stdFlickStr.c_str();
}
void LovyanGFX_DentaroUI::setLayoutPosToAllBtn( lgfx::v1::touch_point_t _layoutPos ){
for(int i=0; i < getAllBtnNum(); i++){
touch_btn_list[ i ]->setlayoutSpritePos(_layoutPos);
}
}
int LovyanGFX_DentaroUI::getXtile(){
return xtile;
}
int LovyanGFX_DentaroUI::getYtile(){
return ytile;
}
int LovyanGFX_DentaroUI::getZtile(){
return ztile;
}
int LovyanGFX_DentaroUI::getXtileNo(){
return xtileNo;
}
int LovyanGFX_DentaroUI::getYtileNo(){
return ytileNo;
}
int LovyanGFX_DentaroUI::getXtileNo(int _objNo){
return MapTiles[_objNo]->getXtileNo();
}
int LovyanGFX_DentaroUI::getYtileNo(int _objNo){
return MapTiles[_objNo]->getYtileNo();
}
int LovyanGFX_DentaroUI::getPreXtileNo(int _objNo){
return MapTiles[_objNo]->getPreXtileNo();
}
int LovyanGFX_DentaroUI::getPreYtileNo(int _objNo){
return MapTiles[_objNo]->getPreYtileNo();
}
int LovyanGFX_DentaroUI::getPreXtileNo(){
return preXtileNo;
}
int LovyanGFX_DentaroUI::getPreYtileNo(){
return preYtileNo;
}
int LovyanGFX_DentaroUI::getPreXtile(){
return preXtile;
}
int LovyanGFX_DentaroUI::getPreYtile(){
return preYtile;
}
int LovyanGFX_DentaroUI::getPreDirID(){
return preDirID;
}
int LovyanGFX_DentaroUI::getVx(){
return vx;
}
int LovyanGFX_DentaroUI::getVy(){
return vy;
}
int LovyanGFX_DentaroUI::getDirID(){
vx = getXtile() - getPreXtile();
vy = getYtile() - getPreYtile();
float r = atan2( vy, vx );
if (r < 0) { r = r + 2 * M_PI; }
float vecAngle = r * 360 / (2 * M_PI);
// preDirID = dirID;
if(vecAngle < 15||vecAngle >= 345) { dirID = 1;}
else if(vecAngle >= 15 && vecAngle < 75 ){ dirID = 2; }
else if(vecAngle >= 75 && vecAngle < 105){ dirID = 3; }
else if(vecAngle >= 105 && vecAngle < 165){ dirID = 4; }
else if(vecAngle >= 165 && vecAngle < 195){ dirID = 5; }
else if(vecAngle >= 195 && vecAngle < 255){ dirID = 6; }
else if(vecAngle >= 255 && vecAngle < 285){ dirID = 7; }
else if(vecAngle >= 285 && vecAngle < 345){ dirID = 8; }
return dirID;
}
void LovyanGFX_DentaroUI::setPreDirID(int _dirID){
preDirID = _dirID;
}
// void LovyanGFX_DentaroUI::setMapNolist(int _spriteNo, int _xTileNo, int _yTileNo){
// mapNolist[_spriteNo][0] = _xTileNo;
// mapNolist[_spriteNo][1] = _yTileNo;
// }
// bool LovyanGFX_DentaroUI::existMapNolist(int _spriteNo, int _xTileNo, int _yTileNo){
// if(mapNolist[_spriteNo][0] == _xTileNo&&mapNolist[_spriteNo][1] == _yTileNo){
// return true;
// }else{
// return false;
// }
// }
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 320
#define X_1 0
#define Y_1 1
#define X_2 2
#define Y_2 3
// (X_1,Y_1)
// o-------
// | \ |
// | \ |
// | \ |
// | \ |
// -------o(X_2,Y_2)
bool LovyanGFX_DentaroUI::getDrawMapF(int _posId){
// Serial.print(MapTiles[1]->getXtilePos());Serial.print(":");//[2]29100
// Serial.print(MapTiles[3]->getXtilePos());Serial.print(":");//[2]29100
// Serial.println(":");
// Serial.print(MapTiles[5]->getYtilePos());Serial.print(":");//[2]29100
//画面内に入っているタイルのみ描画をtrue
//if(tilePositons[_spriteNo][X_1] <= SCREEN_WIDTH && tilePositons[_spriteNo][X_2] >= 0 && tilePositons[_spriteNo][Y_1] <= SCREEN_HEIGHT && tilePositons[_spriteNo][Y_2] >= 0){
MapTiles[_posId]->setMapReadF(false);//一度リセット
// if(MapTiles[_posId]->getXtilePos()<= SCREEN_WIDTH && MapTiles[_posId]->getXtilePos() > -256&&
// MapTiles[_posId]->getYtilePos() <= SCREEN_HEIGHT && MapTiles[_posId]->getYtilePos() > -256){
// MapTiles[_posId]->setMapReadF(true);
// }
if(MapTiles[_posId]->getXtilePos() < SCREEN_WIDTH && MapTiles[_posId]->getXtilePos()+255 >= 0 &&
MapTiles[_posId]->getYtilePos() < SCREEN_HEIGHT && MapTiles[_posId]->getYtilePos()+255 >= 0){
MapTiles[_posId]->setMapReadF(true);
}
return MapTiles[_posId]->getMapReadF();
}
// void LovyanGFX_DentaroUI::setTilePosition(int _spriteNo, int _xtileNo, int _ytileNo, int _addXTileNo, int _addYTileNo)
// {
// MapTiles[_spriteNo]->setXtileNo(_xtileNo);
// MapTiles[_spriteNo]->setYtileNo(_ytileNo);
// MapTiles[_spriteNo]->setAddX(_addXTileNo);
// MapTiles[_spriteNo]->setAddY(_addYTileNo);
// Serial.print(_xtileNo);Serial.print(":");//[2]29100
// Serial.print(_ytileNo);Serial.print(":");//[2]12901
// Serial.print(MapTiles[_spriteNo]->getXtile());Serial.print(":");//[2]7449636
// Serial.print(MapTiles[_spriteNo]->getXtileNo());Serial.print(":");//[2]29100
// Serial.print(MapTiles[2]->getYtile());Serial.print(":");//[2]3302891
// Serial.print(MapTiles[2]->getYtileNo());Serial.print(":");//[2]12901
// for(int i = 0; i < 9; i++){
// // Serial.print(MapTiles[i]->getXtileNo());
// // Serial.print(":");
// // Serial.print(MapTiles[i]->getYtileNo());
// // Serial.print(":");
// if(MapTiles[i]->getXtileNo() == _xtileNo && MapTiles[i]->getYtileNo() == _ytileNo){//タイルのXY番号(ID)が一致したら
// MapTiles[i]->setAddX(_addXTileNo);//9マスのどこに置くかを決める
// MapTiles[i]->setAddY(_addYTileNo);
// // MapTiles[i]->setXtile(getXtile());//9マスのどこに置くかを決める
// // MapTiles[i]->setYtile(getYtile());
// MapTiles[i]->setXtileNo(getXtileNo() + _addXTileNo);//9マスのどこに置くかを決める
// MapTiles[i]->setYtileNo(getYtileNo() + _addYTileNo);
// Serial.print(MapTiles[i]->getAddX());Serial.print(":");//[2]0
// Serial.print(MapTiles[i]->getAddY());Serial.print(":");//[2]0
// break;
// }
// }
// }
// void LovyanGFX_DentaroUI::setTilePositions(int _spriteNo, int _X_1, int _Y_1){
// int _X_2 = _X_1 + 255;
// int _Y_2 = _Y_1 + 255;
// tilePositons[_spriteNo][X_1] = _X_1;
// tilePositons[_spriteNo][Y_1] = _Y_1;
// tilePositons[_spriteNo][X_2] = _X_2;
// tilePositons[_spriteNo][Y_2] = _Y_2;
// }
int LovyanGFX_DentaroUI::getPositionNo(int _addXTileNo, int _addYTileNo)//スプライトに高速描画
{
int _posNo = 0;
if(_addXTileNo == 0 && _addYTileNo == 0){_posNo = 0;}
else if(_addXTileNo == 1 && _addYTileNo == 0){_posNo = 1;}
else if(_addXTileNo == 0 && _addYTileNo == 1){_posNo = 2;}
else if(_addXTileNo == -1 && _addYTileNo == 0){_posNo = 3;}
else if(_addXTileNo == 0 && _addYTileNo == -1){_posNo = 4;}
else if(_addXTileNo == 1 && _addYTileNo == -1){_posNo = 5;}
else if(_addXTileNo == 1 && _addYTileNo == 1){_posNo = 6;}
else if(_addXTileNo == -1 && _addYTileNo == 1){_posNo = 7;}
else if(_addXTileNo == -1 && _addYTileNo == -1){_posNo = 8;}
return _posNo;
}
int LovyanGFX_DentaroUI::getAddX(int _spriteNo)
{
int addX = MapTiles[_spriteNo]->getAddX();
return addX;
}
int LovyanGFX_DentaroUI::getAddY(int _spriteNo)
{
int addY = MapTiles[_spriteNo]->getAddY();
return addY;
}
void LovyanGFX_DentaroUI::setAddX(int _objId, int _xtileNo)
{
MapTiles[_objId]->setAddX(_xtileNo);
}
void LovyanGFX_DentaroUI::setAddY(int _objId, int _ytileNo)
{
MapTiles[_objId]->setAddY(_ytileNo);
}
//---------
int LovyanGFX_DentaroUI::getPreAddX(int _spriteNo)
{
int addX = MapTiles[_spriteNo]->getPreAddX();
return addX;
}
int LovyanGFX_DentaroUI::getPreAddY(int _spriteNo)
{
int addY = MapTiles[_spriteNo]->getPreAddY();
return addY;
}
void LovyanGFX_DentaroUI::setPreAddX(int _objId, int _xtileNo)
{
MapTiles[_objId]->setPreAddX(_xtileNo);
}
void LovyanGFX_DentaroUI::setPreAddY(int _objId, int _ytileNo)
{
MapTiles[_objId]->setPreAddY(_ytileNo);
}
//---------
void LovyanGFX_DentaroUI::setXtileNo(int _objId, int _xtileNo)
{
MapTiles[_objId]->setXtileNo(_xtileNo);
}
void LovyanGFX_DentaroUI::setPreXtileNo(int _objId, int _preXtileNo)
{
MapTiles[_objId]->setPreXtileNo(_preXtileNo);
}
void LovyanGFX_DentaroUI::setYtileNo(int _objId, int _ytileNo)
{
MapTiles[_objId]->setYtileNo(_ytileNo);
}
void LovyanGFX_DentaroUI::setPreYtileNo(int _objId, int _preYtileNo)
{
MapTiles[_objId]->setPreYtileNo(_preYtileNo);
}
void LovyanGFX_DentaroUI::setTileNo(int _objId, int _xtileNo, int _ytileNo)
{
MapTiles[_objId]->setXtileNo(_xtileNo);
MapTiles[_objId]->setYtileNo(_ytileNo);
}
// void LovyanGFX_DentaroUI::setMapName(int objId, int _xtileNo, int _ytileNo){
// // MapTiles[_objId]->setXtileNo(_xtileNo);
// // MapTiles[_objId]->setYtileNo(_ytileNo);
// // MapTiles[_objId]->setMapName(_xtileNo, _ytileNo);
// }
void LovyanGFX_DentaroUI::setXtilePos(int _objId, int _xtilePos)
{
MapTiles[_objId]->setXtilePos(_xtilePos);
}
void LovyanGFX_DentaroUI::setYtilePos(int _objId, int _ytilePos)
{
MapTiles[_objId]->setYtilePos(_ytilePos);
}
int LovyanGFX_DentaroUI::getXtilePos(int _objId)
{
return MapTiles[_objId]->getXtilePos();
}
int LovyanGFX_DentaroUI::getYtilePos(int _objId)
{
return MapTiles[_objId]->getYtilePos();
}
void LovyanGFX_DentaroUI::setMapReadF(int _objId, bool _mapReadF)
{
MapTiles[_objId]->setMapReadF(_mapReadF);
}
void LovyanGFX_DentaroUI::setMapPosNo(int _objId, int _posNo)
{
MapTiles[_objId]->setPosNo(_posNo);
}
int LovyanGFX_DentaroUI::getMapPosNo(int _objId)
{
return MapTiles[_objId]->getPosNo();
}
void LovyanGFX_DentaroUI::setMapNoArray(int _objId, int _mapNo){
mapNoArray[_objId] = _mapNo;
}
void LovyanGFX_DentaroUI::setMapNo(int _objId, int _mapNo)
{
MapTiles[_objId]->setMapNo(_mapNo);
}
int LovyanGFX_DentaroUI::getMapNo(int _objId)
{
return MapTiles[_objId]->getMapNo();
}
void LovyanGFX_DentaroUI::setPreMapNo(int _objId, int _preMapNo)
{
MapTiles[_objId]->setPreMapNo(_preMapNo);
}
int LovyanGFX_DentaroUI::getPreMapNo(int _objId)
{
return MapTiles[_objId]->getPreMapNo();
}
void LovyanGFX_DentaroUI::setExistF(int _objId, bool _existF){
MapTiles[_objId]->setExistF(_existF);
}
bool LovyanGFX_DentaroUI::getExistF(int _objId){
return MapTiles[_objId]->getExistF();
}
void LovyanGFX_DentaroUI::setDrawFinishF(int _objId, bool _drawFinishF){
touch_btn_list[_objId]->setDrawFinishF(_drawFinishF);
}
bool LovyanGFX_DentaroUI::getDrawFinishF(int _objId){
return touch_btn_list[_objId]->getDrawFinishF();
}
// #define BUF_PNG_NUM 9
// int addTPosList[9][2] = {
// { 0, 0},{ 1, 0},{ 0, 1},
// { -1,0},{ 0,-1},{ 1,-1},
// {1, 1},{-1,1},{ -1,-1}
// };
// bool DownloadF = false;
// static LGFX_Sprite layoutSprite_list[BUF_PNG_NUM];
// void LovyanGFX_DentaroUI::drawMaps(){
// for(int objId = 0; objId < BUF_PNG_NUM; objId++){
// setMapNo(objId, objId);//位置番号を登録
// setXtileNo(objId, getXtileNo() + addTPosList[objId][0]);
// setYtileNo(objId, getYtileNo() + addTPosList[objId][1]);
// setAddX(objId, addTPosList[objId][0]);
// setAddY(objId, addTPosList[objId][1]);
// }
// }
// LGFX_Sprite& LovyanGFX_DentaroUI::getLayoutSprite(int _no){
// return &layoutSprite_list[_no];
// }
void LovyanGFX_DentaroUI::setDownloadF(bool _b)
{
DownloadF = _b;
}
bool LovyanGFX_DentaroUI::getDownloadF()
{
return DownloadF;
}
int LovyanGFX_DentaroUI::get_gPosId()
{
return gPosId;
}
void LovyanGFX_DentaroUI::set_gPosId(int _gPosId)
{
gPosId = _gPosId;
}
// int LovyanGFX_DentaroUI::getNowMapNo(int _addX, int _addY){
// // for(int i = 0; i < BUF_PNG_NUM; i++){
// // if(addTPosList[i][0] == _addX && addTPosList[i][1] == _addY){
// // return i;
// // }
// // }
// }
void LovyanGFX_DentaroUI::drawMaps(LGFX* _lcd, double _walkLatPos, double _walkLonPos, int _tileZoom){
for(int objId = 0; objId < BUF_PNG_NUM; objId++)
{
setPreXtileNo(objId, getXtileNo(objId));//過去の名前（位置）を保存
setPreYtileNo(objId, getYtileNo(objId));//過去の名前（位置）を保存
}
getTilePos(_walkLatPos, _walkLonPos, _tileZoom);//経緯度からタイル座標を計算
//9枚のマップ座標取得
for(int objId = 0; objId < BUF_PNG_NUM; objId++){
setAddX(objId, addTPosList[objId][0]);//相対位置情報を登録
setAddY(objId, addTPosList[objId][1]);//相対位置情報を登録
setXtileNo(objId, getXtileNo() + getAddX(objId));//名前（位置）を登録
setYtileNo(objId, getYtileNo() + getAddY(objId));//名前（位置）を登録
matrix_list[objId][2] = 120 + (getAddX(objId)*255) - getXtile()%255;
matrix_list[objId][5] = 120 + (getAddY(objId)*255) - getYtile()%255;
setXtilePos(objId, matrix_list[objId][2]);
setYtilePos(objId, matrix_list[objId][5]);
}
if(getXtileNo() != getPreXtileNo()||getYtileNo() != getPreYtileNo()){
mataidaF = true;
//Serial.println("mataida!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}else{
mataidaF = false;
}
for(int objId = 0; objId < BUF_PNG_NUM; objId++)
{
//ディスプレイ内にはいっていて
//まだ読み込んでいない場合
setExistF(objId, false);
for(int i=0; i < 9; i++){
if(getXtileNo(objId) == preReadXtileNo[i] && getYtileNo(objId) == preReadYtileNo[i])
{
setExistF(objId, true);
break;
}else{
setExistF(objId, false);
}
}
if(getExistF(objId)==false)
{
preReadXtileNo[objId] = -1;
preReadYtileNo[objId] = -1;
}
}
//---------------------------------------
if(!mataidaF){
//地図をまたいでいない時の処理
//描画
for(int objId = 0; objId < BUF_PNG_NUM; objId++)
{
for(int j = 0; j<6; j++ )matrix[j] = matrix_list[objId][j];//位置差分番号からスプライトを置く位置番号を特定し、実際の位置を登録
layoutSprite_list[objId].pushAffine( _lcd, matrix );//0~9までのスプライトを差分位置に描画
}
}
//---------------------------------------
for(int objId = 0; objId < BUF_PNG_NUM; objId++)
{
if(mataidaF){
//読み込む
set_gPosId(objId);
//上書き可能リストに、データ読み込み
//マップID取得
setDownloadF(true);//trueにするだけでタスク２が１回作動する
while(getDownloadF() == true)
{
//読み込み完了を待つだけ
delay(1);
}
drawTileAuto(
objId + BUF_PNG_NUM,
_lcd,
layoutSprite_list[objId],
TFT_ORANGE,
objId);
// Serial.print(objId);
Serial.print("[");
Serial.print(getXtileNo());
Serial.print(":");
Serial.print(getYtileNo());
Serial.print("]");
Serial.println("");
preReadXtileNo[objId] = getXtileNo(objId);
preReadYtileNo[objId] = getYtileNo(objId);
setExistF(objId, true);
}
}
}
void LovyanGFX_DentaroUI::task2_setPngTile(int _posId)
{
ROI_m_url = "/tokyo/" + String(getZtile()) + "/"+String(getXtileNo(_posId)) + "/"+String(getYtileNo(_posId)) + ".png";
setPngTile( SD, ROI_m_url, _posId );//SDからの地図の読み込み
} | 31.354028 | 177 | 0.596571 | dentaro |
613f57ea451610bfa7e2d095863fe3056adab026 | 7,592 | hpp | C++ | rocprim/include/rocprim/detail/various.hpp | YvanMokwinski/rocPRIM | 7b9661cb701fa20218443c5dfb34683e9c6ae295 | [
"MIT"
] | null | null | null | rocprim/include/rocprim/detail/various.hpp | YvanMokwinski/rocPRIM | 7b9661cb701fa20218443c5dfb34683e9c6ae295 | [
"MIT"
] | null | null | null | rocprim/include/rocprim/detail/various.hpp | YvanMokwinski/rocPRIM | 7b9661cb701fa20218443c5dfb34683e9c6ae295 | [
"MIT"
] | null | null | null | // Copyright (c) 2017-2020 Advanced Micro Devices, Inc. All rights reserved.
//
// 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 ROCPRIM_DETAIL_VARIOUS_HPP_
#define ROCPRIM_DETAIL_VARIOUS_HPP_
#include <type_traits>
#include "../config.hpp"
#include "../types.hpp"
#include "../type_traits.hpp"
// TODO: Refactor when it gets crowded
BEGIN_ROCPRIM_NAMESPACE
namespace detail
{
struct empty_storage_type
{
};
template<class T>
ROCPRIM_HOST_DEVICE inline
constexpr bool is_power_of_two(const T x)
{
static_assert(::rocprim::is_integral<T>::value, "T must be integer type");
return (x > 0) && ((x & (x - 1)) == 0);
}
template<class T>
ROCPRIM_HOST_DEVICE inline
constexpr T next_power_of_two(const T x, const T acc = 1)
{
static_assert(::rocprim::is_unsigned<T>::value, "T must be unsigned type");
return acc >= x ? acc : next_power_of_two(x, 2 * acc);
}
template<class T>
ROCPRIM_HOST_DEVICE inline
constexpr auto ceiling_div(T a, T b)
-> typename std::enable_if<::rocprim::is_integral<T>::value, T>::type
{
return (a + b - 1) / b;
}
ROCPRIM_HOST_DEVICE inline
size_t align_size(size_t size, size_t alignment = 256)
{
return ceiling_div(size, alignment) * alignment;
}
// TOOD: Put the block algorithms with warp size variables at device side with macro.
// Temporary workaround
template<class T>
ROCPRIM_HOST_DEVICE inline
constexpr T warp_size_in_class(const T warp_size)
{
return warp_size;
}
// Select the minimal warp size for block of size block_size, it's
// useful for blocks smaller than maximal warp size.
template<class T>
ROCPRIM_HOST_DEVICE inline
constexpr T get_min_warp_size(const T block_size, const T max_warp_size)
{
static_assert(::rocprim::is_unsigned<T>::value, "T must be unsigned type");
return block_size >= max_warp_size ? max_warp_size : next_power_of_two(block_size);
}
template<unsigned int WarpSize>
struct is_warpsize_shuffleable {
static const bool value = detail::is_power_of_two(WarpSize);
};
// Selects an appropriate vector_type based on the input T and size N.
// The byte size is calculated and used to select an appropriate vector_type.
template<class T, unsigned int N>
struct match_vector_type
{
static constexpr unsigned int size = sizeof(T) * N;
using vector_base_type =
typename std::conditional<
sizeof(T) >= 4,
int,
typename std::conditional<
sizeof(T) >= 2,
short,
char
>::type
>::type;
using vector_4 = typename make_vector_type<vector_base_type, 4>::type;
using vector_2 = typename make_vector_type<vector_base_type, 2>::type;
using vector_1 = typename make_vector_type<vector_base_type, 1>::type;
using type =
typename std::conditional<
size % sizeof(vector_4) == 0,
vector_4,
typename std::conditional<
size % sizeof(vector_2) == 0,
vector_2,
vector_1
>::type
>::type;
};
// Checks if Items is odd and ensures that size of T is smaller than vector_type.
template<class T, unsigned int Items>
ROCPRIM_HOST_DEVICE
constexpr bool is_vectorizable()
{
return (Items % 2 == 0) &&
(sizeof(T) < sizeof(typename match_vector_type<T, Items>::type));
}
// Returns the number of LDS (local data share) banks.
ROCPRIM_HOST_DEVICE
constexpr unsigned int get_lds_banks_no()
{
// Currently all devices supported by ROCm have 32 banks (4 bytes each)
return 32;
}
// Finds biggest fundamental type for type T that sizeof(T) is
// a multiple of that type's size.
template<class T>
struct match_fundamental_type
{
using type =
typename std::conditional<
sizeof(T)%8 == 0,
unsigned long long,
typename std::conditional<
sizeof(T)%4 == 0,
unsigned int,
typename std::conditional<
sizeof(T)%2 == 0,
unsigned short,
unsigned char
>::type
>::type
>::type;
};
template<class T>
ROCPRIM_DEVICE inline
auto store_volatile(T * output, T value)
-> typename std::enable_if<std::is_fundamental<T>::value>::type
{
*const_cast<volatile T*>(output) = value;
}
template<class T>
ROCPRIM_DEVICE inline
auto store_volatile(T * output, T value)
-> typename std::enable_if<!std::is_fundamental<T>::value>::type
{
using fundamental_type = typename match_fundamental_type<T>::type;
constexpr unsigned int n = sizeof(T) / sizeof(fundamental_type);
auto input_ptr = reinterpret_cast<volatile fundamental_type*>(&value);
auto output_ptr = reinterpret_cast<volatile fundamental_type*>(output);
#pragma unroll
for(unsigned int i = 0; i < n; i++)
{
output_ptr[i] = input_ptr[i];
}
}
template<class T>
ROCPRIM_DEVICE inline
auto load_volatile(T * input)
-> typename std::enable_if<std::is_fundamental<T>::value, T>::type
{
T retval = *const_cast<volatile T*>(input);
return retval;
}
template<class T>
ROCPRIM_DEVICE inline
auto load_volatile(T * input)
-> typename std::enable_if<!std::is_fundamental<T>::value, T>::type
{
using fundamental_type = typename match_fundamental_type<T>::type;
constexpr unsigned int n = sizeof(T) / sizeof(fundamental_type);
T retval;
auto output_ptr = reinterpret_cast<volatile fundamental_type*>(&retval);
auto input_ptr = reinterpret_cast<volatile fundamental_type*>(input);
#pragma unroll
for(unsigned int i = 0; i < n; i++)
{
output_ptr[i] = input_ptr[i];
}
return retval;
}
// A storage-backing wrapper that allows types with non-trivial constructors to be aliased in unions
template <typename T>
struct raw_storage
{
// Biggest memory-access word that T is a whole multiple of and is not larger than the alignment of T
typedef typename detail::match_fundamental_type<T>::type device_word;
// Backing storage
device_word storage[sizeof(T) / sizeof(device_word)];
// Alias
ROCPRIM_HOST_DEVICE T& get()
{
return reinterpret_cast<T&>(*this);
}
};
// Checks if two iterators have the same type and value
template<class Iterator1, class Iterator2>
inline
bool are_iterators_equal(Iterator1, Iterator2)
{
return false;
}
template<class Iterator>
inline
bool are_iterators_equal(Iterator iter1, Iterator iter2)
{
return iter1 == iter2;
}
} // end namespace detail
END_ROCPRIM_NAMESPACE
#endif // ROCPRIM_DETAIL_VARIOUS_HPP_
| 29.540856 | 105 | 0.691517 | YvanMokwinski |
6140159dd0293c79da763aa24211373028d6c9bd | 5,049 | cpp | C++ | Core/GDCore/Events/Builtin/StandardEvent.cpp | sutao80216/GDevelop | 79461bf01cc0c626e2f094d3fca940d643f93d76 | [
"MIT"
] | 1 | 2018-11-23T11:56:08.000Z | 2018-11-23T11:56:08.000Z | Core/GDCore/Events/Builtin/StandardEvent.cpp | sutao80216/GDevelop | 79461bf01cc0c626e2f094d3fca940d643f93d76 | [
"MIT"
] | 9 | 2020-04-04T19:26:47.000Z | 2022-03-25T18:41:20.000Z | Core/GDCore/Events/Builtin/StandardEvent.cpp | sutao80216/GDevelop | 79461bf01cc0c626e2f094d3fca940d643f93d76 | [
"MIT"
] | 2 | 2020-03-02T05:20:41.000Z | 2021-05-10T03:59:05.000Z | /*
* GDevelop Core
* Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
* reserved. This project is released under the MIT License.
*/
#include "StandardEvent.h"
#include "GDCore/CommonTools.h"
#include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
#include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
#include "GDCore/Events/Serialization.h"
#include "GDCore/IDE/Dialogs/EventsEditor/EventsEditorItemsAreas.h"
#include "GDCore/IDE/Dialogs/EventsEditor/EventsEditorSelection.h"
#include "GDCore/IDE/Dialogs/EventsEditor/EventsRenderingHelper.h"
#include "GDCore/Serialization/SerializerElement.h"
#include "GDCore/TinyXml/tinyxml.h"
using namespace std;
namespace gd {
StandardEvent::StandardEvent() : BaseEvent() {}
StandardEvent::~StandardEvent(){};
vector<const gd::InstructionsList*> StandardEvent::GetAllConditionsVectors()
const {
vector<const gd::InstructionsList*> allConditions;
allConditions.push_back(&conditions);
return allConditions;
}
vector<const gd::InstructionsList*> StandardEvent::GetAllActionsVectors()
const {
vector<const gd::InstructionsList*> allActions;
allActions.push_back(&actions);
return allActions;
}
vector<gd::InstructionsList*> StandardEvent::GetAllConditionsVectors() {
vector<gd::InstructionsList*> allConditions;
allConditions.push_back(&conditions);
return allConditions;
}
vector<gd::InstructionsList*> StandardEvent::GetAllActionsVectors() {
vector<gd::InstructionsList*> allActions;
allActions.push_back(&actions);
return allActions;
}
void StandardEvent::SerializeTo(SerializerElement& element) const {
gd::EventsListSerialization::SerializeInstructionsTo(
conditions, element.AddChild("conditions"));
gd::EventsListSerialization::SerializeInstructionsTo(
actions, element.AddChild("actions"));
gd::EventsListSerialization::SerializeEventsTo(events,
element.AddChild("events"));
}
void StandardEvent::UnserializeFrom(gd::Project& project,
const SerializerElement& element) {
gd::EventsListSerialization::UnserializeInstructionsFrom(
project, conditions, element.GetChild("conditions", 0, "Conditions"));
gd::EventsListSerialization::UnserializeInstructionsFrom(
project, actions, element.GetChild("actions", 0, "Actions"));
gd::EventsListSerialization::UnserializeEventsFrom(
project, events, element.GetChild("events", 0, "Events"));
}
/**
* Render the event in the bitmap
*/
void StandardEvent::Render(wxDC& dc,
int x,
int y,
unsigned int width,
gd::EventsEditorItemsAreas& areas,
gd::EventsEditorSelection& selection,
const gd::Platform& platform) {
#if !defined(GD_NO_WX_GUI)
gd::EventsRenderingHelper* renderingHelper = gd::EventsRenderingHelper::Get();
int border = renderingHelper->instructionsListBorder;
// Draw event rectangle
wxRect rect(x,
y,
renderingHelper->GetConditionsColumnWidth() + border,
GetRenderedHeight(width, platform));
renderingHelper->DrawNiceRectangle(dc, rect);
renderingHelper->DrawConditionsList(
conditions,
dc,
x + border,
y + border,
renderingHelper->GetConditionsColumnWidth() - border,
this,
areas,
selection,
platform);
renderingHelper->DrawActionsList(
actions,
dc,
x + renderingHelper->GetConditionsColumnWidth() + border,
y + border,
width - renderingHelper->GetConditionsColumnWidth() - border * 2,
this,
areas,
selection,
platform);
// Make sure that Render is rendering an event with the same height as
// GetRenderedHeight : Use same values for border and similar calls to compute
// heights
#endif
}
unsigned int StandardEvent::GetRenderedHeight(
unsigned int width, const gd::Platform& platform) const {
#if !defined(GD_NO_WX_GUI)
if (eventHeightNeedUpdate) {
gd::EventsRenderingHelper* renderingHelper =
gd::EventsRenderingHelper::Get();
int border = renderingHelper->instructionsListBorder;
// Get maximum height needed
int conditionsHeight = renderingHelper->GetRenderedConditionsListHeight(
conditions,
renderingHelper->GetConditionsColumnWidth() - border * 2,
platform);
int actionsHeight = renderingHelper->GetRenderedActionsListHeight(
actions,
width - renderingHelper->GetConditionsColumnWidth() - border * 2,
platform);
renderedHeight =
(conditionsHeight > actionsHeight ? conditionsHeight : actionsHeight) +
border * 2;
eventHeightNeedUpdate = false;
}
return renderedHeight;
#else
return 0;
#endif
}
} // namespace gd
| 33 | 81 | 0.676966 | sutao80216 |
6141166193cfd84609833e305d610b278ddd77bd | 1,135 | cpp | C++ | server/Common/Packets/WGTeamList.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | 3 | 2018-06-19T21:37:38.000Z | 2021-07-31T21:51:40.000Z | server/Common/Packets/WGTeamList.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | null | null | null | server/Common/Packets/WGTeamList.cpp | viticm/web-pap | 7c9b1f49d9ba8d8e40f8fddae829c2e414ccfeca | [
"BSD-3-Clause"
] | 13 | 2015-01-30T17:45:06.000Z | 2022-01-06T02:29:34.000Z | #include "stdafx.h"
#include "WGTeamList.h"
BOOL WGTeamList::Read(SocketInputStream& iStream )
{
__ENTER_FUNCTION
iStream.Read( (CHAR*)&m_PlayerID, sizeof(m_PlayerID) );
iStream.Read( (CHAR*)&m_TeamID, sizeof(m_TeamID) );
iStream.Read( (CHAR*)&m_nMemberCount, sizeof(m_nMemberCount) );
iStream.Read( (CHAR*)&m_GUID, sizeof(m_GUID) );
for( INT i=0; i<m_nMemberCount; ++i )
{
m_Members[i].Read(iStream);
}
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
BOOL WGTeamList::Write(SocketOutputStream& oStream ) const
{
__ENTER_FUNCTION
oStream.Write( (CHAR*)&m_PlayerID, sizeof(m_PlayerID) );
oStream.Write( (CHAR*)&m_TeamID, sizeof(m_TeamID) );
oStream.Write( (CHAR*)&m_nMemberCount, sizeof(m_nMemberCount) );
oStream.Write( (CHAR*)&m_GUID, sizeof(m_GUID) );
for( INT i=0; i<m_nMemberCount; ++i )
{
m_Members[i].Write(oStream);
}
return TRUE;
__LEAVE_FUNCTION
return FALSE;
}
UINT WGTeamList::Execute(Player* pPlayer )
{
__ENTER_FUNCTION
return WGTeamListHandler::Execute(this,pPlayer);
__LEAVE_FUNCTION
return FALSE;
}
| 19.912281 | 68 | 0.671366 | viticm |
614294d181432ac57c7c02abaf5841853309d720 | 32,216 | cpp | C++ | src/libdm/dm-qt.cpp | earl-ducaine/brl-cad-svn-follow | 4e90d5416ba764666a798bc7f4774e1fde6747a0 | [
"BSD-4-Clause",
"BSD-3-Clause"
] | null | null | null | src/libdm/dm-qt.cpp | earl-ducaine/brl-cad-svn-follow | 4e90d5416ba764666a798bc7f4774e1fde6747a0 | [
"BSD-4-Clause",
"BSD-3-Clause"
] | null | null | null | src/libdm/dm-qt.cpp | earl-ducaine/brl-cad-svn-follow | 4e90d5416ba764666a798bc7f4774e1fde6747a0 | [
"BSD-4-Clause",
"BSD-3-Clause"
] | 1 | 2018-12-21T21:09:47.000Z | 2018-12-21T21:09:47.000Z | /* D M - Q T . C P P
* BRL-CAD
*
* Copyright (c) 2013-2016 United States Government as represented by
* the U.S. Army Research Laboratory.
*
* 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.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this file; see the file named COPYING for more
* information.
*/
/** @file libdm/dm-qt.cpp
*
*/
#include "common.h"
#include <locale.h>
#ifdef DM_QT
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#include "dm-qt.h"
#include "tcl.h"
#include "tk.h"
#include "bu/log.h"
#include "bu/vls.h"
#include "bu/parse.h"
#include "dm.h"
#include "dm_private.h"
#include "dm/dm_xvars.h"
#include "dm-Null.h"
#include "fb/fb_qt.h"
#define DM_QT_DEFAULT_POINT_SIZE 1.0
/* token used to cancel previous scheduled function using Tcl_CreateTimerHandler */
Tcl_TimerToken token = NULL;
HIDDEN bool
qt_sendRepaintEvent(dm *dmp)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
QEvent e(QEvent::UpdateRequest);
return privars->qapp->sendEvent(privars->win, &e);
}
/**
* Release the display manager
*/
HIDDEN int
qt_close(dm *dmp)
{
struct dm_xvars *pubvars = (struct dm_xvars *)dmp->dm_vars.pub_vars;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_close\n");
}
delete privars->font;
delete privars->painter;
delete privars->pix;
delete privars->win;
delete privars->parent;
privars->qapp->quit();
Tk_DestroyWindow(pubvars->xtkwin);
bu_vls_free(&dmp->dm_pathName);
bu_vls_free(&dmp->dm_tkName);
bu_vls_free(&dmp->dm_dName);
bu_free((void *)dmp->dm_vars.priv_vars, "qt_close: qt_vars");
bu_free((void *)dmp->dm_vars.pub_vars, "qt_close: dm_xvars");
bu_free((void *)dmp, "qt_close: dmp");
return TCL_OK;
}
HIDDEN int
qt_drawBegin(dm *dmp)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawBegin\n");
}
privars->pix->fill(privars->bg);
privars->painter->setPen(privars->fg);
privars->painter->setFont(*privars->font);
if (privars->img != NULL && privars->drawFb == 1) {
privars->painter->drawImage(0, 0, *privars->img, 0, 0, dmp->dm_width - 1, dmp->dm_height - 1);
}
return TCL_OK;
}
HIDDEN int
qt_drawEnd(dm *dmp)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawEnd\n");
}
privars->qapp->processEvents();
qt_sendRepaintEvent(dmp);
privars->qapp->processEvents();
return TCL_OK;
}
/**
* Restore the display processor to a normal mode of operation (i.e.,
* not scaled, rotated, displaced, etc.).
*/
HIDDEN int
qt_normal(dm *dmp)
{
if (dmp->dm_debugLevel)
bu_log("qt_normal()\n");
return TCL_OK;
}
/**
* Load a new transformation matrix. This will be followed by many
* calls to qt_draw().
*/
HIDDEN int
qt_loadMatrix(dm *dmp, fastf_t *mat, int UNUSED(which_eye))
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_loadMatrix\n");
}
MAT_COPY(privars->qmat, mat);
return 0;
}
/**
* Output a string into the displaylist. The starting position of the
* beam is as specified.
*/
HIDDEN int
qt_drawString2D(dm *dmp, const char *str, fastf_t x, fastf_t y, int UNUSED(size), int use_aspect)
{
int sx, sy;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawString2D\n");
}
sx = dm_Normal2Xx(dmp, x);
sy = dm_Normal2Xy(dmp, y, use_aspect);
if (privars->painter == NULL)
return TCL_ERROR;
privars->painter->drawText(sx, sy, str);
return TCL_OK;
}
HIDDEN int
qt_drawLine2D(dm *dmp, fastf_t x_1, fastf_t y_1, fastf_t x_2, fastf_t y_2)
{
int sx1, sy1, sx2, sy2;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawLine2D\n");
}
sx1 = dm_Normal2Xx(dmp, x_1);
sx2 = dm_Normal2Xx(dmp, x_2);
sy1 = dm_Normal2Xy(dmp, y_1, 0);
sy2 = dm_Normal2Xy(dmp, y_2, 0);
if (privars->painter == NULL)
return TCL_ERROR;
privars->painter->drawLine(sx1, sy1, sx2, sy2);
return TCL_OK;
}
HIDDEN int
qt_drawPoint2D(dm *dmp, fastf_t x, fastf_t y)
{
int sx, sy;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawPoint2D\n");
}
sx = dm_Normal2Xx(dmp, x);
sy = dm_Normal2Xy(dmp, y, 0);
if (privars->painter == NULL)
return TCL_ERROR;
privars->painter->drawPoint(sx, sy);
return TCL_OK;
}
HIDDEN int
qt_drawVList(dm *dmp, struct bn_vlist *vp)
{
static vect_t spnt, lpnt, pnt;
struct bn_vlist *tvp;
QLine lines[1024];
QLine *linep;
int nseg;
fastf_t delta;
point_t *pt_prev = NULL;
fastf_t dist_prev=1.0;
fastf_t pointSize = DM_QT_DEFAULT_POINT_SIZE;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_drawVList\n");
}
/* delta is used in clipping to insure clipped endpoint is
* slightly in front of eye plane (perspective mode only). This
* value is a SWAG that seems to work OK.
*/
delta = privars->qmat[15]*0.0001;
if (delta < 0.0)
delta = -delta;
if (delta < SQRT_SMALL_FASTF)
delta = SQRT_SMALL_FASTF;
nseg = 0;
linep = lines;
for (BU_LIST_FOR(tvp, bn_vlist, &vp->l)) {
int i;
int nused = tvp->nused;
int *cmd = tvp->cmd;
point_t *pt = tvp->pt;
fastf_t dist;
for (i = 0; i < nused; i++, cmd++, pt++) {
switch (*cmd) {
case BN_VLIST_POLY_START:
case BN_VLIST_POLY_VERTNORM:
case BN_VLIST_TRI_START:
case BN_VLIST_TRI_VERTNORM:
continue;
case BN_VLIST_POLY_MOVE:
case BN_VLIST_LINE_MOVE:
case BN_VLIST_TRI_MOVE:
/* Move, not draw */
if (dmp->dm_perspective > 0) {
/* cannot apply perspective transformation to
* points behind eye plane!!!!
*/
dist = VDOT(*pt, &privars->qmat[12]) + privars->qmat[15];
if (dist <= 0.0) {
pt_prev = pt;
dist_prev = dist;
continue;
} else {
MAT4X3PNT(lpnt, privars->qmat, *pt);
dist_prev = dist;
pt_prev = pt;
}
} else {
MAT4X3PNT(lpnt, privars->qmat, *pt);
}
lpnt[0] *= 2047;
lpnt[1] *= 2047 * dmp->dm_aspect;
lpnt[2] *= 2047;
continue;
case BN_VLIST_POLY_DRAW:
case BN_VLIST_POLY_END:
case BN_VLIST_LINE_DRAW:
case BN_VLIST_TRI_DRAW:
case BN_VLIST_TRI_END:
/* draw */
if (dmp->dm_perspective > 0) {
dist = VDOT(*pt, &privars->qmat[12]) + privars->qmat[15];
if (dist <= 0.0) {
if (dist_prev <= 0.0) {
/* nothing to plot */
dist_prev = dist;
pt_prev = pt;
continue;
} else {
if (pt_prev) {
fastf_t alpha;
vect_t diff;
point_t tmp_pt;
/* clip this end */
VSUB2(diff, *pt, *pt_prev);
alpha = (dist_prev - delta) / (dist_prev - dist);
VJOIN1(tmp_pt, *pt_prev, alpha, diff);
MAT4X3PNT(pnt, privars->qmat, tmp_pt);
}
}
} else {
if (dist_prev <= 0.0) {
if (pt_prev) {
fastf_t alpha;
vect_t diff;
point_t tmp_pt;
/* clip other end */
VSUB2(diff, *pt, *pt_prev);
alpha = (-dist_prev + delta) / (dist - dist_prev);
VJOIN1(tmp_pt, *pt_prev, alpha, diff);
MAT4X3PNT(lpnt, privars->qmat, tmp_pt);
lpnt[0] *= 2047;
lpnt[1] *= 2047 * dmp->dm_aspect;
lpnt[2] *= 2047;
MAT4X3PNT(pnt, privars->qmat, *pt);
}
} else {
MAT4X3PNT(pnt, privars->qmat, *pt);
}
}
dist_prev = dist;
} else {
MAT4X3PNT(pnt, privars->qmat, *pt);
}
pnt[0] *= 2047;
pnt[1] *= 2047 * dmp->dm_aspect;
pnt[2] *= 2047;
/* save pnt --- it might get changed by clip() */
VMOVE(spnt, pnt);
pt_prev = pt;
if (dmp->dm_zclip) {
if (vclip(lpnt, pnt,
dmp->dm_clipmin,
dmp->dm_clipmax) == 0) {
VMOVE(lpnt, spnt);
continue;
}
}
/* convert to Qt window coordinates */
linep->setLine ((short)GED_TO_Xx(dmp, lpnt[0]),
(short)GED_TO_Xy(dmp, lpnt[1]),
(short)GED_TO_Xx(dmp, pnt[0]),
(short)GED_TO_Xy(dmp, pnt[1])
);
nseg++;
linep++;
VMOVE(lpnt, spnt);
if (nseg == 1024) {
if (privars->painter != NULL)
privars->painter->drawLines(lines, nseg);
nseg = 0;
linep = lines;
}
break;
case BN_VLIST_POINT_DRAW:
if (dmp->dm_debugLevel > 2) {
bu_log("before transformation:\n");
bu_log("pt - %lf %lf %lf\n", V3ARGS(*pt));
}
if (dmp->dm_perspective > 0) {
dist = VDOT(*pt, &privars->qmat[12]) + privars->qmat[15];
if (dist <= 0.0) {
/* nothing to plot - point is behind eye plane */
continue;
}
}
MAT4X3PNT(pnt, privars->qmat, *pt);
pnt[0] *= 2047;
pnt[1] *= 2047 * dmp->dm_aspect;
pnt[2] *= 2047;
VMOVE(lpnt, pnt);
if (dmp->dm_debugLevel > 2) {
bu_log("after clipping:\n");
bu_log("pt - %lf %lf %lf\n", pnt[X], pnt[Y], pnt[Z]);
}
if (pointSize <= DM_QT_DEFAULT_POINT_SIZE) {
privars->painter->drawPoint(GED_TO_Xx(dmp, pnt[0]), GED_TO_Xy(dmp, pnt[1]));
} else {
int upperLeft[2];
upperLeft[X] = GED_TO_Xx(dmp, pnt[0]) - pointSize / 2.0;
upperLeft[Y] = GED_TO_Xy(dmp, pnt[1]) - pointSize / 2.0;
privars->painter->drawRect(upperLeft[X], upperLeft[Y], pointSize, pointSize);
}
break;
case BN_VLIST_POINT_SIZE:
pointSize = (*pt)[0];
if (pointSize < DM_QT_DEFAULT_POINT_SIZE) {
pointSize = DM_QT_DEFAULT_POINT_SIZE;
}
break;
}
}
}
if (nseg) {
if (privars->painter != NULL)
privars->painter->drawLines(lines, nseg);
}
return TCL_OK;
}
HIDDEN int
qt_draw(dm *dmp, struct bn_vlist *(*callback_function)(void *), void **data)
{
struct bn_vlist *vp;
if (dmp->dm_debugLevel) {
bu_log("qt_draw\n");
}
if (!callback_function) {
if (data) {
vp = (struct bn_vlist *)data;
qt_drawVList(dmp, vp);
}
} else {
if (!data) {
return TCL_ERROR;
} else {
(void)callback_function(data);
}
}
return TCL_OK;
}
HIDDEN int
qt_setFGColor(dm *dmp, unsigned char r, unsigned char g, unsigned char b, int UNUSED(strict), fastf_t UNUSED(transparency))
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_setFGColor\n");
}
dmp->dm_fg[0] = r;
dmp->dm_fg[1] = g;
dmp->dm_fg[2] = b;
privars->fg.setRgb(r, g, b);
if (privars->painter != NULL) {
QPen p = privars->painter->pen();
p.setColor(privars->fg);
privars->painter->setPen(p);
}
return TCL_OK;
}
HIDDEN int
qt_setBGColor(dm *dmp, unsigned char r, unsigned char g, unsigned char b)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_setBGColor\n");
}
privars->bg.setRgb(r, g, b);
dmp->dm_bg[0] = r;
dmp->dm_bg[1] = g;
dmp->dm_bg[2] = b;
if (privars->pix == NULL)
return TCL_ERROR;
privars->pix->fill(privars->bg);
return TCL_OK;
}
HIDDEN int
qt_setLineAttr(dm *dmp, int width, int style)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
if (dmp->dm_debugLevel) {
bu_log("qt_setLineAttr\n");
}
dmp->dm_lineWidth = width;
dmp->dm_lineStyle = style;
if (width <= 1)
width = 0;
if (privars->painter == NULL)
return TCL_ERROR;
QPen p = privars->painter->pen();
p.setWidth(width);
if (style == DM_DASHED_LINE)
p.setStyle(Qt::DashLine);
else
p.setStyle(Qt::SolidLine);
privars->painter->setPen(p);
return TCL_OK;
}
HIDDEN int
qt_reshape(dm *dmp, int width, int height)
{
if (dmp->dm_debugLevel) {
bu_log("qt_reshape\n");
}
dmp->dm_height = height;
dmp->dm_width = width;
dmp->dm_aspect = (fastf_t)dmp->dm_width / (fastf_t)dmp->dm_height;
return 0;
}
HIDDEN int
qt_configureWin(dm *dmp, int force)
{
struct dm_xvars *pubvars = (struct dm_xvars *)dmp->dm_vars.pub_vars;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
int width = Tk_Width(pubvars->xtkwin);
int height = Tk_Height(pubvars->xtkwin);
if (!force &&
dmp->dm_height == height &&
dmp->dm_width == width)
return TCL_OK;
qt_reshape(dmp, width, height);
privars->win->resize(width, height);
privars->painter->end();
*privars->pix = privars->pix->scaled(width, height);
privars->painter->begin(privars->pix);
if (dmp->dm_debugLevel) {
bu_log("qt_configureWin()\n");
bu_log("width = %d, height = %d\n", dmp->dm_width, dmp->dm_height);
}
/* set font according to window size */
if (privars->font == NULL) {
privars->font = new QFont(QString(FONTBACK));
}
if (dmp->dm_width < 582) {
if (privars->font->pointSize() != 5) {
privars->font->setPointSize(5);
}
} else if (dmp->dm_width < 679) {
if (privars->font->pointSize() != 6) {
privars->font->setPointSize(6);
}
} else if (dmp->dm_width < 776) {
if (privars->font->pointSize() != 7) {
privars->font->setPointSize(7);
}
} else if (dmp->dm_width < 874) {
if (privars->font->pointSize() != 8) {
privars->font->setPointSize(8);
}
} else {
if (privars->font->pointSize() != 9) {
privars->font->setPointSize(9);
}
}
return TCL_OK;
}
HIDDEN int
qt_setWinBounds(dm *dmp, fastf_t *w)
{
if (dmp->dm_debugLevel) {
bu_log("qt_setWinBounds\n");
}
dmp->dm_clipmin[0] = w[0];
dmp->dm_clipmin[1] = w[2];
dmp->dm_clipmin[2] = w[4];
dmp->dm_clipmax[0] = w[1];
dmp->dm_clipmax[1] = w[3];
dmp->dm_clipmax[2] = w[5];
return TCL_OK;
}
HIDDEN int
qt_setZBuffer(dm *dmp, int zbuffer_on)
{
if (dmp->dm_debugLevel) {
bu_log("qt_setZBuffer\n");
}
dmp->dm_zbuffer = zbuffer_on;
return TCL_OK;
}
HIDDEN int
qt_debug(dm *dmp, int lvl)
{
dmp->dm_debugLevel = lvl;
return TCL_OK;
}
HIDDEN int
qt_logfile(dm *dmp, const char *filename)
{
bu_vls_sprintf(&dmp->dm_log, "%s", filename);
return TCL_OK;
}
HIDDEN int
qt_getDisplayImage(dm *dmp, unsigned char **image)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
int i,j;
int height, width;
if (dmp->dm_debugLevel) {
bu_log("qt_getDisplayImage\n");
}
QImage qimage = privars->pix->toImage();
height = qimage.height();
width = qimage.width();
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
image[i][j] = qimage.pixel(i,j);
}
}
return TCL_OK;
}
HIDDEN int
qt_setLight(dm *dmp, int light_on)
{
if (dmp->dm_debugLevel)
bu_log("qt_setLight:\n");
dmp->dm_light = light_on;
return TCL_OK;
}
HIDDEN void
qt_processEvents(dm *dmp)
{
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
privars->qapp->processEvents();
}
HIDDEN int
qt_openFb(struct dm_internal *dmp)
{
struct fb_platform_specific *fb_ps;
struct qt_fb_info *qtfb_ps;
struct qt_vars *privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
fb_ps = fb_get_platform_specific(FB_QT_MAGIC);
qtfb_ps = (struct qt_fb_info *)fb_ps->data;
qtfb_ps->qapp = privars->qapp;
qtfb_ps->qwin = privars->win;
qtfb_ps->qpainter = privars->painter;
qtfb_ps->draw = &privars->drawFb;
qtfb_ps->qimg = (void **)&privars->img;
dmp->fbp = fb_open_existing("Qt", dm_get_width(dmp), dm_get_height(dmp), fb_ps);
fb_put_platform_specific(fb_ps);
return 0;
}
/**
* Function called in Tk event loop. It simply processes any
* pending Qt events.
*
*/
void processQtEvents(ClientData UNUSED(clientData), int UNUSED(flags)) {
qt_processEvents(&dm_qt);
}
/**
* Call when Tk is idle. It process Qt events then
* reschedules itself.
*
*/
void IdleCall(ClientData UNUSED(clientData)) {
qt_processEvents(&dm_qt);
Tcl_DeleteTimerHandler(token);
/* Reschedule the function so that it continuously tries to process Qt events */
token = Tcl_CreateTimerHandler(1, IdleCall, NULL);
}
__BEGIN_DECLS
/*
* Fire up the display manager, and the display processor.
*
*/
dm *
qt_open(Tcl_Interp *interp, int argc, char **argv)
{
static int count = 0;
int make_square = -1;
dm *dmp = (dm *)NULL;
struct bu_vls init_proc_vls = BU_VLS_INIT_ZERO;
struct bu_vls str = BU_VLS_INIT_ZERO;
Tk_Window tkwin;
struct dm_xvars *pubvars = NULL;
struct qt_vars *privars = NULL;
if (argc < 0 || !argv) {
return DM_NULL;
}
if ((tkwin = Tk_MainWindow(interp)) == NULL) {
return DM_NULL;
}
BU_ALLOC(dmp, struct dm_internal);
*dmp = dm_qt; /* struct copy */
dmp->dm_interp = interp;
BU_ALLOC(dmp->dm_vars.pub_vars, struct dm_xvars);
pubvars = (struct dm_xvars *)dmp->dm_vars.pub_vars;
BU_ALLOC(dmp->dm_vars.priv_vars, struct qt_vars);
privars = (struct qt_vars *)dmp->dm_vars.priv_vars;
bu_vls_init(&dmp->dm_pathName);
bu_vls_init(&dmp->dm_tkName);
bu_vls_init(&dmp->dm_dName);
dm_processOptions(dmp, &init_proc_vls, --argc, ++argv);
if (bu_vls_strlen(&dmp->dm_pathName) == 0) {
bu_vls_printf(&dmp->dm_pathName, ".dm_qt%d", count);
}
++count;
if (bu_vls_strlen(&dmp->dm_dName) == 0) {
char *dp;
dp = getenv("DISPLAY");
if (dp)
bu_vls_strcpy(&dmp->dm_dName, dp);
else
bu_vls_strcpy(&dmp->dm_dName, ":0.0");
}
if (bu_vls_strlen(&init_proc_vls) == 0) {
bu_vls_strcpy(&init_proc_vls, "bind_dm");
}
/* initialize dm specific variables */
pubvars->devmotionnotify = LASTEvent;
pubvars->devbuttonpress = LASTEvent;
pubvars->devbuttonrelease = LASTEvent;
dmp->dm_aspect = 1.0;
if (dmp->dm_top) {
/* Make xtkwin a toplevel window */
pubvars->xtkwin = Tk_CreateWindowFromPath(interp, tkwin,
bu_vls_addr(&dmp->dm_pathName),
bu_vls_addr(&dmp->dm_dName));
pubvars->top = pubvars->xtkwin;
} else {
char *cp;
cp = strrchr(bu_vls_addr(&dmp->dm_pathName), (int)'.');
if (cp == bu_vls_addr(&dmp->dm_pathName)) {
pubvars->top = tkwin;
} else {
struct bu_vls top_vls = BU_VLS_INIT_ZERO;
bu_vls_strncpy(&top_vls, (const char *)bu_vls_addr(&dmp->dm_pathName), cp - bu_vls_addr(&dmp->dm_pathName));
pubvars->top = Tk_NameToWindow(interp, bu_vls_addr(&top_vls), tkwin);
bu_vls_free(&top_vls);
}
/* Make xtkwin an embedded window */
pubvars->xtkwin =
Tk_CreateWindow(interp, pubvars->top,
cp + 1, (char *)NULL);
}
if (pubvars->xtkwin == NULL) {
bu_log("qt_open: Failed to open %s\n", bu_vls_addr(&dmp->dm_pathName));
(void)qt_close(dmp);
return DM_NULL;
}
bu_vls_printf(&dmp->dm_tkName, "%s", (char *)Tk_Name(pubvars->xtkwin));
bu_vls_printf(&str, "_init_dm %s %s\n", bu_vls_addr(&init_proc_vls), bu_vls_addr(&dmp->dm_pathName));
if (Tcl_Eval(interp, bu_vls_addr(&str)) == TCL_ERROR) {
bu_log("qt_open: _init_dm failed\n");
bu_vls_free(&init_proc_vls);
bu_vls_free(&str);
(void)qt_close(dmp);
return DM_NULL;
}
bu_vls_free(&init_proc_vls);
bu_vls_free(&str);
pubvars->dpy = Tk_Display(pubvars->top);
/* make sure there really is a display before proceeding. */
if (!pubvars->dpy) {
bu_log("qt_open: Unable to attach to display (%s)\n", bu_vls_addr(&dmp->dm_pathName));
(void)qt_close(dmp);
return DM_NULL;
}
if (dmp->dm_width == 0) {
dmp->dm_width =
WidthOfScreen(Tk_Screen(pubvars->xtkwin)) - 30;
++make_square;
}
if (dmp->dm_height == 0) {
dmp->dm_height =
HeightOfScreen(Tk_Screen(pubvars->xtkwin)) - 30;
++make_square;
}
if (make_square > 0) {
/* Make window square */
if (dmp->dm_height <
dmp->dm_width)
dmp->dm_width = dmp->dm_height;
else
dmp->dm_height = dmp->dm_width;
}
Tk_GeometryRequest(pubvars->xtkwin, dmp->dm_width, dmp->dm_height);
Tk_MakeWindowExist(pubvars->xtkwin);
pubvars->win = Tk_WindowId(pubvars->xtkwin);
dmp->dm_id = pubvars->win;
Tk_SetWindowBackground(pubvars->xtkwin, 0);
Tk_MapWindow(pubvars->xtkwin);
privars->qapp = new QApplication(argc, argv);
privars->parent = QWindow::fromWinId(pubvars->win);
privars->pix = new QPixmap(dmp->dm_width, dmp->dm_height);
privars->win = new QTkMainWindow(privars->pix, privars->parent, dmp);
privars->win->resize(dmp->dm_width, dmp->dm_height);
privars->win->show();
privars->font = NULL;
privars->painter = new QPainter(privars->pix);
qt_setFGColor(dmp, 1, 0, 0, 0, 0);
qt_setBGColor(dmp, 0, 0, 0);
qt_configureWin(dmp, 1);
MAT_IDN(privars->qmat);
/* inputs and outputs assume POSIX/C locale settings */
setlocale(LC_ALL, "POSIX");
/* Make Tcl_DoOneEvent call QApplication::processEvents */
Tcl_CreateEventSource(NULL, processQtEvents, NULL);
/* Try to process Qt events when idle */
Tcl_DoWhenIdle(IdleCall, NULL);
return dmp;
}
static void
Qt_zclip_hook(const struct bu_structparse *sdp,
const char *name,
void *base,
const char *value,
void *data)
{
dm *dmp = (dm *)base;
fastf_t bounds[6] = { GED_MIN, GED_MAX, GED_MIN, GED_MAX, GED_MIN, GED_MAX };
if (dmp->dm_zclip) {
bounds[4] = -1.0;
bounds[5] = 1.0;
}
(void)dm_make_current(dmp);
(void)dm_set_win_bounds(dmp, bounds);
dm_generic_hook(sdp, name, base, value, data);
}
struct bu_structparse Qt_vparse[] = {
{"%g", 1, "bound", DM_O(dm_bound), dm_generic_hook, NULL, NULL},
{"%d", 1, "useBound", DM_O(dm_boundFlag), dm_generic_hook, NULL, NULL},
{"%d", 1, "zclip", DM_O(dm_zclip), Qt_zclip_hook, NULL, NULL},
{"%d", 1, "debug", DM_O(dm_debugLevel), dm_generic_hook, NULL, NULL},
{"", 0, (char *)0, 0, BU_STRUCTPARSE_FUNC_NULL, NULL, NULL}
};
__END_DECLS
struct dm_internal dm_qt = {
qt_close,
qt_drawBegin,
qt_drawEnd,
qt_normal,
qt_loadMatrix,
null_loadPMatrix,
qt_drawString2D,
qt_drawLine2D,
null_drawLine3D,
null_drawLines3D,
qt_drawPoint2D,
null_drawPoint3D,
null_drawPoints3D,
qt_drawVList,
qt_drawVList,
qt_draw,
qt_setFGColor,
qt_setBGColor,
qt_setLineAttr,
qt_configureWin,
qt_setWinBounds,
qt_setLight,
null_setTransparency,
null_setDepthMask,
qt_setZBuffer,
qt_debug,
qt_logfile,
null_beginDList,
null_endDList,
null_drawDList,
null_freeDLists,
null_genDLists,
NULL,
qt_getDisplayImage,
qt_reshape,
null_makeCurrent,
qt_openFb,
NULL,
NULL,
0,
0, /* no displaylist */
0, /* no stereo */
0.0, /* zoom-in limit */
1, /* bound flag */
"qt",
"Qt Display",
DM_TYPE_QT,
1,
0,/* width */
0,/* height */
0,/* bytes per pixel */
0,/* bits per channel */
0,
0,
1.0,/* aspect ratio */
0,
{0, 0},
NULL,
NULL,
BU_VLS_INIT_ZERO, /* bu_vls path name*/
BU_VLS_INIT_ZERO, /* bu_vls full name drawing window */
BU_VLS_INIT_ZERO, /* bu_vls short name drawing window */
{0, 0, 0}, /* bg color */
{0, 0, 0}, /* fg color */
{GED_MIN, GED_MIN, GED_MIN}, /* clipmin */
{GED_MAX, GED_MAX, GED_MAX}, /* clipmax */
0, /* no debugging */
BU_VLS_INIT_ZERO, /* bu_vls logfile */
0, /* no perspective */
0, /* no lighting */
0, /* no transparency */
0, /* depth buffer is not writable */
0, /* no zbuffer */
0, /* no zclipping */
1, /* clear back buffer after drawing and swap */
0, /* not overriding the auto font size */
Qt_vparse,
FB_NULL,
0 /* Tcl interpreter */
};
/**
* ================================================== Event bindings declaration ==========================================================
*/
/* left click press */
char* qt_mouseButton1Press(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<1> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
/* left click release */
char* qt_mouseButton1Release(QEvent *event) {
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<ButtonRelease-1>");
return bu_vls_addr(&str);
}
}
return NULL;
}
/* right click press */
char* qt_mouseButton3Press(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::RightButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<3> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
/* right click release */
char* qt_mouseButton3Release(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::RightButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<ButtonRelease-3>");
return bu_vls_addr(&str);
}
}
return NULL;
}
/* middle mouse button press */
char* qt_mouseButton2Press(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::MiddleButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<2> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
/* middle mouse button release */
char* qt_mouseButton2Release(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::MiddleButton) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<ButtonRelease-2>");
return bu_vls_addr(&str);
}
}
return NULL;
}
char* qt_controlMousePress(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton && mouseEv->modifiers() == Qt::ControlModifier) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<Control-ButtonPress-1> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
char* qt_altMousePress(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton && mouseEv->modifiers() == Qt::AltModifier) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<Alt-ButtonPress-1> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
char* qt_altControlMousePress(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton && mouseEv->modifiers() & Qt::AltModifier && mouseEv->modifiers() & Qt::ControlModifier) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<Control-Alt-ButtonPress-1> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
char* qt_controlShiftMousePress(QEvent *event) {
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
if (mouseEv->button() == Qt::LeftButton && mouseEv->modifiers() & Qt::ShiftModifier && mouseEv->modifiers() & Qt::ControlModifier) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<Shift-Alt-ButtonPress-1> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
}
return NULL;
}
char* qt_mouseMove(QEvent *event) {
if (event->type() == QEvent::MouseMove) {
QMouseEvent *mouseEv = (QMouseEvent *)event;
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<Motion> -x %d -y %d", mouseEv->x(), mouseEv->y());
return bu_vls_addr(&str);
}
return NULL;
}
char* qt_keyPress(QEvent *event) {
/* FIXME numeric constant needs to be changed to QEvent::KeyPress but at this moment this does not compile */
if (event->type() == 6 /* QEvent::KeyPress */) {
QKeyEvent *keyEv = (QKeyEvent *)event;
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<KeyPress-%s>", keyEv->text().data());
return bu_vls_addr(&str);
}
return NULL;
}
char* qt_keyRelease(QEvent *event) {
/* FIXME numeric constant needs to be changed to QEvent::KeyRelease but at this moment this does not compile */
if (event->type() == 7 /* QEvent::KeyRelease */) {
QKeyEvent *keyEv = (QKeyEvent *)event;
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "<KeyRelease-%s>", keyEv->text().data());
return bu_vls_addr(&str);
}
return NULL;
}
static struct qt_tk_bind qt_bindings[] = {
{qt_keyPress, "keypress"},
{qt_keyRelease, "keyrelease"},
{qt_controlMousePress, "controlbutton1"},
{qt_altMousePress, "altbutton1"},
{qt_altControlMousePress, "altcontrolbutton1"},
{qt_controlShiftMousePress, "controlshiftbutton1"},
{qt_mouseButton1Press, "button1press"},
{qt_mouseButton1Release, "button1release"},
{qt_mouseButton3Press, "button3press"},
{qt_mouseButton3Release, "button3release"},
{qt_mouseButton2Press, "button2press"},
{qt_mouseButton2Release, "button2release"},
{qt_mouseMove, "mouseMove"},
{NULL, NULL}
};
/**
* ===================================================== Main window class ===============================================
*/
QTkMainWindow::QTkMainWindow(QPixmap *p, QWindow *win, void *d)
: QWindow(win)
, m_update_pending(false)
{
m_backingStore = new QBackingStore(this);
create();
pixmap = p;
dmp = d;
}
QTkMainWindow::~QTkMainWindow()
{
delete m_backingStore;
close();
}
void QTkMainWindow::exposeEvent(QExposeEvent *)
{
if (isExposed()) {
renderNow();
}
}
void QTkMainWindow::resizeEvent(QResizeEvent *resizeEv)
{
m_backingStore->resize(resizeEv->size());
if (isExposed())
renderNow();
}
bool QTkMainWindow::event(QEvent *ev)
{
int index = 0;
if (ev->type() == QEvent::UpdateRequest) {
m_update_pending = false;
renderNow();
return true;
}
while (qt_bindings[index].name != NULL) {
char *tk_event = qt_bindings[index].bind_function(ev);
if (tk_event != NULL) {
struct bu_vls str = BU_VLS_INIT_ZERO;
bu_vls_printf(&str, "event generate %s %s", bu_vls_addr(&((dm *)dmp)->dm_pathName), tk_event);
if (Tcl_Eval(((dm *)dmp)->dm_interp, bu_vls_addr(&str)) == TCL_ERROR) {
bu_log("error generate event %s\n", tk_event);
}
return true;
}
index++;
}
return QWindow::event(ev);
}
void QTkMainWindow::renderNow()
{
if (!isExposed()) {
return;
}
QRect rect(0, 0, width(), height());
m_backingStore->beginPaint(rect);
QPaintDevice *device = m_backingStore->paintDevice();
QPainter painter(device);
render(&painter);
m_backingStore->endPaint();
m_backingStore->flush(rect);
}
void QTkMainWindow::render(QPainter *painter)
{
painter->drawPixmap(0, 0, *pixmap);
}
#endif /* DM_QT */
/*
* Local Variables:
* mode: C++
* tab-width: 8
* indent-tabs-mode: t
* c-file-style: "stroustrup"
* End:
* ex: shiftwidth=4 tabstop=8
*/
| 24.240783 | 139 | 0.624876 | earl-ducaine |
61439158ee1fff4233e1116b55a91b813762d8ba | 10,778 | hpp | C++ | include/lcm_SpinOpGenerator.hpp | dch0ph/libcmatrix | 1f5fae7a398fe2c643252f93371b407dbfb70855 | [
"MIT"
] | null | null | null | include/lcm_SpinOpGenerator.hpp | dch0ph/libcmatrix | 1f5fae7a398fe2c643252f93371b407dbfb70855 | [
"MIT"
] | null | null | null | include/lcm_SpinOpGenerator.hpp | dch0ph/libcmatrix | 1f5fae7a398fe2c643252f93371b407dbfb70855 | [
"MIT"
] | null | null | null | //internal file only
template<bool> struct lcm_cache_type_ { typedef Type2Type< BlockedMatrix<double> > type; };
template<> struct lcm_cache_type_<true> { typedef Type2Type< ListList<double> > type; };
class SpinOpGenerator : public SpinOpGeneratorBase {
public:
SpinOpGenerator(const basespin_system&, int flagsv =0, int verbosev =0);
SpinOpGenerator(const basespin_system&, const CrystalStructure&, int flagsv =0, int verbosev =0);
SpinOpGenerator(const basespin_system&, const BaseList<nuclei_spec>&, int flagsv =0, int verbosev =0);
SpinOpGenerator(const basespin_system&, const CrystalStructure&, const BaseList<nuclei_spec>&, int flagsv =0, int verbosev =0);
SpinOpGenerator(const basespin_system&, const CrystalStructure&, const char* label, int flagsv =0, int verbosev =0);
SpinOpGenerator(const HamiltonianStructure&, const CrystalStructure&, int verbosev =0);
SpinOpGeneratorBase* clone() const { return new SpinOpGenerator(*this); }
typedef BlockedMatrix<complex> output_type;
typedef Matrix<complex> suboutput_type;
typedef double base_type; //operators *can* be real
static const bool allowproductop=true;
void proton_frequency(double);
const spin& operator()(size_t n) const {
return (*sysp_)(n);
}
size_t size(size_t mzblk, size_t eigblk) const;
size_t eigweight(size_t) const { return 1; }
const BaseList<size_t>& diagonal_structure() const { return sizes_; }
bool ishomonuclear(size_t j,size_t k) const
{ return ((*sysp_)(j)==(*sysp_)(k)); }
void add(BlockedMatrix<complex>&, block_pattern&, const productoperator_spec&) const;
void mla(BlockedMatrix<complex>&, block_pattern&, double, const operator_spec&) const;
void mla_Iz(ListList<double>&, double scale, size_t sel) const;
void mla_Fz(ListList<double>&,double,nuclei_spec) const;
const ListList<double>& diag_Fz(nuclei_spec whichn) const { return fzcache_(*this,whichn()); }
void rawdiag_Fz(ListList<double>&,size_t) const;
template<class T> void add_A2_homo(T& dest, const typename Ham_traits<T>::coupling_type& coup, size_t j, size_t k,Bool2Type<false>) const {
add_A2(dest,&spin_dipolar,coup,j,k,Type2Type< BlockedMatrix<double> >());
}
template<class T> void add_A2_homo(T&, const typename Ham_traits<T>::coupling_type&, size_t, size_t,Bool2Type<true>) const {
throw Failed("add_A2: can't add homonuclear to diagonal Hamiltonian");
}
template<class T> void add_A2(T& dest, const typename Ham_traits<T>::coupling_type& coup, size_t j, size_t k, bool forceweak =false) const {
if (forceweak || !ishomonuclear(j,k))
add_A2(dest,&diag_spin_truncated_dipolar,coup,j,k,Type2Type< ListList<double> >());
else
add_A2_homo(dest,coup,j,k,Bool2Type<Ham_traits<T>::isdiagonal>());
}
template<class T> void add_A0_strong(T& dest, double coup, size_t j, size_t k,Bool2Type<false>) const {
add_A0(dest,&spin_J,coup,j,k,Type2Type< BlockedMatrix<double> >());
}
template<class T> void add_A0_strong(T&, double, size_t, size_t,Bool2Type<true>) const {
throw Failed("add_A0: can't add strong coupling to diagonal Hamiltonian");
}
template<class T> void add_A0(T& dest, double coup, size_t j, size_t k ,bool forceweak =false) const {
if (forceweak || !ishomonuclear(j,k))
add_A0(dest,&diag_spin_weakJ,coup,j,k,Type2Type< ListList<double> >());
else
add_A0_strong(dest,coup,j,k,Bool2Type<Ham_traits<T>::isdiagonal>());
}
template<class T> void add_ns_(T&, const space_T&, size_t, size_t, ns_flag, Bool2Type<true>) const { throw Failed("Diagonal Hamiltonian incompatible with non-secular interactions"); }
template<class T> void add_ns_(T&, const space_T&, size_t, size_t, ns_flag, Bool2Type<false>) const;
template<class T> void add_ns(T& dest, const space_T& coup, size_t i, size_t j, ns_flag nstype) const
{ add_ns_(dest,coup,i,j,nstype,Bool2Type<Ham_traits<T>::isdiagonal>()); }
template<class T> void add_ns(T&, double, size_t, size_t, ns_flag) const { throw Failed("Non-secular Hamiltonian cannot be initialised from scalar interactions"); }
template<class T> void add_Hquadrupolar2(T&, const space_T&, size_t) const;
template<class T> void add_Hquadrupolar2(T&, double, size_t) const { throw Failed("Can't add second order quadrupole to this Hamiltonian"); }
void add_Hquadrupolar2(List<DiagonalSpinningHamiltonian>&, const space_T&, size_t) const;
template<class T> void add_Hquadrupolar(T& dest, const typename Ham_traits<T>::coupling_type& coup, size_t j) const;
template<class T> void add_Hcs(T& dest, const typename Ham_traits<T>::coupling_type&, size_t j) const;
void print(std::ostream&) const;
template<class T> void create(BlockedMatrix<T>& dest, const block_pattern&) const;
template<class M> void create(M& dest) const
{ SpinOpGeneratorBase::create(dest); }
void create_ns(List< MultiMatrix<double,3> >& dest) const {
dest.create(mzblocks()); //later functions will create contents
}
const basespin_system& spinsystem() const { return *sysp_; }
size_t index(size_t mzblk,size_t eigblk) const {
if (eigblk)
throw Failed("SpinOpGenerator: no eigenvalue structure");
return mzblk;
}
//void coherence_filter(BlockedMatrix<bool>&, block_pattern&, const spinorder_spec&) const;
//void coherence_filter_ip(BlockedMatrix<bool>&, block_pattern&, const spinorder_spec&, state_t) const;
// void mla_Fz_compressed(ListList<double>&, double, state_t) const;
private:
const smartptr<const basespin_system> sysp_;
mutable ScratchList<complex,5> tmp_;
mutable ScratchList<complex,5> coeffs_;
void addQ2_(List<DiagonalSpinningHamiltonian>&, size_t, double, const space_T&, const ListList<double>&) const;
typedef UnionHolder< 3, ListList<double>, BlockedMatrix<double>, List< MultiMatrix<double,3> > > cache_type;
enum { BLOCKEDLIST=1, BLOCKEDMATRIX=2, BLOCKEDTENSOR=3 };
mutable FzCache_ fzcache_;
//These caches are protected by mutexes
mutable Mutex<ThreadingActive> lock;
mutable Matrix<cache_type> A0store,A2store;
mutable List< ListList<double> > CSstore;
mutable Mutex<ThreadingActive> iterlock;
mutable smartptr<CrystalStructure_iterator> cstructiterp;
void common_init(const BaseList<nuclei_spec>& =BaseList<nuclei_spec>());
// void makepartitioning();
block_pattern getdiagtype(size_t nuc, char op) const;
void mla_(cmatrix&,double,const operator_spec&, const operator_spec&) const;
void mla_(cmatrix&,double,const operator_spec&) const;
template<class T1,class T2> void chop_mla(BlockedMatrix<T1>&, double, const Matrix<T2>&, const block_pattern&) const;
template<class T1,class T2> void chop_mla(BlockedMatrix<T1>& dest, double scale, const Matrix<T2>& source) const { chop_mla(dest,scale,source,block_pattern(active_blocking_info())); }
template<class T1,class T2> void chop_mla(Matrix<T1>&, double, const Matrix<T2>&) const;// const block_pattern&) const;
template<class T> void chop_mla(BlockedMatrix<T>&, double, const List<double>&) const;
template<class T> void chop_mla(Matrix<T>&, double, const List<double>&) const;
void chop_mla(ListList<double>&, double, const List<double>&) const;
template<class T,class C> void chop_mla(List<T>&, const C&, const List<double>&) const;
template<class C> void chop_mla(List<double>&, const C&, const List<double>&) const;
template<class C,class M> void chop_mla(RealSpinningHamiltonian&, const C&, const M&) const;
template<class C,class M> void chop_mla(SpinningHamiltonian&, const C&, const M&) const;
template<class C,class M> void chop_mla(DiagonalSpinningHamiltonian&, const C&, const M&) const;
template<class M,class C> void chop_mla(List<M>&, const C&, const rmatrix&) const;
void chop_ns(List< MultiMatrix<double,3> >&, const MultiMatrix<double,3>&) const;
template<class T> void add_ns_(T&, const space_T&, const BaseList< MultiMatrix<double,3> >& ) const { throw Failed("Can't add non-secular interaction to this Hamiltonian"); }
void add_ns_(List<SpinningHamiltonian>& dest, const space_T& coup, const BaseList< MultiMatrix<double,3> >& source) const;
void add_ns_(SpinningHamiltonian& dest, const space_T& coup, const BaseList< MultiMatrix<double,3> >& source) const;
void add_ns_(BlockedMatrix<complex>& dest, const space_T& coup, const BaseList< MultiMatrix<double,3> >& source) const;
void add_ns_(Matrix<complex>& dest, const space_T& coup, const BaseList< MultiMatrix<double,3> >& source) const;
template<class T,class C,class W> static void add_(List<T>& dest, const C& coup, const W& a) {
for (size_t k=a.size();k--;)
dest(k).add(coup,a(k));
}
static void add_(List<double>& dest, double coup, const ListList<double>& a) {
::libcmatrix::mla(dest,coup,a.row());
}
template<class T,class W> static void add_(BlockedMatrix<T>& dest, double coup, const W& a)
{ ::libcmatrix::mla(dest,coup,a); }
static void add_(ListList<double>& dest, double coup, const ListList<double>& a)
{ ::libcmatrix::mla(dest,coup,a); }
template<class T,class M> void add_(Matrix<T>&, double, const M&) const;
template<class T,class F,class C,class ResultType> void add_A2(T&,F func, const C&, size_t,size_t,Type2Type<ResultType>) const;
template<class T,class F,class ResultType> void add_A0(T&,F func, double, size_t,size_t,Type2Type<ResultType>) const;
template<class T,class F,class C,class ResultType> void addraw(T&, F func, const C&, size_t,size_t,Type2Type<ResultType>) const;
template<class T,class C> void addCS(T&, const C&, size_t) const;
template<class T,class C> void addrawCS(T&, const C&, size_t) const;
template<class T,class C> void addrawQ(T&, const C&, size_t) const;
void makeraw_ns(List< MultiMatrix<double,3> >& dest, size_t, size_t, ns_flag) const;
static void spydefined(std::ostream&, const char*, const Matrix<cache_type>&);
static void spydefined(std::ostream&, const char*, const List< ListList<double> >&);
void dump() const;
void update();
void makemzinds(Matrix<size_t>&, List<size_t>&, const BaseList<size_t>&);
};
template<> struct spinsystem_glue_<SpinOpGenerator> {
static const basespin_system& spinsystem(const SpinOpGenerator& a)
{ return a.spinsystem(); }
static size_t ncells(const SpinOpGenerator& a)
{ return a.ncells(); }
static const bool ispurereal=true;
template<class M> static bool arematching(const SpinOpGenerator& a, const HamiltonianStore<M>& store) {
return (store.ncells()==a.ncells()) && (a.nspins()==(store.ncells()*store.nspins()));
}
};
inline std::ostream& operator<< (std::ostream& ostr, const SpinOpGenerator& a) {
a.print(ostr);
return ostr;
}
| 49.898148 | 185 | 0.723511 | dch0ph |
61450a5db13e69e7041ccfe67bb7dd6ffcbfef7a | 589 | cpp | C++ | Uva-591 - Box of Bricks.cpp | Samim-Arefin/UVa-Problem-Solution | 8556639b9e718299f4a52920034dfa0264e06f8e | [
"MIT"
] | 1 | 2020-11-02T22:18:22.000Z | 2020-11-02T22:18:22.000Z | Uva-591 - Box of Bricks.cpp | Samim-Arefin/UVa-Problem-Solution | 8556639b9e718299f4a52920034dfa0264e06f8e | [
"MIT"
] | null | null | null | Uva-591 - Box of Bricks.cpp | Samim-Arefin/UVa-Problem-Solution | 8556639b9e718299f4a52920034dfa0264e06f8e | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
int main()
{
int limit,num[51],result,sum,avg,count=0;
while(cin>>limit && limit>0)
{
result=sum=avg=0;
for(int i=0;i<limit;i++)
{
cin>>num[i];
sum+=num[i];
}
avg=sum/limit;
for(int i=0;i<limit;i++)
{
if(num[i]>avg)
{
result+=(num[i]-avg);
}
}
cout<<"Set #"<<++count<<endl;
cout<<"The minimum number of moves is "<<result<<"."<<endl;
cout<<endl;
}
return 0;
}
| 21.035714 | 67 | 0.424448 | Samim-Arefin |
61467757c376740059efc6aefcae51ce02eb71b1 | 618 | hpp | C++ | c++/en/dropbox/remove_sentences_effectively/remove_sentences_effectively/nlp.hpp | aimldl/coding | 70ddbfaa454ab92fd072ee8dc614ecc330b34a70 | [
"MIT"
] | null | null | null | c++/en/dropbox/remove_sentences_effectively/remove_sentences_effectively/nlp.hpp | aimldl/coding | 70ddbfaa454ab92fd072ee8dc614ecc330b34a70 | [
"MIT"
] | null | null | null | c++/en/dropbox/remove_sentences_effectively/remove_sentences_effectively/nlp.hpp | aimldl/coding | 70ddbfaa454ab92fd072ee8dc614ecc330b34a70 | [
"MIT"
] | null | null | null | #pragma once // NLP.hpp
#include <iostream>
#include <string>
#include <algorithm> // transform
using namespace std;
#define DEBUG 0
//==================================================================
// Class Declaration //
//==================================================================
class NLP // Natural Language Processing
{
public:
NLP();
~NLP();
void normalize(string &str);
private:
void set_chars2forbid(string str);
void lowercase(string& str);
void remove_chars(string& str);
string chars2forbid;
};
| 21.310345 | 69 | 0.456311 | aimldl |
61514a88648318a03c642799e3155d150912773d | 8,868 | cpp | C++ | src/pap.cpp | FaultyRAM/MuckyFoot-UrbanChaos | 45c9553189f80785a4ea0ec34b960d864782155b | [
"MIT"
] | 5 | 2017-10-02T00:20:06.000Z | 2021-07-09T10:00:18.000Z | src/pap.cpp | FaultyRAM/MuckyFoot-UrbanChaos | 45c9553189f80785a4ea0ec34b960d864782155b | [
"MIT"
] | null | null | null | src/pap.cpp | FaultyRAM/MuckyFoot-UrbanChaos | 45c9553189f80785a4ea0ec34b960d864782155b | [
"MIT"
] | null | null | null | //
// A lower memory map: 100k
//
#include <mfstdlib/mfstdlib.h>
#include <fallen/pap.h>
#include <fallen/game.h>
#include <fallen/mav.h>
#ifndef PSX
#include <ddengine/aeng.h>
#else
#include "c:\fallen\psxeng\headers\engine.h"
#endif
#include <fallen/inside2.h>
#include <fallen/ns.h>
#include <fallen/ware.h>
#include <fallen/memory.h>
//
// The maps.
//
MEM_PAP_Lo *PAP_lo; //[PAP_SIZE_LO][PAP_SIZE_LO];
MEM_PAP_Hi *PAP_hi; //[PAP_SIZE_HI][PAP_SIZE_HI];
void PAP_clear(void)
{
memset((UBYTE*) &PAP_lo[0][0],0,sizeof(PAP_Lo)*PAP_SIZE_LO*PAP_SIZE_LO);
memset((UBYTE*) &PAP_hi[0][0],0,sizeof(PAP_Hi)*PAP_SIZE_HI*PAP_SIZE_HI);
}
#ifndef PSX
//
// A couple of debug functions.
//
SLONG PAP_on_map_lo(SLONG x, SLONG z)
{
if (WITHIN(x, 0, PAP_SIZE_LO - 1) &&
WITHIN(z, 0, PAP_SIZE_LO - 1))
{
return TRUE;
}
else
{
return FALSE;
}
}
SLONG PAP_on_map_hi(SLONG x, SLONG z)
{
if (WITHIN(x, 0, PAP_SIZE_HI - 1) &&
WITHIN(z, 0, PAP_SIZE_HI - 1))
{
return TRUE;
}
else
{
return FALSE;
}
}
void PAP_assert_if_off_map_lo(SLONG x, SLONG z)
{
ASSERT(PAP_on_map_lo(x,z));
}
void PAP_assert_if_off_map_hi(SLONG x, SLONG z)
{
ASSERT(PAP_on_map_hi(x,z));
}
#endif // PSX
SLONG PAP_calc_height_at_point(SLONG map_x, SLONG map_z)
{
if (!WITHIN(map_x, 0, PAP_SIZE_HI - 1) ||
!WITHIN(map_z, 0, PAP_SIZE_HI - 1))
{
return 0;
}
else
{
return PAP_2HI(map_x,map_z).Alt << PAP_ALT_SHIFT;
}
}
SLONG PAP_calc_height_at(SLONG x, SLONG z)
{
SLONG h0;
SLONG h1;
SLONG h2;
SLONG h3;
SLONG xfrac;
SLONG zfrac;
SLONG answer;
PAP_Hi *ph;
if (GAME_FLAGS & GF_NO_FLOOR)
{
return -32767;
}
SLONG mx = x >> PAP_SHIFT_HI;
SLONG mz = z >> PAP_SHIFT_HI;
if (mx < 0 || mx > PAP_SIZE_HI - 2 ||
mz < 0 || mz > PAP_SIZE_HI - 2)
{
return 0;
}
ph = &PAP_2HI(mx,mz);
// if(ph->Flags&PAP_FLAG_ROOF_EXISTS)
// return(MAVHEIGHT(mx,mz)<<6);
h0 = ph[ 0].Alt;
h1 = ph[ 1].Alt;
h2 = ph[PAP_SIZE_HI + 0].Alt;
h3 = ph[PAP_SIZE_HI + 1].Alt;
if (h0 == h1 && h1 == h2 && h2 == h3)
{
//
// No need to do any interpolation.
//
answer = h0 << PAP_ALT_SHIFT;
}
else
{
h0 <<= PAP_ALT_SHIFT;
h1 <<= PAP_ALT_SHIFT;
h2 <<= PAP_ALT_SHIFT;
h3 <<= PAP_ALT_SHIFT;
xfrac = x & 0xff;
zfrac = z & 0xff;
if (xfrac + zfrac < 0x100)
{
answer = h0;
answer += (h2 - h0) * xfrac >> 8;
answer += (h1 - h0) * zfrac >> 8;
}
else
{
answer = h3;
answer += (h1 - h3) * (0x100 - xfrac) >> 8;
answer += (h2 - h3) * (0x100 - zfrac) >> 8;
}
}
//
// Modifiers.
//
if (ph->Flags & PAP_FLAG_SINK_SQUARE)
{
answer -= KERB_HEIGHTI;
}
return answer;
}
//
// Things sometimes like to think the map is at a strange height
//
SLONG PAP_calc_height_at_thing(Thing *p_thing,SLONG x, SLONG z)
{
switch(p_thing->Class)
{
case CLASS_PERSON:
if (p_thing->Genus.Person->Flags & FLAG_PERSON_WAREHOUSE)
{
return WARE_calc_height_at(
p_thing->Genus.Person->Ware,
p_thing->WorldPos.X >> 8,
p_thing->WorldPos.Z >> 8);
}
#if 0
else
if(p_thing->Genus.Person->InsideIndex)
{
if(find_inside_flags(p_thing->Genus.Person->InsideIndex,x>>8,z>>8)& FLAG_INSIDE_STAIR)
{
SLONG res,y1;
UWORD new_floor;
res=find_stair_y(p_thing,&y1,x,p_thing->WorldPos.Y>>8,z,&new_floor);
if(res)
{
MSG_add(" inside on stairs at y %d \n",y1);
return(y1);
}
else
MSG_add(" inside at y %d \n",y1);
}
return(get_inside_alt(p_thing->Genus.Person->InsideIndex));
}
else
if (p_thing->Flags & FLAGS_IN_SEWERS)
{
return(NS_calc_height_at(x,z)); //p_thing->WorldPos.X>>8,p_thing->WorldPos.Z>>8));
}
#endif
break;
}
return(PAP_calc_map_height_at(x,z));
}
SLONG PAP_calc_map_height_at(SLONG x, SLONG z)
{
SLONG h0;
SLONG h1;
SLONG h2;
SLONG h3;
SLONG xfrac;
SLONG zfrac;
SLONG answer;
PAP_Hi *ph;
SLONG mx = x >> PAP_SHIFT_HI;
SLONG mz = z >> PAP_SHIFT_HI;
if (mx < 0 || mx > PAP_SIZE_HI - 2 ||
mz < 0 || mz > PAP_SIZE_HI - 2)
{
if (GAME_FLAGS & GF_NO_FLOOR)
{
return -32767;
}
else
{
return 0;
}
}
ph = &PAP_2HI(mx,mz);
if (ph->Flags & PAP_FLAG_HIDDEN)
{
return MAVHEIGHT(mx,mz) << 6;
}
if (GAME_FLAGS & GF_NO_FLOOR)
{
return -32767;
}
h0 = ph[ 0].Alt;
h1 = ph[ 1].Alt;
h2 = ph[PAP_SIZE_HI + 0].Alt;
h3 = ph[PAP_SIZE_HI + 1].Alt;
if (h0 == h1 && h1 == h2 && h2 == h3)
{
//
// No need to do any interpolation.
//
answer = h0 << PAP_ALT_SHIFT;
}
else
{
h0 <<= PAP_ALT_SHIFT;
h1 <<= PAP_ALT_SHIFT;
h2 <<= PAP_ALT_SHIFT;
h3 <<= PAP_ALT_SHIFT;
xfrac = x & 0xff;
zfrac = z & 0xff;
if (xfrac + zfrac < 0x100)
{
answer = h0;
answer += (h2 - h0) * xfrac >> 8;
answer += (h1 - h0) * zfrac >> 8;
}
else
{
answer = h3;
answer += (h1 - h3) * (0x100 - xfrac) >> 8;
answer += (h2 - h3) * (0x100 - zfrac) >> 8;
}
}
//
// Modifiers.
//
if (ph->Flags & PAP_FLAG_SINK_SQUARE)
{
answer -= KERB_HEIGHTI;
}
return answer;
}
#ifndef PSX
SLONG PAP_is_flattish(
SLONG x1, SLONG z1,
SLONG x2, SLONG z2)
{
SLONG i;
SLONG max = -INFINITY;
SLONG min = +INFINITY;
SLONG alongx;
SLONG alongz;
SLONG dx = x2 - x1;
SLONG dz = z2 - z1;
SLONG x;
SLONG z;
SLONG height;
#define PAP_FLATTISH_SAMPLES 8
for (i = 0; i < PAP_FLATTISH_SAMPLES; i++)
{
alongx = Random() & 0xff;
alongz = Random() & 0xff;
x = x1 + (dx * alongx >> 8);
z = z1 + (dz * alongz >> 8);
height = PAP_calc_height_at(x,z);
if (height > max) {max = height;}
if (height < min) {min = height;}
if (abs(max - min) > 0x10)
{
return FALSE;
}
}
return TRUE;
}
SLONG PAP_calc_height_noroads(SLONG x, SLONG z)
{
SLONG h0;
SLONG h1;
SLONG h2;
SLONG h3;
SLONG xfrac;
SLONG zfrac;
SLONG answer;
PAP_Hi *ph;
SLONG mx = x >> PAP_SHIFT_HI;
SLONG mz = z >> PAP_SHIFT_HI;
if (mx < 0 || mx > PAP_SIZE_HI - 2 ||
mz < 0 || mz > PAP_SIZE_HI - 2)
{
return 0;
}
ph = &PAP_2HI(mx,mz);
h0 = ph[ 0].Alt;
h1 = ph[ 1].Alt;
h2 = ph[PAP_SIZE_HI + 0].Alt;
h3 = ph[PAP_SIZE_HI + 1].Alt;
if (h0 == h1 && h1 == h2 && h2 == h3)
{
//
// No need to do any interpolation.
//
answer = h0 << PAP_ALT_SHIFT;
}
else
{
h0 <<= PAP_ALT_SHIFT;
h1 <<= PAP_ALT_SHIFT;
h2 <<= PAP_ALT_SHIFT;
h3 <<= PAP_ALT_SHIFT;
xfrac = x & 0xff;
zfrac = z & 0xff;
if (xfrac + zfrac < 0x100)
{
answer = h0;
answer += (h2 - h0) * xfrac >> 8;
answer += (h1 - h0) * zfrac >> 8;
}
else
{
answer = h3;
answer += (h1 - h3) * (0x100 - xfrac) >> 8;
answer += (h2 - h3) * (0x100 - zfrac) >> 8;
}
}
//
// Modifiers.
//
return answer;
}
SLONG PAP_calc_map_height_near(SLONG x, SLONG z)
{
SLONG i;
SLONG dx;
SLONG dz;
SLONG height;
SLONG max = -INFINITY;
for (i = 0; i < 4; i++)
{
dx = (i & 1) ? -8 : +8;
dz = (i & 2) ? -8 : +8;
height = PAP_calc_map_height_at(x + dx, z + dz);
if (height > max)
{
max = height;
}
}
return max;
}
#endif
SLONG PAP_on_slope(SLONG x,SLONG z,SLONG *angle)
{
SLONG h0;
SLONG h1;
SLONG h2;
SLONG h3;
SLONG xfrac;
SLONG zfrac;
SLONG answer;
PAP_Hi *ph;
SLONG mx = x >> PAP_SHIFT_HI;
SLONG mz = z >> PAP_SHIFT_HI;
if (mx < 0 || mx > PAP_SIZE_HI - 2 ||
mz < 0 || mz > PAP_SIZE_HI - 2)
{
return 0;
}
ph = &PAP_2HI(mx,mz);
if (ph->Flags & PAP_FLAG_HIDDEN)
{
//
// We should be calling RFACE_on_slope here really!
//
// ASSERT(0);
return 0;
}
h0 = ph[ 0].Alt;
h1 = ph[ 1].Alt;
h2 = ph[PAP_SIZE_HI + 0].Alt;
h3 = ph[PAP_SIZE_HI + 1].Alt;
if (h0 == h1 && h1 == h2 && h2 == h3)
{
//
// No need to do any interpolation.
//
return(0);
}
else
{
// h0 h2
//
// h1 h3
h0 <<= PAP_ALT_SHIFT;
h1 <<= PAP_ALT_SHIFT;
h2 <<= PAP_ALT_SHIFT;
h3 <<= PAP_ALT_SHIFT;
xfrac = x & 0xff;
zfrac = z & 0xff;
if (xfrac + zfrac < 0x100)
{
SLONG vx,vy,vz;
SLONG wx,wy,wz;
SLONG rx,ry,rz;
SLONG len;
vx=256;
vy=h2-h0;
vz=0;
wx=0;
wy=h1-h0;
wz=-256;
rx=(vy*wz); //-vz*wy;
ry=65536; //vz*wx-vx*wz; dont care about this
rz=(vx*wy); //-vy*wx;
if(rx==0 && rz==0)
return(0);
*angle = (Arctan(-rx,-rz))&2047;
rx=abs(rx);
rz=abs(rz);
len=QDIST3(rx,ry,rz);
ry=(ry<<8)/(len);
return(abs(256-(len>>8)));
}
else
{
SLONG vx,vy,vz;
SLONG wx,wy,wz;
SLONG rx,ry,rz;
SLONG len;
vx=-256;
vy=h1-h3;
vz=0;
wx=0;
wy=h2-h3;
wz=-256;
rx=(vy*wz); //-vz*wy;
ry=65536; //vz*wx-vx*wz; dont care about this
rz=(vx*wy); //-vy*wx;
if(rx==0 && rz==0)
return(0);
*angle = (Arctan(rx,-rz))&2047 ;
rx=abs(rx);
rz=abs(rz);
len=QDIST3(rx,ry,rz);
ry=(ry<<8)/(len);
return(abs(256-(len>>8)));
}
}
}
| 14.804674 | 90 | 0.563599 | FaultyRAM |
615b3927cb7d6e41ab24da899e21d0c009d0ae03 | 2,441 | cpp | C++ | src/GVis/Viewport.cpp | matthew-reid/Graphtane | 3148039993da185cfb328f89b96c9e5a5b384197 | [
"MIT"
] | 38 | 2015-01-01T05:55:38.000Z | 2022-03-12T23:19:50.000Z | src/GVis/Viewport.cpp | matthew-reid/Graphtane | 3148039993da185cfb328f89b96c9e5a5b384197 | [
"MIT"
] | 1 | 2019-07-29T21:48:40.000Z | 2020-01-13T12:08:08.000Z | src/GVis/Viewport.cpp | matthew-reid/Graphtane | 3148039993da185cfb328f89b96c9e5a5b384197 | [
"MIT"
] | 8 | 2016-04-22T06:41:47.000Z | 2021-11-23T23:44:22.000Z | // Copyright (c) 2013-2014 Matthew Paul Reid
// 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.
#pragma once
#include "Viewport.h"
#include "VisSystem.h"
namespace GVis {
Viewport::Viewport(const ViewportConfig& config) :
m_config(config),
m_renderQueueIdMask(~0),
m_faceVisibility(FaceVisibility_Front),
m_backgroundColor(vec4Zero())
{
}
void Viewport::setCamera(const CameraPtr& camera)
{
m_camera = camera;
}
void Viewport::_render(const VisSystem& visSystem, TechniqueCategory category)
{
glClearColor(m_backgroundColor.r, m_backgroundColor.g, m_backgroundColor.b, m_backgroundColor.a);
if (m_camera)
{
CALL_LISTENERS(viewport_preRender());
switch(m_faceVisibility)
{
case FaceVisibility_Front:
glFrontFace(GL_CCW);
break;
case FaceVisibility_Back:
glFrontFace(GL_CW);
}
glViewport(m_config.left, m_config.top, m_config.width, m_config.height);
glScissor(m_config.left, m_config.top, m_config.width, m_config.height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
visSystem._renderScene(*this, m_camera, category);
CALL_LISTENERS(viewport_postRender());
}
}
void Viewport::setRenderQueueIdMask(RenderQueueIdMask mask)
{
m_renderQueueIdMask = mask;
}
void Viewport::setBackgroundColor(const glm::vec4& color)
{
m_backgroundColor = color;
}
void Viewport::setFaceVisibility(FaceVisiblilty visibility)
{
m_faceVisibility = visibility;
}
} // namespace GVis
| 28.717647 | 98 | 0.770586 | matthew-reid |
615db4478a5a614a202b53c71da52fd96b16ee90 | 168 | cpp | C++ | Team01/Game/Project/Item3Way.cpp | OiCGame/GameJam03 | 535fff1e39a3c509c4104029bd40386c5d8b4a69 | [
"MIT"
] | null | null | null | Team01/Game/Project/Item3Way.cpp | OiCGame/GameJam03 | 535fff1e39a3c509c4104029bd40386c5d8b4a69 | [
"MIT"
] | null | null | null | Team01/Game/Project/Item3Way.cpp | OiCGame/GameJam03 | 535fff1e39a3c509c4104029bd40386c5d8b4a69 | [
"MIT"
] | 1 | 2021-02-01T02:48:17.000Z | 2021-02-01T02:48:17.000Z | #include "Item3Way.h"
CItem3Way::CItem3Way() :
super(){
}
CItem3Way::~CItem3Way() {
}
bool CItem3Way::Use(CCharacter & out) {
out.Attach3WayShot();
return true;
}
| 12 | 39 | 0.672619 | OiCGame |
615eab2ced3494c21318724b1eba30f74aebb4f7 | 962 | cc | C++ | cpp/accelerated-cpp/chapter_05/concat.cc | nyxnaut/learn | 2614675e7b4166833fe6cb2bc17ee504924f6142 | [
"Unlicense"
] | null | null | null | cpp/accelerated-cpp/chapter_05/concat.cc | nyxnaut/learn | 2614675e7b4166833fe6cb2bc17ee504924f6142 | [
"Unlicense"
] | null | null | null | cpp/accelerated-cpp/chapter_05/concat.cc | nyxnaut/learn | 2614675e7b4166833fe6cb2bc17ee504924f6142 | [
"Unlicense"
] | null | null | null | #include "concat.h"
#include <vector>
#include <string>
#include "max_width.h"
using std::vector;
using std::string;
vector<string> vcat(const vector<string>& top, const vector<string>& bottom) {
// copy all of top into ret
vector<string> ret = top;
// append bottom to the end of ret
// Equivalent to:
// for(vector<string>::const_iterator iter = bottom.begin(); iter != bottom.end(); ++iter) {
// ret.push_back(*iter);
// }
ret.insert(ret.end(), bottom.begin(), bottom.end());
return ret;
}
vector<string> hcat(const vector<string>& left, const vector<string>& right) {
vector<string> ret;
string::size_type width1 = max_width(left) + 1;
vector<string>::size_type i = 0, j = 0;
while(i != left.size() || j != right.size()) {
string s;
if (i != left.size())
s = left[i++];
s += string(width1 - s.size(), ' ');
if (j != right.size())
s = right[j++];
ret.push_back(s);
}
return ret;
}
| 22.372093 | 95 | 0.602911 | nyxnaut |
6160fb09710e5b38bf4f959c8f09034939275dcf | 464 | cpp | C++ | test/snippet/utility/simd/iota.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 2 | 2020-10-21T03:56:37.000Z | 2021-06-09T12:07:04.000Z | test/snippet/utility/simd/iota.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 24 | 2020-11-19T12:50:21.000Z | 2022-02-15T11:25:34.000Z | test/snippet/utility/simd/iota.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 1 | 2022-02-13T14:24:00.000Z | 2022-02-13T14:24:00.000Z | #include <seqan3/core/debug_stream.hpp>
#include <seqan3/utility/simd/all.hpp>
#include <seqan3/utility/simd/detail/debug_stream_simd.hpp>
using uint16x8_t = seqan3::simd::simd_type_t<uint16_t, 8>;
int main()
{
uint16x8_t a = seqan3::iota<uint16x8_t>(1);
seqan3::debug_stream << a << "\n"; // [1,2,3,4,5,6,7,8]
// or:
uint16x8_t b = seqan3::simd::iota<uint16x8_t>(1);
seqan3::debug_stream << b << "\n"; // [1,2,3,4,5,6,7,8]
return 0;
}
| 25.777778 | 59 | 0.640086 | joergi-w |
6161867e23e9c82bd54311dc381308bffd89693a | 20,237 | cc | C++ | lamp/lamp.cc | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | lamp/lamp.cc | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | lamp/lamp.cc | pedersor/google-research | 6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6 | [
"Apache-2.0"
] | null | null | null | // Copyright 2022 The Google Research Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdio.h>
#include <time.h>
#include <gflags/gflags.h>
#include <algorithm>
#include <cstdlib>
#include <limits>
#include <random>
#include <unordered_set>
// NOLINTBEGIN(build/include)
#include "common.h"
#include "io.h"
#include "gradient.h"
// NOLINTEND(build/include)
DEFINE_string(
dataset, "you-forgot-to-set-dataset-flag",
"Data set to use. Must be one of brightkite|lastfm|wiki|text|reuters|toy");
DEFINE_string(brightkite, "data/loc-brightkite_totalCheckins.txt",
"File with Brightkite check-ins.");
DEFINE_string(
lastfm,
"data/lastfm-dataset-1K/userid-timestamp-artid-artname-traid-traname.tsv",
"File with Last.fm 1K data.");
DEFINE_string(text_file, "data/romeo_juliet.txt", "Text file to read");
DEFINE_int32(lastfm_max_users, 100,
"Read at most this many users from gigantic Last.fm data");
DEFINE_string(wiki, "data/wiki_paths.txt", "File with Wikispeedia page paths.");
DEFINE_int32(min_location_count, 50,
"Replace all locations with a generic unknown location whose "
"frequency is below this threshold");
DEFINE_int32(max_outer_iter, 1,
"Maximum number of iterations in alternating optimization");
DEFINE_int32(grad_max_weight_iter, 30,
"Gradient ascent maximum number of iterations when optimizing "
"weight vector");
DEFINE_int32(grad_max_transitions_iter, 30,
"Gradient ascent maximum number of iterations when optimizing "
"the transition probablilities matrix");
DEFINE_double(grad_tolerance, 1e-4,
"Gradient ascent is stopped if neither of the parameters changed "
"by more than this amount.");
DEFINE_double(grad_learning_rate, 0.01, "Gradient ascent learning rate");
DEFINE_string(grad_method, "balance",
"Method to update and contsrain parameters to the unit simplex "
"in each step of the gradient ascent. Must be one of "
"project,normalize,greedy,balance");
DEFINE_bool(bruteforce, false,
"Whether to run brute-force search for the best 2 parameter weight "
"combination with the observed transition matrix");
DEFINE_bool(lamp, true, "Whether to fit LAMP models up to --max_lamp_order");
DEFINE_int32(max_lamp_order, 7, "Max LAMP order");
DEFINE_int32(min_lamp_order, 1, "Min LAMP order");
DEFINE_bool(
ngram, true,
"Whether to fit higher order Markov chains up to order --max_ngram_order");
DEFINE_int32(max_ngram_order, 5, "Max N-gram order");
// TODO(stamas): Implement log level 0.
DEFINE_int32(debug_level, 1, "0: no debug 1: some 2: all");
DEFINE_string(max_train_time, "",
"If not empty: max timestamp of visits used for training, newer "
"data is used for testing. Overrides incompatible num_folds");
DEFINE_int32(num_folds, 2,
"Number of cross validation folds, if <= 1 then the entire data "
"set is reused for training and testing");
DEFINE_int32(random_seed, 20151006, "Random seed used in cross-validation");
DEFINE_string(
plot_file, "../data/performance.tsv",
"Name of file to write various permonace metrics into; used for plotting");
double SecondsElapsed(clock_t start) {
clock_t now = clock();
return static_cast<double>(now - start) / CLOCKS_PER_SEC;
}
void PrintEvals(const TrailsSlice& train_slice, const TrailsSlice& test_slice,
double sum_freq, const WeightVector& item_frequencies,
const SparseMatrix& transition_probs,
const WeightVector& weights, EvalMap* eval_map) {
const int order = weights.size();
if (false && order != 4 && order != 5) {
return;
}
Model model = {sum_freq, item_frequencies, transition_probs, weights};
PrintAndAddEval("Initial", order, 0, true, train_slice, model, eval_map);
PrintAndAddEval("Initial", order, 0, true, test_slice, model, eval_map);
std::map<std::string, OptimMethod> name_to_method = {{"project", PROJECT},
{"normalize", NORMALIZE},
{"greedy", GREEDY},
{"balance", BALANCE}};
const auto& it = name_to_method.find(FLAGS_grad_method);
if (it == name_to_method.end()) {
die("Unknown optimization method", FLAGS_grad_method);
}
OptimOptions options = {FLAGS_max_outer_iter,
FLAGS_grad_max_weight_iter,
FLAGS_grad_max_transitions_iter,
FLAGS_grad_tolerance,
FLAGS_grad_learning_rate,
it->second,
FLAGS_debug_level};
// Optimize weights only.
// model.weights = OptimizeWeights(trails, model, options, 0);
// PrintEval(trails, model, "Optimized weights");
clock_t start = clock();
Optimize(train_slice, model, options, test_slice, "LAMP", eval_map);
printf("Optimized LAMP in %g secs\n", SecondsElapsed(start));
}
void PrintEvals(const TrailsSlice& train_slice, const TrailsSlice& test_slice,
double sum_freq, const WeightVector& item_frequencies,
const SparseMatrix& transition_probs, int order,
EvalMap* eval_map) {
WeightVector weights(order);
double w = 1;
for (int i = 0; i < order; i++) {
weights[i] = w;
w *= 0.8;
}
Normalize(&weights);
PrintEvals(train_slice, test_slice, sum_freq, item_frequencies,
transition_probs, weights, eval_map);
}
void GridSearch(const TrailsSlice& train_slice, const TrailsSlice& test_slice,
double sum_freq, const WeightVector& item_frequencies,
const SparseMatrix& transitions) {
clock_t start = clock();
double best_log_lik = std::numeric_limits<double>::lowest();
WeightVector best_weights;
for (double w1 = 0.025; w1 < 1; w1 += 0.025) {
Model model = {sum_freq, item_frequencies, transitions, {w1, 1.0 - w1}};
Eval eval = PrintEval(train_slice, model, "Grid search");
if (best_log_lik < eval.loglik()) {
best_log_lik = eval.loglik();
best_weights = model.weights;
}
}
printf("Ran grid search in %g secs\n", SecondsElapsed(start));
PrintEval(train_slice,
{sum_freq, item_frequencies, transitions, best_weights},
"Grid best");
PrintEval(test_slice, {sum_freq, item_frequencies, transitions, best_weights},
"Grid best");
}
void PrintAndAddEval(const TrailsSlice& trails, const NGramModel& ngram_model,
EvalMap* eval_map) {
double loglik = LogLikelihood(trails, ngram_model);
double perplexity = Perplexity(loglik, NumTransitions(trails));
int num_params = 0;
for (const auto& it : ngram_model.counts) {
num_params += it.second.size();
}
printf("NGram order=%d %s log-likelihood %f perplexity %f num params %d\n",
ngram_model.order, trails.is_test_ ? "test" : "train", loglik,
perplexity, num_params);
Eval eval;
eval.metrics = {{"loglik", loglik},
{"perplexity", perplexity},
{"accuracy", 0.0}, // TODO(stamas): Implement me!
{"num_params", num_params}};
(*eval_map)[{"NGram", ngram_model.order, 0, true, trails.is_test_}].push_back(
eval);
}
void PrintAndAddEval(const TrailsSlice& trails, const KneyserNeyModel& kn_model,
EvalMap* eval_map) {
double discount = 0.25;
double loglik = LogLikelihood(trails, kn_model, discount);
double perplexity = Perplexity(loglik, NumTransitions(trails));
int num_params =
kn_model.num_antecedents.size() + kn_model.middle_counts.size();
for (const auto& it : kn_model.counts) {
num_params += it.second.size();
}
printf(
"KneyserNey order=%d discount=%g %s log-likelihood %f perplexity %f num "
"params %d\n",
kn_model.order, discount, trails.is_test_ ? "test" : "train", loglik,
perplexity, num_params);
Eval eval;
eval.metrics = {{"loglik", loglik},
{"perplexity", perplexity},
{"accuracy", 0.0}, // TODO(stamas): Implement me!
{"num_params", num_params}};
(*eval_map)[{"KneyserNey", kn_model.order, 0, true, trails.is_test_}]
.push_back(eval);
}
void FitNGramModels(const TrailsSlice& train_slice,
const TrailsSlice& test_slice, int num_locations,
int max_order, EvalMap* eval_map) {
for (int order = 1; order <= max_order; order++) {
clock_t start = clock();
NGramModel model = CountNGrams(train_slice, order);
model.num_locations = num_locations;
printf("Computed NGram matrix order %d in %g secs\n", order,
SecondsElapsed(start));
PrintAndAddEval(train_slice, model, eval_map);
PrintAndAddEval(test_slice, model, eval_map);
start = clock();
KneyserNeyModel kn_model = CountKneyserNey(train_slice, order);
kn_model.num_locations = num_locations;
printf("Computed Kneyser-Ney model order %d in %g secs\n", order,
SecondsElapsed(start));
PrintAndAddEval(train_slice, kn_model, eval_map);
PrintAndAddEval(test_slice, kn_model, eval_map);
}
}
double stdev(double sum, double sum_sq, int n) {
if (n > 1) {
double variance = std::max((sum_sq - sum * (sum / n)) / (n - 1), 0.0);
return sqrt(variance);
} else {
return 0;
}
}
void SummarizeEvals(const std::vector<Eval>& evals, const std::string& metric,
double* mean, double* the_stdev) {
double sum = 0, sum_sq = 0;
for (const Eval& eval : evals) {
double value = eval.metrics.at(metric);
sum += value;
sum_sq += value * value;
}
die_if(evals.empty(), "Empty eval vector");
int expected_eval_size = FLAGS_max_train_time.empty() ? FLAGS_num_folds : 1;
die_if(static_cast<int>(evals.size()) != expected_eval_size,
"Unexpected eval vector size");
*mean = sum / evals.size();
*the_stdev = stdev(sum, sum_sq, evals.size());
}
void SummarizeEvals(const std::vector<Eval>& evals, Eval* mean_eval,
Eval* stdev_eval) {
for (const std::string metric :
{"loglik", "perplexity", "accuracy", "num_params"}) {
SummarizeEvals(evals, metric, &mean_eval->metrics[metric],
&stdev_eval->metrics[metric]);
}
mean_eval->weights.clear();
stdev_eval->weights.clear();
if (evals.empty()) {
return;
}
int num_weights = evals.front().weights.size();
mean_eval->weights.resize(num_weights);
stdev_eval->weights.resize(num_weights);
WeightVector sum_weights(num_weights), sum_sq_weights(num_weights);
for (const Eval& eval : evals) {
die_if(static_cast<int>(eval.weights.size()) != num_weights,
"Unexpected number of weights in SummarizeEvals");
for (int i = 0; i < num_weights; i++) {
sum_weights[i] += eval.weights[i];
sum_sq_weights[i] += eval.weights[i] * eval.weights[i];
}
}
for (int i = 0; i < num_weights; i++) {
mean_eval->weights[i] = sum_weights[i] / evals.size();
stdev_eval->weights[i] =
stdev(sum_weights[i], sum_sq_weights[i], evals.size());
}
}
void WritePlotData(const EvalMap& eval_map, FILE* plot_file) {
fprintf(
plot_file,
"Algorithm\tOrder\tIter\tIterType\tTrainOrTest\t"
"LogLikelihood\tPerplexity\tAccuracy\tNumParams\t"
"LogLikelihoodStDev\tPerplexityStDev\tAccuracyStdDev\tNumParamsStDev\t"
"Weights\tWeightsStDev\n");
for (const auto& it : eval_map) {
Eval mean_eval, stdev_eval;
SummarizeEvals(it.second, &mean_eval, &stdev_eval);
const Algorithm& algorithm = it.first;
const char* iter_type = "final";
if (!algorithm.is_final_iter) { // first is used for weight only LAMP plots
iter_type = algorithm.iter == 0 ? "first" : "intermediate";
}
double fractional_iter =
(algorithm.iter + 1) / 2.0; // weight iters become *.5 iter
fprintf(plot_file, "%s\t%d\t%g\t%s\t%s\t%s\t%s\t%s\t%s\n",
algorithm.name.c_str(), algorithm.order, fractional_iter, iter_type,
algorithm.is_test ? "test" : "train",
ToTSVString(mean_eval.metrics).c_str(),
ToTSVString(stdev_eval.metrics).c_str(),
ToString(mean_eval.weights).c_str(),
ToString(stdev_eval.weights).c_str());
}
}
void RunMethods(const TrailsSlice& train_slice, const TrailsSlice& test_slice,
int num_locations, int cv_fold, EvalMap* eval_map) {
std::unordered_set<int> train_loc, test_loc;
for (const Trail& trail : train_slice) {
for (int loc : trail) {
train_loc.insert(loc);
}
}
for (const Trail& trail : test_slice) {
for (int loc : trail) {
test_loc.insert(loc);
}
}
int num_both = 0;
for (int loc : test_loc) {
if (train_loc.count(loc) > 0) {
num_both++;
}
}
if (cv_fold >= 0) {
printf("Cross validation fold %d ", cv_fold);
} else {
printf("Time based split ");
}
printf("common location %d train only %d test only %d\n", num_both,
static_cast<int>(train_loc.size()) - num_both,
static_cast<int>(test_loc.size()) - num_both);
clock_t start = clock();
WeightVector item_frequencies;
SparseMatrix empirical_transitions = ComputeEmpiricalTransitionMatrix(
train_slice, num_locations, &item_frequencies);
double sum_freq = Sum(item_frequencies);
printf(
"Computed empiricial transition matrix and item frequencies in %g secs\n",
SecondsElapsed(start));
if (FLAGS_dataset == "toy") { // Overwrite with true matrix.
empirical_transitions.clear();
empirical_transitions.resize(3);
empirical_transitions[0][0] = 0.5;
empirical_transitions[0][1] = 0.5;
empirical_transitions[1][2] = 1.0;
empirical_transitions[2][0] = 1.0;
}
int num_entries = 0;
for (const SparseVector& row : empirical_transitions) {
num_entries += row.size();
}
printf("Empricial transition matrix has %d non-zero entries\n", num_entries);
if (true || FLAGS_lamp) {
PrintEvals(train_slice, test_slice, sum_freq, item_frequencies,
empirical_transitions, 1, eval_map);
}
// Perform brute force grid search for the best 2 weights.
if (FLAGS_bruteforce) {
GridSearch(train_slice, test_slice, sum_freq, item_frequencies,
empirical_transitions);
}
if (FLAGS_lamp) {
int max_order = FLAGS_dataset == "toy" ? 2 : FLAGS_max_lamp_order;
for (int order = std::max(FLAGS_min_lamp_order, 2); order <= max_order;
order++) {
PrintEvals(train_slice, test_slice, sum_freq, item_frequencies,
empirical_transitions, order, eval_map);
}
// Initial weight vectors were: {0.6, 0.4}, {0.6, 0.35, 0.05}, {0.6, 0.35,
// 0.03, 0.02}, {0.6, 0.33, 0.03, 0.02, 0.02}, {0.6, 0.32, 0.03, 0.02, 0.02,
// 0.01}
}
if (FLAGS_ngram) {
int max_order = FLAGS_dataset == "toy" ? 2 : FLAGS_max_ngram_order;
FitNGramModels(train_slice, test_slice, num_locations, max_order, eval_map);
}
}
int main(int argc, char* argv[]) {
google::ParseCommandLineFlags(&argc, &argv, true);
// Disable buffering to make log messages appear immediately.
setbuf(stdout, NULL);
// Die early if we can't write the results anyway.
FILE* plot_file = fopen(FLAGS_plot_file.c_str(), "w");
die_if(!plot_file, "Can't open", FLAGS_plot_file);
EvalMap eval_map;
// Read or create data.
Trails trails, test_trails; // latter only populated if splitting test and
// train by time.
int num_locations = -1;
bool split_by_time = !FLAGS_max_train_time.empty();
if (FLAGS_dataset == "toy") {
// Maithra's example for a LAMP that can't be expresses as a 1st order
// Markov chain. Node indices are {0, 1, 2} instead of {1, 2, 3}.
// Optimal weights are [0.5, 0.5].
trails = {{0, 0, 0}, {0, 0, 0}, {0, 0, 1}, {0, 0, 1},
{0, 1, 0}, {0, 1, 1}, {0, 1, 2}, {0, 1, 2}};
num_locations = 3;
} else {
clock_t start = clock();
SplitStringTrails string_trails;
if (FLAGS_dataset == "brightkite") {
string_trails = ReadBrightkite(FLAGS_brightkite, FLAGS_max_train_time);
} else if (FLAGS_dataset == "lastfm") {
string_trails = ReadLastfm(FLAGS_lastfm, FLAGS_lastfm_max_users,
FLAGS_max_train_time);
} else if (FLAGS_dataset == "wiki") {
die_if(split_by_time, "Wiki data can't be split by time");
string_trails = ReadWiki(FLAGS_wiki);
} else if (FLAGS_dataset == "text") {
// TODO(stamas): split into sentences
split_by_time = true; // Fake mode
FLAGS_max_train_time = "dummy";
string_trails = ReadText(FLAGS_text_file);
} else if (FLAGS_dataset == "reuters") {
split_by_time = true; // Fake mode
FLAGS_max_train_time = "dummy";
string_trails = ReadReuters();
} else {
die("Unknown dataset type", FLAGS_dataset);
}
ToTrails(string_trails, FLAGS_min_location_count, split_by_time, &trails,
&test_trails, &num_locations);
printf("Read %zu trails with %d transitions total in %g secs\n",
string_trails.size(), NumTransitions(string_trails),
SecondsElapsed(start));
}
if (split_by_time) {
int fake_fold = -1;
int num_train_transitions = NumTransitions(trails);
int num_test_transitions = NumTransitions(test_trails);
double denom = 0.01 * (num_train_transitions + num_test_transitions);
printf(
"Using %zu time based train trails with %d transitions total, %.2f%% "
"of all, %.2f transitions/trail on average\n",
trails.size(), num_train_transitions, num_train_transitions / denom,
num_train_transitions / static_cast<double>(trails.size()));
printf(
"Using %zu time based test trails with %d transitions total, %.2f%% of "
"all, %.2f transitions/trail on average\n",
test_trails.size(), num_test_transitions, num_test_transitions / denom,
num_test_transitions / static_cast<double>(test_trails.size()));
RunMethods(TrailsSlice(trails, false), TrailsSlice(test_trails, true),
num_locations, fake_fold, &eval_map);
} else { // cross validate
std::mt19937 rng;
rng.seed(FLAGS_random_seed);
std::shuffle(trails.begin(), trails.end(), rng);
die_if(FLAGS_num_folds < 1, "Number of folds must be at least one");
die_if(static_cast<int>(trails.size()) < FLAGS_num_folds,
"Too few trails for requested number of folds");
int test_fold_size = trails.size() / FLAGS_num_folds;
int train_fold_size =
FLAGS_num_folds > 1 ? trails.size() - test_fold_size : trails.size();
for (int fold = 0; fold < FLAGS_num_folds; fold++) {
int test_begin = fold * test_fold_size;
int test_end = (fold + 1) * test_fold_size;
int train_begin = test_end % trails.size();
int train_end = train_begin + train_fold_size;
if (FLAGS_num_folds > 1) {
train_end %= trails.size();
}
printf(
"Cross validation fold %d test fold size %d train fold size %d "
"test begin %d test end %d train begin %d train end %d\n",
fold, test_fold_size, train_fold_size, test_begin, test_end,
train_begin, train_end);
TrailsSlice test_slice(trails, test_begin, test_end, true),
train_slice(trails, train_begin, train_end, false);
RunMethods(train_slice, test_slice, num_locations, fold, &eval_map);
}
}
WritePlotData(eval_map, plot_file);
die_if(fclose(plot_file) != 0, "Can't close", FLAGS_plot_file);
return 0;
}
| 41.3 | 80 | 0.653605 | pedersor |
6162658acdc07f3da2545ba8c5affa1e15d0cb08 | 954 | hpp | C++ | umu/singleton_window.hpp | UMU618/win10-screen-blur | 3b492f01eeca1f6032dbe88ee27daf34d94f2e13 | [
"MIT"
] | null | null | null | umu/singleton_window.hpp | UMU618/win10-screen-blur | 3b492f01eeca1f6032dbe88ee27daf34d94f2e13 | [
"MIT"
] | null | null | null | umu/singleton_window.hpp | UMU618/win10-screen-blur | 3b492f01eeca1f6032dbe88ee27daf34d94f2e13 | [
"MIT"
] | null | null | null | #pragma once
namespace umu {
class SingletonWindow {
public:
static HWND FindPrevInstanceWindow(LPCWSTR trait) {
WindowTrait window_trait = {trait, nullptr};
::EnumWindows(EnumWindowsProc, (LPARAM)&window_trait);
return window_trait.hwnd;
}
static bool SetSingleton(HWND hwnd, LPCWSTR trait) {
return !!::SetProp(hwnd, trait, hwnd);
}
static bool CheckWindowProp(HWND hwnd, LPCWSTR trait) {
HANDLE handle = ::GetProp(hwnd, trait);
if (nullptr != handle && handle == hwnd) {
return true;
}
return false;
}
private:
static BOOL CALLBACK EnumWindowsProc(__in HWND hwnd, __in LPARAM lParam) {
if (nullptr != hwnd) {
WindowTrait* trait = (WindowTrait*)lParam;
if (CheckWindowProp(hwnd, trait->trait)) {
trait->hwnd = hwnd;
return FALSE;
}
}
return TRUE;
}
private:
struct WindowTrait {
LPCWSTR trait;
HWND hwnd;
};
};
} // namespace umu
| 21.681818 | 76 | 0.644654 | UMU618 |
6162d3709ad3bd4e1d8b29b7e647e971968fbbd7 | 500 | hpp | C++ | include/utility.hpp | alanjian85/Rayster | f45d0c207b717ef31f6d4e469961653299207b5d | [
"BSL-1.0"
] | null | null | null | include/utility.hpp | alanjian85/Rayster | f45d0c207b717ef31f6d4e469961653299207b5d | [
"BSL-1.0"
] | null | null | null | include/utility.hpp | alanjian85/Rayster | f45d0c207b717ef31f6d4e469961653299207b5d | [
"BSL-1.0"
] | null | null | null | #ifndef BOX_UTILITY_HPP
#define BOX_UTILITY_HPP
#include <algorithm>
namespace box {
constexpr auto pi = 3.14159;
constexpr auto rad(double deg) {
return deg * pi / 180;
}
constexpr auto lerp(double min, double max, double val) {
return min + val * (max - min);
}
constexpr auto smoothstep(double edge0, double edge1, double x) {
auto t = std::clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);
}
}
#endif | 21.73913 | 69 | 0.59 | alanjian85 |
6164cbe783895133e498847939ad4c6640dfe30f | 4,417 | cpp | C++ | Kernel/Net/Socket.cpp | sudipbhandari126/serenity | 9149a519f5f1bbe0ad821fb1a6a408663fd3741d | [
"BSD-2-Clause"
] | null | null | null | Kernel/Net/Socket.cpp | sudipbhandari126/serenity | 9149a519f5f1bbe0ad821fb1a6a408663fd3741d | [
"BSD-2-Clause"
] | null | null | null | Kernel/Net/Socket.cpp | sudipbhandari126/serenity | 9149a519f5f1bbe0ad821fb1a6a408663fd3741d | [
"BSD-2-Clause"
] | null | null | null | #include <Kernel/FileSystem/FileDescription.h>
#include <Kernel/Net/IPv4Socket.h>
#include <Kernel/Net/LocalSocket.h>
#include <Kernel/Net/Socket.h>
#include <Kernel/Process.h>
#include <Kernel/UnixTypes.h>
#include <LibC/errno_numbers.h>
KResultOr<Retained<Socket>> Socket::create(int domain, int type, int protocol)
{
(void)protocol;
switch (domain) {
case AF_LOCAL:
return LocalSocket::create(type & SOCK_TYPE_MASK);
case AF_INET:
return IPv4Socket::create(type & SOCK_TYPE_MASK, protocol);
default:
return KResult(-EAFNOSUPPORT);
}
}
Socket::Socket(int domain, int type, int protocol)
: m_domain(domain)
, m_type(type)
, m_protocol(protocol)
{
m_origin_pid = current->pid();
}
Socket::~Socket()
{
}
KResult Socket::listen(int backlog)
{
LOCKER(m_lock);
if (m_type != SOCK_STREAM)
return KResult(-EOPNOTSUPP);
m_backlog = backlog;
kprintf("Socket{%p} listening with backlog=%d\n", this, m_backlog);
return KSuccess;
}
RetainPtr<Socket> Socket::accept()
{
LOCKER(m_lock);
if (m_pending.is_empty())
return nullptr;
auto client = m_pending.take_first();
ASSERT(!client->is_connected());
client->m_connected = true;
return client;
}
KResult Socket::queue_connection_from(Socket& peer)
{
LOCKER(m_lock);
if (m_pending.size() >= m_backlog)
return KResult(-ECONNREFUSED);
m_pending.append(peer);
return KSuccess;
}
KResult Socket::setsockopt(int level, int option, const void* value, socklen_t value_size)
{
ASSERT(level == SOL_SOCKET);
switch (option) {
case SO_SNDTIMEO:
if (value_size != sizeof(timeval))
return KResult(-EINVAL);
m_send_timeout = *(const timeval*)value;
return KSuccess;
case SO_RCVTIMEO:
if (value_size != sizeof(timeval))
return KResult(-EINVAL);
m_receive_timeout = *(const timeval*)value;
return KSuccess;
default:
kprintf("%s(%u): setsockopt() at SOL_SOCKET with unimplemented option %d\n", current->process().name().characters(), current->process().pid(), option);
return KResult(-ENOPROTOOPT);
}
}
KResult Socket::getsockopt(int level, int option, void* value, socklen_t* value_size)
{
ASSERT(level == SOL_SOCKET);
switch (option) {
case SO_SNDTIMEO:
if (*value_size < sizeof(timeval))
return KResult(-EINVAL);
*(timeval*)value = m_send_timeout;
*value_size = sizeof(timeval);
return KSuccess;
case SO_RCVTIMEO:
if (*value_size < sizeof(timeval))
return KResult(-EINVAL);
*(timeval*)value = m_receive_timeout;
*value_size = sizeof(timeval);
return KSuccess;
case SO_ERROR:
if (*value_size < sizeof(int))
return KResult(-EINVAL);
kprintf("%s(%u): getsockopt() SO_ERROR: WARNING! I have no idea what the real error is, so I'll just stick my fingers in my ears and pretend there is none! %d\n", current->process().name().characters(), option);
*(int*)value = 0;
*value_size = sizeof(int);
return KSuccess;
default:
kprintf("%s(%u): getsockopt() at SOL_SOCKET with unimplemented option %d\n", current->process().name().characters(), option);
return KResult(-ENOPROTOOPT);
}
}
void Socket::load_receive_deadline()
{
kgettimeofday(m_receive_deadline);
m_receive_deadline.tv_sec += m_receive_timeout.tv_sec;
m_receive_deadline.tv_usec += m_receive_timeout.tv_usec;
m_receive_deadline.tv_sec += (m_send_timeout.tv_usec / 1000000) * 1;
m_receive_deadline.tv_usec %= 1000000;
}
void Socket::load_send_deadline()
{
kgettimeofday(m_send_deadline);
m_send_deadline.tv_sec += m_send_timeout.tv_sec;
m_send_deadline.tv_usec += m_send_timeout.tv_usec;
m_send_deadline.tv_sec += (m_send_timeout.tv_usec / 1000000) * 1;
m_send_deadline.tv_usec %= 1000000;
}
static const char* to_string(SocketRole role)
{
switch (role) {
case SocketRole::Listener:
return "Listener";
case SocketRole::Accepted:
return "Accepted";
case SocketRole::Connected:
return "Connected";
default:
return "None";
}
}
String Socket::absolute_path(const FileDescription& description) const
{
return String::format("socket:%x (role: %s)", this, to_string(description.socket_role()));
}
| 29.644295 | 219 | 0.661082 | sudipbhandari126 |
6165be661a1ad7bc4d67ecc2518e5dbc1c2c8cbe | 6,457 | cc | C++ | source/agent/audio/audioMixer/AudioMixerWrapper.cc | yfdandy/owt-server | 93b1721865907c6af94be4fdef8f191e59f345d2 | [
"Apache-2.0"
] | 1 | 2021-05-30T01:19:18.000Z | 2021-05-30T01:19:18.000Z | source/agent/audio/audioMixer/AudioMixerWrapper.cc | vgemv/owt-server | fa6070af33feeeb79a962de08307ac5092991cbf | [
"Apache-2.0"
] | null | null | null | source/agent/audio/audioMixer/AudioMixerWrapper.cc | vgemv/owt-server | fa6070af33feeeb79a962de08307ac5092991cbf | [
"Apache-2.0"
] | null | null | null | // Copyright (C) <2019> Intel Corporation
//
// SPDX-License-Identifier: Apache-2.0
#ifndef BUILDING_NODE_EXTENSION
#define BUILDING_NODE_EXTENSION
#endif
#include "AudioMixerWrapper.h"
using namespace v8;
Persistent<Function> AudioMixer::constructor;
AudioMixer::AudioMixer() {};
AudioMixer::~AudioMixer() {};
void AudioMixer::Init(Handle<Object> exports, Handle<Object> module) {
Isolate* isolate = exports->GetIsolate();
// Prepare constructor template
Local<FunctionTemplate> tpl = FunctionTemplate::New(isolate, New);
tpl->SetClassName(String::NewFromUtf8(isolate, "AudioMixer"));
tpl->InstanceTemplate()->SetInternalFieldCount(1);
// Prototype
NODE_SET_PROTOTYPE_METHOD(tpl, "close", close);
NODE_SET_PROTOTYPE_METHOD(tpl, "enableVAD", enableVAD);
NODE_SET_PROTOTYPE_METHOD(tpl, "disableVAD", disableVAD);
NODE_SET_PROTOTYPE_METHOD(tpl, "resetVAD", resetVAD);
NODE_SET_PROTOTYPE_METHOD(tpl, "addInput", addInput);
NODE_SET_PROTOTYPE_METHOD(tpl, "removeInput", removeInput);
NODE_SET_PROTOTYPE_METHOD(tpl, "setInputActive", setInputActive);
NODE_SET_PROTOTYPE_METHOD(tpl, "addOutput", addOutput);
NODE_SET_PROTOTYPE_METHOD(tpl, "removeOutput", removeOutput);
constructor.Reset(isolate, tpl->GetFunction());
module->Set(String::NewFromUtf8(isolate, "exports"), tpl->GetFunction());
}
void AudioMixer::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
String::Utf8Value param0(isolate, args[0]->ToString());
std::string config = std::string(*param0);
AudioMixer* obj = new AudioMixer();
obj->me = new mcu::AudioMixer(config);
obj->Wrap(args.This());
args.GetReturnValue().Set(args.This());
}
void AudioMixer::close(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
obj->me = nullptr;
delete me;
}
void AudioMixer::enableVAD(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
if (obj->me == nullptr)
return;
int period = args[0]->IntegerValue(Nan::GetCurrentContext()).ToChecked();
obj->me->setEventRegistry(obj);
obj->me->enableVAD(period);
if (args.Length() > 1 && args[1]->IsFunction())
Local<Object>::New(isolate, obj->m_store)->Set(String::NewFromUtf8(isolate, "vad"), args[1]);
}
void AudioMixer::disableVAD(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
obj->me->disableVAD();
obj->me->setEventRegistry(nullptr);
}
void AudioMixer::resetVAD(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
obj->me->resetVAD();
}
void AudioMixer::addInput(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
String::Utf8Value param0(isolate, args[0]->ToString());
std::string endpointID = std::string(*param0);
String::Utf8Value param1(isolate, args[1]->ToString());
std::string streamID = std::string(*param1);
String::Utf8Value param2(isolate, args[2]->ToString());
std::string codec = std::string(*param2);
FrameSource* param3 = ObjectWrap::Unwrap<FrameSource>(args[3]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
owt_base::FrameSource* src = param3->src;
bool r = me->addInput(endpointID, streamID, codec, src);
args.GetReturnValue().Set(Boolean::New(isolate, r));
}
void AudioMixer::removeInput(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
String::Utf8Value param0(isolate, args[0]->ToString());
std::string endpointID = std::string(*param0);
String::Utf8Value param1(isolate, args[1]->ToString());
std::string streamID = std::string(*param1);
me->removeInput(endpointID, streamID);
}
void AudioMixer::setInputActive(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
String::Utf8Value param0(isolate, args[0]->ToString());
std::string endpointID = std::string(*param0);
String::Utf8Value param1(isolate, args[1]->ToString());
std::string streamID = std::string(*param1);
bool active = args[2]->ToBoolean(Nan::GetCurrentContext()).ToLocalChecked()->Value();
me->setInputActive(endpointID, streamID, active);
}
void AudioMixer::addOutput(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
String::Utf8Value param0(isolate, args[0]->ToString());
std::string endpointID = std::string(*param0);
String::Utf8Value param1(isolate, args[1]->ToString());
std::string streamID = std::string(*param1);
String::Utf8Value param2(isolate, args[2]->ToString());
std::string codec = std::string(*param2);
FrameDestination* param3 = ObjectWrap::Unwrap<FrameDestination>(args[3]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
owt_base::FrameDestination* dest = param3->dest;
bool r = me->addOutput(endpointID, streamID, codec, dest);
args.GetReturnValue().Set(Boolean::New(isolate, r));
}
void AudioMixer::removeOutput(const v8::FunctionCallbackInfo<v8::Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
AudioMixer* obj = ObjectWrap::Unwrap<AudioMixer>(args.Holder());
mcu::AudioMixer* me = obj->me;
String::Utf8Value param0(isolate, args[0]->ToString());
std::string endpointID = std::string(*param0);
String::Utf8Value param1(isolate, args[1]->ToString());
std::string streamID = std::string(*param1);
me->removeOutput(endpointID, streamID);
}
| 36.072626 | 128 | 0.721233 | yfdandy |
6168056bf62229737a5f5404b295053939123a09 | 5,912 | hpp | C++ | src/hand/Analysis.hpp | helkebir/suzume | ce330d5c3866b8ced34b6bed8dacc5a3c12625c4 | [
"BSD-3-Clause"
] | null | null | null | src/hand/Analysis.hpp | helkebir/suzume | ce330d5c3866b8ced34b6bed8dacc5a3c12625c4 | [
"BSD-3-Clause"
] | null | null | null | src/hand/Analysis.hpp | helkebir/suzume | ce330d5c3866b8ced34b6bed8dacc5a3c12625c4 | [
"BSD-3-Clause"
] | null | null | null | //
// Created by Hamza El-Kebir on 12/5/21.
//
#ifndef SUZUME_ANALYSIS_HPP
#define SUZUME_ANALYSIS_HPP
#include "tiles/TilesEnum.hpp"
#include "tiles/TileUtils.hpp"
#include <vector>
#include <algorithm>
#include <iostream>
namespace szm {
class Analysis {
public:
template <Languages TLanguage>
using TilesVec = std::vector<Tile<TLanguage>*>;
template <Languages TLanguage>
using TilesVecVec = std::vector<TilesVec<TLanguage>>;
// typedef std::vector<Tiles> TDTilesVec;
// typedef std::vector<std::vector<Tiles>> TDTilesVecVec;
template <Languages TLanguage>
static TilesVecVec<TLanguage> identifyFullRuns(TilesVec<TLanguage> tiles)
{
return identifyRuns(tiles, false, true);
}
template <Languages TLanguage>
static TilesVecVec<TLanguage> identifyPartialRuns(TilesVec<TLanguage> tiles)
{
return identifyRuns(tiles, true, false);
}
template <Languages TLanguage>
static TilesVecVec<TLanguage> identifyRuns(TilesVec<TLanguage> tiles, bool partial=true, bool full=true)
{
std::sort(tiles.begin(), tiles.end(), [&](auto * a, auto * b) {return (*a < *b);});
TilesVecVec<TLanguage> runs;
TilesVec<TLanguage> tmp;
auto expandRun = [&] (int idx, TilesVec<TLanguage> &tmpVec, bool stop2 = false) {
Tile<TLanguage> * t1 = tiles[idx];
if (TileInfoMap::get(t1).honors)
return;
tmpVec.push_back(t1);
int no1 = TileInfoMap::get(t1).number;
auto cat1 = TileInfoMap::get(t1).cat;
int i = idx;
int count = 1;
bool kanchan = false;
while (i < tiles.size()) {
if (kanchan)
break;
if (count == 3)
break;
Tile<TLanguage> * t2 = tiles[i];
if (!TileInfoMap::get(t2).suits) {
i++;
continue;
}
auto cat2 = TileInfoMap::get(t2).cat;
if (cat2 != cat1) {
i++;
continue;
}
no1 = TileInfoMap::get(tmpVec.back()).number;
int no2 = TileInfoMap::get(t2).number;
if (no1 == no2) {
i++;
continue;
}
if ((no2 - no1) == 1) {
if (stop2 && count == 2) {
count++;
break;
} else {
tmpVec.push_back(t2);
count++;
}
} else if (((no2 - no1) == 2) && (count < 2)) {
tmpVec.push_back(t2);
kanchan = true;
count++;
}
i++;
}
};
auto criterion = [&](int l) {
if (partial && !full)
return l == 2;
else if (!partial && full)
return l == 3;
return l >= 2;
};
int i = 0;
for (auto tile : tiles) {
tmp.clear();
expandRun(i, tmp);
// Discard partial run if only one element is recorded.
if (criterion(tmp.size())) {
// Check if run was previously recorded.
bool isSame = false;
for (auto run: runs) {
if ((run.size() == tmp.size()) && equal(run, tmp)) {
isSame = true;
break;
}
}
if (!isSame)
runs.push_back(tmp);
}
if (partial) {
// Limit to 2 elements
tmp.clear();
expandRun(i, tmp, true);
// Discard partial run if only one element is recorded.
if (criterion(tmp.size())) {
// Check if run was previously recorded.
bool isSame = false;
for (auto run: runs) {
if ((run.size() == tmp.size()) && equal(run, tmp)) {
isSame = true;
break;
}
}
if (!isSame)
runs.push_back(tmp);
}
}
i++;
}
return runs;
}
// template <typename TType>
// static bool contains(const std::vector<TType>& vec, const TType& val)
// {
// return std::find(vec.begin(), vec.end(), val);
// }
template <Languages TLanguage>
static bool contains(const TilesVec<TLanguage>& vec, const Tile<TLanguage>* val)
{
for (auto v : vec) {
if (v->getTile() == val->getTile())
return true;
}
return false;
}
template <Languages TLanguage>
static bool equal(const TilesVec<TLanguage>& vec1, const TilesVec<TLanguage>& vec2)
{
auto comparator = [] (const Tile<TLanguage>* a, const Tile<TLanguage>* b) {
return (a->getTile() == b->getTile());
};
return std::equal(vec1.begin(), vec1.end(), vec2.begin(), comparator);
}
};
}
#endif //SUZUME_ANALYSIS_HPP
| 30.163265 | 112 | 0.41069 | helkebir |
616898ad23cfe03a9510755c679cff3f35491bf3 | 592 | hpp | C++ | tests/c++/testsetup.hpp | ssciwr/geolib4d | dd79a746559235e47c2cb5e7c7ba71ef3ae21e29 | [
"MIT"
] | 3 | 2022-01-28T14:18:05.000Z | 2022-03-02T21:52:43.000Z | tests/c++/testsetup.hpp | ssciwr/geolib4d | dd79a746559235e47c2cb5e7c7ba71ef3ae21e29 | [
"MIT"
] | 104 | 2021-06-18T14:10:37.000Z | 2022-03-04T06:12:58.000Z | tests/c++/testsetup.hpp | ssciwr/py4dgeo | dd79a746559235e47c2cb5e7c7ba71ef3ae21e29 | [
"MIT"
] | null | null | null | #include "py4dgeo/py4dgeo.hpp"
#include <memory>
#include <string>
#include <tuple>
#ifndef PY4DGEO_TEST_DATA_DIRECTORY
#error Test data directory needs to be set from CMake
#endif
#define DATAPATH(filename) PY4DGEO_TEST_DATA_DIRECTORY "/" #filename
std::shared_ptr<py4dgeo::EigenPointCloud>
benchcloud_from_file(const std::string& filename);
std::pair<std::shared_ptr<py4dgeo::EigenPointCloud>,
std::shared_ptr<py4dgeo::EigenPointCloud>>
ahk_benchcloud();
std::pair<std::shared_ptr<py4dgeo::EigenPointCloud>,
std::shared_ptr<py4dgeo::EigenPointCloud>>
testcloud();
| 25.73913 | 68 | 0.766892 | ssciwr |
616a419e1c3c56666d1c16feab1b827b6ea45b14 | 292 | cpp | C++ | C++/problem1720.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | C++/problem1720.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | C++/problem1720.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | class Solution {
public:
vector<int> decode(vector<int>& encoded, int first) {
vector<int> ans{first};
for (vector<int>::iterator it = encoded.begin(); it < encoded.end(); ++it)
{
ans.push_back(*it ^ ans.back());
}
return ans;
}
};
| 24.333333 | 82 | 0.523973 | 1050669722 |
616a49ff28123c3c038f6c8cad8afe895d508ed2 | 816 | cpp | C++ | behavioral/iterator/std_iterator.cpp | stefanpantic/cpp-design-patterns | 887f9ddebbb99a773ba132c6298fee37eec25609 | [
"MIT"
] | 2 | 2021-01-21T11:03:08.000Z | 2021-01-31T17:47:12.000Z | behavioral/iterator/std_iterator.cpp | stefanpantic/cpp-design-patterns | 887f9ddebbb99a773ba132c6298fee37eec25609 | [
"MIT"
] | null | null | null | behavioral/iterator/std_iterator.cpp | stefanpantic/cpp-design-patterns | 887f9ddebbb99a773ba132c6298fee37eec25609 | [
"MIT"
] | null | null | null | #include <algorithm>
#include <iostream>
#include <iterator>
#include <ostream>
#include <vector>
void std_iterators()
{
std::vector<std::string> names{"john", "jane", "mads", "mike", "kevin", "chad"};
decltype(names)::iterator it{names.begin()};
std::cout << *it << std::endl;
++it;
std::cout << *it << std::endl;
*it = "jill";
std::cout << *it << std::endl;
for(;it < names.end(); ++it)
{
std::cout << *it << std::endl;
}
std::copy(names.crbegin(), names.crend(), std::ostream_iterator<decltype(names)::value_type>(std::cout, " "));
auto begin{std::begin(names)};
std::cout << *begin << std::endl;
auto rbegin{std::rbegin(names)};
std::cout << *rbegin << std::endl;
std::cout << std::distance(std::begin(names), std::end(names)) << std::endl;
}
int main()
{
std_iterators();
return 0;
}
| 21.473684 | 111 | 0.609069 | stefanpantic |
616c55fb03e66ffbe1376e6526459a696fa0c0a5 | 4,244 | cpp | C++ | yave/graphics/commands/CmdQueue.cpp | gan74/yave | c71b5dd7c05b1aa39c59a8071fc243c1472e71d1 | [
"MIT"
] | null | null | null | yave/graphics/commands/CmdQueue.cpp | gan74/yave | c71b5dd7c05b1aa39c59a8071fc243c1472e71d1 | [
"MIT"
] | null | null | null | yave/graphics/commands/CmdQueue.cpp | gan74/yave | c71b5dd7c05b1aa39c59a8071fc243c1472e71d1 | [
"MIT"
] | null | null | null | /*******************************
Copyright (c) 2016-2022 Grégoire Angerand
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 "CmdQueue.h"
#include <yave/graphics/device/LifetimeManager.h>
namespace yave {
WaitToken::WaitToken(const TimelineFence& fence) : _fence(fence) {
}
void WaitToken::wait() {
wait_for_fence(_fence);
}
CmdQueue::CmdQueue(u32 family_index, VkQueue queue) : _family_index(family_index), _queue(queue) {
}
CmdQueue::~CmdQueue() {
wait();
}
u32 CmdQueue::family_index() const {
return _family_index;
}
VkQueue CmdQueue::vk_queue() const {
return _queue;
}
void CmdQueue::wait() const {
const auto lock = y_profile_unique_lock(_lock);
vk_check(vkQueueWaitIdle(_queue));
}
WaitToken CmdQueue::submit(CmdBufferRecorder&& recorder, VkSemaphore wait, VkSemaphore signal) const {
y_profile();
const VkCommandBuffer cmd_buffer = recorder.vk_cmd_buffer();
vk_check(vkEndCommandBuffer(cmd_buffer));
TimelineFence fence;
{
const auto lock = y_profile_unique_lock(_lock);
// This needs to be inside the lock
fence = create_timeline_fence();
const u64 prev_value = fence._value - 1;
recorder._data->_timeline_fence = fence;
const VkSemaphore timeline_semaphore = vk_timeline_semaphore();
Y_TODO(We do not need to wait on the timeline_semaphore if using SyncPolicy::Wait)
const std::array<VkSemaphore, 2> wait_semaphores = {timeline_semaphore, wait};
const std::array<VkSemaphore, 2> signal_semaphores = {timeline_semaphore, signal};
const std::array<u64, 2> wait_values = {prev_value, 0};
const std::array<u64, 2> signal_values = {fence._value, 0};
const std::array<VkPipelineStageFlags, 2> pipe_stage_flags = {VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT};
const u32 wait_count = wait_semaphores[1] ? 2 : 1;
const u32 signal_count = signal_semaphores[1] ? 2 : 1;
VkTimelineSemaphoreSubmitInfo timeline_info = vk_struct();
{
timeline_info.waitSemaphoreValueCount = wait_count;
timeline_info.pWaitSemaphoreValues = wait_values.data();
timeline_info.signalSemaphoreValueCount = signal_count;
timeline_info.pSignalSemaphoreValues = signal_values.data();
}
VkSubmitInfo submit_info = vk_struct();
{
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &cmd_buffer;
submit_info.pNext = &timeline_info;
submit_info.pWaitDstStageMask = pipe_stage_flags.data();
submit_info.waitSemaphoreCount = wait_count;
submit_info.pWaitSemaphores = wait_semaphores.data();
submit_info.signalSemaphoreCount = signal_count;
submit_info.pSignalSemaphores = signal_semaphores.data();
}
y_profile_zone("submit");
vk_check(vkQueueSubmit(_queue, 1, &submit_info, {}));
}
lifetime_manager().register_for_polling(std::exchange(recorder._data, nullptr));
return WaitToken(fence);
}
}
| 35.966102 | 147 | 0.68803 | gan74 |
616e1b01002ea73372fc1bccb9da8fb573b93b83 | 1,673 | cpp | C++ | PMod_7Segment/Firmware/test_top.cpp | jjhorton/PMod | 82723696c9133fd99905481a8fae3807bbadeb9c | [
"BSD-3-Clause"
] | null | null | null | PMod_7Segment/Firmware/test_top.cpp | jjhorton/PMod | 82723696c9133fd99905481a8fae3807bbadeb9c | [
"BSD-3-Clause"
] | 6 | 2022-03-08T21:25:57.000Z | 2022-03-14T22:04:52.000Z | PMod_LEDArray/Firmware/test_top.cpp | jjhorton/PMod | 82723696c9133fd99905481a8fae3807bbadeb9c | [
"BSD-3-Clause"
] | null | null | null | #include <stdio.h>
#include <stdlib.h>
#include "Vtop.h"
#include "verilated_vcd_c.h"
#include "verilated.h"
void tick(int tickcount, Vtop *tb, VerilatedVcdC* tfp){
tb->eval();
if(tfp)
tfp->dump(tickcount * 10-2);
tb->CLK = 1;
tb->eval();
if(tfp)
tfp->dump(tickcount * 10);
tb->CLK = 0;
tb->eval();
if (tfp) {
tfp->dump(tickcount * 10 + 5);
tfp->flush();
}
}
/*
int serial_tx(int tick_count, int tick_start, int8_t data_byte, Vtop *tb, VerilatedVcdC* tfp){
//function for transmitting the serial message
int clkperbaud = 625;
if(tick_count > tick_start){
//we should be have tx a serial message
int start_delay = tick_start + (clkperbaud);
int bits_completed = (tick_count - start_delay)/clkperbaud;
if(tick_count < start_delay) {
tb->RX = 0;
return 0;
}
if (bits_completed < 10) {
// set RX to be the required data
tb->RX = ((data_byte>>bits_completed)&1);
return 0;
}
else{
// the message has been sent, idle state
tb->RX = 1;
return 1;
}
}
else{
// we have not got to the point in time when the message should be sent
tb->RX = 1;
return 0;
}
}
*/
int main(int argc, char **argv){
Verilated::commandArgs(argc, argv);
// Instantiate the design
Vtop *tb = new Vtop;
unsigned tickcount = 0;
//generate a trace
Verilated::debug(0);
Verilated::traceEverOn(true);
Verilated::mkdir("logs");
VerilatedVcdC* tfp = new VerilatedVcdC;
tb->trace(tfp, 99);
tfp->open("trace.vcd");
for(int i=0; i<100000; i++){
tick(++tickcount, tb, tfp);
if(tickcount==16){
tb->RX = 1;
}
else {
tb->RX = 0;
}
}
Verilated::mkdir("logs");
VerilatedCov::write("logs/coverage.dat");
}
| 18.797753 | 94 | 0.635983 | jjhorton |
61708ba5c89f2729072c7a5033eed3722e679899 | 7,736 | cpp | C++ | hazelcast/test/src/faulttolerance/LoadTest.cpp | pirog-spb/hazelcast-cpp-client | 979cf38b85a8308dbcc75b7e94a2b79fffceae21 | [
"Apache-2.0"
] | null | null | null | hazelcast/test/src/faulttolerance/LoadTest.cpp | pirog-spb/hazelcast-cpp-client | 979cf38b85a8308dbcc75b7e94a2b79fffceae21 | [
"Apache-2.0"
] | null | null | null | hazelcast/test/src/faulttolerance/LoadTest.cpp | pirog-spb/hazelcast-cpp-client | 979cf38b85a8308dbcc75b7e94a2b79fffceae21 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2008-2018, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//
// Created by İhsan Demir on Mar 6 2016.
//
/**
* This has to be the first include, so that Python.h is the first include. Otherwise, compilation warning such as
* "_POSIX_C_SOURCE" redefined occurs.
*/
#include "HazelcastServer.h"
#include <gtest/gtest.h>
#include <boost/foreach.hpp>
#include "hazelcast/util/Runnable.h"
#include "hazelcast/util/Thread.h"
#include "hazelcast/util/CountDownLatch.h"
#include "hazelcast/util/ILogger.h"
#include "ClientTestSupport.h"
#include "hazelcast/client/IMap.h"
#include "hazelcast/client/HazelcastClient.h"
#include "hazelcast/client/ClientConfig.h"
namespace hazelcast {
namespace client {
namespace test {
namespace faulttolerance {
class LoadTest : public ClientTestSupport {
public:
std::auto_ptr<hazelcast::client::ClientConfig> getLoadTestConfig() {
std::auto_ptr<ClientConfig> config = ClientTestSupport::getConfig();
config->setRedoOperation(true);
config->setLogLevel(FINEST);
return config;
}
class LoadClientTask : public util::Runnable {
public:
LoadClientTask(IMap<int, int> &map, int numberOfOps, util::CountDownLatch &latch) : map(map),
numberOfOps(
numberOfOps),
latch(latch) {}
virtual void run() {
latch.countDown();
latch.await(20);
for (int i = 0; i < numberOfOps; ++i) {
int mod = rand() % 3;
switch (mod) {
case 0:
ASSERT_NO_THROW(map.put(i, i));
break;
case 1:
ASSERT_NO_THROW(map.remove(i));
case 2: {
boost::shared_ptr<int> val;
ASSERT_NO_THROW(val = map.get(i));
if ((int *) NULL != val.get()) {
ASSERT_EQ(*val, i);
}
break;
}
default:
abort();
}
}
}
virtual const string getName() const {
return "LoadClientTask";
}
private:
IMap<int, int> ↦
int numberOfOps;
util::CountDownLatch &latch;
};
void addThread(IMap<int, int> &map, int numberOfOps, util::CountDownLatch &latch) {
boost::shared_ptr<util::Runnable> task(new LoadClientTask(map, numberOfOps, latch));
threads.push_back(boost::shared_ptr<util::Thread>(new util::Thread(task)));
}
void startThreads() {
BOOST_FOREACH(boost::shared_ptr<util::Thread> &t, threads) {
t->start();
}
}
void waitForThreadsToFinish() {
BOOST_FOREACH(boost::shared_ptr<util::Thread> &t, threads) {
util::ILogger::getLogger().info() << "Waiting to join for thread "
<< t->getThreadId();
t->join();
}
}
protected:
std::vector<boost::shared_ptr<util::Thread> > threads;
};
void loadIntMapTestWithConfig(ClientConfig &config, LoadTest &test) {
HazelcastServer instance1(*g_srvFactory);
HazelcastServer instance2(*g_srvFactory);
HazelcastServer instance3(*g_srvFactory);
HazelcastServer instance4(*g_srvFactory);
HazelcastClient client(config);
IMap<int, int> imap = client.getMap<int, int>("loadtest");
int numThreads = 40;
int numOps = 5000;
util::CountDownLatch startLatch(numThreads);
for (int i = 0; i < numThreads; ++i) {
test.addThread(imap, numOps, startLatch);
}
test.startThreads();
startLatch.await(20);
util::ILogger::getLogger().info(
"[LoadTest::loadIntMapTestWithConfig] Shutting down server instance 1");
instance1.shutdown();
util::ILogger::getLogger().info(
"[LoadTest::loadIntMapTestWithConfig] Shutting down server instance 2");
instance2.shutdown();
util::ILogger::getLogger().info(
"[LoadTest::loadIntMapTestWithConfig] Shutting down server instance 3");
instance3.shutdown();
util::ILogger::getLogger().info("[LoadTest::loadIntMapTestWithConfig] Starting server instance 5");
HazelcastServer instance5(*g_srvFactory);
/*Note: Could not shutdown instance 5 here, since there may be some incomplete synchronization
* between instance 5 and instance 4. This caused problems in Linux environment. */
test.waitForThreadsToFinish();
util::ILogger::getLogger().info(
"[LoadTest::loadIntMapTestWithConfig] Finished the test successfully :)");
}
TEST_F(LoadTest, DISABLED_testIntMapSmartClientServerRestart) {
std::auto_ptr<ClientConfig> config = getLoadTestConfig();
config->setSmart(true);
loadIntMapTestWithConfig(*config, *this);
}
TEST_F(LoadTest, DISABLED_testIntMapDummyClientServerRestart) {
std::auto_ptr<ClientConfig> config = getLoadTestConfig();
config->setSmart(false);
loadIntMapTestWithConfig(*config, *this);
}
}
}
}
}
| 43.706215 | 129 | 0.456308 | pirog-spb |
61723f0c843ee063675832345b74df488e31f5d8 | 3,700 | cpp | C++ | tests/integration/replay/replay_tests.cpp | pchong90/Umpire | bfc8a153104f13fdb270347b8cd966fbbc121d4c | [
"MIT"
] | null | null | null | tests/integration/replay/replay_tests.cpp | pchong90/Umpire | bfc8a153104f13fdb270347b8cd966fbbc121d4c | [
"MIT"
] | null | null | null | tests/integration/replay/replay_tests.cpp | pchong90/Umpire | bfc8a153104f13fdb270347b8cd966fbbc121d4c | [
"MIT"
] | null | null | null | //////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2018-2019, Lawrence Livermore National Security, LLC.
// Produced at the Lawrence Livermore National Laboratory
//
// Created by David Beckingsale, david@llnl.gov
// LLNL-CODE-747640
//
// All rights reserved.
//
// This file is part of Umpire.
//
// For details, see https://github.com/LLNL/Umpire
// Please also see the LICENSE file for MIT license.
//////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <vector>
#include <string>
#include "umpire/config.hpp"
#include "umpire/ResourceManager.hpp"
#include "umpire/strategy/SlotPool.hpp"
#include "umpire/strategy/MonotonicAllocationStrategy.hpp"
#include "umpire/strategy/DynamicPool.hpp"
#include "umpire/strategy/AllocationStrategy.hpp"
#include "umpire/Allocator.hpp"
#include "umpire/op/MemoryOperation.hpp"
#include "umpire/strategy/AllocationAdvisor.hpp"
#include "umpire/strategy/ThreadSafeAllocator.hpp"
#include "umpire/strategy/FixedPool.hpp"
class replayTest {
public:
replayTest() : testAllocations(3), allocationSize(16)
{
auto& rm = umpire::ResourceManager::getInstance();
rm.makeAllocator<umpire::strategy::DynamicPool>(
"host_simpool_defaults", rm.getAllocator("HOST"));
allocatorNames.push_back("host_simpool_defaults");
rm.makeAllocator<umpire::strategy::DynamicPool>(
"host_simpool_spec1", rm.getAllocator("HOST"), 9876, 1234);
allocatorNames.push_back("host_simpool_spec1");
rm.makeAllocator<umpire::strategy::DynamicPool, false>(
"host_simpool_spec2", rm.getAllocator("HOST"), 9876, 1234);
allocatorNames.push_back("host_simpool_spec2");
#if defined(UMPIRE_ENABLE_DEVICE)
rm.makeAllocator<umpire::strategy::AllocationAdvisor>(
"read_only_um", rm.getAllocator("UM"), "READ_MOSTLY");
allocatorNames.push_back("read_only_um");
#endif
#if defined(UMPIRE_ENABLE_UM)
rm.makeAllocator<umpire::strategy::AllocationAdvisor>(
"preferred_location_host", rm.getAllocator("UM"),
"PREFERRED_LOCATION", rm.getAllocator("HOST"));
allocatorNames.push_back("preferred_location_host");
#endif
rm.makeAllocator<umpire::strategy::MonotonicAllocationStrategy>(
"MONOTONIC 1024", 1024, rm.getAllocator("HOST"));
allocatorNames.push_back("MONOTONIC 1024");
rm.makeAllocator<umpire::strategy::SlotPool>(
"host_slot_pool", 64, rm.getAllocator("HOST"));
allocatorNames.push_back("host_slot_pool");
rm.makeAllocator<umpire::strategy::ThreadSafeAllocator>(
"thread_safe_allocator", rm.getAllocator("HOST"));
allocatorNames.push_back("thread_safe_allocator");
struct data { char _[1024*1024]; };
rm.makeAllocator<umpire::strategy::FixedPool<data>>(
"fixed_pool_allocator", rm.getAllocator("HOST"));
allocatorNames.push_back("fixed_pool_allocator");
}
~replayTest( void )
{
}
void runTest()
{
for ( int i = 0; i < testAllocations; ++i ) {
for ( auto n : allocatorNames ) {
auto& rm = umpire::ResourceManager::getInstance();
auto alloc = rm.getAllocator(n);
allocations.push_back( std::make_pair(alloc.allocate( ++allocationSize ), n) );
}
}
for ( auto ptr : allocations ) {
auto& rm = umpire::ResourceManager::getInstance();
auto alloc = rm.getAllocator(ptr.second);
alloc.deallocate( ptr.first );
}
}
private:
const int testAllocations;
std::size_t allocationSize;
std::vector<std::string> allocatorNames;
std::vector<std::pair<void*, std::string>> allocations;
};
int main(int , char** )
{
replayTest test;
test.runTest();
return 0;
}
| 31.355932 | 87 | 0.680811 | pchong90 |
617601571696d4328be39dd195df93167dab2524 | 530 | hpp | C++ | mge/include/mge/ecs/ComponentFamily.hpp | juliencombattelli/Mortalis-Game-Engine | 8d1ff6301c3c61e3f363a2fbdfc7648a0cc3f43f | [
"MIT"
] | 1 | 2016-09-05T22:38:28.000Z | 2016-09-05T22:38:28.000Z | mge/include/mge/ecs/ComponentFamily.hpp | juliencombattelli/mge | 8d1ff6301c3c61e3f363a2fbdfc7648a0cc3f43f | [
"MIT"
] | null | null | null | mge/include/mge/ecs/ComponentFamily.hpp | juliencombattelli/mge | 8d1ff6301c3c61e3f363a2fbdfc7648a0cc3f43f | [
"MIT"
] | 1 | 2017-05-31T07:37:28.000Z | 2017-05-31T07:37:28.000Z | #ifndef MGE_COMPONENT_FAMILY_HPP_
#define MGE_COMPONENT_FAMILY_HPP_
#include <atomic>
namespace mge {
class BaseComponentFamily {
protected:
BaseComponentFamily() = default;
static inline std::atomic_size_t m_family { 0 };
};
template <typename Component>
class ComponentFamily : public BaseComponentFamily {
public:
static std::size_t family() noexcept
{
static const std::size_t family = m_family.fetch_add(1);
return family;
}
};
} // namespace mge
#endif // MGE_COMPONENT_FAMILY_HPP_ | 19.62963 | 64 | 0.728302 | juliencombattelli |
6177918cc5768e6a76068c01ea2e87168351caee | 9,849 | cpp | C++ | TDEngine2/source/graphics/CSkinnedMesh.cpp | bnoazx005/TDEngine2 | 93ebfecf8af791ff5ecd4f57525a6935e34cd05c | [
"Apache-2.0"
] | 1 | 2019-07-15T01:14:15.000Z | 2019-07-15T01:14:15.000Z | TDEngine2/source/graphics/CSkinnedMesh.cpp | bnoazx005/TDEngine2 | 93ebfecf8af791ff5ecd4f57525a6935e34cd05c | [
"Apache-2.0"
] | 76 | 2018-10-27T16:59:36.000Z | 2022-03-30T17:40:39.000Z | TDEngine2/source/graphics/CSkinnedMesh.cpp | bnoazx005/TDEngine2 | 93ebfecf8af791ff5ecd4f57525a6935e34cd05c | [
"Apache-2.0"
] | 1 | 2019-07-29T02:02:08.000Z | 2019-07-29T02:02:08.000Z | #include "../../include/graphics/CSkinnedMesh.h"
#include "../../include/core/IFileSystem.h"
#include "../../include/core/IFile.h"
#include "../../include/core/IJobManager.h"
#include "../../include/core/IGraphicsContext.h"
#include "../../include/graphics/IGraphicsObjectManager.h"
#include "../../include/graphics/CGeometryBuilder.h"
#include "../../include/utils/CFileLogger.h"
#include <cstring>
#include <climits>
namespace TDEngine2
{
CSkinnedMesh::CSkinnedMesh() :
CBaseMesh()
{
}
E_RESULT_CODE CSkinnedMesh::Init(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext, const std::string& name)
{
E_RESULT_CODE result = _init(pResourceManager, name);
if (result != RC_OK)
{
return result;
}
if (!pGraphicsContext)
{
return RC_INVALID_ARGS;
}
mpGraphicsObjectManager = pGraphicsContext->GetGraphicsObjectManager();
mState = E_RESOURCE_STATE_TYPE::RST_LOADED;
mIsInitialized = true;
return RC_OK;
}
E_RESULT_CODE CSkinnedMesh::Accept(IBinaryMeshFileReader* pReader)
{
if (!pReader)
{
return RC_INVALID_ARGS;
}
return pReader->LoadSkinnedMesh(this);
}
void CSkinnedMesh::AddVertexJointWeights(const TJointsWeightsArray& weights)
{
std::lock_guard<std::mutex> lock(mMutex);
mJointsWeights.push_back(weights);
}
void CSkinnedMesh::AddVertexJointIndices(const TJointsIndicesArray& indices)
{
std::lock_guard<std::mutex> lock(mMutex);
mJointsIndices.push_back(indices);
}
const std::vector<CSkinnedMesh::TJointsWeightsArray>& CSkinnedMesh::GetJointWeightsArray() const
{
std::lock_guard<std::mutex> lock(mMutex);
return mJointsWeights;
}
const std::vector<CSkinnedMesh::TJointsIndicesArray>& CSkinnedMesh::GetJointIndicesArray() const
{
std::lock_guard<std::mutex> lock(mMutex);
return mJointsIndices;
}
bool CSkinnedMesh::HasJointWeights() const
{
std::lock_guard<std::mutex> lock(mMutex);
return _hasJointWeightsInternal();
}
bool CSkinnedMesh::HasJointIndices() const
{
std::lock_guard<std::mutex> lock(mMutex);
return _hasJointIndicesInternal();
}
E_RESULT_CODE CSkinnedMesh::_initPositionOnlyVertexBuffer()
{
auto&& positions = _toPositionOnlyArray();
auto positionOnlyVertexBufferResult = mpGraphicsObjectManager->CreateVertexBuffer(BUT_STATIC, positions.size(), &positions.front());
if (positionOnlyVertexBufferResult.HasError())
{
return positionOnlyVertexBufferResult.GetError();
}
mpPositionOnlyVertexBuffer = positionOnlyVertexBufferResult.Get();
return RC_OK;
}
// \todo Maybe some refactoring is needed
std::vector<U8> CSkinnedMesh::_toPositionOnlyArray() const
{
U32 strideSize = sizeof(TVector4);
strideSize += (_hasJointWeightsInternal() ? sizeof(TVector4) : 0);
strideSize += (_hasJointIndicesInternal() ? sizeof(U32) * 4 : 0);
std::vector<U8> bytes(mPositions.size() * strideSize);
U32 elementsCount = 0;
for (U32 i = 0, ptrPos = 0; i < mPositions.size(); ++i, ptrPos += strideSize)
{
// mandatory element
memcpy(&bytes[ptrPos], &mPositions[i], sizeof(TVector4));
elementsCount = 1;
if (_hasJointWeightsInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * sizeof(TVector4)], &mJointsWeights[i], sizeof(TVector4)); }
if (_hasJointIndicesInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * 4 * sizeof(U32)], &mJointsIndices[i], 4 * sizeof(U32)); }
}
return bytes;
}
std::vector<U8> CSkinnedMesh::_toArrayOfStructsDataLayoutInternal() const
{
U32 strideSize = sizeof(TVector4) + sizeof(TColor32F);
strideSize += (_hasTexCoords0Internal() ? sizeof(TVector4) : 0); // \note texcoords use float2, but we align them manually to float4
strideSize += (_hasNormalsInternal() ? sizeof(TVector4) : 0);
strideSize += (_hasTangentsInternal() ? sizeof(TVector4) : 0);
strideSize += (_hasJointWeightsInternal() ? sizeof(TVector4) : 0);
strideSize += (_hasJointIndicesInternal() ? sizeof(U32) * 4 : 0);
std::vector<U8> bytes(mPositions.size() * strideSize);
U32 elementsCount = 0;
for (U32 i = 0, ptrPos = 0; i < mPositions.size(); ++i, ptrPos += strideSize)
{
// mandatory element
memcpy(&bytes[ptrPos], &mPositions[i], sizeof(TVector4));
memcpy(&bytes[ptrPos + sizeof(TVector4)], _hasColorsInternal() ? &mVertexColors[i] : &TColorUtils::mWhite, sizeof(TColor32F));
elementsCount = 2; // \note equals to 2 because of position and color are mandatory elements of a vertex declaration
if (_hasTexCoords0Internal()) { memcpy(&bytes[ptrPos + elementsCount++ * sizeof(TVector4)], &mTexcoords0[i], sizeof(TVector2)); }
if (_hasNormalsInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * sizeof(TVector4)], &mNormals[i], sizeof(TVector4)); }
if (_hasTangentsInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * sizeof(TVector4)], &mTangents[i], sizeof(TVector4)); }
if (_hasJointWeightsInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * sizeof(TVector4)], &mJointsWeights[i], sizeof(TVector4)); }
if (_hasJointIndicesInternal()) { memcpy(&bytes[ptrPos + elementsCount++ * 4 * sizeof(U32)], &mJointsIndices[i], 4 * sizeof(U32)); }
}
return bytes;
}
const IResourceLoader* CSkinnedMesh::_getResourceLoader()
{
return mpResourceManager->GetResourceLoader<ISkinnedMesh>();
}
bool CSkinnedMesh::_hasJointWeightsInternal() const
{
return !mJointsWeights.empty();
}
bool CSkinnedMesh::_hasJointIndicesInternal() const
{
return !mJointsIndices.empty();
}
TDE2_API ISkinnedMesh* CreateSkinnedMesh(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext, const std::string& name, E_RESULT_CODE& result)
{
return CREATE_IMPL(ISkinnedMesh, CSkinnedMesh, result, pResourceManager, pGraphicsContext, name);
}
CSkinnedMeshLoader::CSkinnedMeshLoader() :
CBaseObject()
{
}
E_RESULT_CODE CSkinnedMeshLoader::Init(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext, IFileSystem* pFileSystem)
{
if (mIsInitialized)
{
return RC_FAIL;
}
if (!pResourceManager || !pGraphicsContext || !pFileSystem)
{
return RC_INVALID_ARGS;
}
mpResourceManager = pResourceManager;
mpFileSystem = pFileSystem;
mpGraphicsContext = pGraphicsContext;
mIsInitialized = true;
return RC_OK;
}
E_RESULT_CODE CSkinnedMeshLoader::Free()
{
if (!mIsInitialized)
{
return RC_FAIL;
}
mIsInitialized = false;
delete this;
return RC_OK;
}
E_RESULT_CODE CSkinnedMeshLoader::LoadResource(IResource* pResource) const
{
if (!mIsInitialized)
{
return RC_FAIL;
}
E_RESULT_CODE result = RC_OK;
IJobManager* pJobManager = mpFileSystem->GetJobManager();
TResult<TFileEntryId> meshFileId = mpFileSystem->Open<IBinaryMeshFileReader>(pResource->GetName());
if (meshFileId.HasError())
{
LOG_WARNING(std::string("[Mesh Loader] Could not load the specified mesh file (").append(pResource->GetName()).append("), load default one instead..."));
return RC_FAIL;
}
IBinaryMeshFileReader* pMeshFileReader = mpFileSystem->Get<IBinaryMeshFileReader>(meshFileId.Get());
auto loadMeshRoutine = [pJobManager, pMeshFileReader, pResource]
{
E_RESULT_CODE result = RC_OK;
IMesh* pMesh = dynamic_cast<IMesh*>(pResource);
if (RC_OK != (result = pMeshFileReader->LoadMesh(pMesh)))
{
TDE2_ASSERT(false);
return;
}
pJobManager->ExecuteInMainThread([pMesh, pResource]
{
E_RESULT_CODE result = RC_OK;
if (RC_OK != (result = pMesh->PostLoad()))
{
TDE2_ASSERT(false);
return;
}
pResource->SetState(E_RESOURCE_STATE_TYPE::RST_LOADED);
});
};
if (E_RESOURCE_LOADING_POLICY::SYNCED == pResource->GetLoadingPolicy())
{
loadMeshRoutine();
return RC_OK;
}
pJobManager->SubmitJob(std::function<void()>(loadMeshRoutine));
return RC_OK;
}
TypeId CSkinnedMeshLoader::GetResourceTypeId() const
{
return ISkinnedMesh::GetTypeId();
}
TDE2_API IResourceLoader* CreateSkinnedMeshLoader(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext, IFileSystem* pFileSystem, E_RESULT_CODE& result)
{
return CREATE_IMPL(IResourceLoader, CSkinnedMeshLoader, result, pResourceManager, pGraphicsContext, pFileSystem);
}
CSkinnedMeshFactory::CSkinnedMeshFactory() :
CBaseObject()
{
}
E_RESULT_CODE CSkinnedMeshFactory::Init(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext)
{
if (mIsInitialized)
{
return RC_FAIL;
}
if (!pGraphicsContext || !pResourceManager)
{
return RC_INVALID_ARGS;
}
mpResourceManager = pResourceManager;
mpGraphicsContext = pGraphicsContext;
mIsInitialized = true;
return RC_OK;
}
E_RESULT_CODE CSkinnedMeshFactory::Free()
{
if (!mIsInitialized)
{
return RC_FAIL;
}
mIsInitialized = false;
delete this;
return RC_OK;
}
IResource* CSkinnedMeshFactory::Create(const std::string& name, const TBaseResourceParameters& params) const
{
E_RESULT_CODE result = RC_OK;
const TMeshParameters& meshParams = dynamic_cast<const TMeshParameters&>(params);
return dynamic_cast<IResource*>(CreateSkinnedMesh(mpResourceManager, mpGraphicsContext, name, result));
}
IResource* CSkinnedMeshFactory::CreateDefault(const std::string& name, const TBaseResourceParameters& params) const
{
E_RESULT_CODE result = RC_OK;
if (auto pResource = dynamic_cast<IResource*>(CreateSkinnedMesh(mpResourceManager, mpGraphicsContext, name, result)))
{
pResource->SetLoadingPolicy(params.mLoadingPolicy);
return pResource;
}
return nullptr;
}
TypeId CSkinnedMeshFactory::GetResourceTypeId() const
{
return ISkinnedMesh::GetTypeId();
}
TDE2_API IResourceFactory* CreateSkinnedMeshFactory(IResourceManager* pResourceManager, IGraphicsContext* pGraphicsContext, E_RESULT_CODE& result)
{
return CREATE_IMPL(IResourceFactory, CSkinnedMeshFactory, result, pResourceManager, pGraphicsContext);
}
} | 26.909836 | 171 | 0.731039 | bnoazx005 |
6178a3245c808c8736685dbf7e56164553a0244d | 958 | hpp | C++ | cslibs_plugins/include/cslibs_plugins/common/plugin.hpp | doge-of-the-day/cslibs_plugins | 9740883e5f93c5a74ea4a889067b25fb3f5cb6f0 | [
"BSD-3-Clause"
] | null | null | null | cslibs_plugins/include/cslibs_plugins/common/plugin.hpp | doge-of-the-day/cslibs_plugins | 9740883e5f93c5a74ea4a889067b25fb3f5cb6f0 | [
"BSD-3-Clause"
] | null | null | null | cslibs_plugins/include/cslibs_plugins/common/plugin.hpp | doge-of-the-day/cslibs_plugins | 9740883e5f93c5a74ea4a889067b25fb3f5cb6f0 | [
"BSD-3-Clause"
] | null | null | null | #ifndef CSLIBS_PLUGINS_PLUGIN_HPP
#define CSLIBS_PLUGINS_PLUGIN_HPP
#include <string>
namespace cslibs_plugins {
template<typename ChildClass>
class Plugin {
public:
virtual inline ~Plugin() = default;
inline std::string const& getName() const { return name_; }
inline void setName(const std::string& name) { name_ = name; }
inline std::size_t getId() const { return id_; }
template <typename T>
inline bool is() const {
const T *t = dynamic_cast<const T *>(this);
return t != nullptr;
}
template <typename T>
T const& as() const {
return dynamic_cast<const T&>(*this);
}
template <typename T>
T& as() {
return dynamic_cast<T&>(*this);
}
protected:
inline Plugin() : id_{generateId()} {}
inline static std::size_t generateId() {
static std::size_t id{0};
return id++;
}
const std::size_t id_;
std::string name_;
};
} // namespace cslibs_plugins
#endif // CSLIBS_PLUGINS_PLUGIN_HPP
| 19.55102 | 64 | 0.669102 | doge-of-the-day |
617a37ab500a5baadea0bbb403776e74f4e4e667 | 1,503 | cpp | C++ | tests/juliet/testcases/CWE775_Missing_Release_of_File_Descriptor_or_Handle/CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad.cpp | RanerL/analyzer | a401da4680f163201326881802ee535d6cf97f5a | [
"MIT"
] | 28 | 2017-01-20T15:25:54.000Z | 2020-03-17T00:28:31.000Z | testcases/CWE775_Missing_Release_of_File_Descriptor_or_Handle/CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad.cpp | mellowCS/cwe_checker_juliet_suite | ae604f6fd94964251fbe88ef04d5287f6c1ffbe2 | [
"MIT"
] | 1 | 2017-01-20T15:26:27.000Z | 2018-08-20T00:55:37.000Z | testcases/CWE775_Missing_Release_of_File_Descriptor_or_Handle/CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad.cpp | mellowCS/cwe_checker_juliet_suite | ae604f6fd94964251fbe88ef04d5287f6c1ffbe2 | [
"MIT"
] | 2 | 2019-07-15T19:07:04.000Z | 2019-09-07T14:21:04.000Z | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad.cpp
Label Definition File: CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close.label.xml
Template File: source-sinks-84_bad.tmpl.cpp
*/
/*
* @description
* CWE: 775 Missing Release of File Descriptor or Handle After Effective Lifetime
* BadSource: Open a file using open()
* Sinks:
* GoodSink: Close the file using close()
* BadSink : Do not close file
* Flow Variant: 84 Data flow: data passed to class constructor and destructor by declaring the class object on the heap and deleting it after use
*
* */
#ifndef OMITBAD
#include "std_testcase.h"
#include "CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84.h"
namespace CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84
{
CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad::CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad(int dataCopy)
{
data = dataCopy;
/* POTENTIAL FLAW: Open a file without closing it */
data = OPEN("BadSource_open.txt", O_RDWR|O_CREAT, S_IREAD|S_IWRITE);
}
CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad::~CWE775_Missing_Release_of_File_Descriptor_or_Handle__open_no_close_84_bad()
{
/* FLAW: No attempt to close the file */
; /* empty statement needed for some flow variants */
}
}
#endif /* OMITBAD */
| 40.621622 | 163 | 0.792415 | RanerL |
617eaf8db71f349e214b5113944d54f3d39aa607 | 787 | hpp | C++ | day12/part1.hpp | Moremar/advent_of_code_2016 | dea264671fc2c31baa42b1282751dfd1ae071a7d | [
"Apache-2.0"
] | null | null | null | day12/part1.hpp | Moremar/advent_of_code_2016 | dea264671fc2c31baa42b1282751dfd1ae071a7d | [
"Apache-2.0"
] | null | null | null | day12/part1.hpp | Moremar/advent_of_code_2016 | dea264671fc2c31baa42b1282751dfd1ae071a7d | [
"Apache-2.0"
] | null | null | null | #pragma once
#include "Utils.hpp"
struct Instruction {
Instruction(const string &cmd, const string &x, const string &y) : cmd(cmd), x(x), y(y) {}
string cmd, x, y;
};
class Assembunny {
public:
Assembunny(const vector<Instruction> &instructions);
void runInstruction(const Instruction &instruction);
void run();
int getRegister(const string ®isterName) const;
void setRegister(const string ®isterName, int val);
private:
vector<Instruction> myInstructions;
size_t myPos = 0;
vector<int> myRegisters;
// convert register name to ID ("a" -> 0)
static size_t registerId(const string ®isterName);
};
namespace Part1 {
vector<Instruction> parse(const string &fileName);
int solve(vector<Instruction> instructions);
}
| 23.848485 | 94 | 0.695044 | Moremar |
6181158f81eebae0737750b65509ba37db1c570e | 597,696 | cpp | C++ | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__58.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__58.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__58.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | // Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See VTestHarness.h for the primary calling header
#include "VTestHarness.h"
#include "VTestHarness__Syms.h"
#include "verilated_dpi.h"
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3822(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3822\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_602) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_617) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state
= ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__s2_tag_match_way_0))
? ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_833)
? 0xcU : 1U) : 1U);
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_631) {
if ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar_auto_in_0_a_ready)
& ((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_295))
? (~ ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_310)
>> 2U)) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_381_3)))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3_io_mem_acquire_valid))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 2U;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_632) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__refill_done) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__grant_had_data)
? 3U : 0xcU);
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_633) {
if ((1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1138)))) {
if (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_empty)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__commit_line)))) {
if ((1U & (~ ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq__DOT__full))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_enq_valid))))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xeU;
}
} else {
if (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_empty)
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_deq_valid)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1075))))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 4U;
}
}
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_637) {
if ((((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__meta_read_arb__DOT___T_1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__metaReadArb_io_in_3_ready))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3_io_meta_read_valid))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 5U;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1150) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 6U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1151) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs_io_meta_resp_valid)
? (((3U
==
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
| ((2U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& ((1U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& ((0U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& ((7U
==
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
| ((6U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& ((5U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& ((4U
!=
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))
& (0xbU
==
(8U
| (3U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_815
>> 0x14U))))))))))))
? 7U
: 0xbU)
: 4U);
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1223) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_628) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 9U;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1225) {
if ((((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__wb_req_arb__DOT___T_1))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__wbArb_io_in_1_ready))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3_io_wb_req_valid))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xaU;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1227) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__wb_io_resp) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xbU;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1228) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1233) {
if (
(3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__refill_ctr))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xcU;
}
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1237) {
if (
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_empty)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__rpq_io_enq_valid)))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xdU;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_603) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_628) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xeU;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_604) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1389) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0xfU;
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_605) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_644) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_1395) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_618) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state
=
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_470)
? 4U
: 1U);
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_617) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT__state
=
((0U
!= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__s2_tag_match_way_0))
?
((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__mshrs_3__DOT___T_833)
? 0xcU
: 1U)
: 1U);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3823(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3823\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if ((0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__prober__DOT__state))) {
if ((1U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__prober__DOT__state))) {
if ((2U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__prober__DOT__state))) {
if ((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__prober__DOT__state))) {
vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__prober__DOT__way_en
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__s2_tag_match_way_0;
}
}
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__wb_forward_ld_addr_0
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_1812)
? (QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_1821))
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__fired_release_0)
? (QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT___T_1822))
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__mem_paddr_0));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3826(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3826\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3827(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3827\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3828(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3828\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__table___DOT__table_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3829(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3829\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__table___DOT__table_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__table___DOT__table_1_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3830(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3830\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3831(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3831\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3832(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3832\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3833(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3833\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3834(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3834\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_0__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_1__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3835(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3835\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_2__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__hi_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3836(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3836\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_3__DOT__lo_us__DOT__hi_us_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_4__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__hi_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3837(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3837\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_1__DOT__tables_5__DOT__lo_us__DOT__hi_us_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3842(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3842\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3843(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3843\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__data__DOT__data_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_0__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_1__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3844(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3844\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_2__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__data_arrays_3__DOT__data_arrays_0_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3845(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3845\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_6__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_4__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3846(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3846\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_7__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_2__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_5__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_0__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_1__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3847(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3847\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB1Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__dataArrayB0Way_3__DOT__dataArrayB0Way_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_0_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_1_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_2_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_3_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3848(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3848\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_4_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_5_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_6_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__data__DOT__array_7_0__DOT__array_0_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3853(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3853\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_4__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_4__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_4__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_4__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_5__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_5__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_5__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_5__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_6__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_6__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_6__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_6__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_7__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_7__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_7__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__meta_0__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_7__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3854(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3854\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3855(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3855\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_0__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__btb_1__DOT__btb_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3857(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3857\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_427__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_427[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_427__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_427__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3858(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3858\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_28__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_29__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_30__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_31__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3861(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3861\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3862(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3862\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_19__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_20__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_21__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_22__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_23__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3863(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3863\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_24__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_25__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_26__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_27__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_2_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3864(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3864\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__ebtb__DOT__ebtb_ext__DOT__mem_0_0__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3870(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3870\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_10__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_11__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3871(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3871\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_12__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_13__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_14__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_15__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_16__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_17__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_18__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3883(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3883\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3884(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3884\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_0__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_4__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_5__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_6__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_7__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3885(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3885\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_8__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__data__DOT__data_arrays_1__DOT__data_arrays_0_ext__DOT__mem_0_9__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3887(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3887\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_target__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_target[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_target__v0] = VL_ULL(0);
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_repair_update__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_repair_update[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_repair_update__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_mispredicted__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_mispredicted[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_mispredicted__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_mispredict_update__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_mispredict_update[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_is_mispredict_update__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_taken__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_taken[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_taken__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_jal__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_jal[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_jal__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_br__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_br[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_is_br__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_1__v0[3U];
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_meta_0__v0[3U];
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3888(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3888\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_br_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_br_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_br_mask__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_btb_mispredicts__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_btb_mispredicts[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_btb_mispredicts__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_btb_mispredicts__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_valid__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_valid[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_valid__v0] = 0U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3889(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3889\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_bits__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_bits[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_cfi_idx_bits__v0] = 0U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3893(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3893\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_4__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_4__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_4__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_4__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_5__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_5__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_5__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_5__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_6__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_6__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_6__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_6__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_7__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_7__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_7__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__icache__DOT__tag_array__DOT__tag_array_0_ext__DOT__mem_0_7__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3897(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3897\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode__v0] = 6U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3898(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3898\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask__v0] = 0xffffU;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3902(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3902\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3903(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3903\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_extra_id__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3904(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3904\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_extra_id__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3905(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3905\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_extra_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_1_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_param[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_param__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3906(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3906\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__Queue_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__Queue_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__Queue_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__Queue_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_extra_id__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3907(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3907\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_extra_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_extra_id[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_extra_id__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_extra_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_opcode[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_mask[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_mask__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3908(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3908\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__uart_sim_0__DOT__rxfifo__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__uart_sim_0__DOT__rxfifo__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__uart_sim_0__DOT__rxfifo__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__uart_sim_0__DOT__rxfifo__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_mask[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_mask__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3909(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3909\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3910(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3910\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_param__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3911(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3911\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_mask__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_mask__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3912(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3912\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__deq_ptr_value = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__do_deq) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__deq_ptr_value
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT___T_7;
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_address[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_address__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3924(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3924\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_523
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_526))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_525));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_571
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_574))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_573));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_625
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT__a_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_627));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3925(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3925\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_643 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_643
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT__d_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__TLMonitor_1__DOT___T_645));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_corrupt__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_opcode__v0] = 6U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_mask__v0] = 0xffffU;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3926(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3926\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_size__v0] = 6U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_mask__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_mask__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3927(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3927\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_720 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_712) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_720
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_723)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor_io_in_d_bits_opcode))
? (~ (0xffffffU &
(((IData)(0xfffU)
<< vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_size
[0U]) >> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_722)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_672 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_663) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_672
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_675)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0xffffffU
& (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_674)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_774 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_663) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_774
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0xffffffU
& (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__TLMonitor__DOT___T_776)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3928(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3928\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT___T_1 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT__do_deq) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT___T_1
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue__DOT___T_11;
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3933(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3933\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3934(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3934\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_corrupt[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_size__v0] = 6U;
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_663 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_663
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_666)
? ((0x200000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_772[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_772[3U]
>> 0xdU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_665)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_765 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_765
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT__a_first)
? ((0x200000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_772[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_772[3U]
>> 0xdU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_767)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_711 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_703) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_711
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_714)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__TLMonitor__DOT___T_713)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3935(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3935\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_taken__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_taken[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_taken__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_taken__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_not_taken__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_not_taken[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_not_taken__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_new_saw_branch_not_taken__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_old_history__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_old_history[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_old_history__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ram_ghist_old_history__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3936(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3936\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_address[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_address__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_address__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3937(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3937\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_id__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_id[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_id__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3938(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3938\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3940(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3940\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_address[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3941(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3941\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_523
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_526))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_525));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_571
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_574))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_573));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3942(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3942\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_625
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT__a_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_627));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_643 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_643
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT__d_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__buffer__DOT__TLMonitor__DOT___T_645));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_523
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_526))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_525));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_571
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_574))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_573));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_625
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT__a_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_627));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_643 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_643
= ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT__d_first))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__TLMonitor__DOT___T_645));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_address[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__ram_address__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3943(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3943\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_1__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_1[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_1__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__data_prio_1__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__tail__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__tail[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__tail__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__tail__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3944(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3944\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3945(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3945\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[0U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[1U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[2U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__divisor[2U];
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3946(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3946\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue_1__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue_1__DOT__ram_mask[0U] = 3U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3949(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3949\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_strb__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_strb[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_strb__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_data[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__ram_data__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3950(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3950\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_len__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_len[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_len__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_echo_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_addr__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_addr[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_addr__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_wen__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_wen[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue_1__DOT__ram_wen__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[3U];
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_address[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3951(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3951\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3952(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3952\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_mask[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_mask__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_mask__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3953(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3953\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[3U];
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_4__DOT__ram_sink__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3954(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3954\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_corrupt__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_size__v0;
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[0U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[1U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[2U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[3U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[3U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[4U]
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__div__DOT__remainder[4U];
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3955(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3955\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_883__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_883[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_883__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_883__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_1__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3956(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3956\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_2__DOT__meta_0__DOT__meta_0_ext__DOT__mem_0_3__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3957(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3957\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3958(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3958\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue_1__DOT__ram_set__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue_1__DOT__ram_set[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue_1__DOT__ram_set__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3959(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3959\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3960(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3960\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3961(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3961\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3962(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3962\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_711 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_703) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_711
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_714)
? ((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__Repeater_io_deq_bits_opcode))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor_io_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_713)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3963(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3963\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_663 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_663
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_666)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_665)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_765 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_765
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__TLMonitor__DOT___T_767)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_711 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_703) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_711
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_714)
? ((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__Repeater_io_deq_bits_opcode))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_713)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_663 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_663
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_666)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_665)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3964(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3964\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_765 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_765
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__fixer__DOT__TLMonitor__DOT___T_767)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_711 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_703) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_711
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_714)
? ((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__Repeater_io_deq_bits_opcode))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_713)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_663 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_663
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_666)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_665)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_765 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_654) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_765
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__out_xbar__DOT__TLMonitor__DOT___T_767)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3966(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3966\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ram_data__v0[3U];
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3967(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3967\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_1__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_1__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_1__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_1__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_2__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_2__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_2__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_2__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_3__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_3__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_3__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_3__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_4__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_4__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_4__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_4__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_5__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_5__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_5__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_5__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_6__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_6__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_6__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_6__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_7__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_7__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_7__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__cc_dir__DOT__cc_dir_ext__DOT__mem_0_7__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3968(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3968\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_717 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_709) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_717
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_720)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor_io_in_d_bits_opcode))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_719)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_669 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_660) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_669
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_672)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_671)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_771 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_660) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_771
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__TLMonitor__DOT___T_773)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_717 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_709) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_717
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_720)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics_auto_in_d_bits_opcode))
? (~ (0x3ffU & (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_719)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3969(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3969\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_669 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_660) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_669
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_672)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_671)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_771 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_660) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_771
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_773)));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3973(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3973\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_29__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_30__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_31__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_20__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_21__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_22__DOT__ram_tl_state_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3974(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3974\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_23__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_24__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_25__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_26__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_27__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_28__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3975(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3975\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3979(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3979\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3980(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3980\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v0[2U];
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__fpuOpt__DOT__regfile__v1[2U];
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3981(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3981\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT__lb__v0[3U];
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3982(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3982\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1193));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1054 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_943) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1054
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT__a_first)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1056));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1000 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1_io_in_d_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1000
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1003)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1002)));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__Queue__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__Queue__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__Queue__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__Queue__DOT__ram__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3984(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3984\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data[0U][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data[0U][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data[0U][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data[0U][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_data__v0[3U];
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3985(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3985\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_corrupt[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_param[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_opcode[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue_1__DOT__ram_opcode__v0;
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_1134));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3986(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3986\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_941 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_933) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_941
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_944)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0xffffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_943)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_893 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_893
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_896)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_895)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_995 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_995
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT__a_first)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__subsystem_fbus_xbar__DOT__TLMonitor__DOT___T_997)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_1134));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_941 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_933) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_941
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_944)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0xffffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_943)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3987(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3987\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_893 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_893
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_896)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_895)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_995 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_995
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT__a_first)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__buffer__DOT__TLMonitor__DOT___T_997)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_1134));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_941 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_933) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_941
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_944)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0xffffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_943)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_893 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_893
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_896)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_895)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3988(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3988\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_995 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_995
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT__a_first)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serialadapter__DOT__fixer__DOT__TLMonitor__DOT___T_997)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_1134));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_941 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_933) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_941
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_944)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0xffffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 3U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_943)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_893 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_893
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_896)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_895)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_995 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_884) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_995
= (0x1ffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT__a_first)
? (((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m__DOT__state))
? 0U : 4U) ? 0U :
(~ (0xffffffU & (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__m_auto_out_a_bits_size))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__TLMonitor__DOT___T_997)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3989(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3989\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_sink__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_opcode__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3990(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3990\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_address[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_address__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__l2_tlb_ram__DOT__l2_tlb_ram_ext__DOT__mem_0_0__DOT__ram__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__l2_tlb_ram__DOT__l2_tlb_ram_ext__DOT__mem_0_0__DOT__ram[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__l2_tlb_ram__DOT__l2_tlb_ram_ext__DOT__mem_0_0__DOT__ram__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw__DOT__l2_tlb_ram__DOT__l2_tlb_ram_ext__DOT__mem_0_0__DOT__ram__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_mask__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_mask[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_mask__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[0U] = 0U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3991(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3991\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_param[0U] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_sink[0U] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_denied[0U] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_data[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_index__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_index[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_index__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_index__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_index[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_index__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_extra_tlrr_extra_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_extra_tlrr_extra_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_extra_tlrr_extra_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_extra_tlrr_extra_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_extra_tlrr_extra_size[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_extra_tlrr_extra_size__v0;
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1837 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1828) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1837
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1840)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1839));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1885 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1877) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1885
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1888)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_c_bits_opcode))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_c_bits_size))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1887)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3992(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3992\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1735 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1726) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1735
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1738)
? ((0x10000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT___T_245[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT___T_245[5U]
>> 0x13U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1737)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1934 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1726) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1934
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT__a_first)
? ((0x10000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT___T_245[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT___T_245[5U]
>> 0x13U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1936)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1783 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1775) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1783
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1786)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1785)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_2104 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_1775) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_2104
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_2107)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__TLMonitor__DOT___T_2106)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3993(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3993\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_sink__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_opcode__v0] = 6U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_corrupt__v0] = 0U;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3994(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3994\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_param__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_denied__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_data__v0] = VL_ULL(0);
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_sink__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_opcode__v0] = 4U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_corrupt__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_param__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_denied__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_data__v0] = VL_ULL(0);
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue_1__DOT__ram_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3995(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3995\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_source__v0;
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1786 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1777) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1786
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1789)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1788));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1834 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1826) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1834
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1837)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_c_bits_opcode))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_c_bits_size))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1836)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1684 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1675) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1684
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1687)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_a_bits_opcode))
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_a_bits_size))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1686)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3996(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3996\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1883 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1675) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1883
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT__a_first)
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_a_bits_opcode))
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache_auto_out_a_bits_size))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1885)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT___T_1 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT__do_deq) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT___T_1
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_2__DOT___T_11;
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1732 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1724) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1732
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1735)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1734)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2053 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1724) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2053
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2056)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2055)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3997(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3997\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_3__DOT__ram_data__v0[3U];
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1870 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1861) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1870
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1873)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1872));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1918 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1910) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1918
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1921)
? ((0x800U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_1011[5U])
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (0xfU &
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_1011[5U]
>> 4U)))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1920)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3998(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3998\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1768 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1759) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1768
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1771)
? ((0x20000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_447[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_447[5U]
>> 0x14U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1770)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1967 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1759) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1967
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT__a_first)
? ((0x20000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_447[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT__mshrs__DOT___T_447[5U]
>> 0x14U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1969)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1816 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1808) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1816
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1819)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1818)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2137 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1808) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2137
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2140)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_2139)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__3999(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__3999\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__tail__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__tail[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__tail__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__tail__v0;
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1921 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1912) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1921
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1924)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1923));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4000(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4000\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1969 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1961) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1969
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1972)
? ((0x800U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_1011[5U])
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (0xfU &
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__dcache__DOT___T_1011[5U]
>> 4U)))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1971)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1819 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1810) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1819
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1822)
? ((0x40000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT___T_245[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT___T_245[5U]
>> 0x15U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1821)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2018 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1810) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2018
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT__a_first)
? ((0x40000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT___T_245[5U])
? 0U : (~ (0x7fffffU
& (((IData)(0xfffU)
<<
(0xfU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT___T_245[5U]
>> 0x15U)))
>> 4U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2020)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT___T_1 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT__do_deq) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT___T_1
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_2__DOT___T_11;
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1867 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1859) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1867
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1870)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1869)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4001(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4001\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2188 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_1859) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2188
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2191)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2190)));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0] = VL_ULL(0);
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0] = 0U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0] = 1U;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_sink__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_denied__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4002(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4002\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_source[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_source__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_size__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_opcode[0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__error__DOT__a__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__Queue_1__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_opcode__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_opcode[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_opcode__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_opcode__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_source__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_source[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_source__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_source__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4004(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4004\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_mstatus_mpp
= vlTOPp->__Vdly__TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_mstatus_mpp;
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ram_data__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4005(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4005\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_sink__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0;
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_525)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4006(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4006\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_627)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor_io_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__TLMonitor__DOT___T_573)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_525)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_627)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4007(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4007\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__subsystem_mbus_xbar__DOT__TLMonitor__DOT___T_573)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_525)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_627)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__fixer__DOT__TLMonitor__DOT___T_573)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4008(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4008\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_525)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_627)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__picker__DOT__TLMonitor__DOT___T_573)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_525)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4009(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4009\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_627)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__widget__DOT__TLMonitor__DOT___T_573)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_525)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_627)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4010(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4010\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__binder__DOT__TLMonitor__DOT___T_573)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_523 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_523
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_526)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_525)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_625 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_514) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_625
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT__a_first)
? ((0x400000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U])
? 0U : (~ (0x3ffU & (
((IData)(0x3fU)
<<
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_274[3U]
>> 0xeU)))
>> 3U))))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_627)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_571 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_563) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_571
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_574)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66)
? 1U : 0U) ? (~ (0x3ffU
& (((IData)(0x3fU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4_auto_in_d_bits_size))
>> 3U)))
: 0U) : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__coupler_to_bus_named_subsystem_mbus__DOT__widget__DOT__TLMonitor__DOT___T_573)));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4011(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4011\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT__inflight
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1193));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1054 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_943) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1054
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT__a_first)
? 0U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1056));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1000 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1_io_in_d_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1000
= (0xffU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1003)
? ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (~ (0x7fffffU &
(((IData)(0xfffU)
<< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_size___05FT_15_data))
>> 4U))) : 0U)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor_1__DOT___T_1002)));
}
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_size__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_size[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_size__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ram_size__v0;
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__4013(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__4013\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][0U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[0U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][1U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[1U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][2U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[2U];
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0][3U]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_data__v0[3U];
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_corrupt__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_denied__v0;
}
if (vlTOPp->__Vdlyvset__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_param[vlTOPp->__Vdlyvdim0__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0]
= vlTOPp->__Vdlyvval__TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ram_param__v0;
}
}
| 124.884246 | 424 | 0.850288 | vargandhi |
6181ad64d328a77782d498d74c74e624ae7f26d9 | 12,409 | cpp | C++ | folly/logging/test/CustomLogFormatterTest.cpp | lrita/folly | a315c6b038935397cddc96653e873a8985b263f6 | [
"Apache-2.0"
] | 1 | 2022-03-09T21:40:42.000Z | 2022-03-09T21:40:42.000Z | folly/logging/test/CustomLogFormatterTest.cpp | lrita/folly | a315c6b038935397cddc96653e873a8985b263f6 | [
"Apache-2.0"
] | 1 | 2022-03-28T16:56:01.000Z | 2022-03-28T16:57:07.000Z | folly/logging/test/CustomLogFormatterTest.cpp | lrita/folly | a315c6b038935397cddc96653e873a8985b263f6 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <folly/logging/CustomLogFormatter.h>
#include <cstdlib>
#include <folly/Format.h>
#include <folly/init/Init.h>
#include <folly/logging/LogMessage.h>
#include <folly/logging/Logger.h>
#include <folly/logging/LoggerDB.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Stdlib.h>
FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations")
using namespace folly;
namespace {
const std::string kGlogFormatString =
"{L}{m:02d}{D:02d} {H:2d}:{M:02d}:{S:02d}.{USECS:06d} "
"{THREAD:5d} {FILE}:{LINE}]";
const std::string kGlogFormatStringWithFunctionName =
"{L}{m:02d}{D:02d} {H:2d}:{M:02d}:{S:02d}.{USECS:06d} "
"{THREAD:5d} {FILE}:{LINE} {FUN}()]";
/**
* Helper function to format a LogMessage using the CustomLogFormatter.
*
* formatMsg() accepts the timestamp as a plain integer simply to reduce the
* verbosity of the test code.
*
* Note that in this test's main() function we set the timezone to "UTC"
* so that the logged time values will be consistent regardless of the actual
* local time on this host.
*/
std::string formatMsg(
StringPiece formatString,
LogLevel level,
StringPiece msg,
StringPiece filename,
StringPiece functionName,
unsigned int lineNumber,
bool colored = false,
// Default timestamp: 2017-04-17 13:45:56.123456 UTC
uint64_t timestampNS = 1492436756123456789ULL) {
LoggerDB db{LoggerDB::TESTING};
auto* category = db.getCategory("test");
CustomLogFormatter formatter{formatString, colored};
std::chrono::system_clock::time_point logTimePoint{
std::chrono::duration_cast<std::chrono::system_clock::duration>(
std::chrono::nanoseconds{timestampNS})};
LogMessage logMessage{
category,
level,
logTimePoint,
filename,
lineNumber,
functionName,
msg.str()};
return formatter.formatMessage(logMessage, category);
}
} // namespace
TEST(CustomLogFormatter, log) {
auto tid = getOSThreadID();
// Test a very simple single-line log message
auto expected = folly::sformat(
"W0417 13:45:56.123456 {:5d} myfile.cpp:1234] hello world\n", tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::WARN,
"hello world",
"myfile.cpp",
"testFunction",
1234));
}
TEST(CustomLogFormatter, filename) {
auto tid = getOSThreadID();
// Make sure only the file basename gets logged
auto expected = folly::sformat(
"W0417 13:45:56.123456 {:5d} myfile.cpp:1234] hello world\n", tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::WARN,
"hello world",
"src/test/logging/code/myfile.cpp",
"testFunction",
1234));
// Log a message with a very long file name.
expected = folly::sformat(
"W0417 13:45:56.123456 {:5d} "
"this_is_a_really_long_file_name_that_will_probably_exceed_"
"our_buffer_allocation_guess.cpp:123456789] oh noes\n",
tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::WARN,
"oh noes",
"this_is_a_really_long_file_name_that_will_probably_exceed_"
"our_buffer_allocation_guess.cpp",
"testFunction",
123456789));
}
TEST(CustomLogFormatter, functionName) {
auto tid = getOSThreadID();
// Make sure the function name gets logged
auto expected = folly::sformat(
"W0417 13:45:56.123456 {:5d} myfile.cpp:1234 testFunction()] "
"hello world\n",
tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatStringWithFunctionName,
LogLevel::WARN,
"hello world",
"src/test/logging/code/myfile.cpp",
"testFunction",
1234));
}
TEST(CustomLogFormatter, multiline) {
auto tid = getOSThreadID();
std::map<std::string, std::string> formatMap{
{"tid", folly::to<std::string>(tid)}};
// Log a multi-line message
auto expected = folly::svformat(
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] Eeek, a mouse!\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] . .\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] ( ).( )\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] (o o) .-._.'\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] ( - )\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] mm mm\n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] \n"
"V0417 13:45:56.123456 {tid:>5s} rodent.cpp:777] =============\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::DBG9,
"Eeek, a mouse!\n"
" . .\n"
" ( ).( )\n"
" (o o) .-._.'\n"
" ( - )\n"
" mm mm\n"
"\n"
"=============",
"src/rodent.cpp",
"testFunction",
777));
}
TEST(CustomLogFormatter, singleNewline) {
auto tid = getOSThreadID();
std::map<std::string, std::string> formatMap{
{"tid", folly::to<std::string>(tid)}};
// Logging a single newline is basically two empty strings.
auto expected = folly::svformat(
"V0417 13:45:56.123456 {tid:>5s} foo.txt:123] \n"
"V0417 13:45:56.123456 {tid:>5s} foo.txt:123] \n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::DBG9,
"\n",
"foo.txt",
"testFunction",
123));
}
TEST(CustomLogFormatter, coloring) {
auto tid = getOSThreadID();
std::map<std::string, std::string> formatMap{
{"tid", folly::to<std::string>(tid)}};
{ // Logging a DBG9 message should log in grey color (\033[1;30m) and should
// call reset color at the end of the message (\033[0m)
auto expected = folly::svformat(
"\033[1;30mV0417 13:45:56.123456 {tid:>5s} foo.txt:123] DBG9\033[0m\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::DBG9,
"DBG9",
"foo.txt",
"testFunction",
123,
true));
}
{ // Logging an INFO message when coloring enabled is displayed as regular
// message. i.e. no color or reset sequence
auto expected = folly::svformat(
"I0417 13:45:56.123456 {tid:>5s} foo.txt:123] INFO\n", formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::INFO,
"INFO",
"foo.txt",
"testFunction",
123,
true));
}
{ // Logging a WARN message should log in yellow color (\033[33m) and should
// call reset color at the end of the message (\033[0m)
auto expected = folly::svformat(
"\033[33mW0417 13:45:56.123456 {tid:>5s} foo.txt:123] WARN\033[0m\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::WARN,
"WARN",
"foo.txt",
"testFunction",
123,
true));
}
{ // Logging a ERR message should log in red color (\033[31m) and should
// call reset color at the end of the message (\033[0m)
auto expected = folly::svformat(
"\033[31mE0417 13:45:56.123456 {tid:>5s} foo.txt:123] ERR\033[0m\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::ERR,
"ERR",
"foo.txt",
"testFunction",
123,
true));
}
{ // Logging a CRITICAL message should log bold in red background (\033[1;41m)
// and should call reset color at the end of the message (\033[0m)
auto expected = folly::svformat(
"\033[1;41mC0417 13:45:56.123456 {tid:>5s} foo.txt:123] "
"CRITICAL\033[0m\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::CRITICAL,
"CRITICAL",
"foo.txt",
"testFunction",
123,
true));
}
{ // Logging a FATAL message should log bold in red background (\033[1;41m)
// and should call reset color at the end of the message (\033[0m)
auto expected = folly::svformat(
"\033[1;41mF0417 13:45:56.123456 {tid:>5s} foo.txt:123] "
"FATAL\033[0m\n",
formatMap);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::FATAL,
"FATAL",
"foo.txt",
"testFunction",
123,
true));
}
}
TEST(CustomLogFormatter, unprintableChars) {
auto tid = getOSThreadID();
// Unprintable characters should be backslash escaped, as should backslashes.
auto expected = folly::sformat(
"E0417 13:45:56.123456 {:5d} escapes.cpp:97] foo\\x07bar\\x1btest\n",
tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::ERR,
"foo\abar\x1btest",
"escapes.cpp",
"testFunction",
97));
expected = folly::sformat(
"I0417 13:45:56.123456 {:5d} escapes.cpp:98] foo\\\\bar\"test\n", tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::INFO,
"foo\\bar\"test",
"escapes.cpp",
"testFunction",
98));
expected = folly::sformat(
"C0417 13:45:56.123456 {:5d} escapes.cpp:99] nul\\x00byte\n", tid);
EXPECT_EQ(
expected,
formatMsg(
kGlogFormatString,
LogLevel::CRITICAL,
std::string("nul\0byte", 8),
"escapes.cpp",
"testFunction",
99));
}
TEST(CustomLogFormatter, invalidFormatStrings) {
EXPECT_THROW(CustomLogFormatter("{", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{}", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{0}", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{WRONG}", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{L} {FORMAT}", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{L}{m:1} {KEY}", false), std::runtime_error);
EXPECT_THROW(CustomLogFormatter("{L", false), std::runtime_error);
}
TEST(CustomLogFormatter, validFormatStringsEdgeCases) {
EXPECT_EQ("msg\n", formatMsg("", LogLevel::INFO, "msg", "file", "fun", 99));
EXPECT_EQ(
"I msg\n", formatMsg("{L}", LogLevel::INFO, "msg", "file", "fun", 99));
EXPECT_EQ(
"{L} msg\n",
formatMsg("{{L}}", LogLevel::INFO, "msg", "file", "fun", 99));
EXPECT_EQ(
"E:099 msg\n",
formatMsg("{L}:{LINE:03}", LogLevel::ERR, "msg", "file", "fun", 99));
EXPECT_EQ(
"{L}:099 msg\n",
formatMsg("{{L}}:{LINE:03}", LogLevel::ERR, "msg", "file", "fun", 99));
EXPECT_EQ(
"E:099{ msg\n",
formatMsg("{L}:{LINE:03}{{", LogLevel::ERR, "msg", "file", "fun", 99));
EXPECT_EQ(
"E:099} msg\n",
formatMsg("{L}:{LINE:03}}}", LogLevel::ERR, "msg", "file", "fun", 99));
EXPECT_EQ(
"{E} msg\n",
formatMsg("{{{L}}}", LogLevel::ERR, "msg", "file", "fun", 99));
}
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
folly::init(&argc, &argv);
// Some of our tests check timestamps emitted by the formatter.
// Set the timezone to a consistent value so that the tests are not
// affected by the local time of the user running the test.
//
// UTC is the only timezone that we can really rely on to work consistently.
// This will work even in the absence of a proper tzdata installation on the
// local system.
setenv("TZ", "UTC", 1);
return RUN_ALL_TESTS();
}
| 30.945137 | 80 | 0.594891 | lrita |
6181e989fe93bc2f28d8907e2c2b6369be9bd411 | 1,889 | cpp | C++ | src/load_msh.cpp | teseoch/MshIO | ed485c1552c17f5a468acc94215c8a8e6d5f0d38 | [
"Apache-2.0"
] | null | null | null | src/load_msh.cpp | teseoch/MshIO | ed485c1552c17f5a468acc94215c8a8e6d5f0d38 | [
"Apache-2.0"
] | null | null | null | src/load_msh.cpp | teseoch/MshIO | ed485c1552c17f5a468acc94215c8a8e6d5f0d38 | [
"Apache-2.0"
] | null | null | null | #include <MshIO/MshSpec.h>
#include "load_msh_curves.h"
#include "load_msh_data.h"
#include "load_msh_elements.h"
#include "load_msh_format.h"
#include "load_msh_nanospline_format.h"
#include "load_msh_nodes.h"
#include "load_msh_patches.h"
#include "load_msh_post_process.h"
#include <cassert>
#include <fstream>
#include <iostream>
#include <string>
namespace mshio {
void forward_to(std::istream& in, const std::string& flag)
{
std::string buf;
while (!in.eof() && buf != flag) {
in >> buf;
}
}
MshSpec load_msh(std::istream& in)
{
MshSpec spec;
std::string buf, end_str;
while (!in.eof()) {
buf.clear();
in >> buf;
if (buf.size() == 0 || buf[0] != '$') continue;
end_str = "$End" + buf.substr(1);
if (buf == "$MeshFormat") {
load_mesh_format(in, spec);
} else if (buf == "$Nodes") {
load_nodes(in, spec);
} else if (buf == "$Elements") {
load_elements(in, spec);
} else if (buf == "$NodeData") {
load_node_data(in, spec);
} else if (buf == "$ElementData") {
load_element_data(in, spec);
} else if (buf == "$ElementNodeData") {
load_element_node_data(in, spec);
} else if (buf == "$NanoSplineFormat") {
load_nanospline_format(in, spec);
} else if (buf == "$Curves") {
load_curves(in, spec);
} else if (buf == "$Patches") {
load_patches(in, spec);
} else {
std::cerr << "Warning: skipping section \"" << buf << "\"" << std::endl;
}
forward_to(in, end_str);
}
load_msh_post_process(spec);
return spec;
}
MshSpec load_msh(const std::string& filename)
{
std::ifstream fin(filename.c_str(), std::ios::binary);
assert(fin.is_open());
return load_msh(fin);
}
} // namespace mshio
| 25.876712 | 84 | 0.56379 | teseoch |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.