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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7e63c8f5b6f87a61e6895cabbfb49dbf1c0053e8 | 1,605 | cpp | C++ | Libraries/RobsJuceModules/rosic/modulators/rosic_DecayEnvelope.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 34 | 2017-04-19T18:26:02.000Z | 2022-02-15T17:47:26.000Z | Libraries/RobsJuceModules/rosic/modulators/rosic_DecayEnvelope.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 307 | 2017-05-04T21:45:01.000Z | 2022-02-03T00:59:01.000Z | Libraries/RobsJuceModules/rosic/modulators/rosic_DecayEnvelope.cpp | RobinSchmidt/RS-MET-Preliminary | 6c01cbaad7cce3daa3293c444dd9e4b74e5ebfbe | [
"FTL"
] | 4 | 2017-09-05T17:04:31.000Z | 2021-12-15T21:24:28.000Z | //#include "rosic_DecayEnvelope.h"
//using namespace rosic;
//-------------------------------------------------------------------------------------------------
// construction/destruction:
DecayEnvelope::DecayEnvelope()
{
c = 1.0;
y = 1.0;
yInit = 1.0;
tau = 200.0;
fs = 44100.0;
normalizeSum = false;
calculateCoefficient();
}
DecayEnvelope::~DecayEnvelope()
{
}
//-------------------------------------------------------------------------------------------------
// parameter settings:
void DecayEnvelope::setSampleRate(double newSampleRate)
{
if( newSampleRate > 0.0 )
{
fs = newSampleRate;
calculateCoefficient();
}
}
void DecayEnvelope::setDecayTimeConstant(double newTimeConstant)
{
if( newTimeConstant > 0.001 ) // at least 0.001 ms decay
{
tau = newTimeConstant;
calculateCoefficient();
}
}
void DecayEnvelope::setNormalizeSum(bool shouldNormalizeSum)
{
normalizeSum = shouldNormalizeSum;
calculateCoefficient();
}
//-------------------------------------------------------------------------------------------------
// others:
void DecayEnvelope::trigger()
{
y = yInit;
}
bool DecayEnvelope::endIsReached(double threshold)
{
if( y < threshold )
return true;
else
return false;
}
//-------------------------------------------------------------------------------------------------
// internal functions:
void DecayEnvelope::calculateCoefficient()
{
c = exp( -1.0 / (0.001*tau*fs) );
if( normalizeSum == true )
yInit = (1.0-c)/c;
else
yInit = 1.0/c;
}
| 20.576923 | 99 | 0.478505 | RobinSchmidt |
7e6595418fc17ae2f1b95b61f9e2afe099948280 | 5,683 | cpp | C++ | src/dialogs/options_dialog.cpp | johannphilippe/Tracker4 | e2eb6700bb8827dc8181aba889a78760f21a98f8 | [
"MIT"
] | null | null | null | src/dialogs/options_dialog.cpp | johannphilippe/Tracker4 | e2eb6700bb8827dc8181aba889a78760f21a98f8 | [
"MIT"
] | 1 | 2021-12-28T10:47:47.000Z | 2021-12-28T18:54:46.000Z | src/dialogs/options_dialog.cpp | johannphilippe/Tracker4 | e2eb6700bb8827dc8181aba889a78760f21a98f8 | [
"MIT"
] | null | null | null | #include<dialogs/options_dialog.h>
auto option_item::make_view()
{
auto tog_enable = plain_toggle_icon_button( icons::cancel, icons::ok, 1.0);
tog_enable.value(enabled);
tog_enable.on_click = [&](bool b)
{
enabled = b;
};
auto tb = input_box("Write a Csound option");
tb.second->set_text(option);
tb.second->on_text = [&](std::string_view v)
{
option = v;
};
return htile(
(tb.first),
(tog_enable)
);
}
option_item::option_item(std::string name, bool enable) :
options_dialog_click_callback(),
audio_cs_option(name, enable),
array_composite<2, htile_element>(make_view())
{}
void cs_option_list::add_item(std::string s, bool enabled)
{
auto item = std::make_shared<option_item>(s, enabled);
auto full_item = share(basic_menu_item( right_margin(15, hold(item) )));
full_item->on_click = [&, item](){
for(size_t i = 0; i < items.size(); i++)
{
if(item.get() == items[i].get())
{
_selected = i;
break;
}
}
};
items.push_back(item);
this->push_back(full_item);
}
void cs_option_list::add_item() {add_item("", true);}
void cs_option_list::remove_selected()
{
if(_selected == -1) return;
items.erase(items.begin() + _selected);
erase(begin() + _selected);
_selected = -1;
}
void cs_option_list::pop()
{
if(size() == 0) return;
if(_selected != -1 && _selected == static_cast<int>(items.size()) - 1)
_selected = -1;
items.pop_back();
vtile_composite::pop_back();
}
auto audio_options_view::make_view()
{
auto plus_but = plain_icon_button(icons::plus, 1.0);
auto minus_but = plain_icon_button(icons::minus, 1.0);
auto rem_but = plain_icon_button(icons::cancel, 1.0);
plus_but.on_click = [&](bool)
{
options_list.add_item();
jtracker::get_app()->_view.layout();
jtracker::get_app()->_view.refresh();
};
minus_but.on_click = [&](bool)
{
if(options_list.size() == 0) return;
options_list.pop();
jtracker::get_app()->_view.layout();
jtracker::get_app()->_view.refresh();
};
rem_but.on_click = [&](bool)
{
if(options_list.size() == 0 ) return;
options_list.remove_selected();
jtracker::get_app()->_view.layout();
jtracker::get_app()->_view.refresh();
};
return (margin({15, 10, 15, 10}, vtile(
simple_heading(link(sample_rate_spin), "Sample rate"),
vspacer(5),
simple_heading(link(ksmps_spin), "Ksmps - audio vector size"),
vspacer(5),
simple_heading(link(dbfs_spin), "0dbfs"),
vspacer(5),
htile(
simple_heading(link(inchnls_spin), "Input channels"),
vspacer(5),
simple_heading(link(nchnls_spin), "Output channels")
),
vspacer(5),
simple_heading(
vtile(
align_center(
htile(
align_left(rem_but),
align_middle(minus_but),
align_right(plus_but)
)),
layer(
limit({{60, 150},{full_extent, full_extent}}, vscroller(
link(options_list)
)),
rbox(jtracker::theme.app_background_color.level(0.65), 6)
)
), "Csound options")
))) ;
}
options_dialog* options_dialog::instance = nullptr;
options_dialog* options_dialog::get_instance()
{
if(instance != nullptr)
delete instance;
instance = new options_dialog();
return instance;
}
auto options_dialog::make_options_tab()
{
// first construct object
audio_options = std::make_shared<audio_options_view>();
auto tabs = hnotebook(
jtracker::get_app()->_view,
deck(
layer(align_center_middle(audio_options->make_view())),
layer(align_center_middle(label("Options2").font_size(100)), frame{}),
layer(align_center_middle(label("Options3").font_size(100)), frame{})
),
tab("Audio Options"),
tab("Options2"),
tab("Options3")
);
return tabs;
}
void options_dialog::update_config()
{
// audio actualize
jtracker::data.audio_config.sample_rate = audio_options->sample_rate_spin.get_value();
jtracker::data.audio_config.ksmps = audio_options->ksmps_spin.get_value();
jtracker::data.audio_config.dbfs = audio_options->dbfs_spin.get_value();
jtracker::data.audio_config.i_nchnls = audio_options->inchnls_spin.get_value();
jtracker::data.audio_config.nchnls = audio_options->nchnls_spin.get_value();
jtracker::data.audio_config.additional_options.clear();
for(auto & it : audio_options->options_list.items)
{
jtracker::data.audio_config.additional_options.push_back( audio_cs_option(it->option, it->enabled) );
}
}
void options_dialog::make_content()
{
_name = "Options";
auto close_but = button("Close");
close_but.on_click = [&](bool)
{
close();
};
auto ok_button = button("Validate");
ok_button.on_click = [&](bool)
{
// save before
jtracker::save_audio_config();
update_config();
close();
};
content_ptr = share(
margin({10, 10, 10, 10},
vtile(
make_options_tab(),
htile(ok_button,close_but)
)
));
}
| 28.557789 | 109 | 0.56801 | johannphilippe |
7e6913bf00ad1968b5095d0623ba0f228991ba57 | 5,426 | cpp | C++ | imp_bridge_ros/src/ros_bridge.cpp | rockenbf/ze_oss | ee04158e2d51acb07a267196f618e9afbc3ffd83 | [
"BSD-3-Clause"
] | 30 | 2016-09-27T07:41:28.000Z | 2021-12-03T20:44:28.000Z | imp_bridge_ros/src/ros_bridge.cpp | rockenbf/ze_oss | ee04158e2d51acb07a267196f618e9afbc3ffd83 | [
"BSD-3-Clause"
] | 1 | 2018-12-18T15:53:06.000Z | 2018-12-21T03:10:06.000Z | imp_bridge_ros/src/ros_bridge.cpp | rockenbf/ze_oss | ee04158e2d51acb07a267196f618e9afbc3ffd83 | [
"BSD-3-Clause"
] | 12 | 2016-11-05T07:51:29.000Z | 2020-07-13T02:26:08.000Z | // Copyright (c) 2015-2016, ETH Zurich, Wyss Zurich, Zurich Eye
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the ETH Zurich, Wyss Zurich, Zurich Eye nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL ETH Zurich, Wyss Zurich, Zurich Eye BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <imp/bridge/ros/ros_bridge.hpp>
#include <sensor_msgs/image_encodings.h>
#include <imp/core/image_raw.hpp>
#include <ze/common/logging.hpp>
#include <ze/common/types.hpp>
namespace ze {
namespace imgenc = sensor_msgs::image_encodings;
//------------------------------------------------------------------------------
std::pair<PixelType, PixelOrder> getPixelTypeFromRosImageEncoding(
const std::string& encoding)
{
//! @todo (MWE) we do not support bayer or YUV images yet.
if (encoding == imgenc::BGR8)
{
return std::make_pair(PixelType::i8uC3, PixelOrder::bgr);
}
else if (encoding == imgenc::MONO8)
{
return std::make_pair(PixelType::i8uC1, PixelOrder::gray);
}
else if (encoding == imgenc::RGB8)
{
return std::make_pair(PixelType::i8uC3, PixelOrder::rgb);
}
else if (encoding == imgenc::MONO16)
{
return std::make_pair(PixelType::i16uC1, PixelOrder::gray);
}
else if (encoding == imgenc::BGR16)
{
return std::make_pair(PixelType::i16uC3, PixelOrder::bgr);
}
else if (encoding == imgenc::RGB16)
{
return std::make_pair(PixelType::i16uC3, PixelOrder::rgb);
}
else if (encoding == imgenc::BGRA8)
{
return std::make_pair(PixelType::i8uC4, PixelOrder::bgra);
}
else if (encoding == imgenc::RGBA8)
{
return std::make_pair(PixelType::i8uC4, PixelOrder::rgba);
}
else if (encoding == imgenc::BGRA16)
{
return std::make_pair(PixelType::i16uC4, PixelOrder::bgra);
}
else if (encoding == imgenc::RGBA16)
{
return std::make_pair(PixelType::i16uC4, PixelOrder::rgba);
}
LOG(FATAL) << "Unsupported image encoding " + encoding + ".";
return std::make_pair(PixelType::undefined, PixelOrder::undefined);
}
//------------------------------------------------------------------------------
ImageBase::Ptr toImageCpu(
const sensor_msgs::Image& src, PixelOrder /*pixel_order*/)
{
PixelType src_pixel_type;
PixelOrder src_pixel_order;
std::tie(src_pixel_type, src_pixel_order) =
getPixelTypeFromRosImageEncoding(src.encoding);
int bit_depth = imgenc::bitDepth(src.encoding);
int num_channels = imgenc::numChannels(src.encoding);
uint32_t width = src.width;
uint32_t height = src.height;
uint32_t pitch = src.step;
// sanity check
CHECK_GE(pitch, width * num_channels * bit_depth/8) << "Input image seem to wrongly formatted";
switch (src_pixel_type)
{
case PixelType::i8uC1:
{
ImageRaw8uC1 src_wrapped(
reinterpret_cast<Pixel8uC1*>(const_cast<uint8_t*>(&src.data[0])),
width, height, pitch, true, PixelOrder::gray);
ImageRaw8uC1::Ptr dst =
std::make_shared<ImageRaw8uC1>(src_wrapped); // Deep copy of the image data.
return dst;
}
// case imp::PixelType::i8uC2:
// { } break;
// case imp::PixelType::i8uC3:
// { } break;
// case imp::PixelType::i8uC4:
// { } break;
// case imp::PixelType::i16uC1:
// { } break;
// case imp::PixelType::i16uC2:
// { } break;
// case imp::PixelType::i16uC3:
// { } break;
// case imp::PixelType::i16uC4:
// { } break;
// case imp::PixelType::i32uC1:
// { } break;
// case imp::PixelType::i32uC2:
// { } break;
// case imp::PixelType::i32uC3:
// { } break;
// case imp::PixelType::i32uC4:
// { } break;
// case imp::PixelType::i32sC1:
// { } break;
// case imp::PixelType::i32sC2:
// { } break;
// case imp::PixelType::i32sC3:
// { } break;
// case imp::PixelType::i32sC4:
// { } break;
// case imp::PixelType::i32fC1:
// { } break;
// case imp::PixelType::i32fC2:
// { } break;
// case imp::PixelType::i32fC3:
// { } break;
// case imp::PixelType::i32fC4:
// { } break;
default:
{
LOG(FATAL) << "Unsupported pixel type" + src.encoding + ".";
break;
}
}
return nullptr;
}
} // namespace ze
| 33.085366 | 97 | 0.661629 | rockenbf |
7e69362c87c64e6c8089a62c817bdaf0067ced2c | 2,489 | cpp | C++ | Source/Samples/99_Benchmark/Benchmark03_MoleculeLogic.cpp | pat2nav/Urho3D | cc0346f39bd365782d825e2e337a1f33bb225308 | [
"MIT"
] | null | null | null | Source/Samples/99_Benchmark/Benchmark03_MoleculeLogic.cpp | pat2nav/Urho3D | cc0346f39bd365782d825e2e337a1f33bb225308 | [
"MIT"
] | null | null | null | Source/Samples/99_Benchmark/Benchmark03_MoleculeLogic.cpp | pat2nav/Urho3D | cc0346f39bd365782d825e2e337a1f33bb225308 | [
"MIT"
] | null | null | null | // Copyright (c) 2008-2022 the Urho3D project
// License: MIT
#include "Benchmark03_MoleculeLogic.h"
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/DebugNew.h>
using namespace Urho3D;
Benchmark03_MoleculeLogic::Benchmark03_MoleculeLogic(Context* context)
: LogicComponent(context)
, moleculeType_(0)
{
SetUpdateEventMask(USE_UPDATE | USE_POSTUPDATE);
}
void Benchmark03_MoleculeLogic::SetParameters(i32 type)
{
moleculeType_ = type;
}
static constexpr float MOLECULE_RADIUS = 1.f;
static constexpr float INTERACTION_RANGE = MOLECULE_RADIUS * 4.f;
static constexpr float CONTAINER_RADIUS = 9.f;
void Benchmark03_MoleculeLogic::Update(float timeStep)
{
PODVector<Node*> moleculeNodes;
GetScene()->GetChildrenWithComponent<Benchmark03_MoleculeLogic>(moleculeNodes);
Vector2 moleculePos = node_->GetPosition2D();
for (Node* anotherMoleculeNode : moleculeNodes)
{
if (anotherMoleculeNode == node_)
continue;
Vector2 anotherMoleculePos = anotherMoleculeNode->GetPosition2D();
i32 anotherMoleculeType = anotherMoleculeNode->GetComponent<Benchmark03_MoleculeLogic>()->GetMoleculeType();
float distance = (anotherMoleculePos - moleculePos).Length();
if (Equals(distance, 0.f))
{
// Molecules are at the same point
velocity_ = Vector2(Random(-2.f, 2.f), Random(-2.f, 2.f));
continue;
}
// Molecules are too far away and don't interact
if (distance >= INTERACTION_RANGE)
continue;
Vector2 direction = (anotherMoleculePos - moleculePos).Normalized();
float forceModulus = 1.f - distance / INTERACTION_RANGE;
forceModulus = forceModulus * forceModulus * forceModulus;
forceModulus = forceModulus * 25.f;
if (moleculeType_ != anotherMoleculeType)
forceModulus *= 1.5f;
force_ -= forceModulus * direction;
}
if (moleculePos.Length() > CONTAINER_RADIUS - MOLECULE_RADIUS)
{
Vector2 backDirection = -moleculePos.Normalized();
float backModulus = (moleculePos.Length() - CONTAINER_RADIUS + MOLECULE_RADIUS) * 50.0f;
force_ = force_ + backDirection * backModulus;
}
velocity_ = velocity_ + force_ * timeStep;
velocity_ = velocity_.Lerp(Vector2::ZERO, timeStep * 0.5f);
}
void Benchmark03_MoleculeLogic::PostUpdate(float timeStep)
{
node_->Translate2D(velocity_ * timeStep);
force_ = Vector2::ZERO;
}
| 29.630952 | 116 | 0.688228 | pat2nav |
7e69c58fe619dda520c796e42f83119eae54948b | 1,409 | cpp | C++ | safe_drive/src/safe_drive_node.cpp | RafalStaszak/autonomous-real | e45214ed323d9627de2c5f1f4188e330d65dd202 | [
"MIT"
] | null | null | null | safe_drive/src/safe_drive_node.cpp | RafalStaszak/autonomous-real | e45214ed323d9627de2c5f1f4188e330d65dd202 | [
"MIT"
] | null | null | null | safe_drive/src/safe_drive_node.cpp | RafalStaszak/autonomous-real | e45214ed323d9627de2c5f1f4188e330d65dd202 | [
"MIT"
] | 1 | 2018-06-05T18:08:29.000Z | 2018-06-05T18:08:29.000Z | #include <ros/ros.h>
#include <geometry_msgs/Twist.h>
class Safety
{
public:
Safety();
private:
void Callback(const geometry_msgs::Twist::ConstPtr& move);
ros::NodeHandle n;
ros::Publisher stop_pub;
ros::Subscriber twist_sub;
ros::Time current_time, last_time;
float czas;
};
Safety::Safety()
{
stop_pub = n.advertise<geometry_msgs::Twist>("Twist", 1); //declaration of publisher on topic Twist
geometry_msgs::Twist stop;
czas=0; //variable czas (eng. time)
current_time = ros::Time::now();
last_time = ros::Time::now();
ros::Rate r(10); //loop is rated at 10Hz
while(n.ok())
{
ros::spinOnce();
current_time = ros::Time::now();
czas+=(current_time - last_time).toSec(); //czas is counting the time as the program run, it is valued in seconds
twist_sub = n.subscribe<geometry_msgs::Twist>("Twist", 1, &Safety::Callback, this); //declaration of subscribing the Twist topic
if(czas>5) //if there were no messages from Twist in last five seconds
{
stop_pub.publish(stop); //send a message to stop
}
last_time = ros::Time::now();
r.sleep();
}
}
void Safety::Callback(const geometry_msgs::Twist::ConstPtr& move)
{
czas=0; //when a massege received czas is set to zero, and time is counted again
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "safe_drive_node");
Safety safety;
}
| 24.719298 | 133 | 0.660043 | RafalStaszak |
7e69f826c471f129bcffa9d0d121ec25b7803a03 | 22,550 | cpp | C++ | zinew/extremephysics-2-2/extremephysics-2-2/c++/ExtremePhysics 2.2 DLL/gm_shape.cpp | Bitl/Game-Maker-Projects | 99f3eabcae8ef624f39f11715ebba327631dd78c | [
"MIT"
] | null | null | null | zinew/extremephysics-2-2/extremephysics-2-2/c++/ExtremePhysics 2.2 DLL/gm_shape.cpp | Bitl/Game-Maker-Projects | 99f3eabcae8ef624f39f11715ebba327631dd78c | [
"MIT"
] | null | null | null | zinew/extremephysics-2-2/extremephysics-2-2/c++/ExtremePhysics 2.2 DLL/gm_shape.cpp | Bitl/Game-Maker-Projects | 99f3eabcae8ef624f39f11715ebba327631dd78c | [
"MIT"
] | null | null | null | /*
* Copyright 2009-2011 Maarten Baert
* [email protected]
* http://www.maartenbaert.be/
*
* This file is part of ExtremePhysics.
*
* ExtremePhysics 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 3 of the License, or
* (at your option) any later version.
*
* ExtremePhysics 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 ExtremePhysics. If not, see <http://www.gnu.org/licenses/>.
*
* File: gm_shape.cpp
* Wrapper for ep_Shape.
*/
#include "gm.h"
gmexport double ep_shape_create_box(double world_id, double body_id, double w, double h, double x, double y, double rot, double density) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_box: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_box: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->CreateBoxShape(w, h, x, y, rot, density))==NULL) {
return 0;
}
((gmuserdata*)(shape->GetUserData()))->Clear();
shape->CacheID();
return shape->GetID();
}
gmexport double ep_shape_create_line(double world_id, double body_id, double x1, double y1, double x2, double y2, double density) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_box: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_box: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->CreateLineShape(x1, y1, x2, y2, density))==NULL) {
return 0;
}
((gmuserdata*)(shape->GetUserData()))->Clear();
shape->CacheID();
return shape->GetID();
}
gmexport double ep_shape_create_circle(double world_id, double body_id, double r, double x, double y, double rot, double density) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_circle: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_circle: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->CreateCircleShape(r, x, y, rot, density))==NULL) {
return 0;
}
((gmuserdata*)(shape->GetUserData()))->Clear();
shape->CacheID();
return shape->GetID();
}
gmexport double ep_shape_create_polygon(double world_id, double body_id, double polygon_id, double x, double y, double rot, double density) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_polygon: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_polygon: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Polygon *polygon;
if((polygon = world->FindPolygon(gm_cast<unsigned long>(polygon_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_create_polygon: Polygon %lu doesn't exist in world %lu.", gm_cast<unsigned long>(polygon_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->CreatePolygonShape(polygon, x, y, rot, density))==NULL) {
return 0;
}
((gmuserdata*)(shape->GetUserData()))->Clear();
shape->CacheID();
return shape->GetID();
}
gmexport double ep_shape_destroy(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_destroy: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_destroy: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_destroy: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
body->DestroyShape(shape);
return 1;
}
gmexport double ep_shape_exists(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_exists: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_exists: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
return (body->FindShape(gm_cast<unsigned long>(shape_id))!=NULL)? 1 : 0;
}
gmexport double ep_shape_get_first_contact(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_first_contact: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_first_contact: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_first_contact: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
ep_Contact *contact = shape->GetFirstContact();
if(contact==NULL) {
return 0;
}
contact->CacheID();
return contact->GetID();
}
gmexport double ep_shape_get_last_contact(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_last_contact: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_last_contact: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_last_contact: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
ep_Contact *contact = shape->GetLastContact();
if(contact==NULL) {
return 0;
}
contact->CacheID();
return contact->GetID();
}
gmexport double ep_shape_get_previous_contact(double world_id, double body_id, double shape_id, double contact_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_previous_contact: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_previous_contact: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_previous_contact: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
ep_Contact *contact;
if((contact = world->FindContact(gm_cast<unsigned long>(contact_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_previous_contact: Contact %lu doesn't exist in world %lu.", gm_cast<unsigned long>(contact_id), world->GetID());
return 0;
}
contact = shape->GetPreviousContact(contact);
if(contact==NULL) {
return 0;
}
contact->CacheID();
return contact->GetID();
}
gmexport double ep_shape_get_next_contact(double world_id, double body_id, double shape_id, double contact_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_next_contact: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_next_contact: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_next_contact: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
ep_Contact *contact;
if((contact = world->FindContact(gm_cast<unsigned long>(contact_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_next_contact: Contact %lu doesn't exist in world %lu.", gm_cast<unsigned long>(contact_id), world->GetID());
return 0;
}
contact = shape->GetNextContact(contact);
if(contact==NULL) {
return 0;
}
contact->CacheID();
return contact->GetID();
}
gmexport double ep_shape_set_material(double world_id, double body_id, double shape_id, double restitution, double friction, double normalvelocity, double tangentvelocity) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_material: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_material: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_material: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
shape->SetMaterial(gm_cast<float>(restitution), gm_cast<float>(friction), normalvelocity, tangentvelocity);
return 1;
}
gmexport double ep_shape_set_collision(double world_id, double body_id, double shape_id, double collidemask1, double collidemask2, double group) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_collision: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_collision: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_collision: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
shape->SetCollision(gm_cast<unsigned long>(collidemask1), gm_cast<unsigned long>(collidemask2), gm_cast<unsigned long>(group));
return 1;
}
gmexport double ep_shape_collision_test_box(double world_id, double body_id, double shape_id, double w, double h, double x, double y, double rot, double contact_threshold) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_box: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_box: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_box: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
return (shape->CollisionTestBox(w, h, x, y, rot, contact_threshold))? 1 : 0;
}
gmexport double ep_shape_collision_test_line(double world_id, double body_id, double shape_id, double x1, double y1, double x2, double y2, double contact_threshold) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_line: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_line: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_line: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
return (shape->CollisionTestLine(x1, y1, x2, y2, contact_threshold))? 1 : 0;
}
gmexport double ep_shape_collision_test_circle(double world_id, double body_id, double shape_id, double r, double x, double y, double contact_threshold) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_circle: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_circle: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_circle: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
return (shape->CollisionTestCircle(r, x, y, contact_threshold))? 1 : 0;
}
gmexport double ep_shape_collision_test_polygon(double world_id, double body_id, double shape_id, double polygon_id, double x, double y, double rot, double contact_threshold) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_polygon: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_polygon: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_polygon: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
ep_Polygon *polygon;
if((polygon = world->FindPolygon(gm_cast<unsigned long>(polygon_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_collision_test_polygon: Polygon %lu doesn't exist in world %lu.", gm_cast<unsigned long>(polygon_id), world->GetID());
return 0;
}
return (shape->CollisionTestPolygon(polygon, x, y, rot, contact_threshold))? 1 : 0;
}
gmexport double ep_shape_ray_cast(double world_id, double body_id, double shape_id, double x, double y, double vx, double vy) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_ray_cast: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_ray_cast: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_ray_cast: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
return shape->RayCast(x, y, vx, vy);
}
gmexport double ep_shape_previous(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_previous: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_previous: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_previous: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
if(shape->GetPrevious()==NULL) {
return 0;
}
shape->GetPrevious()->CacheID();
return shape->GetPrevious()->GetID();
}
gmexport double ep_shape_next(double world_id, double body_id, double shape_id) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_next: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_next: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_next: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
if(shape->GetNext()==NULL) {
return 0;
}
shape->GetNext()->CacheID();
return shape->GetNext()->GetID();
}
gmexport double ep_shape_set_uservar(double world_id, double body_id, double shape_id, double index, double value) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_uservar: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_uservar: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_set_uservar: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
int i = gm_cast<int>(index);
if(i<0 || i>=GM_USERVARS) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "Can't set user variable of shape %lu of body %lu in world %lu, index is out of range.", shape->GetID(), body->GetID(), world->GetID());
return 0;
}
((gmuserdata*)(shape->GetUserData()))->var[i] = value;
return 1;
}
gmexport double ep_shape_get_uservar(double world_id, double body_id, double shape_id, double index) {
ep_World *world;
if((world = epmain.FindWorld(gm_cast<unsigned long>(world_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_uservar: World %lu doesn't exist.", gm_cast<unsigned long>(world_id));
return 0;
}
ep_Body *body;
if((body = world->FindBody(gm_cast<unsigned long>(body_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_uservar: Body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(body_id), world->GetID());
return 0;
}
ep_Shape *shape;
if((shape = body->FindShape(gm_cast<unsigned long>(shape_id)))==NULL) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "ep_shape_get_uservar: Shape %lu of body %lu doesn't exist in world %lu.", gm_cast<unsigned long>(shape_id), body->GetID(), world->GetID());
return 0;
}
int i = gm_cast<int>(index);
if(i<0 || i>=GM_USERVARS) {
epmain.Message(EP_MESSAGELEVEL_ERROR, "Can't get user variable of shape %lu of body %lu in world %lu, index is out of range.", shape->GetID(), body->GetID(), world->GetID());
return 0;
}
return ((gmuserdata*)(shape->GetUserData()))->var[i];
}
| 46.303901 | 191 | 0.732639 | Bitl |
7e6fc41ce5a29f91f9dbed457bc49f66d346d4b9 | 635 | hpp | C++ | requester/test/mock_request.hpp | amboar/pldm | d0405c3555427c03b231c8d52958f8689b3fa114 | [
"Apache-2.0"
] | null | null | null | requester/test/mock_request.hpp | amboar/pldm | d0405c3555427c03b231c8d52958f8689b3fa114 | [
"Apache-2.0"
] | null | null | null | requester/test/mock_request.hpp | amboar/pldm | d0405c3555427c03b231c8d52958f8689b3fa114 | [
"Apache-2.0"
] | null | null | null | #pragma once
#include "requester/request.hpp"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
namespace pldm
{
namespace requester
{
class MockRequest : public RequestRetryTimer
{
public:
MockRequest(int /*fd*/, mctp_eid_t /*eid*/, sdeventplus::Event& event,
pldm::Request&& /*requestMsg*/, uint8_t numRetries,
std::chrono::milliseconds responseTimeOut,
int /*currentSendbuffSize*/, bool /*verbose*/) :
RequestRetryTimer(event, numRetries, responseTimeOut)
{}
MOCK_METHOD(int, send, (), (const, override));
};
} // namespace requester
} // namespace pldm
| 21.166667 | 74 | 0.651969 | amboar |
7e752c5be62ec32fe6f9b85f1f7e1f8a6add85fb | 1,730 | cpp | C++ | 1199 Round #576 (Div.2)/F - Rectangle Painting 1.cpp | Jatin-Nagpal/CF-Complete | 2381ab746982676db3610d66ab33d4177f2d555f | [
"MIT"
] | 1 | 2019-08-17T05:35:30.000Z | 2019-08-17T05:35:30.000Z | 1199 Round #576 (Div.2)/F - Rectangle Painting 1.cpp | Jatin-Nagpal/CF-Complete | 2381ab746982676db3610d66ab33d4177f2d555f | [
"MIT"
] | null | null | null | 1199 Round #576 (Div.2)/F - Rectangle Painting 1.cpp | Jatin-Nagpal/CF-Complete | 2381ab746982676db3610d66ab33d4177f2d555f | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;
#define MP make_pair
#define PB push_back
// #define ll long long
#define int long long
#define f(i,x,n) for(int i=x;i<n;i++)
#define ld long double
#define mod 1000000007
int a[51][51];
string s[51];
int n,ans;
int dp[51][51][51][51];
int dp2[51][51];
inline int sum(int stx,int sty,int enx,int eny)
{
return dp2[enx][eny] -dp2[stx-1][eny] -dp2[enx][sty-1] +dp2[stx-1][sty-1];
}
int dfs(int stx,int sty,int enx,int eny)
{
// cout<<stx<<" "<<sty<<" "<<enx<<" "<<eny<<'\n';
int &an=dp[stx][sty][enx][eny];
if(an!=-1)
return an;
if( dp2[enx][eny] -dp2[stx-1][eny] -dp2[enx][sty-1] +dp2[stx-1][sty-1] ==0)
return an=0;
if(stx>enx||sty>eny)
return an=0;
if(stx==enx&&sty==eny)
return an=a[stx][sty];
if(sum(stx,sty,stx,eny)==0)
return an=dfs(stx+1,sty,enx,eny);
if(sum(stx,sty,enx,sty)==0)
return an=dfs(stx,sty+1,enx,eny);
if(sum(enx,sty,enx,eny)==0)
return an=dfs(stx,sty,enx-1,eny);
if(sum(stx,eny,enx,eny)==0)
return an=dfs(stx,sty,enx,eny-1);
int ret=min( max(enx-stx+1,eny-sty+1),sum(stx,sty,enx,eny));
int tmp=0;
f(i,stx,enx)
{
ret=min(ret,dfs(stx,sty,i,eny) +dfs(i+1,sty,enx,eny) );
}
f(i,sty,eny)
{
ret=min(ret,dfs(stx,sty,enx,i) +dfs(stx,i+1,enx,eny) );
}
return an=ret;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
ans=n;
f(i,0,51)
f(j,0,51)
f(k,0,51)
f(l,0,51)
dp[i][j][k][l]=-1;
f(i,0,n)
cin>>s[i];
f(i,1,n+1)
{
f(j,1,n+1)
{
if(s[i-1][j-1]=='#')
a[i][j]=1;
}
}
f(i,1,n+1)
{
f(j,1,n+1)
{
dp2[i][j]=dp2[i-1][j]+dp2[i][j-1]-dp2[i-1][j-1];
if(a[i][j]==1)
dp2[i][j]++;
}
}
cout<<dfs(1,1,n,n)<<endl;
return 0;
} | 20.116279 | 77 | 0.573988 | Jatin-Nagpal |
7e7791ace9851d83f2066fe1ffb8462b8af17cb0 | 1,599 | hpp | C++ | src/include/cpp_playground/delayed_call.hpp | rxcompile/cpp_playground | 63cd54f18e15415f779d9a6d08c5dac8ba33e3be | [
"MIT"
] | null | null | null | src/include/cpp_playground/delayed_call.hpp | rxcompile/cpp_playground | 63cd54f18e15415f779d9a6d08c5dac8ba33e3be | [
"MIT"
] | null | null | null | src/include/cpp_playground/delayed_call.hpp | rxcompile/cpp_playground | 63cd54f18e15415f779d9a6d08c5dac8ba33e3be | [
"MIT"
] | null | null | null | #pragma once
#include "cpp_playground/python_container.hpp"
#include "cpp_playground/function_traits.hpp"
#include <vector>
#include <functional>
namespace CppTest
{
template <typename TRet, typename... TArgs>
class DelayedCall
{
public:
DelayedCall(std::function<TRet(TArgs...)> fn, Container &data)
: args(parseArgs(data, std::index_sequence_for<TArgs...>())), func(fn)
{
}
auto call()
{
return callInternal(std::index_sequence_for<TArgs...>());
}
private:
template <typename TArg, size_t idx>
TArg parseArg(Container &data)
{
//TArg a = std::any_cast<TArg>(data[idx]);
TArg a = data[idx];
return a;
}
template <size_t... S>
auto parseArgs(Container &data, std::index_sequence<S...>)
{
return std::make_tuple(parseArg<typename function_traits<decltype(func)>::template arg<S>::type, S>(data)...);
}
template <size_t... S>
auto callInternal(std::index_sequence<S...>)
{
return func(std::get<S>(args)...);
}
private:
std::tuple<TArgs...> args;
std::function<TRet(TArgs...)> func;
};
template <typename TRet, typename... TArgs>
TRet delayedCall(std::function<TRet(TArgs...)> func, Container &data)
{
return DelayedCall<TRet, TArgs...>(func, data).call();
}
template <typename M, typename TRet, typename... TArgs>
TRet delayedCall(M &ptr, TRet (M::*func)(TArgs...), Container &data)
{
std::function<TRet(TArgs...)> f = [&ptr, func](TArgs... args) { return (ptr.*func)(args...); };
return DelayedCall<TRet, TArgs...>(f, data).call();
}
} | 24.984375 | 118 | 0.627892 | rxcompile |
7e7bf634c4566a32456aefbb6d5e6ac06ea721cf | 683 | cpp | C++ | mainwindow.cpp | stweise/rico-cluster-qt | 7b712319de1b8feb53172b089867038c977c96d5 | [
"BSD-3-Clause"
] | 1 | 2020-07-12T19:33:25.000Z | 2020-07-12T19:33:25.000Z | mainwindow.cpp | stweise/rico-qt | 7b712319de1b8feb53172b089867038c977c96d5 | [
"BSD-3-Clause"
] | 1 | 2020-11-19T15:56:23.000Z | 2020-11-29T08:54:29.000Z | mainwindow.cpp | stweise/rico-qt | 7b712319de1b8feb53172b089867038c977c96d5 | [
"BSD-3-Clause"
] | null | null | null | // SPDX-License-Identifier: BSD-3-Clause
#include "mainwindow.h"
#include "./ui_mainwindow.h"
#include "graphicsscene.h"
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindow) {
ui->setupUi(this);
scene = new GraphicsScene(this);
ui->graphicsView->setScene(scene);
}
MainWindow::~MainWindow() { delete ui; }
void MainWindow::on_actionSave_triggered() { scene->save(); }
void MainWindow::on_actionLoad_triggered() { scene->load(); }
void MainWindow::on_actionPrint_triggered() { scene->print(); }
void MainWindow::on_actionSave_as_triggered() { scene->saveAs(); }
void MainWindow::on_actionExport_triggered() { scene->exportToDot(); }
| 27.32 | 70 | 0.727672 | stweise |
7e7c2a02776b994cb11e1ce65f4f15343f1cbfe1 | 35,191 | cpp | C++ | src/VAC/View3D.cpp | CELLINKAB/vpaint | 83f66645407a1467a450bd42bc3d62038bf7d11a | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2021-09-10T15:10:30.000Z | 2021-09-10T15:10:30.000Z | src/VAC/View3D.cpp | CELLINKAB/vpaint | 83f66645407a1467a450bd42bc3d62038bf7d11a | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2021-11-24T11:21:05.000Z | 2021-11-24T11:21:05.000Z | src/VAC/View3D.cpp | CELLINKAB/vpaint | 83f66645407a1467a450bd42bc3d62038bf7d11a | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | // Copyright (C) 2012-2019 The VPaint Developers.
// See the COPYRIGHT file at the top-level directory of this distribution
// and at https://github.com/dalboris/vpaint/blob/master/COPYRIGHT
//
// 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 <math.h>
#include <algorithm>
#include "View3D.h"
#include "Scene.h"
#include "Timeline.h"
#include <QtDebug>
#include "Global.h"
#include "View.h"
#include "Background/Background.h"
#include "Background/BackgroundRenderer.h"
#include "VectorAnimationComplex/VAC.h"
#include "VectorAnimationComplex/KeyCell.h"
#include "VectorAnimationComplex/InbetweenCell.h"
#include "VectorAnimationComplex/InbetweenEdge.h"
// GLU was removed from Qt in version 4.8
// TODO: remove this dependancy and code it myself
#ifdef Q_OS_MAC
# include <OpenGL/glu.h>
#else
# include <GL/glu.h>
#endif
// define mouse actions
#define DRAW_ACTION 10
#define SELECT_ACTION 20
#define ADDSELECT_ACTION 21
#define DESELECT_ACTION 22
#define TOGGLESELECT_ACTION 23
#define DESELECTALL_ACTION 24
View3D::View3D(VPaint::Scene *scene, QWidget *parent) :
GLWidget(parent, false), // Difference from View here
scene_(scene),
displayedTimes_(),
pickingImg_(0),
//frame_(0),
vac_(0)
{
// Make renderers
// XXX Make it work with layers
//Background * bg = scene_->background();
//backgroundRenderers_[bg] = new BackgroundRenderer(bg, context(), this);
cameraTravellingIsEnabled_ = true;
drawingIsEnable_ = false;
// behave as a separate window
this->setWindowFlags(Qt::Window);
resize(600,600);
setWindowTitle("3D View [Beta]");
// Redraw when moving the camera
//connect(this, SIGNAL(viewIsGoingToChange(int, int)), this, SLOT(updatePicking()));
////connect(this, SIGNAL(viewIsGoingToChange(int, int)), this, SLOT(updateHighlightedObject(int, int)));
//connect(this, SIGNAL(viewIsGoingToChange(int, int)), this, SLOT(update()));
////connect(this, SIGNAL(viewIsBeingChanged(int, int)), this, SLOT(updatePicking()));
////connect(this, SIGNAL(viewIsBeingChanged(int, int)), this, SLOT(updateHighlightedObject(int, int)));
connect(this, SIGNAL(viewIsBeingChanged(int, int)), this, SLOT(update()));
//connect(this, SIGNAL(viewChanged(int, int)), this, SLOT(updatePicking()));
//connect(this, SIGNAL(viewChanged(int, int)), this, SLOT(updateHighlightedObject(int, int)));
connect(this, SIGNAL(viewChanged(int, int)), this, SLOT(update()));
//connect(global(),SIGNAL(keyboardModifiersChanged()),this,SLOT(handleNewKeyboardModifiers()));
connect(global()->timeline(), SIGNAL(playingWindowChanged()), this, SLOT(update()));
}
View3D::~View3D()
{
deletePicking();
}
View3DSettings * View3D::settings() {
return &viewSettings_;
}
void View3D::closeEvent(QCloseEvent * event)
{
emit closed();
event->accept();
}
void View3D::keyPressEvent(QKeyEvent *event)
{
GLWidget::keyPressEvent(event);
// Nothing changed in the scene, but keyboard state can affect
// the display settings, hence should redraw the scene. Pass the
// event to multiview to do this
if(!event->isAccepted())
event->ignore();
}
View3D::MouseEvent View3D::mouseEvent() const
{
MouseEvent me;
me.x = mouse_PressEvent_X_;
me.y = mouse_PressEvent_Y_;
me.left = mouse_LeftButton_;
me.mid = mouse_MidButton_;
me.right = mouse_RightButton_;
me.alt = mouse_AltWasDown_;
me.control = mouse_ControlWasDown_;
me.shift = mouse_ShiftWasDown_;
return me;
}
void View3D::MoveEvent(double x, double y)
{
bool hasChanged = updateHighlightedObject(x, y);
if(hasChanged)
{
if(highlightedObject_.isNull())
scene_->setNoHoveredObject();
else
scene_->setHoveredObject(
//Timeline::time(highlightedObject_.time()),
Time(), // ignored by VAC anyway...
highlightedObject_.index(),
highlightedObject_.id());
}
}
int View3D::decideClicAction()
{
if(mouse_LeftButton_)
{
if(!mouse_AltWasDown_ &&
!mouse_ControlWasDown_ &&
!mouse_ShiftWasDown_)
{
if(highlightedObject_.isNull())
return DESELECTALL_ACTION;
else
return SELECT_ACTION;
}
if(!mouse_AltWasDown_ &&
!mouse_ControlWasDown_ &&
mouse_ShiftWasDown_)
{
return ADDSELECT_ACTION;
}
if(mouse_AltWasDown_ &&
!mouse_ControlWasDown_ &&
!mouse_ShiftWasDown_)
{
return DESELECT_ACTION;
}
if(mouse_AltWasDown_ &&
!mouse_ControlWasDown_ &&
mouse_ShiftWasDown_)
{
return TOGGLESELECT_ACTION;
}
}
return GLWidget::decideClicAction();
}
int View3D::decidePMRAction()
{
return GLWidget::decidePMRAction();
}
void View3D::ClicEvent(int action, double x, double y)
{
if(action==SELECT_ACTION)
{
if(!highlightedObject_.isNull())
{
scene_->deselectAll(); // deselect at all
// times. different from 2D behaviour
scene_->select(Time() /*Timeline::time(highlightedObject_.time())*/,
highlightedObject_.index(),
highlightedObject_.id());
}
}
else if(action==DESELECTALL_ACTION)
{
// same here: deselect at all times
// different from 2D version
scene_->deselectAll();
}
else if(action==ADDSELECT_ACTION)
{
if(!highlightedObject_.isNull())
{
scene_->select(Time()/*Timeline::time(highlightedObject_.time())*/,
highlightedObject_.index(),
highlightedObject_.id());
}
}
else if(action==DESELECT_ACTION)
{
if(!highlightedObject_.isNull())
{
scene_->deselect(Time()/*Timeline::time(highlightedObject_.time())*/,
highlightedObject_.index(),
highlightedObject_.id());
}
}
else if(action==TOGGLESELECT_ACTION)
{
if(!highlightedObject_.isNull())
{
scene_->toggle(Time()/*Timeline::time(highlightedObject_.time())*/,
highlightedObject_.index(),
highlightedObject_.id());
}
}
GLWidget::ClicEvent(action, x, y);
}
void View3D::PMRPressEvent(int action, double x, double y)
{
GLWidget::PMRPressEvent(action, x, y);
}
void View3D::PMRMoveEvent(int action, double x, double y)
{
GLWidget::PMRMoveEvent(action, x, y);
}
void View3D::PMRReleaseEvent(int action, double x, double y)
{
GLWidget::PMRReleaseEvent(action, x, y);
}
/***********************************************************
* DRAWING
*/
namespace
{
/*
void drawSphere(double r, int lats, int longs)
{
int i, j;
for(i = 0; i <= lats; i++)
{
double lat0 = M_PI * (-0.5 + (double) (i - 1) / lats);
double z0 = sin(lat0);
double zr0 = cos(lat0);
double lat1 = M_PI * (-0.5 + (double) i / lats);
double z1 = sin(lat1);
double zr1 = cos(lat1);
glBegin(GL_QUAD_STRIP);
for(j = 0; j <= longs; j++)
{
double lng = 2 * M_PI * (double) (j - 1) / longs;
double x = cos(lng);
double y = sin(lng);
glNormal3f(x * zr0, y * zr0, z0);
glVertex3f(r * x * zr0, r * y * zr0, r * z0);
glNormal3f(x * zr1, y * zr1, z1);
glVertex3f(r * x * zr1, r * y * zr1, r * z1);
}
glEnd();
}
}
*/
}
int View3D::activeFrame() const
{
return std::floor(activeTime().floatTime());
}
Time View3D::activeTime() const
{
return global()->activeTime(); // XXX should refactor this
}
void View3D::drawBackground_(Background * background, double t)
{
// Get canvas boundary
double x1 = scene_->left();
double y1 = scene_->top();
double w = scene_->width();
double h = scene_->height();
double x2 = x1 + w;
double y2 = y1 + h;
// Convert to 3D coords
x1 = viewSettings_.xFromX2D(x1);
x2 = viewSettings_.xFromX2D(x2);
y1 = viewSettings_.yFromY2D(y1);
y2 = viewSettings_.yFromY2D(y2);
// Draw background
backgroundRenderers_[background]->draw(
Time(t).frame(),
true, // = showCanvas
x1, y1, w, h,
0, 0, 0, 0);
}
// XXX Refactor this: move it to a CanvasRenderer class
// Right now, this codes duplicates part of Scene::drawCanvas()
void View3D::drawCanvas_()
{
// Get canvas boundary
double x1 = scene_->left();
double y1 = scene_->top();
double w = scene_->width();
double h = scene_->height();
double x2 = x1 + w;
double y2 = y1 - h;
// Convert to 3D coords
x1 = viewSettings_.xFromX2D(x1);
x2 = viewSettings_.xFromX2D(x2);
y1 = viewSettings_.yFromY2D(y1);
y2 = viewSettings_.yFromY2D(y2);
// Draw quad boundary
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glBegin(GL_QUADS);
{
glColor4f(0.0, 0.0, 0.0, 1.0);
glVertex2d(x1, y1);
glVertex2d(x2, y1);
glVertex2d(x2, y2);
glVertex2d(x1, y2);
}
glEnd();
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
}
void View3D::drawScene()
{
drawSceneDelegate_(global()->activeTime());
}
void View3D::drawSceneDelegate_(Time activeTime)
{
using namespace VectorAnimationComplex;
// Get VAC
VAC * vac = scene_->activeVAC();
if (!vac) {
return;
}
// Get t-position of camera eye to determine back-to-front order
double zEye = camera_.position()[2];
double tEye = - zEye / viewSettings_.timeScale();
if(viewSettings_.cameraFollowActiveTime())
tEye += activeTime.floatTime();
// Collect all items to draw
bool drawAllFrames = viewSettings_.drawAllFrames();
bool drawKeyCells = drawAllFrames || viewSettings_.drawKeyCells();
bool drawInbetweenCells = viewSettings_.drawInbetweenCells();
bool drawCurrentFrame = viewSettings_.drawCurrentFrame();
bool drawCurrentFrameAsTopology = viewSettings_.drawCurrentFrameAsTopology();
bool drawOtherFramesAsTopology = viewSettings_.drawFramesAsTopology();
DrawMode currentFrameDrawMode = drawCurrentFrameAsTopology ? DrawMode::DrawTopology : DrawMode::Draw;
DrawMode otherFramesDrawMode = drawOtherFramesAsTopology ? DrawMode::DrawTopology : DrawMode::Draw;
drawItems_.clear();
if (viewSettings_.drawTimePlane()) {
drawItems_.push_back({nullptr, DrawMode::DrawCanvas, activeTime, activeTime});
}
const ZOrderedCells & cells = vac->zOrdering();
for(auto it = cells.cbegin(); it != cells.cend(); ++it)
{
if (KeyCell * kc = (*it)->toKeyCell()) {
if (drawCurrentFrame && kc->exists(activeTime)) {
drawItems_.push_back({kc, currentFrameDrawMode, activeTime, activeTime});
}
else if (drawKeyCells) {
drawItems_.push_back({kc, otherFramesDrawMode, kc->time(), kc->time()});
}
}
else if (InbetweenCell * ic = (*it)->toInbetweenCell()) {
Time t1 = ic->beforeTime();
Time t2 = ic->afterTime();
if (drawCurrentFrame && t1 < activeTime && activeTime < t2) {
// Note: (t1 < activeTime && activeTime < t2) is equivalent to
// ic->exists(activeTime), but avoid computing ic->beforeTime()
// and ic->afterTime() again.
drawItems_.push_back({ic, currentFrameDrawMode, activeTime, activeTime});
}
if (drawAllFrames) {
// Note: unlike for key cells, this block is not an "else if"
// because ic might exist both at activeTime and other frames.
int f1 = std::floor(t1.floatTime());
int f2 = std::ceil(t2.floatTime());
for (int f = f1 + 1; f < f2; ++f) {
Time t = f;
if (!drawCurrentFrame || t != activeTime) {
drawItems_.push_back({ic, otherFramesDrawMode, t, t});
}
}
}
if (drawInbetweenCells) {
double t1f = t1.floatTime();
double t2f = t2.floatTime();
int f1 = std::floor(t1f);
int f2 = std::ceil(t2f);
// Cut the inbetween cell into one-frame-long sections
for (int f = f1; f < f2; ++f) {
Time t1_ = (f == f1) ? t1 : f;
Time t2_ = (f == f2 - 1) ? t2 : f + 1;
if (drawCurrentFrame && t1_ < activeTime && activeTime < t2_) {
// Cut at current frame
drawItems_.push_back({ic, DrawMode::Draw3D, t1_, activeTime});
t1_ = activeTime;
}
drawItems_.push_back({ic, DrawMode::Draw3D, t1_, t2_});
}
}
}
}
// Sort back to front, using stable_sort to preserve z-ordering.
//
// time: ---------------.------------------->
// tEye
//
// order: -------------->.<------------------
// (1) (3) (2)
//
// We draw items in this order:
// - First, items completely before tEye (orderCategory = 1)
// - Then, items completely after tEye (orderCategory = 2)
// - Finally, items whose timespan include tEye (orderCategory = 3)
//
// For items belonging to the same order category then:
// - We define their average time u = (t1+t2)/2
// - If orderCategory = 1, we draw items in order of increasing u
// - Otherwise, we draw items in order of decreasing u
//
std::stable_sort(
drawItems_.begin(), drawItems_.end(),
[tEye](const DrawItem& i1, const DrawItem& i2) {
double t11 = i1.t1.floatTime();
double t12 = i1.t2.floatTime();
double t21 = i2.t1.floatTime();
double t22 = i2.t2.floatTime();
int orderCategory1 = (t12 < tEye) ? 1 : ((tEye < t11) ? 2 : 3);
int orderCategory2 = (t22 < tEye) ? 1 : ((tEye < t21) ? 2 : 3);
if (orderCategory1 == orderCategory2) {
double u1 = 0.5 * (t11 + t12);
double u2 = 0.5 * (t21 + t22);
return (orderCategory1 == 1) ? (u1 < u2) : (u2 < u1);
}
else {
return orderCategory1 < orderCategory2;
}
});
// Set 2D settings from 3D settings
ViewSettings view2DSettings = global()->activeView()->viewSettings();
view2DSettings.setScreenRelative(false);
view2DSettings.setVertexTopologySize(viewSettings_.vertexTopologySize());
view2DSettings.setEdgeTopologyWidth(viewSettings_.edgeTopologyWidth());
view2DSettings.setDrawTopologyFaces(viewSettings_.drawTopologyFaces());
// Disable lighting, depth testing and writing to depth buffer
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glDepthMask(false);
// Scale and translate view
double s = viewSettings_.spaceScale();
glPushMatrix();
glScaled(s,s,s);
if(viewSettings_.cameraFollowActiveTime())
glTranslated(0,0,-viewSettings_.zFromT(activeTime));
// Draw all items
bool drawAsMesh = viewSettings_.drawAsMesh();
double opacity = viewSettings_.opacity();
for (const DrawItem& item: drawItems_)
{
if (item.mode == DrawMode::Draw3D)
{
double t1 = item.t1.floatTime();
double t2 = item.t2.floatTime();
double z1 = viewSettings_.zFromT(t1);
double z2 = viewSettings_.zFromT(t2);
GLdouble clipEquation1[4] = { 0.0, 0.0, -1.0, z1};
GLdouble clipEquation2[4] = { 0.0, 0.0, 1.0, -z2};
glEnable(GL_CLIP_PLANE0);
glEnable(GL_CLIP_PLANE1);
glClipPlane(GL_CLIP_PLANE0, clipEquation1);
glClipPlane(GL_CLIP_PLANE1, clipEquation2);
if (item.cell->toInbetweenVertex()) {
glColor4d(0.0, 0.0, 0.0, opacity);
item.cell->draw3D(viewSettings_);
}
else if (item.cell->toInbetweenEdge()) {
glColor4d(1.0, 0.5, 0.5, opacity);
if(drawAsMesh) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glLineWidth(2); // TODO: make this a view settings
}
item.cell->draw3D(viewSettings_);
if(drawAsMesh) {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glLineWidth(1);
}
}
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
}
else
{
double t = item.t1.floatTime();
glPushMatrix();
glScaled(1.0, -1.0, 1.0);
glTranslated(0.0, 0.0, viewSettings_.zFromT(t));
if (item.mode == DrawMode::Draw) {
item.cell->draw(t, view2DSettings);
}
else if (item.mode == DrawMode::DrawTopology) {
item.cell->drawTopology(t, view2DSettings);
}
else if (item.mode == DrawMode::DrawCanvas) {
drawCanvas_();
// TODO: layer background?
}
glPopMatrix();
}
}
// Restore state
//
// Note: should we also re-enable GL_DEPTH_TEST and/or GL_LIGHTING, or is
// enabling these the responsability of any drawing code that need it?
//
glDepthMask(true);
glPopMatrix();
}
/***********************************************************
* PICKING
*/
void View3D::drawPick()
{
// TODO
}
bool View3D::updateHighlightedObject(int x, int y)
{
if(!pickingImg_)
return false; // otherwise the scene will keep updating
Picking::Object old = highlightedObject_;
if(x<0 || x>=pickingWidth_ || y<0 || y>=pickingHeight_)
{
highlightedObject_ = Picking::Object();
}
else
{
highlightedObject_ = getCloserObject(x, y);
}
return !(highlightedObject_ == old);
}
uchar * View3D::pickingImg(int x, int y)
{
int k = 4*( (pickingHeight_ - y - 1)*pickingWidth_ + x);
return &pickingImg_[k];
}
Picking::Object View3D::getCloserObject(int x, int y)
{
Picking::Object noObject;
if(!pickingImg_)
return noObject;
int leftBorderDist = x;
int rightBorderDist = pickingWidth_-1-x;
int topBorderDist = y;
int bottomBorderDist = pickingHeight_-1-y;
int borderDist = qMin(qMin(leftBorderDist, rightBorderDist),
qMin(topBorderDist, bottomBorderDist));
if(borderDist<0)
return noObject;
int D = 10;
if(borderDist < D)
D = borderDist;
for(int d=0; d<=D; d++)
{
if(d==0)
{
uchar * p = pickingImg(x,y);
uchar r=p[0], g=p[1], b=p[2];
if(r!=255 || g!=255 || b!=255)
return Picking::objectFromRGB(r,g,b);
}
else
{
// top row
for(int varX=x-d; varX<=x+d; varX++)
{
uchar * p = pickingImg(varX,y-d);
uchar r=p[0], g=p[1], b=p[2];
if(r!=255 || g!=255 || b!=255)
return Picking::objectFromRGB(r,g,b);
}
// bottom row
for(int varX=x-d; varX<=x+d; varX++)
{
uchar * p = pickingImg(varX,y+d);
uchar r=p[0], g=p[1], b=p[2];
if(r!=255 || g!=255 || b!=255)
return Picking::objectFromRGB(r,g,b);
}
// left column
for(int varY=y-d; varY<=y+d; varY++)
{
uchar * p = pickingImg(x-d,varY);
uchar r=p[0], g=p[1], b=p[2];
if(r!=255 || g!=255 || b!=255)
return Picking::objectFromRGB(r,g,b);
}
// right column
for(int varY=y-d; varY<=y+d; varY++)
{
uchar * p = pickingImg(x+d,varY);
uchar r=p[0], g=p[1], b=p[2];
if(r!=255 || g!=255 || b!=255)
return Picking::objectFromRGB(r,g,b);
}
}
}
// no object within the range
return noObject;
}
void View3D::deletePicking()
{
if(pickingImg_)
{
gl_fbo_->glDeleteFramebuffers(1, &fboId_);
gl_fbo_->glDeleteRenderbuffers(1, &rboId_);
glDeleteTextures(1, &textureId_);
highlightedObject_ = Picking::Object();
delete[] pickingImg_;
pickingImg_ = 0;
pickingWidth_ = 0;
pickingHeight_ = 0;
}
}
void View3D::newPicking()
{
pickingWidth_ = width();
pickingHeight_ = height();
pickingImg_ = new uchar[4 * pickingWidth_ * pickingHeight_];
// code adapted from http://www.songho.ca/opengl/gl_fbo.html
// create a texture object
glGenTextures(1, &textureId_);
glBindTexture(GL_TEXTURE_2D, textureId_);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, pickingWidth_, pickingHeight_, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
// create a renderbuffer object to store depth info
gl_fbo_->glGenRenderbuffers(1, &rboId_);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, rboId_);
gl_fbo_->glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
pickingWidth_, pickingHeight_);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, 0);
// create a framebuffer object
gl_fbo_->glGenFramebuffers(1, &fboId_);
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, fboId_);
// attach the texture to FBO color attachment point
gl_fbo_->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, textureId_, 0);
// attach the renderbuffer to depth attachment point
gl_fbo_->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, rboId_);
// check FBO status
GLenum status = gl_fbo_->glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE)
{
qDebug() << "ERROR void View::newPicking()"
<< "FBO status != GL_FRAMEBUFFER_COMPLETE";
return;
}
// switch back to window-system-provided framebuffer
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebufferObject());
}
void View3D::updatePicking()
{
/* Picking (and thus editing) in the 3D View isn't supported. This code is
* just an example on how this function would look like. We would have to
* implement View3D::drawPick().
*
// Make this widget's rendering context the current OpenGL context
makeCurrent();
// get the viewport size, allocate memory if necessary
if( !(width()>0) || !(height()>0))
{
deletePicking();
return;
}
else if(
pickingImg_
&& (pickingWidth_ == width())
&& (pickingHeight_ == height()))
{
// necessary objects already created: do nothing
}
else
{
deletePicking();
newPicking();
}
// set rendering destination to FBO
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, fboId_);
// clear buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// clear buffers
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Should we setup other things? (e.g., disabling antialiasing)
// Seems to work as is. If issues, check GLWidget::initilizeGL()
// Set viewport
GLint oldViewport[4];
glGetIntegerv(GL_VIEWPORT, oldViewport);
glViewport(0, 0, pickingWidth_, pickingHeight_);
// Setup camera position and orientation
setCameraPositionAndOrientation();
// draw the picking
drawPick3D();
// Restore viewport
glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
// unbind FBO
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebufferObject());
// extract the texture info from GPU to RAM
glBindTexture(GL_TEXTURE_2D, textureId_);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pickingImg_);
glBindTexture(GL_TEXTURE_2D, 0);
*/
}
QImage View3D::drawToImage(int imgW, int imgH)
{
return drawToImage(activeTime(), imgW, imgH);
}
namespace
{
void imageCleanupHandler(void * info)
{
uchar * img = reinterpret_cast<uchar*>(info);
delete[] img;
}
}
QImage View3D::drawToImage(Time t, int IMG_SIZE_X, int IMG_SIZE_Y)
{
// TODO: factorize this code with View::drawToImage
// Make this widget's rendering context the current OpenGL context
makeCurrent();
// ------------ Create multisample FBO --------------------
GLuint ms_fboId;
GLuint ms_ColorBufferId;
GLuint ms_DepthBufferId;
GLint ms_samples;
// Maximum supported samples
glGetIntegerv(GL_MAX_SAMPLES, &ms_samples);
// Create FBO
gl_fbo_->glGenFramebuffers(1, &ms_fboId);
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, ms_fboId);
// Create multisample color buffer
gl_fbo_->glGenRenderbuffers(1, &ms_ColorBufferId);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, ms_ColorBufferId);
gl_fbo_->glRenderbufferStorageMultisample(GL_RENDERBUFFER, ms_samples, GL_RGBA8, IMG_SIZE_X, IMG_SIZE_Y);
// Create multisample depth buffer
gl_fbo_->glGenRenderbuffers(1, &ms_DepthBufferId);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, ms_DepthBufferId);
gl_fbo_->glRenderbufferStorageMultisample(GL_RENDERBUFFER, ms_samples, GL_DEPTH_COMPONENT24, IMG_SIZE_X, IMG_SIZE_Y);
// Attach render buffers to FBO
gl_fbo_->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, ms_ColorBufferId);
gl_fbo_->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, ms_DepthBufferId);
// Check FBO status
GLenum ms_status = gl_fbo_->glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(ms_status != GL_FRAMEBUFFER_COMPLETE) {
qDebug() << "Error: FBO ms_status != GL_FRAMEBUFFER_COMPLETE";
return QImage();
}
// ------------ Create standard FBO --------------------
GLuint fboId;
GLuint textureId;
GLuint rboId;
// Create FBO
gl_fbo_->glGenFramebuffers(1, &fboId);
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, fboId);
// Create color texture
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, IMG_SIZE_X, IMG_SIZE_Y, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
// Create depth buffer
gl_fbo_->glGenRenderbuffers(1, &rboId);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, rboId);
gl_fbo_->glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, IMG_SIZE_X, IMG_SIZE_Y);
gl_fbo_->glBindRenderbuffer(GL_RENDERBUFFER, 0);
// Attach render buffers / textures to FBO
gl_fbo_->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0);
gl_fbo_->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId);
// Check FBO status
GLenum status = gl_fbo_->glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE) {
qDebug() << "Error: FBO status != GL_FRAMEBUFFER_COMPLETE";
return QImage();
}
// ------------ Render scene to multisample FBO --------------------
// Bind FBO
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, ms_fboId);
// Set viewport
GLint oldViewport[4];
glGetIntegerv(GL_VIEWPORT, oldViewport);
glViewport(0, 0, IMG_SIZE_X, IMG_SIZE_Y);
// XXX is this necessary? (copied from paintGL)
glDepthMask(GL_TRUE);
// Clear the window and buffers
glClearColor(1, 1, 1, 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Initialize the view and lighting
// This is like setCameraPositionAndOrientation(), but with a slightly
// different gluPerspective to account for the new size
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(isOrtho_)
{
double h = 2 * camera_.r() * tan(camera_.fovy()/2.0);
double ratio = h / IMG_SIZE_Y;
double w = IMG_SIZE_X * ratio;
glOrtho (-0.5*w, 0.5*w, -0.5*h, 0.5*h, 0, 100);
}
else
{
gluPerspective(camera_.fovy() * 180 / M_PI,
(double) IMG_SIZE_X / (double) IMG_SIZE_Y,
0.1, 100);
}
glScaled(1, -1, 1); // Invert Y-axis for compatibility with QImage
Eigen::Vector3d pos = camera_.position();
Eigen::Vector3d focus = camera_.focusPoint();
Eigen::Vector3d up = camera_.upDirection();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(pos[0], pos[1], pos[2],
focus[0], focus[1], focus[2],
up[0], up[1], up[2]);
setLighting();
setMaterial(material_);
glEnable(GL_COLOR_MATERIAL);
// Draw scene
drawSceneDelegate_(t);
// Restore viewport
glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
// Unbind FBO
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebufferObject());
// ------ Blit multisample FBO to standard FBO ---------
// Bind multisample FBO for reading
gl_fbo_->glBindFramebuffer(GL_READ_FRAMEBUFFER, ms_fboId);
// Bind standard FBO for drawing
gl_fbo_->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fboId);
// Blit
gl_fbo_->glBlitFramebuffer(0, 0, IMG_SIZE_X, IMG_SIZE_Y, 0, 0, IMG_SIZE_X, IMG_SIZE_Y, GL_COLOR_BUFFER_BIT, GL_NEAREST);
// Unbind FBO
gl_fbo_->glBindFramebuffer(GL_FRAMEBUFFER, defaultFramebufferObject());
// ------ Read standard FBO to RAM data ---------
// Bind standard FBO for reading
glBindTexture(GL_TEXTURE_2D, textureId);
// Read
uchar * img = new uchar[4 * IMG_SIZE_X * IMG_SIZE_Y];
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img);
// Unbind FBO
glBindTexture(GL_TEXTURE_2D, 0);
// ------ Release allocated GPU memory ---------
gl_fbo_->glDeleteFramebuffers(1, &ms_fboId);
gl_fbo_->glDeleteRenderbuffers(1, &ms_ColorBufferId);
gl_fbo_->glDeleteRenderbuffers(1, &ms_DepthBufferId);
gl_fbo_->glDeleteFramebuffers(1, &fboId);
gl_fbo_->glDeleteRenderbuffers(1, &rboId);
glDeleteTextures(1, &textureId);
// ------ un-premultiply alpha ---------
// Once can notice that glBlendFuncSeparate(alpha, 1-alpha, 1, 1-alpha)
// performs the correct blending function with input:
// Frame buffer color as pre-multiplied alpha
// Input fragment color as post-multiplied alpha
// and output:
// New frame buffer color as pre-multiplied alpha
//
// So by starting with glClearColor(0.0, 0.0, 0.0, 0.0), which is the
// correct pre-multiplied representation for fully transparent, then
// by specifying glColor() in post-multiplied alpha, we get the correct
// blending behaviour and simply have to un-premultiply the value obtained
// in the frame buffer at the very end
for(int k=0; k<IMG_SIZE_X*IMG_SIZE_Y; ++k)
{
uchar * pixel = &(img[4*k]);
double a = pixel[3];
if( 0 < a && a < 255 )
{
double s = 255.0 / a;
pixel[0] = (uchar) (std::min(255.0,std::floor(0.5+s*pixel[0])));
pixel[1] = (uchar) (std::min(255.0,std::floor(0.5+s*pixel[1])));
pixel[2] = (uchar) (std::min(255.0,std::floor(0.5+s*pixel[2])));
}
}
// ------ Convert to Qimage ---------
// Create cleanup info to delete[] img when appropriate
QImageCleanupFunction cleanupFunction = &imageCleanupHandler;
void * cleanupInfo = reinterpret_cast<void*>(img);
// Create QImage
QImage res(img, IMG_SIZE_X, IMG_SIZE_Y, QImage::Format_RGBA8888, cleanupFunction, cleanupInfo);
// Return QImage
return res;
}
bool View3D::exportMesh(QString filename)
{
using namespace VectorAnimationComplex;
QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return false;
// Get VAC
VAC * vac = scene_->activeVAC();
if (!vac) {
return false;
}
// Get mesh geometry
QList<Eigen::Vector3d> positions;
QList<Eigen::Vector3d> normals;
QList<int> indices;
const ZOrderedCells & cells = vac->zOrdering();
for(auto it = cells.cbegin(); it != cells.cend(); ++it)
{
if (InbetweenEdge * ie = (*it)->toInbetweenEdge()) {
ie->getMesh(viewSettings_, positions, normals, indices);
}
}
// Write to file.
double s = viewSettings_.spaceScale();
QTextStream out(&file);
out.setLocale(QLocale::c());
out.setRealNumberNotation(QTextStream::FixedNotation);
out.setRealNumberPrecision(6);
for (Eigen::Vector3d& p : positions) {
out << "v " << s * p[0] << " " << s * p[1] << " " << s * p[2] << "\n";
}
for (Eigen::Vector3d p : normals) {
p.normalize();
out << "vn " << p[0] << " " << p[1] << " " << p[2] << "\n";
}
for (int i = 3; i < indices.size(); i += 4) {
int k1 = indices[i-3];
int k2 = indices[i-2];
int k3 = indices[i-1];
int k4 = indices[i];
out << "f "
<< k1 << "//" << k1 << " "
<< k2 << "//" << k2 << " "
<< k3 << "//" << k3 << " "
<< k4 << "//" << k4 << "\n";
}
return true;
}
| 32.554117 | 124 | 0.600466 | CELLINKAB |
7e7c5dddb92ae7751e8674adbc992a91043ad3ab | 2,905 | cc | C++ | test/persist_alloc_read.cc | moksha11/nvmalloc | 7ea255d09b1aed3acab8344be6904464aab8ba11 | [
"BSD-3-Clause"
] | 2 | 2015-06-11T17:50:53.000Z | 2015-07-04T08:24:50.000Z | test/persist_alloc_read.cc | moksha11/nvmalloc | 7ea255d09b1aed3acab8344be6904464aab8ba11 | [
"BSD-3-Clause"
] | null | null | null | test/persist_alloc_read.cc | moksha11/nvmalloc | 7ea255d09b1aed3acab8344be6904464aab8ba11 | [
"BSD-3-Clause"
] | null | null | null |
/*
* malloc-test
* cel - Thu Jan 7 15:49:16 EST 1999
*
* Benchmark libc's malloc, and check how well it
* can handle malloc requests from multiple threads.
*
* Syntax:
* malloc-test [ size [ iterations [ thread count ]]]
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>
#include <nv_map.h>
#include <c_io.h>
#ifdef ENABLE_MPI_RANKS
#include "mpi.h"
#endif
#define USECSPERSEC 1000000
#define pthread_attr_default NULL
#define MAX_THREADS 2
#define BASE_PROC_ID 20000
unsigned int procid;
void run_test(char a);
static unsigned size = 10487657; /* 1MB */
static int total_iterations = 10;
int main(int argc, char *argv[])
{
if(argc < 2) {
fprintf(stdout, "enter read (r) or write(w) mode \n");
exit(0);
}
nvinit_(BASE_PROC_ID);
#ifdef ENABLE_MPI_RANKS
MPI_Init (&argc, &argv);
#endif
printf("Starting test...\n");
if(!strcmp(argv[1], "w"))
run_test('w');
else
run_test('r');
exit(0);
}
void run_test(char r)
{
register int i;
register unsigned request_size = size;
struct timeval start, end, null, elapsed, adjusted;
#ifdef ENABLE_MPI_RANKS
int rank;
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
fprintf(stderr,"rank %d \n",rank);
procid = rank + 1;
#else
procid = 1;
#endif
/*
* Time a null loop. We'll subtract this from the final
* malloc loop results to get a more accurate value.
*/
null.tv_sec = end.tv_sec - start.tv_sec;
null.tv_usec = end.tv_usec - start.tv_usec;
if (null.tv_usec < 0) {
null.tv_sec--;
null.tv_usec += USECSPERSEC;
}
/*
* Run the real malloc test
*/
gettimeofday(&start, NULL);
for (i = 0; i < total_iterations; i++) {
register char * buf;
char varname[100];
bzero(varname,0);
sprintf(varname,"%d",i);
strcat(varname,"_");
strcat(varname,(char* )"buf");
if(r == 'w') {
buf = (char *)nvalloc_(size,varname,BASE_PROC_ID);
assert(buf);
for(unsigned int j=0; j < size; j++)
buf[j]= 'a' + (char)i;
}else{
buf = (char *)nvread_(varname,BASE_PROC_ID);
assert(buf);
fprintf(stdout,"varname %s\n", varname);
//TODO: Add verify code
//for(unsigned int j=0;j<size;j++)
// fprintf(stdout,"%d:%c",j,buf[j]);
}
fprintf(stdout,"\n");
}
gettimeofday(&end, NULL);
elapsed.tv_sec = end.tv_sec - start.tv_sec;
elapsed.tv_usec = end.tv_usec - start.tv_usec;
if (elapsed.tv_usec < 0) {
elapsed.tv_sec--;
elapsed.tv_usec += USECSPERSEC;
}
/*
* Adjust elapsed time by null loop time
*/
adjusted.tv_sec = elapsed.tv_sec - null.tv_sec;
adjusted.tv_usec = elapsed.tv_usec - null.tv_usec;
if (adjusted.tv_usec < 0) {
adjusted.tv_sec--;
adjusted.tv_usec += USECSPERSEC;
}
printf("Thread %lu adjusted timing: %lu.%06lu seconds for %d requests"
" of %d bytes.\n", pthread_self(),
elapsed.tv_sec, elapsed.tv_usec, total_iterations,
request_size);
pthread_exit(NULL);
}
| 20.75 | 71 | 0.655422 | moksha11 |
7e7edbfb94cbfde933bbb33f93444919b6348b2f | 7,814 | hpp | C++ | src/ibeo_8l_sdk/src/ibeosdk/datablocks/snippets/ObjectEcu.hpp | tomcamp0228/ibeo_ros2 | ff56c88d6e82440ae3ce4de08f2745707c354604 | [
"MIT"
] | 1 | 2020-06-19T11:01:49.000Z | 2020-06-19T11:01:49.000Z | include/ibeosdk/datablocks/snippets/ObjectEcu.hpp | chouer19/enjoyDriving | e4a29e6cad7d3b0061d59f584cce7cdea2a55351 | [
"MIT"
] | null | null | null | include/ibeosdk/datablocks/snippets/ObjectEcu.hpp | chouer19/enjoyDriving | e4a29e6cad7d3b0061d59f584cce7cdea2a55351 | [
"MIT"
] | 2 | 2020-06-19T11:01:48.000Z | 2020-10-29T03:07:14.000Z | //======================================================================
/*! \file ObjectEcu.hpp
*
* \copydoc Copyright
* \author Mario Brumm (mb)
* \date Apr 26, 2012
*///-------------------------------------------------------------------
#ifndef IBEOSDK_OBJECTECU_HPP_SEEN
#define IBEOSDK_OBJECTECU_HPP_SEEN
//======================================================================
#include <ibeosdk/misc/WinCompatibility.hpp>
#include <ibeosdk/datablocks/snippets/Point2dFloat.hpp>
#include <ibeosdk/Time.hpp>
#include <ibeosdk/ObjectBasic.hpp>
#include <ibeosdk/datablocks/snippets/Snippet.hpp>
#include <ibeosdk/misc/deprecatedwarning.hpp>
#include <vector>
#include <iostream>
//======================================================================
namespace ibeosdk {
//======================================================================
class ObjectEcu : public Snippet {
public:
ObjectEcu();
ObjectEcu(const ObjectEcu& src);
public:
virtual std::streamsize getSerializedSize() const;
virtual bool deserialize(std::istream& is);
virtual bool serialize(std::ostream& os) const;
// int getSerializedSize() const;
public:
UINT16 getObjectId() const { return m_id; }
UINT16 getReserved() const { return m_reserved; }
UINT32 getObjectAge() const { return m_age; }
NTPTime getTimestamp() const { return m_timestamp; }
UINT16 getHiddenStatusAge() const { return m_hiddenStatusAge; }
ObjectClass getClassification() const { return m_class; }
UINT8 getClassificationCertainty() const { return m_classCertainty; }
UINT32 getClassificationAge() const { return m_classAge; }
Point2dFloat getBoundingBoxCenter() { return m_boundingBoxCenter; }
const Point2dFloat& getBoundingBoxCenter() const { return m_boundingBoxCenter; }
Point2dFloat getBoundingBoxSize() { return m_boundingBoxSize; }
const Point2dFloat& getBoundingBoxSize() const { return m_boundingBoxSize; }
Point2dFloat getObjectBoxCenter() { return m_objectBoxCenter; }
const Point2dFloat& getObjectBoxCenter() const { return m_objectBoxCenter; }
Point2dFloat getObjectBoxSigma() { return m_objectBoxSigma; }
const Point2dFloat& getObjectBoxSigma() const { return m_objectBoxSigma; }
Point2dFloat getObjectBoxSize() { return m_objectBoxSize; }
const Point2dFloat& getObjectBoxSize() const { return m_objectBoxSize; }
UINT64 getReserved2() const { return m_reserved2; }
IBEOSDK_DEPRECATED float getYawAngle() const { return m_objectBoxOrientation; }
IBEOSDK_DEPRECATED float getYawAngleSigma() const { return m_objectBoxOrientationSigma; }
float getObjectBoxOrientation() const { return m_objectBoxOrientation; }
float getObjectBoxOrientationSigma() const { return m_objectBoxOrientationSigma; }
Point2dFloat getRelativeVelocity() { return m_relVelocity; }
const Point2dFloat& getRelativeVelocity() const { return m_relVelocity; }
Point2dFloat getRelativeVelocitySigma() { return m_relVelocitySigma; }
const Point2dFloat& getRelativeVelocitySigma() const { return m_relVelocitySigma; }
Point2dFloat getAbsoluteVelocity() { return m_absVelocity; }
const Point2dFloat& getAbsoluteVelocity() const { return m_absVelocity; }
Point2dFloat getAbsoluteVelocitySigma() { return m_absVelocitySigma; }
const Point2dFloat& getAbsoluteVelocitySigma() const { return m_absVelocitySigma; }
float getOrientation() const { return this->m_orientation; }
UINT8 getNumberOfContourPoints() const { return m_numContourPoints; }
std::vector<Point2dFloat>& getContourPoints() { return m_contourPoints; }
const std::vector<Point2dFloat>& getContourPoints() const { return m_contourPoints; }
UINT8 getIndexOfClosestPoint() const { return m_indexOfClosedPoint; }
public:
void setObjectId(const UINT16 newObjectId) { m_id = newObjectId; }
void setReserved( const UINT16 newReserved) { m_reserved = newReserved; }
void setObjectAge(const UINT32 newObjectAge) { m_age = newObjectAge; }
void setTimestamp(const NTPTime newTimestamp) { m_timestamp = newTimestamp; }
void setHiddenStatusAge(const UINT16 newHiddenStatusAge) { m_hiddenStatusAge = newHiddenStatusAge; }
void setClassification(const ObjectClass newClassification) { m_class = newClassification; }
void setClassificationCertainty(const UINT8 newClassificationCertainty) { m_classCertainty = newClassificationCertainty; }
void setClassificationAge(const UINT32 newClassificationAge) { m_classAge = newClassificationAge; }
void setBoundingBoxCenter(const Point2dFloat& newBoundingBoxCenter) { m_boundingBoxCenter = newBoundingBoxCenter; }
void setBoundingBoxSize(const Point2dFloat& newBoundingBoxSize) { m_boundingBoxSize=newBoundingBoxSize; }
void setReserved2(const UINT64& newReserved2) { m_reserved2 = newReserved2; }
void setObjectBoxCenter(const Point2dFloat& newObjectBoxCenter) { m_objectBoxCenter=newObjectBoxCenter; }
void setObjectBoxSigma(const Point2dFloat& newObjectBoxSigma) { m_objectBoxSigma=newObjectBoxSigma; }
void setObjectBoxSize(const Point2dFloat& newObjectBoxSize) { m_objectBoxSize=newObjectBoxSize; }
IBEOSDK_DEPRECATED void setYawAngle(const float newObjBoxOrientation) { m_objectBoxOrientation=newObjBoxOrientation; }
IBEOSDK_DEPRECATED void setYawAngleSigma(const float newObjBoxOrientationSigma) { m_objectBoxOrientationSigma=newObjBoxOrientationSigma; }
void setObjBoxOrientation(const float newObjBoxOrientation) { m_objectBoxOrientation = newObjBoxOrientation; }
void setObjBoxOrientationSigma(const float newObjBoxOrientationSigma) { m_objectBoxOrientationSigma = newObjBoxOrientationSigma; }
void setRelativeVelocity(const Point2dFloat& newRelativeVelocity) { m_relVelocity=newRelativeVelocity; }
void setRelativeVelocitySigma(const Point2dFloat& newRelativeVelocitySigma) { m_relVelocitySigma=newRelativeVelocitySigma; }
void setAbsoluteVelocity(const Point2dFloat& newAbsoluteVelocity) { m_absVelocity=newAbsoluteVelocity; }
void setAbsoluteVelocitySigma(const Point2dFloat& newAbsoluteVelocitySigma) { m_absVelocitySigma=newAbsoluteVelocitySigma; }
void setOrientation(const float newOrientation) { this->m_orientation = newOrientation; }
void setNumberOfContourPoints(const UINT8 newNumberOfContourPoints) { m_numContourPoints = newNumberOfContourPoints; }
void setContourPoints(const std::vector<Point2dFloat>& newContourPoints) { m_contourPoints = newContourPoints; }
void setIndexOfClosestPoint(const UINT8 newIndexOfClosestPoint) { m_indexOfClosedPoint = newIndexOfClosestPoint; }
public:
bool operator==(const ObjectEcu& other) const;
bool operator!=(const ObjectEcu& other) const { return !((*this) == other); }
protected:
static const int nbOfBytesInReserved3 = 18;
protected:
UINT16 m_id;
UINT16 m_reserved;
UINT32 m_age;
NTPTime m_timestamp;
UINT16 m_hiddenStatusAge;
ObjectClass m_class;
UINT8 m_classCertainty;
UINT32 m_classAge;
Point2dFloat m_boundingBoxCenter;
Point2dFloat m_boundingBoxSize;
Point2dFloat m_objectBoxCenter;
Point2dFloat m_objectBoxSigma;
Point2dFloat m_objectBoxSize;
UINT64 m_reserved2;
float m_objectBoxOrientation;
float m_objectBoxOrientationSigma;
Point2dFloat m_relVelocity;
Point2dFloat m_relVelocitySigma;
Point2dFloat m_absVelocity;
Point2dFloat m_absVelocitySigma;
char m_reserved3[nbOfBytesInReserved3];
UINT8 m_numContourPoints;
UINT8 m_indexOfClosedPoint;
std::vector<Point2dFloat> m_contourPoints;
protected: // not serialized data
float m_orientation;
}; // ObjectEcu
//======================================================================
std::ostream& operator<<(std::ostream& os, const ObjectEcu& o);
//======================================================================
} // namespace ibeosdk
//======================================================================
#endif // IBEOSDK_OBJECTECU_HPP_SEEN
//======================================================================
| 41.343915 | 139 | 0.743665 | tomcamp0228 |
7e8c99a09f05faf22d17891c7bfe7bc5f4fb7178 | 3,017 | cc | C++ | src/Core/GeometryPrimitives/OrientedBBox.cc | kimjohn1/SCIRun | 62ae6cb632100371831530c755ef0b133fb5c978 | [
"MIT"
] | 92 | 2015-02-09T22:42:11.000Z | 2022-03-25T09:14:50.000Z | src/Core/GeometryPrimitives/OrientedBBox.cc | kimjohn1/SCIRun | 62ae6cb632100371831530c755ef0b133fb5c978 | [
"MIT"
] | 1,618 | 2015-01-05T19:39:13.000Z | 2022-03-27T20:28:45.000Z | src/Core/GeometryPrimitives/OrientedBBox.cc | kimjohn1/SCIRun | 62ae6cb632100371831530c755ef0b133fb5c978 | [
"MIT"
] | 64 | 2015-02-20T17:51:23.000Z | 2021-11-19T07:08:08.000Z | /*
For more information, please see: http://software.sci.utah.edu
The MIT License
Copyright (c) 2020 Scientific Computing and Imaging Institute,
University of Utah.
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 <Core/Utils/Exception.h>
#include <Core/GeometryPrimitives/OrientedBBox.h>
using namespace SCIRun;
using namespace SCIRun::Core::Geometry;
OrientedBBox::OrientedBBox(const Vector &e1, const Vector &e2, const Vector &e3)
: BBoxBase(false)
{
eigvecs_ = {e1, e2, e3};
}
void OrientedBBox::extend(const Point &p)
{
auto originToPos = Vector(p);
if (is_valid_)
for (int iDim = 0; iDim < 3; ++iDim)
{
auto projectedPos = Dot(originToPos, eigvecs_[iDim]);
cmin_[iDim] = std::min(projectedPos, cmin_[iDim]);
cmax_[iDim] = std::max(projectedPos, cmax_[iDim]);
}
else
{
is_valid_ = true;
for (int iDim = 0; iDim < 3; ++iDim)
{
auto projectedPos = Dot(originToPos, eigvecs_[iDim]);
cmin_[iDim] = projectedPos;
cmax_[iDim] = projectedPos;
}
}
}
/// Extend the bounding box on all sides by a margin
/// For example to expand it by a certain epsilon to make
/// sure that a lookup will be inside the bounding box
void OrientedBBox::extend(double val)
{
if (is_valid_)
{
cmin_.x(cmin_.x()-val);
cmin_.y(cmin_.y()-val);
cmin_.z(cmin_.z()-val);
cmax_.x(cmax_.x()+val);
cmax_.y(cmax_.y()+val);
cmax_.z(cmax_.z()+val);
}
}
Vector OrientedBBox::diagonal() const
{
//TODO: needs invariant check, or refactoring.
if (!is_valid_)
THROW_INVALID_STATE("OrientedBBox is not valid.");
return cmax_-cmin_;
}
Point OrientedBBox::get_min() const
{ return cmin_; }
Point OrientedBBox::get_max() const
{ return cmax_; }
Point OrientedBBox::center() const
{
Vector d = diagonal();
return cmin_ + (d * 0.5);
}
std::ostream& SCIRun::Core::Geometry::operator<<(std::ostream& out, const OrientedBBox& b)
{
return out << b.get_min() << " : " << b.get_max();
}
| 29.291262 | 90 | 0.698044 | kimjohn1 |
7e9041ab19b10b9bdde25fc7195d0a9af2350a32 | 12,514 | cpp | C++ | stdlib/core.cpp | Oj18/Ethereal | 16a0a167693c27615e5c63044f1c38b5c8d863b2 | [
"BSD-3-Clause"
] | null | null | null | stdlib/core.cpp | Oj18/Ethereal | 16a0a167693c27615e5c63044f1c38b5c8d863b2 | [
"BSD-3-Clause"
] | null | null | null | stdlib/core.cpp | Oj18/Ethereal | 16a0a167693c27615e5c63044f1c38b5c8d863b2 | [
"BSD-3-Clause"
] | null | null | null | /*
Copyright (c) 2019, Electrux
All rights reserved.
Using the BSD 3-Clause license for the project,
main LICENSE file resides in project's root directory.
Please read that file and understand the license terms
before using or altering the project.
*/
#include "../src/VM/Core.hpp"
#include "Core/Int.hpp"
#include "Core/Flt.hpp"
#include "Core/Bool.hpp"
const int MAX_C_STR_LEN = 1025;
var_base_t * flush_out( vm_state_t & vm, func_call_data_t & fcd )
{
fflush( stdout );
return nullptr;
}
var_base_t * flush_err( vm_state_t & vm, func_call_data_t & fcd )
{
fflush( stderr );
return nullptr;
}
var_base_t * print( vm_state_t & vm, func_call_data_t & fcd )
{
for( auto & v : fcd.args ) {
fprintf( stdout, "%s", v->to_str().c_str() );
}
return nullptr;
}
var_base_t * println( vm_state_t & vm, func_call_data_t & fcd )
{
for( auto & v : fcd.args ) {
fprintf( stdout, "%s", v->to_str().c_str() );
}
fprintf( stdout, "\n" );
return nullptr;
}
var_base_t * dprint( vm_state_t & vm, func_call_data_t & fcd )
{
for( auto & v : fcd.args ) {
fprintf( stderr, "%s", v->to_str().c_str() );
}
return nullptr;
}
var_base_t * dprintln( vm_state_t & vm, func_call_data_t & fcd )
{
for( auto & v : fcd.args ) {
fprintf( stderr, "%s", v->to_str().c_str() );
}
fprintf( stderr, "\n" );
return nullptr;
}
var_base_t * scan( vm_state_t & vm, func_call_data_t & fcd )
{
if( fcd.args.size() > 0 ) fprintf( stdout, "%s", fcd.args[ 0 ]->to_str().c_str() );
char str[ MAX_C_STR_LEN ];
fgets( str, MAX_C_STR_LEN, stdin );
std::string res( str );
while( res.back() == '\n' ) res.pop_back();
while( res.back() == '\r' ) res.pop_back();
return new var_str_t( res );
}
var_base_t * type( vm_state_t & vm, func_call_data_t & fcd )
{
return new var_str_t( fcd.args[ 0 ]->type_str() );
}
var_base_t * to_str( vm_state_t & vm, func_call_data_t & fcd )
{
return new var_str_t( fcd.args[ 0 ]->to_str() );
}
var_base_t * exit_eth( vm_state_t & vm, func_call_data_t & fcd )
{
vm.exit_called = true;
vm.exit_status = fcd.args.size() == 0 ? 0 : fcd.args[ 0 ]->to_int().get_si();
return nullptr;
}
var_base_t * assert_eth( vm_state_t & vm, func_call_data_t & fcd )
{
if( fcd.args[ 0 ]->to_bool() ) { return nullptr; }
src_t & src = * vm.srcstack.back();
int line = src.bcode[ vm.bcodectr.back() ].line;
int col = src.bcode[ vm.bcodectr.back() ].col;
std::string op;
int sz = fcd.args.size();
for( int i = 1; i < sz; ++i ) {
op += fcd.args[ i ]->to_str();
}
src_fail( src.name, src.code[ line - 1 ], line, col, "assertion failed: %s", op.c_str() );
vm.exit_called = true;
vm.exit_status = 1;
return nullptr;
}
var_base_t * var_exists( vm_state_t & vm, func_call_data_t & fcd )
{
return TRUE_FALSE( vm.vars->exists( fcd.args[ 0 ]->to_str(), true ) );
}
var_base_t * var_mfn_exists( vm_state_t & vm, func_call_data_t & fcd )
{
if( vm.typefuncs.find( fcd.args[ 0 ]->type_str() ) == vm.typefuncs.end() ) return vm.vars->get( "false" );
return TRUE_FALSE( vm.typefuncs[ fcd.args[ 0 ]->type_str() ].exists_name( fcd.args[ 1 ]->to_str() ) );
}
var_base_t * var_ref_count( vm_state_t & vm, func_call_data_t & fcd )
{
if( !vm.vars->exists( fcd.args[ 0 ]->to_str(), true ) ) return new var_int_t( -1 );
return new var_int_t( vm.vars->get( fcd.args[ 0 ]->to_str() )->ref() );
}
var_base_t * nil_eq( vm_state_t & vm, func_call_data_t & fcd )
{
return TRUE_FALSE( fcd.args[ 1 ]->type() == fcd.args[ 0 ]->type() );
}
var_base_t * nil_ne( vm_state_t & vm, func_call_data_t & fcd )
{
return TRUE_FALSE( fcd.args[ 1 ]->type() != fcd.args[ 0 ]->type() );
}
REGISTER_MODULE( core )
{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////// CORE ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
vm.funcs.add( { "flush_out", 0, 0, {}, FnType::MODULE, { .modfn = flush_out }, false } );
vm.funcs.add( { "flush_err", 0, 0, {}, FnType::MODULE, { .modfn = flush_err }, false } );
vm.funcs.add( { "print", 1, -1, { "_whatever_" }, FnType::MODULE, { .modfn = print }, false } );
vm.funcs.add( { "println", 0, -1, { "_whatever_" }, FnType::MODULE, { .modfn = println }, false } );
vm.funcs.add( { "dprint", 1, -1, { "_whatever_" }, FnType::MODULE, { .modfn = dprint }, false } );
vm.funcs.add( { "dprintln", 0, -1, { "_whatever_" }, FnType::MODULE, { .modfn = dprintln }, false } );
vm.funcs.add( { "scan", 0, 1, { "_whatever_" }, FnType::MODULE, { .modfn = scan }, true } );
vm.funcs.add( { "exit", 0, 1, { "_any_" }, FnType::MODULE, { .modfn = exit_eth }, false } );
vm.funcs.add( { "assert", 2, -1, { "_any_", "_whatever_" }, FnType::MODULE, { .modfn = assert_eth }, false } );
vm.funcs.add( { "var_exists", 1, 1, { "str" }, FnType::MODULE, { .modfn = var_exists }, false } );
vm.funcs.add( { "var_mfn_exists",2, 2, { "_any_", "str" }, FnType::MODULE, { .modfn = var_mfn_exists }, false } );
vm.funcs.add( { "var_ref_count", 1, 1, { "_any_" }, FnType::MODULE, { .modfn = var_ref_count }, true } );
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// INT ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// basic arithmetic
vm.funcs.add( { "+", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = add }, true } );
vm.funcs.add( { "-", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = sub }, true } );
vm.funcs.add( { "*", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = mul }, true } );
vm.funcs.add( { "/", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = div }, true } );
vm.funcs.add( { "%", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = mod }, true } );
// arithmetic assignments
vm.funcs.add( { "+=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = add_assn }, false } );
vm.funcs.add( { "-=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = sub_assn }, false } );
vm.funcs.add( { "*=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = mul_assn }, false } );
vm.funcs.add( { "/=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = div_assn }, false } );
vm.funcs.add( { "%=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = mod_assn }, false } );
// comparisons
vm.funcs.add( { "==", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = eqi }, false } );
vm.funcs.add( { "!=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = nei }, false } );
vm.funcs.add( { "<", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = lti }, false } );
vm.funcs.add( { "<=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = lei }, false } );
vm.funcs.add( { ">", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = gti }, false } );
vm.funcs.add( { ">=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = gei }, false } );
vm.funcs.add( { "!", 1, 1, { "int" }, FnType::MODULE, { .modfn = not_oper }, false } );
// bitshift
vm.funcs.add( { "<<", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = lshift }, true } );
vm.funcs.add( { ">>", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = rshift }, true } );
// bitwise assignments
vm.funcs.add( { "<<=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = lshift_assn }, false } );
vm.funcs.add( { ">>=", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = rshift_assn }, false } );
// bitwise
vm.funcs.add( { "&", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = andi }, true } );
vm.funcs.add( { "|", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = ori }, true } );
vm.funcs.add( { "~", 1, 1, { "int" }, FnType::MODULE, { .modfn = not_oper_bitwise }, true } );
// cool arithmetic
vm.funcs.add( { "**", 2, 2, { "int", "int" }, FnType::MODULE, { .modfn = power }, true } );
// unary
vm.funcs.add( { "u-", 1, 1, { "int" }, FnType::MODULE, { .modfn = unary_sub }, true } );
// other types to int
vm.funcs.add( { "num", 1, 1, { "_any_" }, FnType::MODULE, { .modfn = num }, true } );
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// FLT ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// basic arithmetic
vm.funcs.add( { "+", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = addf }, true } );
vm.funcs.add( { "-", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = subf }, true } );
vm.funcs.add( { "*", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = mulf }, true } );
vm.funcs.add( { "/", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = divf }, true } );
// arithmetic assignments
vm.funcs.add( { "+=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = add_assnf }, false } );
vm.funcs.add( { "-=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = sub_assnf }, false } );
vm.funcs.add( { "*=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = mul_assnf }, false } );
vm.funcs.add( { "/=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = div_assnf }, false } );
// comparisons
vm.funcs.add( { "==", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = eqf }, false } );
vm.funcs.add( { "!=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = nef }, false } );
vm.funcs.add( { "<", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = ltf }, false } );
vm.funcs.add( { "<=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = lef }, false } );
vm.funcs.add( { ">", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = gtf }, false } );
vm.funcs.add( { ">=", 2, 2, { "flt", "flt" }, FnType::MODULE, { .modfn = gef }, false } );
vm.funcs.add( { "!", 1, 1, { "flt" }, FnType::MODULE, { .modfn = not_operf }, false } );
// cool arithmetic
vm.funcs.add( { "**", 2, 2, { "int", "flt" }, FnType::MODULE, { .modfn = powerf }, true } );
// unary
vm.funcs.add( { "u-", 1, 1, { "flt" }, FnType::MODULE, { .modfn = unary_subf }, true } );
// other types to flt
vm.funcs.add( { "flt", 1, 1, { "_any_" }, FnType::MODULE, { .modfn = flt }, true } );
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// BOOL ///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// basic logical
vm.funcs.add( { "==", 2, 2, { "bool", "bool" }, FnType::MODULE, { .modfn = log_eq }, false } );
vm.funcs.add( { "!=", 2, 2, { "bool", "bool" }, FnType::MODULE, { .modfn = log_ne }, false } );
vm.funcs.add( { "!", 1, 1, { "bool" }, FnType::MODULE, { .modfn = not_operb }, false } );
// other types to bool
vm.funcs.add( { "bool", 1, 1, { "_any_" }, FnType::MODULE, { .modfn = bool_create }, false } );
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// NIL ////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
vm.funcs.add( { "==", 2, 2, { "nil", "_any_" }, FnType::MODULE, { .modfn = nil_eq }, false } );
vm.funcs.add( { "==", 2, 2, { "_any_", "nil" }, FnType::MODULE, { .modfn = nil_eq }, false } );
vm.funcs.add( { "!=", 2, 2, { "nil", "_any_" }, FnType::MODULE, { .modfn = nil_ne }, false } );
vm.funcs.add( { "!=", 2, 2, { "_any_", "nil" }, FnType::MODULE, { .modfn = nil_ne }, false } );
// global object functions
functions_t & anyfns = vm.typefuncs[ "_any_" ];
anyfns.add( { "type", 0, 0, {}, FnType::MODULE, { .modfn = type }, true } );
anyfns.add( { "to_str", 0, 0, {}, FnType::MODULE, { .modfn = to_str }, true } );
} | 48.503876 | 136 | 0.464839 | Oj18 |
7e9fe639bcc6cb8a18084be9f50fccce240f8070 | 384 | cpp | C++ | osu!gen/src/osu!gen.cpp | cody-bui/osu--aim-trainer | 7525bf271cf565bf83795a9178e32319c8d06629 | [
"MIT"
] | 1 | 2019-12-29T08:14:42.000Z | 2019-12-29T08:14:42.000Z | osu!gen/src/osu!gen.cpp | cody-bui/osu-aim-trainer | 7525bf271cf565bf83795a9178e32319c8d06629 | [
"MIT"
] | 2 | 2020-02-05T03:57:54.000Z | 2020-02-05T11:19:52.000Z | osu!gen/src/osu!gen.cpp | cody-bui/Echo | 7525bf271cf565bf83795a9178e32319c8d06629 | [
"MIT"
] | null | null | null | #include "osu!gen.h"
#include <Gen/GenCircle.h>
OsuGen::Program::Program()
{
patterns = new EchoGen::PatternList("PatternList.txt");
int index = 0;
std::ofstream map("map.txt");
std::vector<int> beat = { 0,500,1000 };
GenCircle gc;
gc.Gen(patterns, beat, index, map);
}
void OsuGen::Program::Run()
{
}
OsuGen::Program::~Program()
{
delete patterns;
} | 16.695652 | 57 | 0.625 | cody-bui |
7ea6a0a4f44f380c21cb1a0b39ec96603ceb4061 | 4,149 | cpp | C++ | External/RendererToolkit/Assimp/AssimpUnityBuild5.cpp | cofenberg/unrimp | 90310657f106eb83f3a9688329b78619255a1042 | [
"MIT"
] | 187 | 2015-11-02T21:27:57.000Z | 2022-02-17T21:39:17.000Z | External/RendererToolkit/Assimp/AssimpUnityBuild5.cpp | cofenberg/unrimp | 90310657f106eb83f3a9688329b78619255a1042 | [
"MIT"
] | null | null | null | External/RendererToolkit/Assimp/AssimpUnityBuild5.cpp | cofenberg/unrimp | 90310657f106eb83f3a9688329b78619255a1042 | [
"MIT"
] | 20 | 2015-11-04T19:17:01.000Z | 2021-11-18T11:23:25.000Z | /*********************************************************\
* Copyright (c) 2012-2021 The Unrimp Team
*
* 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.
\*********************************************************/
// Amalgamated/unity build
#ifdef _WIN32
// Disable warnings in external headers, we can't fix them
__pragma(warning(disable: 4355)) // warning C4355: 'this': used in base member initializer list
__pragma(warning(disable: 4619)) // warning C4619: #pragma warning: there is no warning number '4351'
__pragma(warning(disable: 4777)) // warning C4777: 'snprintf' : format string '%Iu' requires an argument of type 'unsigned int', but variadic argument 1 has type 'const size_t'
__pragma(warning(disable: 4826)) // warning C4826: Conversion from 'aiBone **' to 'uint64_t' is sign-extended. This may cause unexpected runtime behavior.
#endif
#include "Configuration.h"
// AssetLib
// FBX
#include "code/AssetLib/FBX/FBXImporter.cpp"
#include "code/AssetLib/FBX/FBXParser.cpp"
// PostProcessing
#include "code/PostProcessing/ArmaturePopulate.cpp"
#include "code/PostProcessing/CalcTangentsProcess.cpp"
#undef small // Get rid of some nasty macros
#include "code/PostProcessing/ComputeUVMappingProcess.cpp"
#include "code/PostProcessing/ConvertToLHProcess.cpp"
#include "code/PostProcessing/DeboneProcess.cpp"
#include "code/PostProcessing/DropFaceNormalsProcess.cpp"
#include "code/PostProcessing/EmbedTexturesProcess.cpp"
#include "code/PostProcessing/FindDegenerates.cpp"
#include "code/PostProcessing/FindInstancesProcess.cpp"
#include "code/PostProcessing/FindInvalidDataProcess.cpp"
#include "code/PostProcessing/FixNormalsStep.cpp"
#include "code/PostProcessing/GenBoundingBoxesProcess.cpp"
#include "code/PostProcessing/GenFaceNormalsProcess.cpp"
#include "code/PostProcessing/GenVertexNormalsProcess.cpp"
#include "code/PostProcessing/ImproveCacheLocality.cpp"
#include "code/PostProcessing/JoinVerticesProcess.cpp"
#include "code/PostProcessing/LimitBoneWeightsProcess.cpp"
#include "code/PostProcessing/MakeVerboseFormat.cpp"
#include "code/PostProcessing/OptimizeGraph.cpp"
#include "code/PostProcessing/OptimizeMeshes.cpp"
#include "code/PostProcessing/PretransformVertices.cpp"
#include "code/PostProcessing/ProcessHelper.cpp"
#include "code/PostProcessing/RemoveRedundantMaterials.cpp"
#include "code/PostProcessing/RemoveVCProcess.cpp"
#include "code/PostProcessing/ScaleProcess.cpp"
#include "code/PostProcessing/SortByPTypeProcess.cpp"
#include "code/PostProcessing/SplitByBoneCountProcess.cpp"
#include "code/PostProcessing/SplitLargeMeshes.cpp"
#include "code/PostProcessing/TextureTransform.cpp"
#include "code/PostProcessing/TriangulateProcess.cpp"
#include "code/PostProcessing/ValidateDataStructure.cpp"
// contrib
// irrXML
#include "contrib/irrXML/irrXML.cpp"
// poly2tri
#include "contrib/poly2tri/poly2tri/common/shapes.cc"
#include "contrib/poly2tri/poly2tri/sweep/advancing_front.cc"
#include "contrib/poly2tri/poly2tri/sweep/cdt.cc"
#include "contrib/poly2tri/poly2tri/sweep/sweep.cc"
#include "contrib/poly2tri/poly2tri/sweep/sweep_context.cc"
| 54.592105 | 177 | 0.772957 | cofenberg |
7eab5869e8eedc903422a73a34ee3e766d9f2480 | 1,305 | cpp | C++ | C++/LeetCode/0051.cpp | Nimesh-Srivastava/DSA | db33aa138f0df8ab6015d2e8ec3ddde1c6838848 | [
"MIT"
] | 4 | 2021-08-28T19:16:50.000Z | 2022-03-04T19:46:31.000Z | C++/LeetCode/0051.cpp | Nimesh-Srivastava/DSA | db33aa138f0df8ab6015d2e8ec3ddde1c6838848 | [
"MIT"
] | 8 | 2021-10-29T19:10:51.000Z | 2021-11-03T12:38:00.000Z | C++/LeetCode/0051.cpp | Nimesh-Srivastava/DSA | db33aa138f0df8ab6015d2e8ec3ddde1c6838848 | [
"MIT"
] | 4 | 2021-09-06T05:53:07.000Z | 2021-12-24T10:31:40.000Z | class Solution {
vector<vector<string>> ans;
public:
bool isValid(vector<string>& board, int row, int col){
//column checking
for(int i = row; i >= 0; i--)
if(board[i][col] == 'Q')
return false;
//left diagonal
for(int i = row, j = col; i >= 0 && j >= 0; i--, j--)
if(board[i][j] == 'Q')
return false;
//right diagonal
for(int i = row, j = col; i >= 0 && j < board.size(); i--, j++)
if(board[i][j] == 'Q')
return false;
return true;
}
void dfs(vector<string>& board, int row){
if(row == board.size()){
ans.push_back(board);
return;
}
for(int i = 0; i < board.size(); i++){
if(isValid(board, row, i)){
board[row][i] = 'Q';
dfs(board, row + 1);
board[row][i] = '.'; //bactracking
}
}
}
vector<vector<string>> solveNQueens(int n) {
if(n < 1)
return ans;
vector<string> board(n, string(n, '.'));
dfs(board, 0);
return ans;
}
};
| 24.166667 | 71 | 0.376245 | Nimesh-Srivastava |
7eb0fef8f15e20e9a813a0d88dd2a892d125e446 | 528 | cc | C++ | Dates/src/tools.cc | ULL-ESIT-IB-2020-2021/ib-practica11-oop-cmake-SergioPerera | 58b6d9fac4667fead018dc94ccbfbefa1c59a8c2 | [
"MIT"
] | null | null | null | Dates/src/tools.cc | ULL-ESIT-IB-2020-2021/ib-practica11-oop-cmake-SergioPerera | 58b6d9fac4667fead018dc94ccbfbefa1c59a8c2 | [
"MIT"
] | null | null | null | Dates/src/tools.cc | ULL-ESIT-IB-2020-2021/ib-practica11-oop-cmake-SergioPerera | 58b6d9fac4667fead018dc94ccbfbefa1c59a8c2 | [
"MIT"
] | null | null | null | #include <iostream>
#include <tools.h>
void Usage (int argc, char *argv[]){
if ( argc < 6 ){
std::cout << argv[0] << ": Falta un parámetro" << std::endl;
std::cout << "Pruebe " << argv[0] << " --help para más información" << std::endl;
}
std::string kHelpText = "Este programa necesita que se le introduzca una fecha tal que dd mm aaaa N fichero_salida.txt";
std::string parameter{argv[1]};
if ( parameter == "--help" ) {
std::cout << kHelpText << std::endl;
exit(EXIT_SUCCESS);
}
}
| 20.307692 | 122 | 0.592803 | ULL-ESIT-IB-2020-2021 |
7eb32dc621f8a1736557b2987e0fe669dd24881b | 130 | cpp | C++ | Code/Source/GPIO/RPI4Chip.cpp | MrAviator93/GPIO | 71b645eebad3cd5c8558c440ddb170f4292cc34b | [
"Unlicense"
] | null | null | null | Code/Source/GPIO/RPI4Chip.cpp | MrAviator93/GPIO | 71b645eebad3cd5c8558c440ddb170f4292cc34b | [
"Unlicense"
] | null | null | null | Code/Source/GPIO/RPI4Chip.cpp | MrAviator93/GPIO | 71b645eebad3cd5c8558c440ddb170f4292cc34b | [
"Unlicense"
] | null | null | null |
#include "RPI4Chip.hpp"
namespace GPIO
{
CRPI4GPIOChip::CRPI4GPIOChip()
: CGPIOChip( m_rpi4ChipName )
{ }
} // namespace GPIO
| 11.818182 | 30 | 0.715385 | MrAviator93 |
9d18f632cbd8454377cdc90cb567477f69e36ab6 | 465,649 | cpp | C++ | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__88.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__88.cpp | vargandhi/ime-congs | 963be79b7b319d8e74edae09df7bdf3330371401 | [
"BSD-3-Clause"
] | null | null | null | chipyard.TestHarness.LargeBoomAndRocketConfig/chipyard.TestHarness.LargeBoomAndRocketConfig/VTestHarness__88.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__5503(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5503\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__tlb__DOT___T_2225) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__tlb__DOT__r_refill_tag
= (0x7ffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__s1_pc
>> 0xcU)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT___GEN_38
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_debug))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT___T_3832
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_bp_0_control_dmode))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr_io_singleStep
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_dcsr_step)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_389
= ((0x80U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x17U))
<< 1U)) | (1U & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x17U)))))
<< 7U)) | ((0x40U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x16U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x16U)))))
<< 6U)) |
((0x20U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x15U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x15U)))))
<< 5U))
| ((0x10U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x14U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x14U)))))
<< 4U))
| ((8U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x13U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x13U)))))
<< 3U))
| ((4U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x12U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x12U)))))
<< 2U))
| ((2U &
(((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x11U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x11U)))))
<< 1U))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x10U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x10U)))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5504(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5504\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_420
= ((0x80U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x37U))
<< 1U)) | (1U & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x37U)))))
<< 7U)) | ((0x40U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x36U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x36U)))))
<< 6U)) |
((0x20U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x35U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x35U)))))
<< 5U))
| ((0x10U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x34U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x34U)))))
<< 4U))
| ((8U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x33U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x33U)))))
<< 3U))
| ((4U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x32U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x32U)))))
<< 2U))
| ((2U &
(((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x31U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x31U)))))
<< 1U))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x30U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x30U)))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5505(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5505\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_374
= ((0x80U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 7U)) << 1U))
| (1U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 7U)))))
<< 7U)) | ((0x40U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 6U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 6U)))))
<< 6U)) |
((0x20U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 5U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 5U)))))
<< 5U))
| ((0x10U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 4U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 4U)))))
<< 4U))
| ((8U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 3U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 3U)))))
<< 3U))
| ((4U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 2U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 2U)))))
<< 2U))
| ((2U &
(((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 1U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 1U)))))
<< 1U))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data)
<< 1U))
| (1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5506(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5506\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_405
= ((0x80U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x27U))
<< 1U)) | (1U & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x27U)))))
<< 7U)) | ((0x40U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x26U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x26U)))))
<< 6U)) |
((0x20U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x25U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x25U)))))
<< 5U))
| ((0x10U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x24U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x24U)))))
<< 4U))
| ((8U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x23U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x23U)))))
<< 3U))
| ((4U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x22U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x22U)))))
<< 2U))
| ((2U &
(((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x21U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x21U)))))
<< 1U))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x20U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x20U)))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5507(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5507\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_471
= (((0x80U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x3fU)) << 7U)) |
((0x40U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x37U)) << 6U))
| ((0x20U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x2fU)) << 5U))
| ((0x10U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x27U)) << 4U))
| ((8U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x1fU)) << 3U))
| ((4U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0x17U))
<< 2U)) | ((2U & ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 0xfU))
<< 1U))
| (1U & (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_6_0_data
>> 7U))))))))))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT___T_436)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT___T_8
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT___T)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT___T)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__Queue_1__DOT___T_1));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__maybe_full = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT___T_4) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__maybe_full
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT__empty)
? ((~ (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fw_ready_reg))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT___T_1))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__Queue__DOT___T_1));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___GEN_44
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_70)
? (3U == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_resp_reg))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_73));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_b_bits_echo_tl_state_size
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xbU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__deq_ptr_value]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__deq_ptr_value]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__deq_ptr_value]
:
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__deq_ptr_value])))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5508(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5508\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_b_bits_echo_tl_state_source
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : ((0xbU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
? 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] : (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__deq_ptr_value]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__deq_ptr_value]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fb_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__deq_ptr_value]
:
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__deq_ptr_value])))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5509(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5509\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_r_bits_echo_tl_state_size
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xbU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__deq_ptr_value]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__deq_ptr_value]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__deq_ptr_value]
:
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__deq_ptr_value])))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5510(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5510\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_r_bits_echo_tl_state_source
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : ((0xbU == (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
? 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] : (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__deq_ptr_value]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__deq_ptr_value]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_id_reg))
?
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__deq_ptr_value]
:
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->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__deq_ptr_value])))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5511(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5511\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_66
= ((IData)(vlTOPp->TestHarness__DOT__SimDRAM__DOT_____05Fr_valid_reg)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___T_63));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__maybe_full = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT___T_4) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__maybe_full
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__do_enq;
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_2 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_47) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_2
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_6)
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__plic__DOT__Queue__DOT__ram_extra_tlrr_extra_source
[0U] : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___T_49)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_outer_TLBuffer__DOT__TLMonitor__DOT___T_30
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data)))
>> 2U) & (~ (0x20000000U
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_address___05FT_15_data
>> 2U)))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_outer_TLBuffer__DOT__TLMonitor__DOT___T_33
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data)))
>> 2U) & (0x20000000U |
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_address___05FT_15_data
>> 2U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__TLMonitor__DOT___T_30
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data)))
>> 2U) & (~ (0x20000000U
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_address___05FT_15_data
>> 2U)))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5512(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5512\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__TLMonitor__DOT___T_33
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_size___05FT_15_data)))
>> 2U) & (0x20000000U |
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__Queue__DOT__ram_address___05FT_15_data
>> 2U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_52
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_size___05FT_11_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_size___05FT_11_data)))
>> 2U) & (~ (0x20000000U
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_address___05FT_11_data
>> 2U)))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT___T_55
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_size___05FT_11_data))
| (1U & ((((IData)(1U) << (3U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_size___05FT_11_data)))
>> 2U) & (0x20000000U |
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ram_address___05FT_11_data
>> 2U))))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__mem_pc_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__wb_reg_inst
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__mem_reg_inst;
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT___T_8
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT___T)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT___T)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__Queue__DOT___T_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__TLMonitor__DOT___T_708
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__TLMonitor__DOT___T_643)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5513(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5513\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT___T_337
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__Queue_1__DOT__maybe_full)))
& (~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__Queue__DOT__ram_read
[0U]));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT__bpd_ptr = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT__do_commit_update) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT__bpd_ptr
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__ftq__DOT___T_148;
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__amoalu__DOT___T_32
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__amoalu_io_lhs)
< (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__pstore1_data));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__grantIsUncached
= (((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
| (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data)))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__icache__DOT___T_27
= ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (0xffU & (~ (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);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_3566
= ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
? (0xffU & (~ (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);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_3748
= ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__blockUncachedGrant)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s1_valid)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__grantIsCached
= ((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__buffer__DOT__Queue_1__DOT__ram_opcode___05FT_15_data)));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s0_clk_en) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s1_req_signed
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__ptw_io_mem_req_valid))
& (~ (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__ex_reg_inst
>> 0xeU))));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5514(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5514\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_256
= ((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_253)
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__head)
& ((0x80U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 0xeU)) | ((0x40U &
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 0xcU))
| ((0x20U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 0xaU))
| ((0x10U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 8U))
| ((8U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 6U))
| ((4U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 4U))
| ((2U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107
>> 2U))
| (1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_107))))))))))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__head)
& ((0x80U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 0xeU)) | ((0x40U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 0xcU))
| ((0x20U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 0xaU))
| ((0x10U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 8U))
| ((8U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 6U))
| ((4U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 4U))
| ((2U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142
>> 2U))
| (1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_142))))))))))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__head)
& ((0x80U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 0xeU)) | ((0x40U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 0xcU))
| ((0x20U &
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 0xaU))
| ((0x10U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 8U))
| ((8U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 6U))
| ((4U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 4U))
| ((2U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177
>> 2U))
| (1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT___T_177))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5515(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5515\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__first
= (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT___T_61));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT___T_63
= (3U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT___T_61)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___GEN_40
= ((5U == (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1996
>> 1U))) ? 2U : ((4U == (7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1996
>> 1U)))
? 1U : (
(3U
==
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1996
>> 1U)))
? 1U
:
((2U
==
(7U
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__tlMasterXbar__DOT__TLMonitor__DOT___T_1996
>> 1U)))
? 1U
: 0U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___GEN_40
= ((5U == (7U & (IData)((VL_ULL(7) & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2047
>> 1U)))))
? 2U : ((4U == (7U & (IData)((VL_ULL(7)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2047
>> 1U)))))
? 1U : ((3U == (7U & (IData)((VL_ULL(7)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2047
>> 1U)))))
? 1U : ((2U == (7U & (IData)(
(VL_ULL(7)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__TLMonitor__DOT___T_2047
>> 1U)))))
? 1U : 0U))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5516(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5516\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT___T_8
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT___T)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT___T)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__buffer__DOT__Queue_1__DOT___T_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_vaddr
= (((QData)((IData)((0xfffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_411
>> 0xcU)))))
<< 0xcU) | (QData)((IData)((0xfffU & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1535
= (1U & ((((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_size))
>> 3U) & (~ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1538
= (1U & ((((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_size))
>> 3U) & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1543
= (1U & ((~ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U))) & (~ (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1546
= (1U & ((~ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U))) & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1549
= (1U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U)) & (~ (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_1552
= (1U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 3U)) & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_3908
= ((1U & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))) ? (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_data_word
>> 0x20U))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_data_word));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5517(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5517\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_408) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_pma_cacheable
= (0U != ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__c_array)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__hits)));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2225) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__r_refill_tag
= (0x7ffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s1_tlb_req_vaddr
>> 0xcU)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__slot_will_hit_tail
= (7U & (((((((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 3U)) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 6U)) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 9U))
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 0xcU)) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 0xfU)) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 0x12U))
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__fb__DOT__tail_collisions
>> 0x15U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1721
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1701)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
| (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1752
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 1U) | (((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1783
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 2U) | (((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5518(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5518\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1814
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 3U) | (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1721
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1701)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
| (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1752
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 1U) | (((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1783
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 2U) | (((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1814
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___T_1701)
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_br_mask)
>> 3U) | (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_bits))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_taken))
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_cfi_idx_valid))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_480
= ((0x80000000U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1fU))
<< 1U)) | (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1fU)))))
<< 0x1fU)) | ((0x40000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1eU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1eU)))))
<< 0x1eU))
| ((0x20000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1dU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1dU)))))
<< 0x1dU))
| ((0x10000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1cU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1cU)))))
<< 0x1cU))
| ((0x8000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1bU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1bU)))))
<< 0x1bU))
| ((0x4000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x1aU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x1aU)))))
<< 0x1aU))
| ((0x2000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x19U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x19U)))))
<< 0x19U))
| ((0x1000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x18U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x18U)))))
<< 0x18U))
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_471)
<< 0x10U)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_464))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5519(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5519\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_511
= ((0x80000000U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3fU))
<< 1U)) | (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3fU)))))
<< 0x1fU)) | ((0x40000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3eU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3eU)))))
<< 0x1eU))
| ((0x20000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3dU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3dU)))))
<< 0x1dU))
| ((0x10000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3cU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3cU)))))
<< 0x1cU))
| ((0x8000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3bU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3bU)))))
<< 0x1bU))
| ((0x4000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x3aU))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x3aU)))))
<< 0x1aU))
| ((0x2000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x39U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x39U)))))
<< 0x19U))
| ((0x1000000U
& (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_data
>> 0x38U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_6_0_data
>> 0x38U)))))
<< 0x18U))
| (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_502)
<< 0x10U)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_495))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5520(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5520\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_957
= (0U < (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__lrscCount));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_972
= (0x7fU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__lrscCount)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_sc_fail
= ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_cmd))
& (~ ((3U < (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__lrscCount))
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__lrscAddr
== (VL_ULL(0x3ffffffff) & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 6U))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__block_probe_for_core_progress
= ((0U < (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__blockProbeAfterGrantCount))
| (3U < (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__lrscCount)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_774
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__probe_bits_param)
<< 2U) | (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_probe_state_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s1_probe
= (1U & ((~ (IData)(vlTOPp->reset)) & ((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__release_state))
? (
(~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__metaArb__DOT___T_3))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_17))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_17))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_558
= ((0xfeU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_550)
<< 1U)) | (0xfcU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_550)
<< 2U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_599
= ((0xfeU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_553)
<< 1U)) | (0xfcU & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_553)
<< 2U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_7
= (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_4_0_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_8
= (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_4_0_state));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_933
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_5_0_bits_source)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ram_source___05FT_15_data))
& (0U != (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT___T_4_0_state)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5521(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5521\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
WData/*95:0*/ __Vtemp2692[3];
WData/*95:0*/ __Vtemp2693[3];
WData/*95:0*/ __Vtemp2698[3];
WData/*95:0*/ __Vtemp2699[3];
WData/*95:0*/ __Vtemp2704[3];
WData/*95:0*/ __Vtemp2705[3];
WData/*95:0*/ __Vtemp2710[3];
WData/*95:0*/ __Vtemp2711[3];
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__MaxPeriodFibonacciLFSR__DOT__state_12 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory_io_read_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__MaxPeriodFibonacciLFSR__DOT__state_12
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__MaxPeriodFibonacciLFSR__DOT__state_11;
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__flushInValid
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT___GEN_8));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT___T_8
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT___T)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT___T)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__Queue_1__DOT___T_1));
__Vtemp2692[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__coupler_to_bus_named_subsystem_cbus__DOT__widget__DOT__TLMonitor__DOT___T_1175[0U]
>> 1U));
__Vtemp2692[1U] = 0U;
__Vtemp2692[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2693, __Vtemp2692);
__Vtemp2698[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__coupler_to_bus_named_subsystem_cbus__DOT__widget__DOT__TLMonitor__DOT___T_1175[0U]
>> 1U));
__Vtemp2698[1U] = 0U;
__Vtemp2698[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2699, __Vtemp2698);
__Vtemp2704[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__coupler_to_bus_named_subsystem_cbus__DOT__widget__DOT__TLMonitor__DOT___T_1175[0U]
>> 1U));
__Vtemp2704[1U] = 0U;
__Vtemp2704[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2705, __Vtemp2704);
__Vtemp2710[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__coupler_to_bus_named_subsystem_cbus__DOT__widget__DOT__TLMonitor__DOT___T_1175[0U]
>> 1U));
__Vtemp2710[1U] = 0U;
__Vtemp2710[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2711, __Vtemp2710);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__coupler_to_bus_named_subsystem_cbus__DOT__widget__DOT__TLMonitor__DOT___GEN_28
= ((5U == (7U & __Vtemp2693[0U])) ? 2U : ((4U
==
(7U
& __Vtemp2699[0U]))
? 1U
:
((3U
==
(7U
& __Vtemp2705[0U]))
? 1U
:
((2U
==
(7U
& __Vtemp2711[0U]))
? 1U
: 0U))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5522(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5522\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
WData/*95:0*/ __Vtemp2716[3];
WData/*95:0*/ __Vtemp2717[3];
WData/*95:0*/ __Vtemp2722[3];
WData/*95:0*/ __Vtemp2723[3];
WData/*95:0*/ __Vtemp2728[3];
WData/*95:0*/ __Vtemp2729[3];
WData/*95:0*/ __Vtemp2734[3];
WData/*95:0*/ __Vtemp2735[3];
WData/*95:0*/ __Vtemp2740[3];
WData/*95:0*/ __Vtemp2741[3];
WData/*95:0*/ __Vtemp2746[3];
WData/*95:0*/ __Vtemp2747[3];
WData/*95:0*/ __Vtemp2752[3];
WData/*95:0*/ __Vtemp2753[3];
WData/*95:0*/ __Vtemp2758[3];
WData/*95:0*/ __Vtemp2759[3];
// Body
__Vtemp2716[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2716[1U] = 0U;
__Vtemp2716[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2717, __Vtemp2716);
__Vtemp2722[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2722[1U] = 0U;
__Vtemp2722[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2723, __Vtemp2722);
__Vtemp2728[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2728[1U] = 0U;
__Vtemp2728[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2729, __Vtemp2728);
__Vtemp2734[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2734[1U] = 0U;
__Vtemp2734[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2735, __Vtemp2734);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__TLMonitor__DOT___GEN_28
= ((5U == (7U & __Vtemp2717[0U])) ? 2U : ((4U
==
(7U
& __Vtemp2723[0U]))
? 1U
:
((3U
==
(7U
& __Vtemp2729[0U]))
? 1U
:
((2U
==
(7U
& __Vtemp2735[0U]))
? 1U
: 0U))));
__Vtemp2740[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2740[1U] = 0U;
__Vtemp2740[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2741, __Vtemp2740);
__Vtemp2746[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2746[1U] = 0U;
__Vtemp2746[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2747, __Vtemp2746);
__Vtemp2752[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2752[1U] = 0U;
__Vtemp2752[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2753, __Vtemp2752);
__Vtemp2758[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__in_xbar__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2758[1U] = 0U;
__Vtemp2758[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2759, __Vtemp2758);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__in_xbar__DOT__TLMonitor__DOT___GEN_28
= ((5U == (7U & __Vtemp2741[0U])) ? 2U : ((4U
==
(7U
& __Vtemp2747[0U]))
? 1U
:
((3U
==
(7U
& __Vtemp2753[0U]))
? 1U
:
((2U
==
(7U
& __Vtemp2759[0U]))
? 1U
: 0U))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5523(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5523\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
WData/*95:0*/ __Vtemp2764[3];
WData/*95:0*/ __Vtemp2765[3];
WData/*95:0*/ __Vtemp2770[3];
WData/*95:0*/ __Vtemp2771[3];
WData/*95:0*/ __Vtemp2776[3];
WData/*95:0*/ __Vtemp2777[3];
WData/*95:0*/ __Vtemp2782[3];
WData/*95:0*/ __Vtemp2783[3];
WData/*95:0*/ __Vtemp2788[3];
WData/*95:0*/ __Vtemp2789[3];
WData/*95:0*/ __Vtemp2794[3];
WData/*95:0*/ __Vtemp2795[3];
WData/*95:0*/ __Vtemp2800[3];
WData/*95:0*/ __Vtemp2801[3];
WData/*95:0*/ __Vtemp2806[3];
WData/*95:0*/ __Vtemp2807[3];
// Body
__Vtemp2764[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2764[1U] = 0U;
__Vtemp2764[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2765, __Vtemp2764);
__Vtemp2770[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2770[1U] = 0U;
__Vtemp2770[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2771, __Vtemp2770);
__Vtemp2776[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2776[1U] = 0U;
__Vtemp2776[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2777, __Vtemp2776);
__Vtemp2782[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2782[1U] = 0U;
__Vtemp2782[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2783, __Vtemp2782);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__TLMonitor__DOT___GEN_28
= ((5U == (7U & __Vtemp2765[0U])) ? 2U : ((4U
==
(7U
& __Vtemp2771[0U]))
? 1U
:
((3U
==
(7U
& __Vtemp2777[0U]))
? 1U
:
((2U
==
(7U
& __Vtemp2783[0U]))
? 1U
: 0U))));
__Vtemp2788[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer_1__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2788[1U] = 0U;
__Vtemp2788[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2789, __Vtemp2788);
__Vtemp2794[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer_1__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2794[1U] = 0U;
__Vtemp2794[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2795, __Vtemp2794);
__Vtemp2800[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer_1__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2800[1U] = 0U;
__Vtemp2800[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2801, __Vtemp2800);
__Vtemp2806[0U] = (7U & (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer_1__DOT__TLMonitor__DOT___T_1116[0U]
>> 1U));
__Vtemp2806[1U] = 0U;
__Vtemp2806[2U] = 0U;
VL_EXTEND_WW(84,83, __Vtemp2807, __Vtemp2806);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__buffer_1__DOT__TLMonitor__DOT___GEN_28
= ((5U == (7U & __Vtemp2789[0U])) ? 2U : ((4U
==
(7U
& __Vtemp2795[0U]))
? 1U
:
((3U
==
(7U
& __Vtemp2801[0U]))
? 1U
:
((2U
==
(7U
& __Vtemp2807[0U]))
? 1U
: 0U))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5524(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5524\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_2 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_47) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_2
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_6)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter_auto_out_a_bits_source)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT___T_49)));
}
}
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_2 = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_47) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_2
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_6)
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter_auto_out_a_bits_source)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT___T_49)));
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4654
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_0_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4674
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_1_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4694
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_2_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4714
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_3_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4734
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_4_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4754
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_5_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4774
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_6_cfg_l)));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5525(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5525\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
WData/*127:0*/ __Vtemp2846[4];
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___T_4794
= ((0x3a0U == (0xfffU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_exe_unit__DOT___T_83))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_pmp_7_cfg_l)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT___GEN_40
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_debug))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_io_singleStep
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_dcsr_step)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT___T_3
= (VL_ULL(0xffffffffff) & ((~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__used)
| (VL_ULL(0xfffffffffe)
& ((~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__used)
<< 1U))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT___T_3
= (0xffU & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__used))
| (0xfeU & ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__used))
<< 1U))));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2225) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT__r_superpage_repl_addr
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2244))
? ((2U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2016)
<< 1U)) | (1U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2016)
<< 1U)
>> (2U |
(1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2016))))))
: ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2244))
? ((2U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2244))
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__tlb__DOT___T_2244))
? 3U : 2U) : 1U) : 0U));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue__DOT__empty
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue__DOT__maybe_full)));
__Vtemp2846[0U] = ((0x800000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x1000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x40000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x80000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
((2U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_134[0U])))))))))));
__Vtemp2846[1U] = ((0x800000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x800000U : ((0x1000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x1000000U
: ((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x2000000U
: ((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x4000000U
: (
(0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x8000000U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x10000000U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x20000000U
:
((0x40000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x40000000U
:
((0x80000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x80000000U
:
((1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
((2U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_134[1U])))))))))));
__Vtemp2846[2U] = ((0x800000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x1000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x40000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x80000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 1U
:
((2U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 2U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_134[2U])))))))))));
__Vtemp2846[3U] = ((0x800000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x1000000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x40000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x80000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((1U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
((2U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[2U])
? 0U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_134[3U])))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_151[0U]
= ((0x20000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x40000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x100000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
: (
(0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
__Vtemp2846[0U]))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_151[1U]
= ((0x20000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x20000U : ((0x40000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x40000U : ((0x80000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x80000U
: ((0x100000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x100000U
: ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x200000U
:
((0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x400000U
:
__Vtemp2846[1U]))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_151[2U]
= ((0x20000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x40000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x100000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
: (
(0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
__Vtemp2846[2U]))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT___T_151[3U]
= ((0x20000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x40000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x100000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
: (
(0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
__Vtemp2846[3U]))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5526(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5526\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
WData/*95:0*/ __Vtemp2897[3];
// Body
__Vtemp2897[0U] = ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x100000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x800000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x1000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_130[0U])))))))))));
__Vtemp2897[1U] = ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x80000U : ((0x100000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x100000U :
((0x200000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x200000U
: ((0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x400000U
: ((0x800000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x800000U
: (
(0x1000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x1000000U
:
((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x2000000U
:
((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x4000000U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x8000000U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x10000000U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x20000000U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_130[1U])))))))))));
__Vtemp2897[2U] = ((0x80000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x100000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x200000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x400000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x800000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x1000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x2000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x4000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x8000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x10000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
((0x20000000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_130[2U])))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_147[0U]
= ((0x2000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x4000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x8000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x10000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x20000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
: (
(0x40000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
__Vtemp2897[0U]))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_147[1U]
= ((0x2000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x2000U : ((0x4000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x4000U : ((0x8000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x8000U :
((0x10000U &
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x10000U
: ((0x20000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x20000U
: ((0x40000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0x40000U
:
__Vtemp2897[1U]))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT___T_147[2U]
= ((0x2000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x4000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x8000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x10000U & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U : ((0x20000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
: (
(0x40000U
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_rename_stage__DOT__freelist__DOT__free_list[1U])
? 0U
:
__Vtemp2897[2U]))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5527(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5527\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4_io_resp_f2_3_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_req_rdata_3)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4_io_resp_f2_2_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_req_rdata_2)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4_io_resp_f2_1_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_req_rdata_1)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4_io_resp_f2_0_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__s2_req_rdata_0)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4_io_resp_f2_3_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_req_rdata_3)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4_io_resp_f2_2_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_req_rdata_2)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4_io_resp_f2_1_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_req_rdata_1)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4_io_resp_f2_0_taken
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_valid)
& ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__s2_req_rdata_0)
>> 1U)) & (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_4__DOT__doing_reset)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT___T_531
= ((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_sbus__DOT__system_bus_xbar__DOT___T_529))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__Queue__DOT__maybe_full)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT___T_3
= (0xfffffffU & ((~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__used)
| (0xffffffeU & ((~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__used)
<< 1U))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5528(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5528\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__csr_io_tval
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_963)
& (((((((((VL_ULL(3) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974)
| (VL_ULL(4) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(6) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(5) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(7) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(1) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(0xd) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(0xf) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974))
| (VL_ULL(0xc) == vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_974)))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT___T_1003
: VL_ULL(0));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_2235) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu_io_core_lxcpt_valid) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_2242) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__r_xcpt_uop_exc_cause
= (QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__r_xcpt_cause));
}
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_2246) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__r_xcpt_uop_exc_cause
= ((2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__idx))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_2_exc_cause
: ((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT__idx))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_1_exc_cause
: vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rename_stage__DOT__ren2_uops_0_exc_cause));
}
}
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1093
= ((((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__wb_reg_xcpt)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1078))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1080))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1082))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1084))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1086));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1098
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1078)
? 6U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1080)
? 4U : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1082)
? 0xfU : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1084)
? 0xdU : ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1086)
? 7U
: 5U)))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_valid_masked
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_valid_no_xcpt)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_401));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5529(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5529\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_70
= (3U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_68)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_71
= (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_68));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___GEN_6
= ((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_68))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_135)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_182));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_67
= ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_opcode___05FT_15_data))
? (3U & (~ (0x1ffU & (((IData)(0x3fU) << (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_size___05FT_15_data))
>> 4U)))) : 0U);
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_139
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_opcode___05FT_15_data)
& (0xffU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__ListBuffer__DOT__used)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_142
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_opcode___05FT_15_data)
& (0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_68)))
& (3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_113)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___T_82
= ((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_opcode___05FT_15_data))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_opcode___05FT_15_data)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_12__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_11__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_10__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_9__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_8__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_7__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_7__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_7__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_6__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_6__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_6__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_5__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_5__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_5__DOT__p2));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5530(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5530\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__pstore1_valid_likely
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_write))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__pstore1_held));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_readwrite
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_read)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_write));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT___T_588
= (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_write)
| (3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (6U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__dcache__DOT__s2_req_cmd)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_4__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_4__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_4__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_3__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_3__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_3__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_2440
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_1804)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__rob__DOT___T_1792));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_valid
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb_io_btb_update_valid));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_1028
= (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_27))
<< 0x1bU) | (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_26))
<< 0x1aU) | (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_25))
<< 0x19U) |
(((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_24))
<< 0x18U)
| (((3U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_23))
<< 0x17U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_22))
<< 0x16U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_21))
<< 0x15U)
| ((((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_20))
<< 0x14U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_19))
<< 0x13U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_18))
<< 0x12U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_17))
<< 0x11U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_16))
<< 0x10U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_15))
<< 0xfU)
| ((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_14))
<< 0xeU)))))))
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_13))
<< 0xdU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_12))
<< 0xcU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_11))
<< 0xbU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_10))
<< 0xaU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_9))
<< 9U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_8))
<< 8U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_7))
<< 7U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_6))
<< 6U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_5))
<< 5U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_4))
<< 4U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_3))
<< 3U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_2))
<< 2U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_1))
<< 1U)
| (3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_0)))))))))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5531(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5531\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT___T_939
= (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_27))
<< 0x1bU) | (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_26))
<< 0x1aU) | (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_25))
<< 0x19U) |
(((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_24))
<< 0x18U)
| (((0U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_23))
<< 0x17U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_22))
<< 0x16U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_21))
<< 0x15U)
| ((((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_20))
<< 0x14U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_19))
<< 0x13U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_18))
<< 0x12U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_17))
<< 0x11U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_16))
<< 0x10U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_15))
<< 0xfU)
| ((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_14))
<< 0xeU)))))))
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_13))
<< 0xdU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_12))
<< 0xcU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_11))
<< 0xbU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_10))
<< 0xaU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_9))
<< 9U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_8))
<< 8U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_7))
<< 7U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_6))
<< 6U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_5))
<< 5U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_4))
<< 4U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_3))
<< 3U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_2))
<< 2U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_1))
<< 1U)
| (0U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_0)))))))))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5532(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5532\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb_io_btb_update_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_cfiType
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core_io_imem_btb_update_valid)
? (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1398)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__mem_reg_inst
>> 7U)) ? 2U : (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__mem_ctrl_jalr)
& (1U == (0x1bU
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT__mem_reg_inst
>> 0xfU))))
? 3U : (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1398)))
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb_io_ras_update_bits_cfiType));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb_io_btb_update_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
= (VL_ULL(0x7fffffffff) & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core_io_imem_btb_update_valid)
? (VL_ULL(0x7fffffffff)
& (~ (VL_ULL(3)
| (~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1412))))
: (~ (VL_ULL(3)
| (~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__s2_pc)))));
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb_io_btb_update_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_br_pc
= (VL_ULL(0x7fffffffff) & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core_io_imem_btb_update_valid)
? (VL_ULL(0x7fffffffff)
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__core__DOT___T_1412)
: ((~ (VL_ULL(3)
| (~ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__s2_pc)))
| (QData)((IData)(
(2U
& ((~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__tile__DOT__frontend__DOT__taken_taken))
<< 1U)))))));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__probe_bit));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5533(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5533\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__probe_bit)
: 0U));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5534(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5534\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_5__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_6__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_7__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_8__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_9__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__probe_bit)
: 0U));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5535(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5535\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__probe_bit));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_745
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__probes_toN)
| ((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data))
| (2U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ram_param___05FT_15_data)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__probe_bit)
: 0U));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___T_731
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__probes_done)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__probe_bit));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__entering_PB_normalCase) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__bit0FractA_PB
= (1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__fractA_PA));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT___T_125
= (7U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_E)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__val_s1
= (1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw_io_usingMulAdd));
if ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw_io_usingMulAdd))) {
if (((((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT___T_449)
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_B6_sqrt))
| (4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_B)))
| (6U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C)))
| (4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C)))
| (1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C)))) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_b_s1
= ((((((((1U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_A))
? ((QData)((IData)((0x8000U
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT___T_404))))
<< 0x24U) : VL_ULL(0))
| ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_B))
? ((QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__ESqrR1_B_sqrt))
<< 0x13U) : VL_ULL(0)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_B6_sqrt)
? ((QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__ER1_B_sqrt))
<< 0x24U) : VL_ULL(0)))
| vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__zSigma1_B4)
| (QData)((IData)(((6U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C))
? (0x3fffffffU
& (IData)(
(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__sqrSigma1_C
>> 1U)))
: 0U)))) |
((4U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C))
? vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__sqrSigma1_C
: VL_ULL(0))) | vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__zComplSigT_C1);
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5536(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5536\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw_io_usingMulAdd))) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw_io_latchMulAddA_0) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_a_s1
= (VL_ULL(0x3fffffffffffff) & (((((
(((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_A1_sqrt)
?
((QData)((IData)(
((1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__sExp_PA))
?
(0x10000U
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT___T_404)
<< 1U))
:
(0x8000U
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT___T_404)))))
<< 0x24U)
: VL_ULL(0))
| (((7U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_B))
| (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_A1_div))
?
(VL_ULL(0x10000000000000)
| vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__fractB_PA)
: VL_ULL(0)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_B6_div)
?
(VL_ULL(0x10000000000000)
| vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__fractA_PA)
: VL_ULL(0)))
| (VL_ULL(0x3ffffffff)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__zSigma1_B4
>> 0xcU)))
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_B))
| (6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C)))
?
(VL_ULL(0x3fffffffffff)
& (((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[3U]))
<< 0x25U)
| (((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[2U]))
<< 5U)
| ((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[1U]))
>> 0x1bU))))
: VL_ULL(0)))
| (((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cycleNum_C))
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__sqrtOp_PB)))
?
(VL_ULL(0x3fffffffe000)
& (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__sigXN_C
>> 0xcU))
: VL_ULL(0)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_C4_sqrt)
?
((QData)((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__u_C_sqrt))
<< 0xfU)
: VL_ULL(0)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_C1_div)
?
(VL_ULL(0x10000000000000)
| vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__fractB_PC)
: VL_ULL(0)))
| ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__ds__DOT__divSqrtRecF64ToRaw__DOT__cyc_C1_sqrt)
?
(~
(((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[3U]))
<< 0x2dU)
| (((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[2U]))
<< 0xdU)
| ((QData)((IData)(
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__divsqrt__DOT__mul__DOT__reg_result_s3[1U]))
>> 0x13U))))
: VL_ULL(0))));
}
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5537(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5537\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT___T_149
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__p2)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__ppred));
if (vlTOPp->reset) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__ppred = 0U;
} else {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2__DOT__ppred
= (1U & (~ ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_24)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_5__DOT__ppred))
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_22)))
? (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_4__DOT__ppred))
: (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_3__DOT__ppred))))));
}
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0_io_in_uop_valid) {
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0_io_in_uop_valid) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__slot_uop_br_mask
= ((4U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_20)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_3_io_out_uop_br_mask)
: ((2U == (7U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT___GEN_18)))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_2_io_out_uop_br_mask)
: ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__slot_uop_br_mask)
& (~ (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit_io_brupdate_b1_resolve_mask)))));
}
} else {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__slot_uop_br_mask
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__next_br_mask;
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT___T_8
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT___T)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT___T)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__Queue__DOT___T_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT___T_148
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__ppred));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT___T_118
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_0__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT__p1
= ((~ (IData)(vlTOPp->reset)) & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__mem_issue_unit__DOT__slots_1__DOT___GEN_145));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1830) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__r_superpage_repl_addr
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1849))
? ((2U & ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1668)
<< 1U)) | (1U & (((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1668)
<< 1U)
>> (2U |
(1U
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1668))))))
: ((1U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1849))
? ((2U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1849))
? ((4U & (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1849))
? 3U : 2U) : 1U) : 0U));
}
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5538(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5538\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT___T_1830) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb__DOT__r_refill_tag
= (0x7ffffffU & (IData)((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__lsu__DOT__dtlb_io_req_0_bits_vaddr
>> 0xcU)));
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT___T_5
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__enq_ptr_value)));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__f4_btb_corrections__DOT__deq_ptr_value));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_20__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_20__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_20__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_19__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_19__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_19__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_18__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_17__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_16__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_15__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_14__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_13__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_12__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_11__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_10__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_9__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_21__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_21__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_21__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_8__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_22__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_22__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_22__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_7__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_7__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_7__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_23__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_23__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_23__DOT__p2));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5539(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5539\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_6__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_6__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_6__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_5__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_5__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_5__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_4__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_4__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_4__DOT__p2));
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT___T_72) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__r_buffer_req_uop_rob_idx
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fregister_read__DOT__exe_reg_uops_0_rob_idx;
}
if (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT___T_72) {
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fpiu_unit__DOT__fdivsqrt__DOT__r_buffer_req_uop_pdst
= vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fregister_read__DOT__exe_reg_uops_0_pdst;
}
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_3__DOT___T_88
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_3__DOT__p1)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__core__DOT__fp_pipeline__DOT__fp_issue_unit__DOT__slots_3__DOT__p2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_1342
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_0_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_0_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_0_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_0_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_0_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_0_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_0_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_0_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_0_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_0_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_0_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_0_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_0_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_0_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5540(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5540\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_1345
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_1_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_1_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_1_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_1_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_1_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_1_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_1_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_1_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_1_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_1_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_1_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_1_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_1_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_1_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5541(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5541\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_1348
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_2_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_2_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_2_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_2_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_2_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_2_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_2_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_2_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_2_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_2_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_2_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_2_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_2_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_2_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5542(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5542\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_1351
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_3_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_3_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_3_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_3_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_3_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_3_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_3_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_3_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_3_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_3_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_3_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_3_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_3_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_3_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5543(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5543\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3_io_resp_f1_3_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_resp_3_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_831
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_15_3_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_14_3_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_13_3_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_12_3_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_11_3_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_10_3_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_9_3_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_8_3_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_7_3_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_6_3_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_5_3_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_4_3_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_3_3_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_2_3_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_1_3_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_0_3_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_1021
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_15_3_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_14_3_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_3_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_3_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_3_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_3_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_3_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_3_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_3_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_3_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_3_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_3_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_3_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_3_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_3_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_3_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5544(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5544\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3_io_resp_f1_0_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_0));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_resp_0_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_0));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_60
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_15_0_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_14_0_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_13_0_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_12_0_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_11_0_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_10_0_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_9_0_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_8_0_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_7_0_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_6_0_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_5_0_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_4_0_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_3_0_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_2_0_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_1_0_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_0_0_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_244
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_15_0_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_14_0_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_0_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_0_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_0_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_0_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_0_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_0_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_0_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_0_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_0_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_0_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_0_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_0_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_0_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_0_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5545(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5545\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3_io_resp_f1_1_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_resp_1_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_317
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_15_1_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_14_1_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_13_1_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_12_1_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_11_1_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_10_1_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_9_1_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_8_1_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_7_1_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_6_1_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_5_1_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_4_1_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_3_1_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_2_1_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_1_1_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_0_1_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_503
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_15_1_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_14_1_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_1_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_1_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_1_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_1_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_1_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_1_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_1_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_1_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_1_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_1_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_1_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_1_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_1_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_1_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5546(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5546\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3_io_resp_f1_2_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_resp_2_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hits_2));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_574
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_15_2_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_14_2_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_13_2_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_12_2_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_11_2_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_10_2_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_9_2_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_8_2_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_7_2_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_6_2_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_5_2_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_4_2_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_3_2_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_2_2_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_1_2_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__btb_0_2_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___GEN_762
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_15_2_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_14_2_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_13_2_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_12_2_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_11_2_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_10_2_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_9_2_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_8_2_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_7_2_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_6_2_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_5_2_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_4_2_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_3_2_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_2_2_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__s1_hit_ways_2))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_1_2_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT__meta_0_2_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5547(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5547\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_1015
= (0xfU & (((((((((((((((((((((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_995)
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[2U]
>> 0x14U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
<< 8U) | (
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[2U]
>> 0x18U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
<< 4U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[2U]
>> 0x1cU)))
^ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U])
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 0x1cU) | (
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 4U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 0x18U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 8U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 0x14U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 0xcU)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 0x10U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 0x10U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 0x14U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 8U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 0x18U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
<< 4U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[3U]
>> 0x1cU)))
^ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U])
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 0x1cU) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 4U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 0x18U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 8U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 0x14U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 0xcU)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 0x10U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 0x10U)))
^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 0x14U))) ^
((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 8U) | (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 0x18U))) ^ ((vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]
<< 4U)
| (vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[4U]
>> 0x1cU)))
^ vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_0__DOT__components_3__DOT___T_390[5U]));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5548(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5548\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_1342
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_0_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_0_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_0_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_0_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_0_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_0_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_0_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_0_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_0_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_0_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_0_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_0_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_0_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_0_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5549(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5549\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_1345
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_1_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_1_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_1_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_1_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_1_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_1_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_1_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_1_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_1_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_1_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_1_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_1_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_1_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_1_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5550(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5550\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_1348
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_2_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_2_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_2_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_2_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_2_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_2_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_2_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_2_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_2_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_2_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_2_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_2_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_2_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_2_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5551(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5551\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_1351
= ((0xdU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_3_ctr)
: ((0xcU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_3_ctr)
: ((0xbU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_3_ctr)
: ((0xaU == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_3_ctr)
: ((9U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_3_ctr)
: ((8U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_3_ctr)
: ((7U == (0xfU & vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_3_ctr)
: ((6U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_3_ctr)
: ((5U == (0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_3_ctr)
: ((4U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_3_ctr)
: (
(3U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_3_ctr)
:
((2U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_3_ctr)
:
((1U
==
(0xfU
& vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_update___05Fbits_meta[0U]))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_3_ctr)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_3_ctr))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5552(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5552\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3_io_resp_f1_3_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_resp_3_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_3));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_831
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_15_3_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_14_3_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_13_3_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_12_3_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_11_3_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_10_3_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_9_3_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_8_3_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_7_3_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_6_3_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_5_3_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_4_3_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_3_3_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_2_3_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_1_3_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_0_3_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_1021
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_15_3_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_14_3_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_3_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_3_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_3_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_3_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_3_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_3_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_3_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_3_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_3_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_3_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_3_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_3_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_3))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_3_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_3_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5553(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5553\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3_io_resp_f1_0_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_0));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_resp_0_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_0));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_60
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_15_0_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_14_0_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_13_0_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_12_0_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_11_0_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_10_0_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_9_0_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_8_0_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_7_0_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_6_0_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_5_0_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_4_0_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_3_0_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_2_0_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_1_0_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_0_0_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_244
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_15_0_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_14_0_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_0_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_0_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_0_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_0_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_0_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_0_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_0_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_0_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_0_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_0_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_0_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_0_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_0))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_0_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_0_is_br))))))))))))))));
}
VL_INLINE_OPT void VTestHarness::_sequent__TOP__5554(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_sequent__TOP__5554\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3_io_resp_f1_1_predicted_pc_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_resp_1_valid
= ((IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_valid)
& (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hits_1));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_317
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_15_1_offset)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_14_1_offset)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_13_1_offset)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_12_1_offset)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_11_1_offset)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_10_1_offset)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_9_1_offset)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_8_1_offset)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_7_1_offset)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_6_1_offset)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_5_1_offset)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_4_1_offset)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_3_1_offset)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_2_1_offset)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_1_1_offset)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__btb_0_1_offset))))))))))))))));
vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT___GEN_503
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_15_1_is_br)
: ((0xeU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_14_1_is_br)
: ((0xdU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_13_1_is_br)
: ((0xcU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_12_1_is_br)
: ((0xbU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_11_1_is_br)
: ((0xaU == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_10_1_is_br)
: ((9U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_9_1_is_br)
: ((8U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_8_1_is_br)
: ((7U == (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_7_1_is_br)
: ((6U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_6_1_is_br)
: (
(5U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_5_1_is_br)
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_4_1_is_br)
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_3_1_is_br)
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_2_1_is_br)
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__s1_hit_ways_1))
? (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_1_1_is_br)
: (IData)(vlTOPp->TestHarness__DOT__dut__DOT__system__DOT__boom_tile__DOT__frontend__DOT__bpd__DOT__banked_predictors_1__DOT__components_3__DOT__meta_0_1_is_br))))))))))))))));
}
| 113.989963 | 269 | 0.623257 | vargandhi |
9d1deeadee0dd75c5add4869c1dbe93d8129be2c | 8,603 | cc | C++ | arcane/src/arcane/tests/accelerator/NumArrayUnitTest.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | arcane/src/arcane/tests/accelerator/NumArrayUnitTest.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | arcane/src/arcane/tests/accelerator/NumArrayUnitTest.cc | JeromeDuboisPro/framework | d88925495e3787fdaf640c29728dcac385160188 | [
"Apache-2.0"
] | null | null | null | // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2021 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* NumArrayUnitTest.cc (C) 2000-2021 */
/* */
/* Service de test des 'NumArray'. */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/utils/NumArray.h"
#include "arcane/utils/ValueChecker.h"
#include "arcane/BasicUnitTest.h"
#include "arcane/ServiceFactory.h"
#include "arcane/accelerator/Runner.h"
#include "arcane/accelerator/NumArrayViews.h"
#include "arcane/accelerator/RunCommandLoop.h"
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
namespace ArcaneTest
{
using namespace Arcane;
namespace ax = Arcane::Accelerator;
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
* \brief Service de test de la classe 'NumArray'.
*/
class NumArrayUnitTest
: public BasicUnitTest
{
public:
explicit NumArrayUnitTest(const ServiceBuildInfo& cb);
~NumArrayUnitTest();
public:
void initializeTest() override;
void executeTest() override;
private:
ax::Runner m_runner;
static constexpr double _getValue(Int64 i)
{
return static_cast<double>(i*2);
}
static constexpr double _getValue(Int64 i,Int64 j)
{
return static_cast<double>(i*2 + j*3);
}
static constexpr double _getValue(Int64 i,Int64 j,Int64 k)
{
return static_cast<double>(i*2 + j*3 + k*4);
}
static constexpr double _getValue(Int64 i,Int64 j,Int64 k,Int64 l)
{
return static_cast<double>(i*2 + j*3 + k*4 + l*8);
}
template<int Rank> double
_doSum(NumArray<double,Rank> values,ArrayBounds<Rank> bounds)
{
double total = 0.0;
SimpleLoopRanges<Rank> lb(bounds);
arcaneSequentialFor(lb,[&](ArrayBoundsIndex<Rank> idx){ total += values(idx); });
return total;
}
public:
void _executeTest1();
void _executeTest2();
};
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
ARCANE_REGISTER_CASE_OPTIONS_NOAXL_FACTORY(NumArrayUnitTest,IUnitTest,NumArrayUnitTest);
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
NumArrayUnitTest::
NumArrayUnitTest(const ServiceBuildInfo& sb)
: BasicUnitTest(sb)
{
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
NumArrayUnitTest::
~NumArrayUnitTest()
{
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void NumArrayUnitTest::
initializeTest()
{
IApplication* app = subDomain()->application();
const auto& acc_info = app->acceleratorRuntimeInitialisationInfo();
initializeRunner(m_runner,traceMng(),acc_info);
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void NumArrayUnitTest::
executeTest()
{
_executeTest1();
// Appelle deux fois _executeTest2() pour vérifier l'utilisation des pools
// de RunQueue.
_executeTest2();
_executeTest2();
}
void NumArrayUnitTest::
_executeTest1()
{
ValueChecker vc(A_FUNCINFO);
auto queue = makeQueue(m_runner);
auto command = makeCommand(queue);
// Ne pas changer les dimensions du tableau sinon
// il faut aussi changer le calcul des sommes
constexpr int n1 = 1000;
constexpr int n2 = 3;
constexpr int n3 = 4;
constexpr int n4 = 13;
constexpr double expected_sum1 = 999000.0;
constexpr double expected_sum2 = 3006000.0;
constexpr double expected_sum3 = 12096000.0;
constexpr double expected_sum4 = 164736000.0;
{
NumArray<double,1> t1(n1);
auto out_t1 = ax::viewOut(command,t1);
command << RUNCOMMAND_LOOP1(iter,n1)
{
auto [i] = iter();
out_t1(i) = _getValue(i);
};
double s1 = _doSum(t1,{n1});
info() << "SUM1 = " << s1;
vc.areEqual(s1,expected_sum1,"SUM1");
}
{
NumArray<double,2> t1(n1,n2);
auto out_t1 = ax::viewOut(command,t1);
command << RUNCOMMAND_LOOP2(iter,n1,n2)
{
auto [i, j] = iter();
out_t1(i,j) = _getValue(i,j);
};
double s2 = _doSum(t1,{n1,n2});
info() << "SUM2 = " << s2;
vc.areEqual(s2,expected_sum2,"SUM2");
}
{
NumArray<double,3> t1(n1,n2,n3);
auto out_t1 = ax::viewOut(command,t1);
command << RUNCOMMAND_LOOP3(iter,n1,n2,n3)
{
auto [i, j, k] = iter();
out_t1(i,j,k) = _getValue(i,j,k);
};
double s3 = _doSum(t1,{n1,n2,n3});
info() << "SUM3 = " << s3;
vc.areEqual(s3,expected_sum3,"SUM3");
}
{
NumArray<double,4> t1(n1,n2,n3,n4);
auto out_t1 = ax::viewOut(command,t1);
command << RUNCOMMAND_LOOP4(iter,n1,n2,n3,n4)
{
auto [i, j, k, l] = iter();
out_t1(i,j,k,l) = _getValue(i,j,k,l);
};
double s4 = _doSum(t1,{n1,n2,n3,n4});
info() << "SUM4 = " << s4;
vc.areEqual(s4,expected_sum4,"SUM4");
}
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
void NumArrayUnitTest::
_executeTest2()
{
// Teste plusieurs queues simultanément.
ValueChecker vc(A_FUNCINFO);
// Ne pas changer les dimensions du tableau sinon
// il faut aussi changer le calcul des sommes
constexpr int n1 = 1000;
constexpr int n2 = 3;
constexpr int n3 = 4;
constexpr int n4 = 13;
constexpr double expected_sum4 = 164736000.0;
auto queue1 = makeQueue(m_runner);
queue1.setAsync(true);
auto queue2 = makeQueue(m_runner);
queue2.setAsync(true);
auto queue3 = makeQueue(m_runner);
queue3.setAsync(true);
NumArray<double,4> t1(n1,n2,n3,n4);
// NOTE: Normalement il ne devrait pas être autorisé d'accéder au
// même tableau depuis plusieurs commandes sur des files différentes
// mais cela fonctionne avec la mémoire unifiée.
// Utilise 3 files asynchrones pour positionner les valeurs du tableau,
// chaque file gérant une partie du tableau.
{
auto command = makeCommand(queue1);
auto out_t1 = ax::viewOut(command,t1);
Int64 s1 = 300;
auto b = makeLoopRanges(s1,n2,n3,n4);
command << RUNCOMMAND_LOOP(iter,b)
{
auto [i, j, k, l] = iter();
out_t1(i,j,k,l) = _getValue(i,j,k,l);
};
}
{
auto command = makeCommand(queue2);
auto out_t1 = ax::viewOut(command,t1);
Int64 base = 300;
Int64 s1 = 400;
auto b = makeLoopRanges({base,s1},n2,n3,n4);
command << RUNCOMMAND_LOOP(iter,b)
{
auto [i, j, k, l] = iter();
out_t1(i,j,k,l) = _getValue(i,j,k,l);
};
}
{
auto command = makeCommand(queue3);
auto out_t1 = ax::viewOut(command,t1);
Int64 base = 700;
Int64 s1 = 300;
auto b = makeLoopRanges({base,s1},n2,n3,n4);
command << RUNCOMMAND_LOOP(iter,b)
{
auto [i, j, k, l] = iter();
out_t1(i,j,k,l) = _getValue(i,j,k,l);
};
}
queue1.barrier();
queue2.barrier();
queue3.barrier();
double s4 = _doSum(t1,{n1,n2,n3,n4});
info() << "SUM4_ASYNC = " << s4;
vc.areEqual(s4,expected_sum4,"SUM4_ASYNC");
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
} // End namespace ArcaneTest
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
| 28.676667 | 88 | 0.479019 | JeromeDuboisPro |
9d2eff61f24b80ed8d0f5f7686b16c04b779d508 | 6,377 | cc | C++ | node_modules/nodegit/src/transport.cc | jiumx60rus/grishyGhost | c56241304da11b9a1307c6261cca50f7546981b1 | [
"MIT"
] | null | null | null | node_modules/nodegit/src/transport.cc | jiumx60rus/grishyGhost | c56241304da11b9a1307c6261cca50f7546981b1 | [
"MIT"
] | null | null | null | node_modules/nodegit/src/transport.cc | jiumx60rus/grishyGhost | c56241304da11b9a1307c6261cca50f7546981b1 | [
"MIT"
] | null | null | null | // This is a generated file, modify: generate/templates/class_content.cc.
#include <nan.h>
#include <string.h>
#include <chrono>
#include <thread>
extern "C" {
#include <git2.h>
#include <git2/sys/transport.h>
}
#include "../include/functions/copy.h"
#include "../include/macros.h"
#include "../include/transport.h"
#include "../include/transport.h"
#include "../include/remote.h"
#include <iostream>
using namespace std;
using namespace v8;
using namespace node;
GitTransport::GitTransport(git_transport *raw, bool selfFreeing) {
this->raw = raw;
this->selfFreeing = selfFreeing;
}
GitTransport::~GitTransport() {
// this will cause an error if you have a non-self-freeing object that also needs
// to save values. Since the object that will eventually free the object has no
// way of knowing to free these values.
}
void GitTransport::InitializeComponent(Handle<v8::Object> target) {
NanScope();
Local<FunctionTemplate> tpl = NanNew<FunctionTemplate>(JSNewFunction);
tpl->InstanceTemplate()->SetInternalFieldCount(1);
tpl->SetClassName(NanNew<String>("Transport"));
NODE_SET_PROTOTYPE_METHOD(tpl, "init", Init);
NODE_SET_METHOD(tpl, "sshWithPaths", SshWithPaths);
NODE_SET_METHOD(tpl, "unregister", Unregister);
Local<Function> _constructor_template = tpl->GetFunction();
NanAssignPersistent(constructor_template, _constructor_template);
target->Set(NanNew<String>("Transport"), _constructor_template);
}
NAN_METHOD(GitTransport::JSNewFunction) {
NanScope();
if (args.Length() == 0 || !args[0]->IsExternal()) {
return NanThrowError("A new GitTransport cannot be instantiated.");
}
GitTransport* object = new GitTransport(static_cast<git_transport *>(Handle<External>::Cast(args[0])->Value()), args[1]->BooleanValue());
object->Wrap(args.This());
NanReturnValue(args.This());
}
Handle<v8::Value> GitTransport::New(void *raw, bool selfFreeing) {
NanEscapableScope();
Handle<v8::Value> argv[2] = { NanNew<External>((void *)raw), NanNew<Boolean>(selfFreeing) };
return NanEscapeScope(NanNew<Function>(GitTransport::constructor_template)->NewInstance(2, argv));
}
git_transport *GitTransport::GetValue() {
return this->raw;
}
git_transport **GitTransport::GetRefValue() {
return this->raw == NULL ? NULL : &this->raw;
}
void GitTransport::ClearValue() {
this->raw = NULL;
}
/*
* @param Number version
* @return Number result */
NAN_METHOD(GitTransport::Init) {
NanEscapableScope();
if (args.Length() == 0 || !args[0]->IsNumber()) {
return NanThrowError("Number version is required.");
}
// start convert_from_v8 block
unsigned int from_version;
from_version = (unsigned int) args[0]->ToNumber()->Value();
// end convert_from_v8 block
int result = git_transport_init(
ObjectWrap::Unwrap<GitTransport>(args.This())->GetValue()
,from_version
);
Handle<v8::Value> to;
// start convert_to_v8 block
to = NanNew<Number>( result);
// end convert_to_v8 block
NodeGitPsueodoNanReturnEscapingValue(to);
}
/*
* @param Remote owner
* @param Void payload
* @param Transport callback
*/
NAN_METHOD(GitTransport::SshWithPaths) {
NanScope();
if (args.Length() == 0 || !args[0]->IsObject()) {
return NanThrowError("Remote owner is required.");
}
if (args.Length() == 2 || !args[2]->IsFunction()) {
return NanThrowError("Callback is required and must be a Function.");
}
SshWithPathsBaton* baton = new SshWithPathsBaton;
baton->error_code = GIT_OK;
baton->error = NULL;
SshWithPaths_globalPayload* globalPayload = new SshWithPaths_globalPayload;
// start convert_from_v8 block
git_remote * from_owner;
from_owner = ObjectWrap::Unwrap<GitRemote>(args[0]->ToObject())->GetValue();
// end convert_from_v8 block
baton->owner = from_owner;
baton->payload = globalPayload;
NanCallback *callback = new NanCallback(Local<Function>::Cast(args[2]));
SshWithPathsWorker *worker = new SshWithPathsWorker(baton, callback);
if (!args[0]->IsUndefined() && !args[0]->IsNull())
worker->SaveToPersistent("owner", args[0]->ToObject());
if (!args[1]->IsUndefined() && !args[1]->IsNull())
worker->SaveToPersistent("payload", args[1]->ToObject());
NanAsyncQueueWorker(worker);
NanReturnUndefined();
}
void GitTransport::SshWithPathsWorker::Execute() {
int result = git_transport_ssh_with_paths(
&baton->out,baton->owner,baton->payload );
baton->error_code = result;
if (result != GIT_OK && giterr_last() != NULL) {
baton->error = git_error_dup(giterr_last());
}
}
void GitTransport::SshWithPathsWorker::HandleOKCallback() {
TryCatch try_catch;
if (baton->error_code == GIT_OK) {
Handle<v8::Value> to;
// start convert_to_v8 block
if (baton->out != NULL) {
// GitTransport baton->out
to = GitTransport::New((void *)baton->out, false);
}
else {
to = NanNull();
}
// end convert_to_v8 block
Handle<v8::Value> result = to;
Handle<v8::Value> argv[2] = {
NanNull(),
result
};
callback->Call(2, argv);
} else {
if (baton->error) {
Handle<v8::Value> argv[1] = {
NanError(baton->error->message)
};
callback->Call(1, argv);
if (baton->error->message)
free((void *)baton->error->message);
free((void *)baton->error);
} else {
callback->Call(0, NULL);
}
}
if (try_catch.HasCaught()) {
node::FatalException(try_catch);
}
delete (SshWithPaths_globalPayload*)baton->payload;
delete baton;
}
/*
* @param String prefix
* @return Number result */
NAN_METHOD(GitTransport::Unregister) {
NanEscapableScope();
if (args.Length() == 0 || !args[0]->IsString()) {
return NanThrowError("String prefix is required.");
}
// start convert_from_v8 block
const char * from_prefix;
String::Utf8Value prefix(args[0]->ToString());
from_prefix = (const char *) strdup(*prefix);
// end convert_from_v8 block
int result = git_transport_unregister(
from_prefix
);
Handle<v8::Value> to;
// start convert_to_v8 block
to = NanNew<Number>( result);
// end convert_to_v8 block
NodeGitPsueodoNanReturnEscapingValue(to);
}
Persistent<Function> GitTransport::constructor_template;
| 26.460581 | 141 | 0.66928 | jiumx60rus |
9d38b0b6f864491a141cb269625424204800d4a8 | 1,514 | cpp | C++ | Leetcode/Hashing/intersection-of-two-arrays-ii.cpp | susantabiswas/competitive_coding | 49163ecdc81b68f5c1bd90988cc0dfac34ad5a31 | [
"MIT"
] | 2 | 2021-04-29T14:44:17.000Z | 2021-10-01T17:33:22.000Z | Leetcode/Hashing/intersection-of-two-arrays-ii.cpp | adibyte95/competitive_coding | a6f084d71644606c21840875bad78d99f678a89d | [
"MIT"
] | null | null | null | Leetcode/Hashing/intersection-of-two-arrays-ii.cpp | adibyte95/competitive_coding | a6f084d71644606c21840875bad78d99f678a89d | [
"MIT"
] | 1 | 2021-10-01T17:33:29.000Z | 2021-10-01T17:33:29.000Z | /*
https://leetcode.com/problems/intersection-of-two-arrays-ii/submissions/
Idea is to create a hash table and store the frequency of all the
elements of the smaller length array. Then iterate through the longer
array and check in the hash table if the element exists. If it does, add to
the list of common elements.
TC: O(max(M, N))
SC: O(min(M, N))
*/
class Solution {
public:
// Find the frequency of all the elements
void findFrequency(vector<int> *smaller, unordered_map<int, int>& freq) {
for(int &num: *smaller)
++freq[num];
}
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
// Hash table of element frequency
unordered_map<int, int> freq;
vector<int> common;
// pick the smaller array and find the frequency map
vector<int> *smaller = nullptr, *larger = nullptr;
if(nums1.size() < nums2.size())
smaller = &nums1, larger = &nums2;
else
smaller = &nums2, larger = &nums1;
findFrequency(smaller, freq);
for(int &num: *larger) {
// Common element found
if(freq.count(num) && freq[num] > 0) {
common.emplace_back(num);
// remove the current instance
--freq[num];
if(freq[num] == 0)
freq.erase(num);
}
}
return common;
}
};
| 30.897959 | 80 | 0.541612 | susantabiswas |
9d39d38841fee2fca1d6b2aee890ec493d60d6d7 | 9,940 | cxx | C++ | src/adplug/core/dmo.cxx | CBke/audacious-plugins | f17617a38d8412ca30750775208733dc1287e122 | [
"BSD-3-Clause"
] | null | null | null | src/adplug/core/dmo.cxx | CBke/audacious-plugins | f17617a38d8412ca30750775208733dc1287e122 | [
"BSD-3-Clause"
] | null | null | null | src/adplug/core/dmo.cxx | CBke/audacious-plugins | f17617a38d8412ca30750775208733dc1287e122 | [
"BSD-3-Clause"
] | null | null | null | /*
Adplug - Replayer for many OPL2/OPL3 audio file formats.
Copyright (C) 1999 - 2004, 2006 Simon Peter, <[email protected]>, et al.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
dmo.cpp - TwinTeam loader by Riven the Mage <[email protected]>
*/
/*
NOTES:
Panning is ignored.
A WORD ist 16 bits, a DWORD is 32 bits and a BYTE is 8 bits in this context.
*/
#include <string.h>
#include <binstr.h>
#include "dmo.h"
#include "debug.h"
#define LOWORD(l) ((l) & 0xffff)
#define HIWORD(l) ((l) >> 16)
#define LOBYTE(w) ((w) & 0xff)
#define HIBYTE(w) ((w) >> 8)
#define ARRAY_AS_DWORD(a, i) \
((a[i + 3] << 24) + (a[i + 2] << 16) + (a[i + 1] << 8) + a[i])
#define ARRAY_AS_WORD(a, i) ((a[i + 1] << 8) + a[i])
#define CHARP_AS_WORD(p) (((*(p + 1)) << 8) + (*p))
/* -------- Public Methods -------------------------------- */
CPlayer *
CdmoLoader::factory (Copl * newopl)
{
return new CdmoLoader (newopl);
}
bool
CdmoLoader::load (VFSFile * fd, const CFileProvider & fp)
{
int i, j;
binistream *f;
std::string filename (vfs_get_filename (fd));
// check header
dmo_unpacker *unpacker = new dmo_unpacker;
unsigned char chkhdr[16];
f = fp.open (fd);
if (!f)
{
delete unpacker;
return false;
}
if (!fp.extension (filename, ".dmo"))
{
delete unpacker;
return false;
}
f->readString ((char *) chkhdr, 16);
if (!unpacker->decrypt (chkhdr, 16))
{
delete unpacker;
fp.close (f);
return false;
}
// get file size
long packed_length = fp.filesize (f);
f->seek (0);
unsigned char *packed_module = new unsigned char[packed_length];
// load file
f->readString ((char *) packed_module, packed_length);
fp.close (f);
// decrypt
unpacker->decrypt (packed_module, packed_length);
long unpacked_length = 0x2000 * ARRAY_AS_WORD (packed_module, 12);
unsigned char *module = new unsigned char[unpacked_length];
// unpack
if (!unpacker->unpack (packed_module + 12, module, unpacked_length))
{
delete unpacker;
delete[]packed_module;
delete[]module;
return false;
}
delete unpacker;
delete[]packed_module;
// "TwinTeam" - signed ?
if (memcmp (module, "TwinTeam Module File" "\x0D\x0A", 22))
{
delete module;
return false;
}
// load header
binisstream uf (module, unpacked_length);
uf.setFlag (binio::BigEndian, false);
uf.setFlag (binio::FloatIEEE);
memset (&header, 0, sizeof (s3mheader));
uf.ignore (22); // ignore DMO header ID string
uf.readString (header.name, 28);
uf.ignore (2); // _unk_1
header.ordnum = uf.readInt (2);
header.insnum = uf.readInt (2);
header.patnum = uf.readInt (2);
uf.ignore (2); // _unk_2
header.is = uf.readInt (2);
header.it = uf.readInt (2);
memset (header.chanset, 0xFF, 32);
for (i = 0; i < 9; i++)
header.chanset[i] = 0x10 + i;
uf.ignore (32); // ignore panning settings for all 32 channels
// load orders
for (i = 0; i < 256; i++)
orders[i] = uf.readInt (1);
orders[header.ordnum] = 0xFF;
// load pattern lengths
unsigned short my_patlen[100];
for (i = 0; i < 100; i++)
my_patlen[i] = uf.readInt (2);
// load instruments
for (i = 0; i < header.insnum; i++)
{
memset (&inst[i], 0, sizeof (s3minst));
uf.readString (inst[i].name, 28);
inst[i].volume = uf.readInt (1);
inst[i].dsk = uf.readInt (1);
inst[i].c2spd = uf.readInt (4);
inst[i].type = uf.readInt (1);
inst[i].d00 = uf.readInt (1);
inst[i].d01 = uf.readInt (1);
inst[i].d02 = uf.readInt (1);
inst[i].d03 = uf.readInt (1);
inst[i].d04 = uf.readInt (1);
inst[i].d05 = uf.readInt (1);
inst[i].d06 = uf.readInt (1);
inst[i].d07 = uf.readInt (1);
inst[i].d08 = uf.readInt (1);
inst[i].d09 = uf.readInt (1);
inst[i].d0a = uf.readInt (1);
/*
* Originally, riven sets d0b = d0a and ignores 1 byte in the
* stream, but i guess this was a typo, so i read it here.
*/
inst[i].d0b = uf.readInt (1);
}
// load patterns
for (i = 0; i < header.patnum; i++)
{
long cur_pos = uf.pos ();
for (j = 0; j < 64; j++)
{
while (1)
{
unsigned char token = uf.readInt (1);
if (!token)
break;
unsigned char chan = token & 31;
// note + instrument ?
if (token & 32)
{
unsigned char bufbyte = uf.readInt (1);
pattern[i][j][chan].note = bufbyte & 15;
pattern[i][j][chan].oct = bufbyte >> 4;
pattern[i][j][chan].instrument = uf.readInt (1);
}
// volume ?
if (token & 64)
pattern[i][j][chan].volume = uf.readInt (1);
// command ?
if (token & 128)
{
pattern[i][j][chan].command = uf.readInt (1);
pattern[i][j][chan].info = uf.readInt (1);
}
}
}
uf.seek (cur_pos + my_patlen[i]);
}
delete[]module;
rewind (0);
return true;
}
std::string CdmoLoader::gettype ()
{
return std::string ("TwinTeam (packed S3M)");
}
std::string CdmoLoader::getauthor ()
{
/*
All available .DMO modules written by one composer. And because all .DMO
stuff was lost due to hd crash (TwinTeam guys said this), there are
never(?) be another.
*/
return std::string ("Benjamin GERARDIN");
}
/* -------- Private Methods ------------------------------- */
unsigned short
CdmoLoader::dmo_unpacker::brand (unsigned short range)
{
unsigned short
ax,
bx,
cx,
dx;
ax = LOWORD (bseed);
bx = HIWORD (bseed);
cx = ax;
ax = LOWORD (cx * 0x8405);
dx = HIWORD (cx * 0x8405);
cx <<= 3;
cx = (((HIBYTE (cx) + LOBYTE (cx)) & 0xFF) << 8) + LOBYTE (cx);
dx += cx;
dx += bx;
bx <<= 2;
dx += bx;
dx = (((HIBYTE (dx) + LOBYTE (bx)) & 0xFF) << 8) + LOBYTE (dx);
bx <<= 5;
dx = (((HIBYTE (dx) + LOBYTE (bx)) & 0xFF) << 8) + LOBYTE (dx);
ax += 1;
if (!ax)
dx += 1;
// leave it that way or amd64 might get it wrong
bseed = dx;
bseed <<= 16;
bseed += ax;
return HIWORD (HIWORD (LOWORD (bseed) * range) + HIWORD (bseed) * range);
}
bool
CdmoLoader::dmo_unpacker::decrypt (unsigned char *buf, long len)
{
unsigned long
seed = 0;
int
i;
bseed = ARRAY_AS_DWORD (buf, 0);
for (i = 0; i < ARRAY_AS_WORD (buf, 4) + 1; i++)
seed += brand (0xffff);
bseed = seed ^ ARRAY_AS_DWORD (buf, 6);
if (ARRAY_AS_WORD (buf, 10) != brand (0xffff))
return false;
for (i = 0; i < (len - 12); i++)
buf[12 + i] ^= brand (0x100);
buf[len - 2] = buf[len - 1] = 0;
return true;
}
short
CdmoLoader::dmo_unpacker::unpack_block (unsigned char *ibuf, long ilen,
unsigned char *obuf)
{
unsigned char
code,
par1,
par2;
unsigned short
ax,
bx,
cx;
unsigned char *
ipos = ibuf;
unsigned char *
opos = obuf;
// LZ77 child
while (ipos - ibuf < ilen)
{
code = *ipos++;
// 00xxxxxx: copy (xxxxxx + 1) bytes
if ((code >> 6) == 0)
{
cx = (code & 0x3F) + 1;
if (opos + cx >= oend)
return -1;
for (int i = 0; i < cx; i++)
*opos++ = *ipos++;
continue;
}
// 01xxxxxx xxxyyyyy: copy (Y + 3) bytes from (X + 1)
if ((code >> 6) == 1)
{
par1 = *ipos++;
ax = ((code & 0x3F) << 3) + ((par1 & 0xE0) >> 5) + 1;
cx = (par1 & 0x1F) + 3;
if (opos + cx >= oend)
return -1;
for (int i = 0; i < cx; i++) {
*opos = *(opos - ax);
opos++;
}
continue;
}
// 10xxxxxx xyyyzzzz: copy (Y + 3) bytes from (X + 1); copy Z bytes
if ((code >> 6) == 2)
{
int
i;
par1 = *ipos++;
ax = ((code & 0x3F) << 1) + (par1 >> 7) + 1;
cx = ((par1 & 0x70) >> 4) + 3;
bx = par1 & 0x0F;
if (opos + bx + cx >= oend)
return -1;
for (i = 0; i < cx; i++) {
*opos = *(opos - ax);
opos++;
}
for (i = 0; i < bx; i++)
*opos++ = *ipos++;
continue;
}
// 11xxxxxx xxxxxxxy yyyyzzzz: copy (Y + 4) from X; copy Z bytes
if ((code >> 6) == 3)
{
int
i;
par1 = *ipos++;
par2 = *ipos++;
bx = ((code & 0x3F) << 7) + (par1 >> 1);
cx = ((par1 & 0x01) << 4) + (par2 >> 4) + 4;
ax = par2 & 0x0F;
if (opos + ax + cx >= oend)
return -1;
for (i = 0; i < cx; i++) {
*opos = *(opos - bx);
opos++;
}
for (i = 0; i < ax; i++)
*opos++ = *ipos++;
continue;
}
}
return opos - obuf;
}
long
CdmoLoader::dmo_unpacker::unpack (unsigned char *ibuf, unsigned char *obuf,
unsigned long outputsize)
{
long
olen = 0;
unsigned short
block_count = CHARP_AS_WORD (ibuf);
ibuf += 2;
unsigned char *
block_length = ibuf;
ibuf += 2 * block_count;
oend = obuf + outputsize;
for (int i = 0; i < block_count; i++)
{
unsigned short
bul = CHARP_AS_WORD (ibuf);
if (unpack_block (ibuf + 2, CHARP_AS_WORD (block_length) - 2, obuf) !=
bul)
return 0;
obuf += bul;
olen += bul;
ibuf += CHARP_AS_WORD (block_length);
block_length += 2;
}
return olen;
}
| 21.750547 | 80 | 0.544064 | CBke |
9d3a42fafeff22abbf2b799afd1fcdff573194b3 | 5,466 | cpp | C++ | unittests/test_mgpu_Hemm.cpp | brunowu/ChASE | 89649df6027cec70709f55d277b3625989e8cb3c | [
"BSD-3-Clause"
] | 4 | 2021-03-18T14:04:17.000Z | 2021-11-17T18:21:57.000Z | unittests/test_mgpu_Hemm.cpp | brunowu/ChASE | 89649df6027cec70709f55d277b3625989e8cb3c | [
"BSD-3-Clause"
] | null | null | null | unittests/test_mgpu_Hemm.cpp | brunowu/ChASE | 89649df6027cec70709f55d277b3625989e8cb3c | [
"BSD-3-Clause"
] | 3 | 2021-03-18T14:14:51.000Z | 2021-08-19T10:21:13.000Z | // This file is a part of the ChASE library.
// Copyright (c) 2015-2021, Simulation and Data Laboratory Quantum Materials,
// Forschungszentrum Juelich GmbH, Germany.
// All rights reserved.
// ChASE is licensed under the 3-clause BSD license (BSD 2.0).
// https://github.com/ChASE-library/ChASE/
/**
* The program tests the mgpu_cudaHemm class for computing
*
* W = op(H) * V + W
*
* on multiple GPUs, where A is square matrix and B and C are tall and skinny.
* Matrix A is divided into tiles and each tile is distributed to one GPU.
* The matrix A cannot be larger than a total aggregated memory of all availble GPUs.
* Matrices B and C are divided in a column-tiles
*/
#include <cstdio>
#include <cstdlib>
#include <complex>
#include <iomanip>
#include <cuda_runtime_api.h>
#include <cublas_v2.h>
#include <cuda_profiler_api.h>
#define MKL_Complex16 std::complex<double>
#include "mkl.h"
#include "ChASE-MPI/impl/mgpu_cudaHemm.hpp"
using T = std::complex<double>;
using namespace chase;
using namespace chase::mpi;
typedef mgpu_cudaHemm<T> MGPU;
void print(T *A, int ldA, int m, int n);
int main (int argc, char *argv[]) {
/// Matrix dimension
int m;
int n;
int blockDim;
/// Matrices
T *H = nullptr;
T *V = nullptr;
T *W = nullptr;
T *GPU_OUT = nullptr;
// Random generator seeds
int iseed1[] = {1,11,7,1};
int iseed2[] = {3,7,13,13};
int iseed3[] = {3,11,13,1};
/// Auxiliary variables
int num_elem;
int two = 2;
/// MGPU object
MGPU *M = nullptr;
/// Hemm parameters
//T alpha(1.5, 1.0);
//T beta(0.0, 0.0);
std::complex<double> alpha(1.5, 0.0);
std::complex<double> beta(0.0, 0.0);
std::complex<double> one(1.0, 0.0);
char transa = 'N';
char transb = 'N';
/// Read matrix size
m = atoi(argv[1]);
n = atoi(argv[2]);
blockDim = atoi(argv[3]);
int ldH = m;
int ldV = n;
int ldW = m;
// Allocate arrays for A, B, and C on the host
cudaMallocHost((void**)&H, ldH*n*sizeof(T));
cudaMallocHost((void**)&V, ldV*blockDim*sizeof(T));
cudaMallocHost((void**)&W, ldW*blockDim*sizeof(T));
cudaMallocHost((void**)&GPU_OUT, ldV*blockDim*sizeof(T));
// Fill matrices with random values
num_elem = ldV * blockDim;
zlarnv(&two, iseed1, &num_elem, V);
num_elem = ldW * blockDim;
zlarnv(&two, iseed2, &num_elem, W);
num_elem = ldH * n;
zlarnv(&two, iseed3, &num_elem, H);
// Copy V to GPU_OUT
memcpy((void*)GPU_OUT, (void*)V, ldV*blockDim*sizeof(T));
#if 0
std::cout << "H = " << std::endl;
print(H, ldH, m, n);
std::cout << "V = " << std::endl;
print(V, ldV, m, blockDim);
#endif
std::cout << std::endl << "====== CPU PART ====== " << std::endl;
/// Compute CPU version
/* FIRST STEP: W_1 = H * V_0 + W_0 */
zgemm(&transa, &transb, &m, &blockDim, &n, &alpha, H, &ldH, V, &ldV, &beta, W, &ldW);
#if 0
std::cout << "CPU output step 1: " << std::endl;
print(W, ldW, m, blockDim);
#endif
/* SECOND STEP: V_1 = H^T * W_1 + V_0 */
transa = 'C';
zgemm(&transa, &transb, &n, &blockDim, &m, &alpha, H, &ldH, W, &ldW, &one, V, &ldV);
std::cout << std::endl << "====== GPU PART ====== " << std::endl;
// Construct a new MGPU object
M = new MGPU(m, n, blockDim);
// Copy H to GPUs
M->distribute_H(H, ldH);
/* FIRST STEP: W_1 = H * V_0 + W_0 */
// Copy V to GPUs
M->distribute_V(GPU_OUT, ldV, blockDim);
// Run on GPUs
M->computeHemm(blockDim, alpha, beta);
// Collect results from GPUs
M->return_W(W, ldW, blockDim);
#if 0
std::cout << std::endl << "GPU output step 1: " << std::endl;
print(W, ldW, m, blockDim);
#endif
// SECOND STEP: V_1 = H^T * W_1 + V_0 */
/* Switch operation to V = H * W + V */
M->switch_operation();
// Distribute previously computed W to the devices.
M->distribute_V(W, ldW, blockDim);
// Run HEMM on GPUs
M->computeHemm(blockDim, alpha, one);
// Collect results
M->return_W(GPU_OUT, ldV, blockDim);
//M->synchronizeAll();
#if 0
std::cout << "CPU output step 2: " << std::endl;
print(V, ldV, n, blockDim);
std::cout << std::endl << "GPU output step 2: " << std::endl;
print(GPU_OUT, ldV, n, blockDim);
#endif
#if 0
double err = 10e-12;
std::cout << "Error on positions: " << std::endl;
for(int i=0; i<m; i++){
for(int j=0; j<blockDim; j++){
if(real(GPU_OUT[j*ldW+i]) - real(W[j*ldW+i]) > err && imag(GPU_OUT[j*ldW+i]) - imag(W[j*ldW+i]) > err) std::cout<<"("<<i<< ","<<j<<"), ";
}
}
std::cout << std::endl;
#endif
// Compare CPU and GPUs results
std::complex<double> zalpha(-1.0, 0.0);
cblas_zaxpy(n*blockDim, &zalpha, GPU_OUT, 1, V, 1);
#if 0
std::cout << "Difference after zaxpy:" << std::endl;
for(int i=0; i<m*blockDim; i++){
if (real(W[i]) > err || imag(W[i]) > err) std::cout << i << ", ";
}
std::cout << std::endl;
#endif
char norm = 'M';
int rows = n;
double *tmp = nullptr;
double error = zlange(&norm, &rows, &blockDim, V, &ldV, tmp);
// Print output
std::cout << "Absolute error = " << std::scientific << error << std::endl;
delete M;
cudaFreeHost(H);
cudaFreeHost(V);
cudaFreeHost(W);
cudaFreeHost(GPU_OUT);
return EXIT_SUCCESS;
}
void print(T *A, int ldA, int m, int n) {
for (int i=0; i<m; i++) {
for (int j=0; j<n; j++) {
//std::cout << std::fixed << std::setprecision(6) << std::setw(10) << real(A[i*ldA + j]) << " ";
std::cout << std::fixed << std::setprecision(6) << std::setw(25) << A[j*ldA + i] << " ";
}
std::cout << std::endl;
}
/* for (int i=0; i<m*n; i++) {
std::cout << real(A[i]) << " ";
}
std::cout << std::endl;
*/
}
| 24.511211 | 140 | 0.60794 | brunowu |
9d3a471ea9f488055dad8efb9f7b323e0f5c5a4f | 3,996 | hpp | C++ | cpp-projects/base/utility/benchmark.hpp | FlorianLance/toolbox | 87882a14ec86852d90527c81475b451b9f6e12cf | [
"MIT"
] | null | null | null | cpp-projects/base/utility/benchmark.hpp | FlorianLance/toolbox | 87882a14ec86852d90527c81475b451b9f6e12cf | [
"MIT"
] | null | null | null | cpp-projects/base/utility/benchmark.hpp | FlorianLance/toolbox | 87882a14ec86852d90527c81475b451b9f6e12cf | [
"MIT"
] | 1 | 2021-07-06T14:47:41.000Z | 2021-07-06T14:47:41.000Z |
/*******************************************************************************
** Toolbox-base **
** MIT License **
** Copyright (c) [2018] [Florian Lance] **
** **
** 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
// std
#include <string_view>
#include <vector>
#include <memory>
#include <thread>
namespace tool {
using namespace std::literals::string_view_literals;
using BenchId = std::string_view;
using OTID = std::optional<std::thread::id>;
enum class BenchUnit{
milliseconds, microseconds, nanoseconds
};
[[maybe_unused]] constexpr static std::string_view milliUnitStr = "ms"sv;
[[maybe_unused]] constexpr static std::string_view microUnitStr = "μs"sv;
[[maybe_unused]] constexpr static std::string_view nanoUnitStr = "ns"sv;
struct Bench{
Bench();
static void disable_display();
static void clear(OTID otId = std::nullopt);
static void reset(OTID otId = std::nullopt);
static void check(OTID otId = std::nullopt);
static void start(BenchId id, bool display = false, OTID otId = std::nullopt);
static void stop(BenchId id = ""sv, OTID otId = std::nullopt);
static void display(BenchUnit unit = BenchUnit::milliseconds, std::int64_t minTime = -1, bool sort = false, OTID otId = std::nullopt);
static std::string to_string(BenchUnit unit, std::int64_t minTime, bool sort, OTID otId = std::nullopt);
static bool is_started(BenchId id, OTID otId = std::nullopt);
static int level(BenchId id, OTID otId = std::nullopt);
static size_t calls_count(BenchId id, OTID otId = std::nullopt);
static std::int64_t compute_total_time(BenchUnit unit, BenchId id, OTID otId = std::nullopt);
static std::vector<std::tuple<BenchId, int64_t, size_t>> all_total_times(BenchUnit unit, std::int64_t minTime = -1, bool sort = false, OTID otId = std::nullopt);
private:
static constexpr std::string_view unit_to_str(BenchUnit unit);
struct Impl;
std::unique_ptr<Impl> m_p = nullptr;
};
struct BenchGuard{
// std::string_view id;
BenchGuard() = delete;
BenchGuard(BenchId id, bool display = false);
~BenchGuard();
};
}
| 44.898876 | 169 | 0.556557 | FlorianLance |
9d3fdc7afd63a43b912876f98dfe2ce33685e3f6 | 199 | cpp | C++ | Week 8/Week 8(2)/Source.cpp | liuyuwang2016/-C- | 11e58e25514923d491e77fae20f3bf25ff0136c7 | [
"MIT"
] | null | null | null | Week 8/Week 8(2)/Source.cpp | liuyuwang2016/-C- | 11e58e25514923d491e77fae20f3bf25ff0136c7 | [
"MIT"
] | null | null | null | Week 8/Week 8(2)/Source.cpp | liuyuwang2016/-C- | 11e58e25514923d491e77fae20f3bf25ff0136c7 | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
int main() {
int a = 0, b = 0, sum = 0;
cin >> a;
for (int i = 0; i < 5; i++) {
cin >> b;
if (b < a) {
sum += b;
}
}
cout << sum;
return 0;
} | 12.4375 | 30 | 0.457286 | liuyuwang2016 |
9d4483eb4f307931e047cd1b3c8e766a0045e352 | 1,843 | cpp | C++ | src/WerkTest/OS/Time.cpp | AgalmicVentures/Werk | 99afecb310aadb90d941a3a1031bc91b33edac59 | [
"MIT"
] | 27 | 2017-04-22T22:46:07.000Z | 2022-03-30T21:14:16.000Z | src/WerkTest/OS/Time.cpp | AgalmicVentures/Werk | 99afecb310aadb90d941a3a1031bc91b33edac59 | [
"MIT"
] | null | null | null | src/WerkTest/OS/Time.cpp | AgalmicVentures/Werk | 99afecb310aadb90d941a3a1031bc91b33edac59 | [
"MIT"
] | 14 | 2017-02-26T09:28:02.000Z | 2022-03-03T16:33:47.000Z |
/*
* Copyright (c) 2015-2021 Agalmic Ventures LLC (www.agalmicventures.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include <boost/test/unit_test.hpp>
#include "Werk/OS/Time.hpp"
BOOST_AUTO_TEST_SUITE(ClockTest)
BOOST_AUTO_TEST_CASE(TestEpochTime)
{
uint64_t t1 = werk::epochTime();
BOOST_REQUIRE(t1 > 0);
}
BOOST_AUTO_TEST_CASE(TestMonotoneTime)
{
uint64_t t1 = werk::monotoneTime();
for (uint32_t i = 0; i < 100; ++i) {
uint64_t t2 = werk::monotoneTime();
BOOST_REQUIRE(t2 >= t1);
t1 = t2;
}
}
BOOST_AUTO_TEST_CASE(TestClock)
{
werk::Clock c;
BOOST_REQUIRE_EQUAL(c.time(), 0);
c.setTime(100);
BOOST_REQUIRE_EQUAL(c.time(), 100);
c.setEpochTime();
uint64_t t1 = c.time();
c.setEpochTime();
uint64_t t2 = c.time();
BOOST_REQUIRE(t2 >= t1);
}
BOOST_AUTO_TEST_SUITE_END()
| 28.796875 | 79 | 0.737927 | AgalmicVentures |
9d507214940608719380b8735813a6a0d2baf5c5 | 1,030 | cpp | C++ | algorithms/image-smoother.cpp | Chronoviser/leetcode-1 | 65ee0504d64c345f822f216fef6e54dd62b8f858 | [
"MIT"
] | 41 | 2018-07-03T07:35:30.000Z | 2021-09-25T09:33:43.000Z | algorithms/image-smoother.cpp | Chronoviser/leetcode-1 | 65ee0504d64c345f822f216fef6e54dd62b8f858 | [
"MIT"
] | 2 | 2018-07-23T10:50:11.000Z | 2020-10-06T07:34:29.000Z | algorithms/image-smoother.cpp | Chronoviser/leetcode-1 | 65ee0504d64c345f822f216fef6e54dd62b8f858 | [
"MIT"
] | 7 | 2018-07-06T13:43:18.000Z | 2020-10-06T02:29:57.000Z | class Solution
{
private:
inline int average(vector<int> nums)
{
return accumulate(nums.begin(), nums.end(), 0, [](int a, int b) -> int { return a + b; }) / nums.size();
}
public:
vector<vector<int>> imageSmoother(vector<vector<int>>& M)
{
if (M.empty()) return {};
vector<pair<int, int>> next = {{1, 0}, {0, 1},{-1, 0}, {0, -1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}};
vector<vector<int>> result = vector<vector<int>>(M.size(), vector<int>(M[0].size()));
for (int i = 0; i < M.size(); i++) {
for (int j = 0; j < M[i].size(); j++) {
vector<int> nums = {M[i][j]};
for (int k = 0; k < next.size(); k++) {
int x = i + next[k].first;
int y = j + next[k].second;
if (x >= 0 && x < M.size() && y >= 0 && y < M[i].size()) nums.push_back(M[x][y]);
}
result[i][j] = this->average(nums);
}
}
return result;
}
};
| 33.225806 | 112 | 0.418447 | Chronoviser |
9d59091ebacbd924af8f4763d789f12d72aafd43 | 26,554 | cpp | C++ | src/systems/physics/wrappers/ode_physics.cpp | vi3itor/Blunted2 | 318af452e51174a3a4634f3fe19b314385838992 | [
"Unlicense"
] | 56 | 2020-07-22T22:11:06.000Z | 2022-03-09T08:11:43.000Z | GameplayFootball/src/systems/physics/wrappers/ode_physics.cpp | ElsevierSoftwareX/SOFTX-D-20-00016 | 48c28adb72aa167a251636bc92111b3c43c0be67 | [
"MIT"
] | 9 | 2021-04-22T07:06:25.000Z | 2022-01-22T12:54:52.000Z | GameplayFootball/src/systems/physics/wrappers/ode_physics.cpp | ElsevierSoftwareX/SOFTX-D-20-00016 | 48c28adb72aa167a251636bc92111b3c43c0be67 | [
"MIT"
] | 20 | 2017-11-07T16:52:32.000Z | 2022-01-25T02:42:48.000Z | // written by bastiaan konings schuiling 2008 - 2014
// this work is public domain. the code is undocumented, scruffy, untested, and should generally not be used for anything important.
// i do not offer support, so don't ask. to be used for inspiration :)
#include "ode_physics.hpp"
#include "base/log.hpp"
#include "base/utils.hpp"
namespace blunted {
OdePhysics::OdePhysics() {
dInitODE();
};
OdePhysics::~OdePhysics() {
dCloseODE();
};
static void OdePhysicsNearCallback(void *data, dGeomID o1, dGeomID o2) {
if (dGeomIsSpace(o1) || dGeomIsSpace(o2)) {
// colliding a space with something
dSpaceCollide2(o1, o2, data, &OdePhysicsNearCallback);
// collide all geoms internal to the space(s)
if (dGeomIsSpace(o1)) dSpaceCollide((dSpaceID)o1, data, &OdePhysicsNearCallback);
if (dGeomIsSpace(o2)) dSpaceCollide((dSpaceID)o2, data, &OdePhysicsNearCallback);
} else {
dBodyID bodies[2];
bodies[0] = dGeomGetBody(o1);
bodies[1] = dGeomGetBody(o2);
if (bodies[0] != NULL || bodies[1] != NULL) {
// todo: find out what exactly these do
if (bodies[0] && bodies[1] && dAreConnectedExcluding(bodies[0], bodies[1], dJointTypeContact)) return;
if (bodies[0] && bodies[1] && dAreConnected(bodies[0], bodies[1])) return;
Properties *properties[2];
properties[0] = static_cast<Properties*>(dGeomGetData(o1));
properties[1] = static_cast<Properties*>(dGeomGetData(o2));
// the properties of the dynamic object
// if both of the colliding objects are colliding, take the first (kinda hacky ;))
// example problem is, if both are dynamic, what fdir1 to use? so just use the first
int dynamicBody = 0;
if (bodies[0]) dynamicBody = 0;
else if (bodies[1]) dynamicBody = 1;
// when larger, collisions near seams between trimesh triangles causes 2 contacts (with both triangles) to be created.
// this causes bumpy movement on seams.
// max 1 contact probably won't work with non-convex objects, so they are not supported (yet)
int MAX_CONTACTS = 12;
dContact contactsArray[MAX_CONTACTS];
std::vector<dContact> contacts;
// colliding two non-space geoms, so generate contact points between o1 and o2
int num_contact = dCollide(o1, o2, MAX_CONTACTS, &contactsArray[0].geom, sizeof(dContact));
// put into vector for simpler merging
for (int i = 0; i < num_contact; i++) {
dContact contact = contactsArray[i];
contacts.push_back(contact);
}
// contact point merging strategy
// more info: http://www.ode.org/old_list_archives/2007-June/022137.html
float mergeThreshold = 0.4; // contact points less than 40 centimeters apart? merge em
bool firstTime = true;
bool possibleNeighbours = false;
int startContacts = contacts.size();
//if (startContacts > 1) printf("before: %i points\n", contacts.size());
while (possibleNeighbours || firstTime) {
firstTime = false;
possibleNeighbours = false;
std::vector<dContact>::iterator subjectIter = contacts.begin();
while (subjectIter != contacts.end()) {
// for each contact, find all neighbours
Vector3 pos((*subjectIter).geom.pos[0], (*subjectIter).geom.pos[1], (*subjectIter).geom.pos[2]);
Vector3 normal((*subjectIter).geom.normal[0], (*subjectIter).geom.normal[1], (*subjectIter).geom.normal[2]);
std::vector<dContact>::iterator checkIter = subjectIter + 1;
while (checkIter != contacts.end()) {
Vector3 pos2((*checkIter).geom.pos[0], (*checkIter).geom.pos[1], (*checkIter).geom.pos[2]);
Vector3 normal2((*checkIter).geom.normal[0], (*checkIter).geom.normal[1], (*checkIter).geom.normal[2]);
if (pos.GetDistance(pos2) < mergeThreshold) {
// merge
Vector3 newPos = (pos + pos2) * 0.5;
Vector3 newNormal = (normal + normal2) * 0.5;
if (newNormal.GetLength() == 0) {
newNormal.Set(0, 0, 1);
Log(e_Warning, "ode_physics.cpp", "OdePhysicsNearCallback", "Unable to normalize Vector3");
}
newNormal.Normalize();
// replace subject with new contact pos/normal
// edit: just ignoring the second contact seems to give better results
/*
(*subjectIter).geom.pos[0] = newPos.coords[0];
(*subjectIter).geom.pos[1] = newPos.coords[1];
(*subjectIter).geom.pos[2] = newPos.coords[2];
(*subjectIter).geom.normal[0] = newNormal.coords[0];
(*subjectIter).geom.normal[1] = newNormal.coords[1];
(*subjectIter).geom.normal[2] = newNormal.coords[2];
(*subjectIter).geom.depth += (*checkIter).geom.depth;
(*subjectIter).geom.depth *= 0.5;
*/
//newNormal.Print();
//newPos.Print();
//printf("depth: %f\n", (*subjectIter).geom.depth);
//printf("sub %f\n", (*subjectIter).geom.depth);
//printf("chk %f\n", (*checkIter).geom.depth);
// remove mergee
checkIter = contacts.erase(checkIter);
// iterate the 'main loop' once more after this, there might be more neighbours
possibleNeighbours = true;
} else {
// leave alone
checkIter++;
}
} // check iter
subjectIter++;
} // subject iter
} // possible neighbors
//if (startContacts > 1) printf("after: %i points", contacts.size());
//if (contacts.size() >= 2) printf(" <-- !!!");
//if (startContacts > 1) printf("\n");
// add these contact points to the simulation ...
std::vector<dContact>::iterator subjectIter = contacts.begin();
//printf("%f - %f\n", properties1->GetReal("friction"), properties2->GetReal("friction"));
while (subjectIter != contacts.end()) {
(*subjectIter).surface.mode = dContactMu2 | dContactSoftCFM | dContactSoftERP | dContactApprox1;
(*subjectIter).surface.mu = properties[0]->GetReal("friction_1", 1) * properties[1]->GetReal("friction_1", 1);
(*subjectIter).surface.mu2 = properties[0]->GetReal("friction_2", 1) * properties[1]->GetReal("friction_2", 1);
(*subjectIter).surface.soft_cfm = 1e-5f;
(*subjectIter).surface.soft_erp = 0.8;
if (properties[dynamicBody]->Exists("bounce")) {
(*subjectIter).surface.mode |= dContactBounce;
(*subjectIter).surface.bounce = properties[dynamicBody]->GetReal("bounce", 0.1);
(*subjectIter).surface.bounce_vel = properties[dynamicBody]->GetReal("bounce_minimum_velocity", 0.1);
}
if (properties[dynamicBody]->Exists("friction_direction_1")) {
(*subjectIter).surface.mode |= dContactFDir1;
/* disabled, calculate using the body's linear velocity
// get user fdir1
Vector3 fdir1 = properties[dynamicBody]->GetVector3("friction_direction_1");
*/
// get object's rotation
const dReal *R;
R = dBodyGetLinearVel(bodies[dynamicBody]);
Vector3 fdir1((float)R[0], (float)R[1], (float)R[2]);
if (fdir1.GetLength() == 0) {
Log(e_Warning, "ode_physics", "OdePhysicsCollisionCallback", "Unable to normalize fdir1");
fdir1.Set(1, 0, 0);
}
fdir1.Normalize();
// rotate fdir by object's rotation
//fdir1 = rot * fdir1;
(*subjectIter).fdir1[0] = fdir1.coords[0];
(*subjectIter).fdir1[1] = fdir1.coords[1];
(*subjectIter).fdir1[2] = fdir1.coords[2];
if (properties[dynamicBody]->Exists("slip")) {
(*subjectIter).surface.mode |= dContactSlip2;
// get rolling velocity
R = dBodyGetAngularVel(bodies[dynamicBody]);
Vector3 vel((float)R[0], (float)R[1], (float)R[2]);
float velocity = vel.GetLength();
(*subjectIter).surface.slip2 = properties[dynamicBody]->GetReal("slip") * velocity;
}
}
dJointID c = dJointCreateContact(static_cast<dWorldID>(data), collisionGroup, &*subjectIter);
dJointAttach(c, bodies[0], bodies[1]);
//printf("%f %f %f\n", contact[i].geom.normal[0], contact[i].geom.normal[1], contact[i].geom.normal[2]);
subjectIter++;
}
}
}
}
int OdePhysics::StepTime(int timediff_ms, int resolution_ms) {
mutex.lock();
// how many steps to undertake?
// modulus version
int numSteps = timediff_ms / resolution_ms;
int remainder_ms = timediff_ms % resolution_ms;
//printf("%i %i %i %i\n", numSteps, timediff_ms, resolution_ms, remainder_ms);
//printf("%i timesteps * %i resolution_ms\n", numSteps, resolution_ms);
// for each world..
// check for collisions and add contact joints
// do timestep
// quick hax: link world and space id's, since ODE is kinda silly
// todo: combine world and space into one map
std::map <int, dWorldID>::iterator worldIter = worldMap.begin();
std::map <int, dSpaceID>::iterator spaceIter = spaceMap.begin();
while (worldIter != worldMap.end()) {
for (int i = 0; i < numSteps; i++) {
dSpaceCollide((*spaceIter).second, (*worldIter).second, &OdePhysicsNearCallback);
dWorldQuickStep((*worldIter).second, resolution_ms * 0.001);
dJointGroupEmpty(collisionGroup);
}
spaceIter++;
worldIter++;
}
mutex.unlock();
return remainder_ms;
}
int OdePhysics::CreateWorld() {
mutex.lock();
dWorldID worldID = dWorldCreate();
//dWorldSetContactSurfaceLayer(worldID, 0.001);
collisionGroup = dJointGroupCreate(0);
int entry = worldMap.size();
std::pair <std::map <int, dWorldID>::iterator, bool> result = worldMap.insert(std::map <int, dWorldID>::value_type(entry, worldID));
if (result.second == false) {
Log(e_FatalError, "OdePhysics", "CreateWorld", "Could not insert worldMap entry");
return 0;
}
mutex.unlock();
return entry;
}
void OdePhysics::DeleteWorld(int worldID) {
mutex.lock();
dJointGroupDestroy(collisionGroup);
dWorldDestroy(GetOdeWorldID(worldID));
worldMap.erase(worldMap.find(worldID));
mutex.unlock();
}
int OdePhysics::CreateSpace() {
mutex.lock();
dSpaceID spaceID = dHashSpaceCreate(0);
dHashSpaceSetLevels(spaceID, 10, 100);
dSpaceSetCleanup(spaceID, 1); // delete geoms on space destroy
int entry = spaceMap.size();
std::pair <std::map <int, dSpaceID>::iterator, bool> result = spaceMap.insert(std::map <int, dSpaceID>::value_type(entry, spaceID));
if (result.second == false) {
Log(e_FatalError, "OdePhysics", "CreateSpace", "Could not insert spaceMap entry");
return 0;
}
mutex.unlock();
return entry;
}
void OdePhysics::DeleteSpace(int spaceID) {
mutex.lock();
dSpaceDestroy(GetOdeSpaceID(spaceID));
spaceMap.erase(spaceMap.find(spaceID));
mutex.unlock();
}
void OdePhysics::SetGravity(int worldID, const Vector3 &gravity) {
mutex.lock();
dWorldSetGravity(GetOdeWorldID(worldID), gravity.coords[0], gravity.coords[1], gravity.coords[2]);
mutex.unlock();
}
void OdePhysics::SetErrorCorrection(int worldID, float value) {
mutex.lock();
dWorldSetERP(GetOdeWorldID(worldID), value);
mutex.unlock();
}
void OdePhysics::SetConstraintForceMixing(int worldID, float value) {
mutex.lock();
dWorldSetCFM(GetOdeWorldID(worldID), value);
mutex.unlock();
}
// actor functions
IPhysicsActor *OdePhysics::CreateActor(int worldID) {
mutex.lock();
dBodyID id = dBodyCreate(GetOdeWorldID(worldID));
OdePhysicsActor *actor = new OdePhysicsActor();
actor->id = id;
mutex.unlock();
return actor;
}
void OdePhysics::DeleteActor(IPhysicsActor *actor) {
mutex.lock();
dBodyDestroy(static_cast<OdePhysicsActor*>(actor)->id);
delete actor;
actor = 0;
mutex.unlock();
}
void OdePhysics::ActorSetMassSphere(IPhysicsActor *actor, float radius, float weight) {
mutex.lock();
dMass mass;
dMassSetZero(&mass);
dMassSetSphereTotal(&mass, weight, radius);
dBodySetMass(static_cast<OdePhysicsActor*>(actor)->id, &mass);
mutex.unlock();
}
void OdePhysics::ActorSetMassBox(IPhysicsActor *actor, const Vector3 &sides, float weight) {
mutex.lock();
dMass mass;
dMassSetZero(&mass);
dMassSetBoxTotal(&mass, weight, sides.coords[0], sides.coords[1], sides.coords[2]);
dBodySetMass(static_cast<OdePhysicsActor*>(actor)->id, &mass);
mutex.unlock();
}
void OdePhysics::ActorSetMassPosition(IPhysicsActor *actor, const Vector3 &pos) {
mutex.lock();
const dReal *bla = dBodyGetPosition(static_cast<OdePhysicsActor*>(actor)->id);
dGeomID geom = dBodyGetFirstGeom(static_cast<OdePhysicsActor*>(actor)->id);
dBodySetPosition(static_cast<OdePhysicsActor*>(actor)->id, bla[0] + pos.coords[0], bla[1] + pos.coords[1], bla[2] + pos.coords[2]);
dGeomSetOffsetPosition(geom, -pos.coords[0], -pos.coords[1], -pos.coords[2]);
mutex.unlock();
}
void OdePhysics::ActorSetPosition(IPhysicsActor *actor, const Vector3 &pos) {
mutex.lock();
dBodySetPosition(static_cast<OdePhysicsActor*>(actor)->id, pos.coords[0], pos.coords[1], pos.coords[2]);
mutex.unlock();
}
void OdePhysics::ActorSetRotation(IPhysicsActor *actor, const Quaternion &rot) {
mutex.lock();
dReal R[4] = { rot.elements[3], rot.elements[0], rot.elements[1], rot.elements[2] };
dBodySetQuaternion(static_cast<OdePhysicsActor*>(actor)->id, R);
mutex.unlock();
}
Vector3 OdePhysics::ActorGetPosition(IPhysicsActor *actor) {
mutex.lock();
const dReal *P;
P = dBodyGetPosition(static_cast<OdePhysicsActor*>(actor)->id);
Vector3 pos = Vector3((float)P[0], (float)P[1], (float)P[2]);
mutex.unlock();
return pos;
}
Quaternion OdePhysics::ActorGetRotation(IPhysicsActor *actor) {
mutex.lock();
const dReal *R;
R = dBodyGetQuaternion(static_cast<OdePhysicsActor*>(actor)->id);
Quaternion rot((float)R[1], (float)R[2], (float)R[3], (float)R[0]);
mutex.unlock();
return rot;
}
float OdePhysics::ActorGetVelocity(IPhysicsActor *actor) {
mutex.lock();
const dReal *P;
P = dBodyGetLinearVel(static_cast<OdePhysicsActor*>(actor)->id);
Vector3 velocity = Vector3((float)P[0], (float)P[1], (float)P[2]);
mutex.unlock();
return velocity.GetLength();
}
Vector3 OdePhysics::ActorGetMovement(IPhysicsActor *actor) {
mutex.lock();
const dReal *P;
P = dBodyGetLinearVel(static_cast<OdePhysicsActor*>(actor)->id);
Vector3 velocity = Vector3((float)P[0], (float)P[1], (float)P[2]);
mutex.unlock();
return velocity;
}
void OdePhysics::ActorApplyForceAtRelativePosition(IPhysicsActor *actor, float force, const Vector3 &direction, const Vector3 &position) {
mutex.lock();
dBodyAddForceAtRelPos(static_cast<OdePhysicsActor*>(actor)->id,
direction.coords[0] * force, direction.coords[1] * force, direction.coords[2] * force,
position.coords[0], position.coords[1], position.coords[2]);
mutex.unlock();
}
// collision functions
IPhysicsCollisionMesh *OdePhysics::CreateCollisionPlane(int spaceID, const Vector3 &normal, float d) {
mutex.lock();
dGeomID id = dCreatePlane(GetOdeSpaceID(spaceID), normal.coords[0], normal.coords[1], normal.coords[2], d);
OdePhysicsCollisionMesh *coll = new OdePhysicsCollisionMesh();
coll->id = id;
mutex.unlock();
return coll;
}
IPhysicsCollisionMesh *OdePhysics::CreateCollisionSphere(int spaceID, float radius) {
mutex.lock();
dGeomID id = dCreateSphere(GetOdeSpaceID(spaceID), radius);
OdePhysicsCollisionMesh *coll = new OdePhysicsCollisionMesh();
coll->id = id;
mutex.unlock();
return coll;
}
IPhysicsCollisionMesh *OdePhysics::CreateCollisionBox(int spaceID, const Vector3 &sides) {
mutex.lock();
dGeomID id = dCreateBox(GetOdeSpaceID(spaceID), sides.coords[0], sides.coords[1], sides.coords[2]);
OdePhysicsCollisionMesh *coll = new OdePhysicsCollisionMesh();
coll->id = id;
mutex.unlock();
return coll;
}
IPhysicsCollisionMesh *OdePhysics::CreateCollisionTriMesh(int spaceID, const float *vertices, int vertexCount) {
mutex.lock();
dTriMeshDataID trimesh_id = dGeomTriMeshDataCreate();
// unique vertices version
dReal *dvertices = new dReal[vertexCount * 3];
int *indices = new int[vertexCount];
// put all meshes' vertices in ode vertex buffer
for (int i = 0; i < vertexCount; i++) {
for (int v = 0; v < 3; v++) {
dvertices[i * 3 + v] = vertices[i * 3 + v];
}
indices[i] = i;
}
dGeomTriMeshDataBuildSingle(trimesh_id, dvertices, sizeof(dReal) * 3, vertexCount,
indices, vertexCount, sizeof(unsigned int) * 3);
// shared vertices version
/*
// find duplicate vertices and index them
std::vector<Vector3> uniqueVertices;
//std::map <int, int> newVertexIndices;
int *indices = new int[vertexCount];
//printf("size before: %i\n", vertexCount);
for (int i = 0; i < vertexCount; i++) {
Vector3 pos(vertices[i * 3], vertices[i * 3 + 1], vertices[i * 3 + 2]);
std::vector<Vector3>::iterator found = std::find(uniqueVertices.begin(), uniqueVertices.end(), pos);
if (found == uniqueVertices.end()) {
uniqueVertices.push_back(pos);
indices[i] = uniqueVertices.size() - 1;
} else {
// map vertex to new vertex id
indices[i] = std::distance(uniqueVertices.begin(), found);
}
}
dReal *dvertices = new dReal[uniqueVertices.size() * 3];
for (int i = 0; i < uniqueVertices.size(); i++) {
dvertices[i * 3 + 0] = uniqueVertices.at(i).coords[0];
dvertices[i * 3 + 1] = uniqueVertices.at(i).coords[1];
dvertices[i * 3 + 2] = uniqueVertices.at(i).coords[2];
}
//printf("size after: %i\n", uniqueVertices.size());
dGeomTriMeshDataBuildSingle(trimesh_id, dvertices, sizeof(dReal) * 3, uniqueVertices.size(),
indices, vertexCount, sizeof(unsigned int) * 3);
*/
dGeomID id = dCreateTriMesh(GetOdeSpaceID(spaceID), trimesh_id, NULL, NULL, NULL);
OdePhysicsCollisionMesh *coll = new OdePhysicsCollisionMesh();
coll->id = id;
coll->vertices = dvertices;
coll->indices = indices;
mutex.unlock();
return coll;
}
void OdePhysics::DeleteCollisionMesh(IPhysicsCollisionMesh *mesh) {
mutex.lock();
// unlink body first
dGeomSetBody(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, 0);
dGeomDestroy(static_cast<OdePhysicsCollisionMesh*>(mesh)->id);
delete mesh;
mesh = 0;
mutex.unlock();
}
void OdePhysics::CollisionMeshSetActor(IPhysicsCollisionMesh *mesh, IPhysicsActor *actor) {
mutex.lock();
dGeomSetBody(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, static_cast<OdePhysicsActor*>(actor)->id);
mutex.unlock();
}
void OdePhysics::CollisionMeshSetPosition(IPhysicsCollisionMesh *mesh, const Vector3 &pos) {
mutex.lock();
dGeomSetPosition(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, pos.coords[0], pos.coords[1], pos.coords[2]);
mutex.unlock();
}
void OdePhysics::CollisionMeshSetRotation(IPhysicsCollisionMesh *mesh, const Quaternion &rot) {
mutex.lock();
dReal R[4] = { rot.elements[3], rot.elements[0], rot.elements[1], rot.elements[2] };
dGeomSetQuaternion(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, R);
mutex.unlock();
}
Vector3 OdePhysics::CollisionMeshGetPosition(IPhysicsCollisionMesh *mesh) {
mutex.lock();
const dReal *P;
P = dGeomGetPosition(static_cast<OdePhysicsCollisionMesh*>(mesh)->id);
Vector3 pos = Vector3((float)P[0], (float)P[1], (float)P[2]);
mutex.unlock();
return pos;
}
Quaternion OdePhysics::CollisionMeshGetRotation(IPhysicsCollisionMesh *mesh) {
mutex.lock();
dReal *R = 0;
dGeomGetQuaternion(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, R);
Quaternion rot((float)R[1], (float)R[2], (float)R[3], (float)R[0]);
mutex.unlock();
return rot;
}
void OdePhysics::CollisionMeshSetData(IPhysicsCollisionMesh *mesh, const Properties *data) {
mutex.lock();
// need to const_cast, cause ODE needs a non-const.
// just don't alter it in the collision callback function!
dGeomSetData(static_cast<OdePhysicsCollisionMesh*>(mesh)->id, const_cast<Properties*>(data));
mutex.unlock();
}
// joint functions
IPhysicsJoint *OdePhysics::CreateJoint(int worldID, e_JointType jointType, IPhysicsActor *actor1, IPhysicsActor *actor2, const Vector3 &anchor, const Vector3 &axis1, const Vector3 &axis2) {
mutex.lock();
dWorldID odeWorldID = GetOdeWorldID(worldID);
// hmm create a nice joint! smokin'
OdePhysicsJoint *joint = new OdePhysicsJoint();
switch (jointType) {
case e_JointType_Hinge:
joint->id = dJointCreateHinge(odeWorldID, 0);
dJointAttach(joint->id, static_cast<OdePhysicsActor*>(actor1)->id, static_cast<OdePhysicsActor*>(actor2)->id);
dJointSetHingeAnchor(joint->id, anchor.coords[0], anchor.coords[1], anchor.coords[2]);
dJointSetHingeAxis(joint->id, axis1.coords[0], axis1.coords[1], axis1.coords[2]);
break;
case e_JointType_Hinge2:
joint->id = dJointCreateHinge2(odeWorldID, 0);
dJointAttach(joint->id, static_cast<OdePhysicsActor*>(actor1)->id, static_cast<OdePhysicsActor*>(actor2)->id);
dJointSetHinge2Anchor(joint->id, anchor.coords[0], anchor.coords[1], anchor.coords[2]);
dJointSetHinge2Axis1(joint->id, axis1.coords[0], axis1.coords[1], axis1.coords[2]);
dJointSetHinge2Axis2(joint->id, axis2.coords[0], axis2.coords[1], axis2.coords[2]);
break;
default:
Log(e_FatalError, "OdePhysics", "CreateJoint", "Joint type " + int_to_str(jointType) + " not yet supported ;)");
break;
}
joint->jointType = jointType;
mutex.unlock();
return joint;
}
void OdePhysics::DeleteJoint(IPhysicsJoint *joint) {
mutex.lock();
dJointDestroy(static_cast<OdePhysicsJoint*>(joint)->id);
mutex.unlock();
}
void OdePhysics::JointSetStops(IPhysicsJoint *joint, radian lowStop, radian highStop, int paramNum) {
mutex.lock();
// hack for ode 'flaw': http://opende.sourceforge.net/wiki/index.php/FAQ#My_wheels_are_sloppy.3B_they_don.27t_stay_straight_when_I_turn_them.
JointSetParameter(joint, dParamHiStop, highStop, paramNum);
JointSetParameter(joint, dParamLoStop, lowStop, paramNum);
JointSetParameter(joint, dParamHiStop, highStop, paramNum);
mutex.unlock();
}
void OdePhysics::JointSetVelocity(IPhysicsJoint *joint, float velocity, int paramNum) { // desired velocity
mutex.lock();
JointSetParameter(joint, dParamVel, velocity, paramNum);
mutex.unlock();
}
void OdePhysics::JointSetMaxForce(IPhysicsJoint *joint, float force, int paramNum) { // maximum force to reach the desired velocity
mutex.lock();
JointSetParameter(joint, dParamFMax, force, paramNum);
mutex.unlock();
}
void OdePhysics::JointSetConstraintForceMixing(IPhysicsJoint *joint, float value, int paramNum) {
mutex.lock();
JointSetParameter(joint, dParamCFM, value, paramNum);
mutex.unlock();
}
void OdePhysics::JointSetErrorCorrection(IPhysicsJoint *joint, float value, int paramNum) {
mutex.lock();
JointSetParameter(joint, dParamERP, value, paramNum);
mutex.unlock();
}
void OdePhysics::JointSetSuspensionConstraintForceMixing(IPhysicsJoint *joint, float value) { // only on hinge2 joints
mutex.lock();
JointSetParameter(joint, dParamSuspensionCFM, value);
mutex.unlock();
}
void OdePhysics::JointSetSuspensionErrorReduction(IPhysicsJoint *joint, float value) { // only on hinge2 joints
mutex.lock();
dJointID id = static_cast<OdePhysicsJoint*>(joint)->id;
JointSetParameter(joint, dParamSuspensionERP, value);
mutex.unlock();
}
float OdePhysics::JointGetAngleRate(IPhysicsJoint *joint, int paramNum) {
float value = 0;
mutex.lock();
dJointID id = static_cast<OdePhysicsJoint*>(joint)->id;
switch (static_cast<OdePhysicsJoint*>(joint)->jointType) {
case e_JointType_Hinge:
value = dJointGetHingeAngleRate(id);
break;
case e_JointType_Hinge2:
if (paramNum == 1) value = dJointGetHinge2Angle1Rate(id);
if (paramNum == 2) value = dJointGetHinge2Angle2Rate(id);
break;
default:
break;
}
mutex.unlock();
return value;
}
// utility
void OdePhysics::JointSetParameter(IPhysicsJoint *joint, int parameter, float value, int paramNum) {
OdePhysicsJoint *odeJoint = static_cast<OdePhysicsJoint*>(joint);
/*
e_JointType_Ball,
e_JointType_Hinge,
e_JointType_Slider,
e_JointType_Contact,
e_JointType_Universal,
e_JointType_Hinge2,
e_JointType_PR,
e_JointType_PU,
e_JointType_Piston,
e_JointType_Fixed,
e_JointType_AMotor,
e_JointType_LMotor,
e_JointType_Plane2D
*/
switch (odeJoint->jointType) {
case e_JointType_Hinge:
dJointSetHingeParam(odeJoint->id, parameter, value);
break;
case e_JointType_Hinge2:
dJointSetHinge2Param(odeJoint->id, parameter + dParamGroup * (paramNum - 1), value);
break;
default:
break;
}
}
dSpaceID OdePhysics::GetOdeSpaceID(int spaceID) {
if (spaceMap.find(spaceID) == spaceMap.end()) Log(e_FatalError, "OdePhysics", "GetOdeSpaceID", "spaceID non-existant");
return spaceMap.find(spaceID)->second;
}
dWorldID OdePhysics::GetOdeWorldID(int worldID) {
if (worldMap.find(worldID) == worldMap.end()) Log(e_FatalError, "OdePhysics", "GetOdeWorldID", "worldID non-existant");
return worldMap.find(worldID)->second;
}
}
| 33.401258 | 191 | 0.644423 | vi3itor |
9d5d93c98491094b849fbcc4b8800d8b831d9a1d | 376 | cpp | C++ | sandbox/t_read1.cpp | f-fathurrahman/ffr-pspw-dft-c | 5e673e33385eb467d99fcd992b350614c2709740 | [
"MIT"
] | 1 | 2018-05-17T09:01:12.000Z | 2018-05-17T09:01:12.000Z | sandbox/t_read1.cpp | f-fathurrahman/ffr-pspw-dft-c | 5e673e33385eb467d99fcd992b350614c2709740 | [
"MIT"
] | null | null | null | sandbox/t_read1.cpp | f-fathurrahman/ffr-pspw-dft-c | 5e673e33385eb467d99fcd992b350614c2709740 | [
"MIT"
] | null | null | null | // reading a text file
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main()
{
string line;
ifstream myfile ("example.txt");
if (myfile.is_open()) {
while(myfile.good()) {
getline(myfile,line);
cout << line << endl;
}
myfile.close();
}
else{
cout << "Unable to open file" << endl;
}
return 0;
}
| 14.461538 | 42 | 0.587766 | f-fathurrahman |
9d68bfca2418dc0189c9a50c64a2ff088c05fc32 | 2,722 | cpp | C++ | RogueEngine/Source/CameraShake.cpp | silferysky/RogueArcher | 3c77696260f773a0b7adb88b991e09bb35069901 | [
"FSFAP"
] | 1 | 2019-06-18T20:07:47.000Z | 2019-06-18T20:07:47.000Z | RogueEngine/Source/CameraShake.cpp | silferysky/RogueArcher | 3c77696260f773a0b7adb88b991e09bb35069901 | [
"FSFAP"
] | null | null | null | RogueEngine/Source/CameraShake.cpp | silferysky/RogueArcher | 3c77696260f773a0b7adb88b991e09bb35069901 | [
"FSFAP"
] | null | null | null | /* Start Header ************************************************************************/
/*!
\file CameraShake.cpp
\project Exale
\author Javier Foo, javier.foo, 440002318 (100%)
\par javier.foo\@digipen.edu
\date 1 December,2019
\brief This file contains the function definitions for CameraShake
All content (C) 2019 DigiPen (SINGAPORE) Corporation, all rights
reserved.
Reproduction or disclosure of this file or its contents
without the prior written consent of DigiPen Institute of
Technology is prohibited.
*/
/* End Header **************************************************************************/
#include "Precompiled.h"
#include "CameraShake.h"
#include "Main.h"
#include "ParticleEmitterSystem.h"
#define PI 3.141592
namespace Rogue
{
CameraShake::CameraShake() : m_shakeAngleMagnitude{ 180 }, m_shakeInterval{ 0.05f }, m_currentShakeMagnitude{ 0.0f }, m_currentShakeAngle{ rand() % 360 }, m_duration{ 0 }, m_shakeOffset{ 0, 0 }, m_shakeAngle { 0 }
{}
void CameraShake::Update()
{
m_duration += g_fixedDeltaTime; //* g_engine.GetTimeScale();
//Updates the angle and shake magnitude when time every ShakeInterval seconds
if (m_duration > m_shakeInterval && m_currentShakeMagnitude > 0)
{
m_duration = 0;
m_currentShakeMagnitude *= 0.9f; //diminish radius each frame
m_currentShakeAngle += (180 + (-(m_shakeAngleMagnitude / 2) + int(m_pn.noise(0.45, 0.8, 0.55)) /* rand() */ % m_shakeAngleMagnitude)); //pick new angle
//m_currentShakeAngle += (180 + (-(m_shakeAngleMagnitude / 2) + rand() % m_shakeAngleMagnitude)); //pick new angle
//m_shakeAngle = glm::radians((m_shakeAngleMagnitude) * m_currentShakeMagnitude * float(m_pn.noise(-1.0, 1.0, 0) * 0.05f));
m_shakeAngle = glm::radians((m_shakeAngleMagnitude / 10) * m_currentShakeMagnitude * RandFloat(-1.0f, 1.0f) * 0.005f);
m_shakeOffset.x = static_cast<float>(sin(m_currentShakeAngle) * m_currentShakeMagnitude);
m_shakeOffset.y = static_cast<float>(cos(m_currentShakeAngle) * m_currentShakeMagnitude);
//Don't micro shake the screen, also returns the screen back to centre after shaking is done
/*if (m_currentShakeMagnitude < 0.2f)
{
//m_shakeAngle = 0;
//m_currentShakeMagnitude = 0;
//m_shakeOffset = { 0,0 };
//g_engine.m_coordinator.GetSystem<CameraSystem>()->setIsActive(true);
} */
}
}
void CameraShake::SetShake(float magnitude)
{
m_currentShakeMagnitude = magnitude;
}
float CameraShake::GetShake() const
{
return m_currentShakeMagnitude;
}
float CameraShake::GetShakeAngle() const
{
return static_cast<float>(m_shakeAngle);
}
Vec2 CameraShake::getOffset() const
{
return m_shakeOffset;
}
} | 34.455696 | 214 | 0.671565 | silferysky |
9d6a3d694f41db9116118032cadb45ff6564c017 | 1,398 | cpp | C++ | test/unit_string_view_tests.cpp | dsyoi/iutest | b7b08c6ac4c75f98f87aa5756244afc93e4b624f | [
"BSD-3-Clause"
] | null | null | null | test/unit_string_view_tests.cpp | dsyoi/iutest | b7b08c6ac4c75f98f87aa5756244afc93e4b624f | [
"BSD-3-Clause"
] | null | null | null | test/unit_string_view_tests.cpp | dsyoi/iutest | b7b08c6ac4c75f98f87aa5756244afc93e4b624f | [
"BSD-3-Clause"
] | null | null | null | //======================================================================
//-----------------------------------------------------------------------
/**
* @file unit_string_view_tests.cpp
* @brief iutest test
*
* @author t.shirayanagi
* @par copyright
* Copyright (C) 2019, Takazumi Shirayanagi\n
* The new BSD License is applied to this software.
* see LICENSE
*/
//-----------------------------------------------------------------------
//======================================================================
//======================================================================
// include
#include "iutest.hpp"
IUTEST(UnitTest, StringView)
{
::std::string s = "abc";
::iutest::detail::iu_string_view sv1 = "abc";
::iutest::detail::iu_string_view sv2 = s;
::iutest::detail::iu_string_view sv3 = "ABC";
IUTEST_EXPECT_EQ(sv1, sv2);
IUTEST_EXPECT_EQ(sv1, "abc");
IUTEST_EXPECT_EQ(sv1, s);
IUTEST_EXPECT_EQ("abc", sv1);
IUTEST_EXPECT_EQ(s, sv1);
IUTEST_EXPECT_STREQ(sv1, "abc");
IUTEST_EXPECT_STREQ("abc", sv2);
IUTEST_EXPECT_STREQ(sv1, sv2);
IUTEST_EXPECT_STREQ(s, sv2);
IUTEST_EXPECT_STREQ(sv1, s);
IUTEST_EXPECT_NE(sv1, sv3);
IUTEST_EXPECT_NE(sv3, s);
IUTEST_EXPECT_NE(sv3, "Abc");
IUTEST_EXPECT_NE("Abc", sv3);
IUTEST_EXPECT_NE(s, sv3);
//IUTEST_EXPECT_STRNE("Abc", sv1);
}
| 30.391304 | 73 | 0.478541 | dsyoi |
9d6a4974b28e6401543419dca620fc370d090518 | 19,768 | cpp | C++ | Classes/data/Item.cpp | thales-vogso/deer | f3492538881f632b55be657bb9529027897b0e63 | [
"Apache-2.0"
] | null | null | null | Classes/data/Item.cpp | thales-vogso/deer | f3492538881f632b55be657bb9529027897b0e63 | [
"Apache-2.0"
] | null | null | null | Classes/data/Item.cpp | thales-vogso/deer | f3492538881f632b55be657bb9529027897b0e63 | [
"Apache-2.0"
] | null | null | null | /****************************************************************************
* @desc 道具数据
* @date 2015-1-7
* @author 110101
* @file data/Item.cpp
******************************************************************************/
#include "Item.h"
#include "utils/DeerUtils.h"
#include "data/Task.h"
USING_NS_CC;
namespace data {
const std::string Item::USER_ITEM_CHANGE = "userItemChange";
const std::string Item::PRODUCE = "produceEvent";
Item* Item::_instance = nullptr;
Item::Item() :Event()
{
this->init();
}
Item::~Item()
{
}
Item* Item::getInstance()
{
if (!_instance) {
_instance = new Item();
}
return _instance;
}
void Item::destroyInstance()
{
if (_instance)
{
CC_SAFE_DELETE(_instance);
}
}
void Item::init()
{
bool res = false;
_uid = User::getInstance()->getUID(); /* 获取用户uid */
_db = DBConnector::getInstance()->open();
//更新表--
_db->upgrade(TABLE_ITEM, Table::getInstance()->getTableByName(TABLE_ITEM), Table::getInstance()->getCSVByName(TABLE_ITEM));//道具及其数据..
_db->upgrade(TABLE_USER_ITEM, Table::getInstance()->getTableByName(TABLE_USER_ITEM));//用户道具..
_db->upgrade(TABLE_PRODUCE, Table::getInstance()->getTableByName(TABLE_PRODUCE), Table::getInstance()->getCSVByName(TABLE_PRODUCE));//生产及其数据..
_db->upgrade(TABLE_USER_PRODUCT, Table::getInstance()->getTableByName(TABLE_USER_PRODUCT));//用户生产..
_db->upgrade(TABLE_SHOP, Table::getInstance()->getTableByName(TABLE_SHOP), Table::getInstance()->getCSVByName(TABLE_SHOP));//商店及其数据..
_db->upgrade(TABLE_USER_SHOP, Table::getInstance()->getTableByName(TABLE_USER_SHOP));//用户商店..
//配置..
_db->upgrade(TABLE_GATHER, Table::getInstance()->getTableByName(TABLE_GATHER), Table::getInstance()->getCSVByName(TABLE_GATHER));//采集表..
_db->upgrade(TABLE_MINT, Table::getInstance()->getTableByName(TABLE_MINT), Table::getInstance()->getCSVByName(TABLE_MINT));//炼金表..
_db->upgrade(TABLE_PACKAGE, Table::getInstance()->getTableByName(TABLE_PACKAGE), Table::getInstance()->getCSVByName(TABLE_PACKAGE));//背包表..
_db->upgrade(TABLE_CARRIAGE, Table::getInstance()->getTableByName(TABLE_CARRIAGE), Table::getInstance()->getCSVByName(TABLE_CARRIAGE));//马车表..
_db->upgrade(TABLE_FACTORY, Table::getInstance()->getTableByName(TABLE_FACTORY), Table::getInstance()->getCSVByName(TABLE_FACTORY));//自动工厂表..
_db->upgrade(TABLE_DRUG, Table::getInstance()->getTableByName(TABLE_DRUG), Table::getInstance()->getCSVByName(TABLE_DRUG));//药剂表..
/**
* 添加商店中的起始可见商品,这里希望有一个初始化表，这样就可以从后台导入，起始商品
*/
if (data::User::getInstance()->getFirstPlay()) /* 判断是否是第一次启动 */
{
stringstream sql;
sql << "SELECT * FROM `" << TABLE_SHOP << "` WHERE `fid` != " << MANOR_SHOP_ID;
auto all = _db->getAll(sql.str());
for (auto &i : all.asValueVector())
{
shopItemShow(i.asValueMap()["fid"].asInt(), i.asValueMap()["iid"].asInt());
}
}
}
Value Item::getItemByIID(int iid)
{
Value val = getMem(iid);
if (!val.isNull()) return val;
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_ITEM << "` WHERE iid = '" << iid << "' LIMIT 1";
val = _db->getRow(sql.str());
Value produce = getProduceByIID(iid);
if (produce.asValueVector().size() > 0) val.asValueMap()["produce"] = produce;
setMem(iid, val);
return val;
}
Value Item::getUserItems()
{
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_ITEM << "` `i` WHERE `u`.`iid` = `i`.`iid` AND `u`.`uid` = '" << _uid << "' AND `u`.`amount` > 0 " << comment;
ValueVector vec(_db->getAll(sql.str()).asValueVector());
return Value(vec);
}
Value Item::getResouces(){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_ITEM << "` `i` WHERE `u`.`iid` = `i`.`iid` AND `i`.`space` >= 0 AND `u`.`uid` = '" << _uid << "' AND `u`.`amount` > 0 ORDER BY `iid` ASC " << comment;
Value all = _db->getAll(sql.str());
return all;
}
void Item::userItemPlus(int iid, int amount){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
int num = getUserItemAmountByIID(iid);
if (num == 0)
{
sql << "REPLACE INTO `" << TABLE_USER_ITEM << "` (`uid`,`iid`,`amount`) VALUES ('" << _uid << "', '" << iid << "', '" << amount << "')" << comment;
}
else
{
sql << "UPDATE `" << TABLE_USER_ITEM << "` SET `amount` = `amount` + '" << amount << "' WHERE `iid`='" << iid << "' AND `uid`='" << _uid << "'" << comment;
}
int res = _db->query(sql.str());
Task::getInstance()->itemCheck(iid);
Value item = getItemByIID(iid);
item.asValueMap()["total"] = getUserItemAmountByIID(iid);
item.asValueMap()["amount"] = amount;
if(res)
{
dispatch(Item::USER_ITEM_CHANGE, &item);
}
}
bool Item::userItemReduce(int iid, int amount){
std::stringstream sql;
amount = abs(amount);
int num = getUserItemAmountByIID(iid);
if (amount > num) return false;
sql << "UPDATE `" << TABLE_USER_ITEM << "` SET `amount` = `amount` - '" << amount << "' WHERE `iid`='" << iid << "' AND `uid`='" << _uid << "'";
int res = _db->query(sql.str());
Value item = getItemByIID(iid);
item.asValueMap()["amount"] = -amount;
item.asValueMap()["total"] = getUserItemAmountByIID(iid);
if(res)
{
dispatch(Item::USER_ITEM_CHANGE, &item);
}
return true;
}
Value Item::getUserItemByIID(int iid){
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_USER_ITEM << "` WHERE uid = '" << _uid << "' AND iid = '" << iid << "' LIMIT 1";
return _db->getRow(sql.str());
}
int Item::getUserItemAmountByIID(int iid){
std::stringstream sql;
sql << "SELECT `amount` FROM `" << TABLE_USER_ITEM << "` WHERE uid = '" << _uid << "' AND iid = '" << iid << "' LIMIT 1";
return _db->getOne(sql.str()).asInt();
}
Value Item::getUserProducts()
{
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_USER_PRODUCT << "` WHERE uid = '" << _uid << "' ";
Value all = _db->getAll(sql.str());
for (Value &row : all.asValueVector())
{
Value item = getItemByIID(row.asValueMap()["iid"].asInt());
if (row.asValueMap()["mdate"].asString() == TIME_NULL) row.asValueMap()["new"] = true;
for (Value& i : item.asValueMap()["produce"].asValueVector()){
auto material = getItemByIID(i.asValueMap()["material_iid"].asInt());
for (auto &j : material.asValueMap())
{
i.asValueMap()[j.first] = j.second;
}
i.asValueMap()["shortage"] = i.asValueMap()["amount"].asInt() > Item::getInstance()->getUserItemAmountByIID(i.asValueMap()["iid"].asInt());
}
for (auto &i : item.asValueMap())
{
row.asValueMap()[i.first] = i.second;
}
}
return Value(all);
}
void Item::addUserProduct(int iid){
Task::getInstance()->setBtnShowNew(Task::BtnID::kProduceBtn);
std::stringstream sql;
sql << "REPLACE INTO `" << TABLE_USER_PRODUCT << "` (uid, iid, cdate) VALUES ('" << _uid << "', '" << iid << "', '" << data::User::getInstance()->getTimeDate() << "')";
_db->query(sql.str());
}
void Item::delUserProduct(int iid){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "DELETE FROM `" << TABLE_USER_PRODUCT << "` WHERE `uid` = '" << _uid << "' AND `iid` = '" << iid << "' " << comment;
_db->query(sql.str());
}
void Item::userProductInitial(int iid){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "UPDATE " << TABLE_USER_PRODUCT << " SET mdate = '0000-00-00 00:00:00' WHERE iid = " << iid << comment;
_db->query(sql.str());
}
void Item::userProductVisited(int iid){
Value item = getItemByIID(iid);
if (item.asValueMap()["userProductMtime"].asString().size() > 0 && item.asValueMap()["userProductMtime"].asString() != "0000-00-00 00:00:00") return;
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
custom::LibDate d(0);
sql << "UPDATE " << TABLE_USER_PRODUCT << " SET mdate = '" << d.datetime() << "' WHERE iid = " << iid << comment;
_db->query(sql.str());
item.asValueMap()["userProductMtime"] = d.datetime();
}
cocos2d::Value Item::getProduceByIID(int iid){
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_PRODUCE << "` WHERE `produce_iid` = '" << iid << "' ";
Value all = _db->getAll(sql.str());
for (Value &row : all.asValueVector()){
Value item = getItemByIID(row.asValueMap()["material_iid"].asInt());
auto temp = item.asValueMap();
}
return all;
}
Value Item::produce(int iid, int num)
{
userProductVisited(iid);
Value item = getItemByIID(iid);
int code = 0;
ValueMap data;
for (Value material : item.asValueMap()["produce"].asValueVector())
{
int total = getUserItemAmountByIID(material.asValueMap()["material_iid"].asInt());
int current = material.asValueMap()["amount"].asInt();
bool flag = true;
if (total >= current){
int n = total / current;
if (n < num) num = n;
flag = false;
}
if (flag)
{
code = 1;
auto temp = getItemByIID(material.asValueMap()["material_iid"].asInt());
for (auto &i : temp.asValueMap())
{
material.asValueMap()[i.first] = i.second;
}
data[material.asValueMap()["material_iid"].asString()] = material;
}
}
if (code == 0)
{
userItemPlus(iid, num);
for (Value material : item.asValueMap()["produce"].asValueVector())
{
userItemReduce(material.asValueMap()["material_iid"].asInt(), material.asValueMap()["amount"].asInt() * num);
}
produceCheck(iid);
}
ValueMap ret;
ret["code"] = code;
ret["data"] = data;
ret["num"] = num;
ValueMap eventData = ret;
eventData["name"] = item.asValueMap()["name"];
dispatch(data::Item::PRODUCE, &eventData);
return Value(ret);
}
Value Item::produce(int iid){
return produce(iid, 1);
}
bool Item::isProduceDisposable(int iid){
Value item = getItemByIID(iid);
bool res = item.asValueMap()["space"].asInt() == -1;
if(res)
{
delUserProduct(iid);
}
return res;
}
void Item::produceCheck(int iid){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT COUNT(*) AS `num` FROM `" << TABLE_GATHER << "` WHERE `tool_iid` = '" << iid << "' LIMIT 1 " << comment;
bool exist = _db->getOne(sql.str()).asBool();
if (exist){
delUserProduct(iid);
sql.str(""); sql.clear();
int iid2 = iid + 1;
sql << "SELECT COUNT(*) AS `num` FROM `" << TABLE_GATHER << "` WHERE `tool_iid` = '" << iid2 << "' LIMIT 1 " << comment;
exist = _db->getOne(sql.str()).asBool();
if (exist){
addUserProduct(iid2);
}
return;
}
std::vector<std::string> vec;
vec.push_back(TABLE_MINT);
vec.push_back(TABLE_CARRIAGE);
vec.push_back(TABLE_PACKAGE);
for (std::string table : vec)
{
sql.str(""); sql.clear();
sql << "SELECT COUNT(*) AS `num` FROM `" << table << "` WHERE `iid` = '" << iid << "' LIMIT 1 " << comment;
bool exist = _db->getOne(sql.str()).asBool();
if (exist){
delUserProduct(iid);
sql.str(""); sql.clear();
int iid2 = iid + 1;
sql << "SELECT COUNT(*) AS `num` FROM `" << table << "` WHERE `iid` = '" << iid2 << "' LIMIT 1 " << comment;
exist = _db->getOne(sql.str()).asBool();
if (exist){
addUserProduct(iid2);
}
return;
}
}
}
bool Item::mint(){
int amount = getMint();
userItemPlus(ItemID::COIN, amount);
Achievement::getInstance()->count(Achievement::MINT);
return true;
}
Value Item::getUserGather(){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT `g`.`tool_iid` AS `tool_iid`, `g`.`gather_iid` AS `iid`, `g`.`amount` AS `amount` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_GATHER << "` `g` WHERE `u`.`iid` = `g`.`tool_iid` ORDER BY `g`.`tool_iid` DESC " << comment;
Value all = _db->getAll(sql.str());
if (all.asValueVector().size() == 0){
sql.clear();
sql.str("");
sql << "SELECT `tool_iid`, `gather_iid` AS `iid`, `amount` FROM `" << TABLE_GATHER << "` WHERE `tool_iid` = 0 " << comment;
all = _db->getAll(sql.str());
}
int toolIID = -1;
ValueVector vec = ValueVectorNull;
for (Value row : all.asValueVector())
{
if (toolIID != -1 && row.asValueMap()["tool_iid"].asInt() != toolIID){
break;
}
toolIID = row.asValueMap()["tool_iid"].asInt();
Value item = getItemByIID(row.asValueMap()["iid"].asInt());
item.asValueMap()["amount"] = row.asValueMap()["amount"].asInt();
vec.push_back(item);
}
return Value(vec);
}
int Item::getValidOutGainTime(){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT `f`.`time` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_FACTORY << "` `f` WHERE `u`.`iid` = `f`.`iid` ORDER BY `f`.`iid` DESC LIMIT 1";
int time = _db->getOne(sql.str()).asInt();
if (time == 0){
sql.clear();
sql.str("");
sql << "SELECT `time` FROM `" << TABLE_FACTORY << "` WHERE `iid` = 0 LIMIT 1";
time = _db->getOne(sql.str()).asInt();
}
return time;
}
int Item::getAlchemy(){
std::stringstream sql;
sql << "SELECT `p`.`amount` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_MINT << "` `p` WHERE `u`.`iid` = `p`.`iid` ORDER BY `p`.`iid` DESC LIMIT 1";
int amount = _db->getOne(sql.str()).asInt();
if (amount == 0){
sql.clear();
sql.str("");
sql << "SELECT `amount` FROM `" << TABLE_MINT << "` WHERE `iid` = 0 LIMIT 1";
amount = _db->getOne(sql.str()).asInt();
}
return amount;
}
int Item::getMint(){
return getAlchemy();
}
int Item::getPackage(){
std::stringstream sql;
sql << "SELECT `p`.`amount` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_PACKAGE << "` `p` WHERE `u`.`iid` = `p`.`iid` ORDER BY p.`iid` DESC LIMIT 1";
int amount = _db->getOne(sql.str()).asInt();
if (amount == 0){
sql.clear();
sql.str("");
sql << "SELECT `amount` FROM `" << TABLE_PACKAGE << "` WHERE `iid` = 0 LIMIT 1";
amount = _db->getOne(sql.str()).asInt();
}
return amount;
}
int Item::getCarriage(){
std::stringstream sql;
sql << "SELECT `c`.`amount` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_CARRIAGE << "` `c` WHERE `u`.`iid` = `c`.`iid` ORDER BY c.`iid` DESC LIMIT 1";
int amount = _db->getOne(sql.str()).asInt();
if (amount == 0){
sql.clear();
sql.str("");
sql << "SELECT `amount` FROM `" << TABLE_CARRIAGE << "` WHERE `iid` = 0 LIMIT 1";
amount = _db->getOne(sql.str()).asInt();
}
return amount;
}
int Item::getDrug(){
std::stringstream sql;
sql << "SELECT `d`.`amount` FROM `" << TABLE_USER_ITEM << "` `u`, `" << TABLE_DRUG << "` `d` WHERE `u`.`iid` = `d`.`iid` ORDER BY `d`.`iid` DESC LIMIT 1";
int amount = _db->getOne(sql.str()).asInt();
if (amount == 0){
sql.clear();
sql.str("");
sql << "SELECT `amount` FROM `" << TABLE_DRUG << "` WHERE `iid` = 0 LIMIT 1";
amount = _db->getOne(sql.str()).asInt();
}
return amount;
}
int Item::getGold(){
return getUserItemAmountByIID(ItemID::COIN);
}
int Item::getPoint(){
return getUserItemAmountByIID(ItemID::POINT);
}
Value Item::getShopByFID(int sid){
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_SHOP << "` `s`,`" << TABLE_USER_SHOP << "` `u` WHERE `s`.`fid` = '" << sid << "' AND `s`.`iid`=`u`.`iid` "<< " AND `u`.`fid`='"<<sid<<"'"<< comment;
Value all = _db->getAll(sql.str());
for (Value &row : all.asValueVector())
{
Value price = row.asValueMap()["price"];
Value item = getItemByIID(row.asValueMap()["iid"].asInt());
item.asValueMap()["price"] = price;
item.asValueMap()["rmb"] = row.asValueMap()["rmb"];
//判断价格是否足够..
item.asValueMap()["shortage"] = price.asInt() > getUserItemAmountByIID(ItemID::COIN);
//判断用户是否拥有..
if (row.asValueMap()["mdate"].asString() == TIME_NULL)
{
item.asValueMap()["new"] = true;
}
else
{
item.asValueMap()["new"] = false;
}
row = item;
}
return all;
}
Value Item::buy(int fid, int iid, int amount)
{
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_SHOP << "` WHERE `fid` = '" << fid << "' AND `iid` = '" << iid << "' ";
Value row = _db->getRow(sql.str());
if (row.isNull()) return Value();
/**
* 这一段添加mdate的记录
*/
sql.str("");
sql << "UPDATE " << TABLE_USER_SHOP << " SET `mdate` = '" << data::User::getInstance()->getTimeDate() << "' WHERE `iid` = " << iid << comment;
_db->query(sql.str());
int gold = getGold();
int unitPrice = row.asValueMap()["price"].asInt();
int num = gold / unitPrice;
if (num == 0) return Value();
if (num < amount){
amount = num;
}
bool res = userItemReduce(ItemID::COIN, amount * unitPrice);
if (!res) return Value();
if (row.asValueMap()["disposable"].asInt() == 1){
shopItemHide(fid, iid);
}
userItemPlus(iid, amount);
return Value(amount);
}
Value Item::cash(int fid, int iid, int amount)
{
char comment[200];
sprintf(comment, "/* %s, %d */", __FILE__, __LINE__);
std::stringstream sql;
sql << "SELECT * FROM `" << TABLE_SHOP << "` WHERE `fid` = '" << fid << "' AND `iid` = '" << iid << "' ";
Value row = _db->getRow(sql.str());
if (row.asValueMap()["fid"].isNull()) return Value();
/**
* 这一段添加mdate的记录
*/
sql.str("");
sql << "UPDATE " << TABLE_USER_SHOP << " SET `mdate` = '" << data::User::getInstance()->getTimeDate() << "' WHERE `iid` = " << iid << comment;
_db->query(sql.str());
//支付----
float unitPrice = row.asValueMap()["rmb"].asFloat();
userItemPlus(iid, amount);
if (row.asValueMap()["disposable"].asInt() == 1){
shopItemHide(fid, iid);
}
return Value(amount);
}
int Item::sell(int iid, int amount){
Value row = getUserItemByIID(iid);
if (row.asValueMap()["amount"].asInt() < amount) amount = row.asValueMap()["amount"].asInt();
bool res = userItemReduce(iid, amount);
if(res)
{
Value item = getItemByIID(iid);
userItemPlus(ItemID::COIN, amount * item.asValueMap()["price"].asInt());
}
return amount;
}
void Item::shopItemShow(int fid, int iid){
std::stringstream sql;
custom::LibDate d;
sql << "REPLACE INTO `" << TABLE_USER_SHOP << "` (`uid`, `fid`, `iid`, `cdate`) VALUES ('" << _uid << "', '" << fid << "', '" << iid << "', '" << d.datetime() << "')";
_db->query(sql.str());
}
void Item::shopItemShow(int iid){
Task::getInstance()->setBtnShowNew(Task::BtnID::kStoreBtn);
shopItemShow(MANOR_SHOP_ID, iid);
}
void Item::shopItemHide(int fid, int iid){
std::stringstream sql;
sql << "DELETE FROM `" << TABLE_USER_SHOP << "` WHERE `fid`='" << fid << "' AND `iid`='" << iid << "' AND `uid`='" << _uid << "'";
_db->query(sql.str());
}
} | 36.539741 | 241 | 0.571783 | thales-vogso |
9d6e706d4c87a758c034b76376569cc19e48f238 | 4,620 | cc | C++ | utilities/ioprof/ioprof.cc | shampoo365/terarkdb | a05a42789b310e1a79f6b5bb2f98f78993f9fbb2 | [
"Apache-2.0",
"BSD-3-Clause"
] | 1,658 | 2020-12-21T04:53:44.000Z | 2022-03-30T16:16:07.000Z | utilities/ioprof/ioprof.cc | shampoo365/terarkdb | a05a42789b310e1a79f6b5bb2f98f78993f9fbb2 | [
"Apache-2.0",
"BSD-3-Clause"
] | 105 | 2020-12-21T09:09:55.000Z | 2022-03-28T09:57:36.000Z | utilities/ioprof/ioprof.cc | shampoo365/terarkdb | a05a42789b310e1a79f6b5bb2f98f78993f9fbb2 | [
"Apache-2.0",
"BSD-3-Clause"
] | 151 | 2020-12-21T09:25:34.000Z | 2022-03-13T08:58:37.000Z | #include "ioprof.h"
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <assert.h>
// Author: Haiping Zhao (ByteDance)
// Date: July 30, 2020
using namespace std;
using namespace IOProfiler;
///////////////////////////////////////////////////////////////////////////////////////////////////
Data Data::operator-(const Data &another) const {
Data data = *this;
data.rchar -= another.rchar;
data.wchar -= another.wchar;
data.syscr -= another.syscr;
data.syscw -= another.syscw;
data.read_bytes -= another.read_bytes;
data.write_bytes -= another.write_bytes;
data.cancelled_write_bytes -= another.cancelled_write_bytes;
data.walltime -= another.walltime;
data.error = (data.error || another.error);
return data;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
string read_file(const char *filename) {
string content;
FILE *f = fopen(filename, "r");
if (f) {
char buf[1024];
size_t len = fread(buf, 1, sizeof(buf), f);
while (len > 0) {
content += string(buf, len);
len = fread(buf, 1, sizeof(buf), f);
}
fclose(f);
}
return content;
}
bool decode_file(const string &content, Data &data) {
struct {
const char *name;
int64 *field;
} mappings[] = {
{ "rchar", &data.rchar },
{ "wchar", &data.wchar },
{ "syscr", &data.syscr },
{ "syscw", &data.syscw },
{ "read_bytes", &data.read_bytes },
{ "write_bytes", &data.write_bytes },
{ "cancelled_write_bytes", &data.cancelled_write_bytes },
};
size_t pos = 0;
for (auto &mapping : mappings) {
pos = content.find(mapping.name, pos);
if (pos == string::npos) return false;
pos = content.find(": ", pos);
if (pos == string::npos) return false;
auto end = content.find('\n', pos);
if (end == string::npos || end - pos <= 2) return false;
*mapping.field = atoi(content.substr(pos + 2, end - pos - 2).c_str());
}
return true;
}
Data LocalDiskCollector::Collect() {
Data data{0};
// getting disk io stats
int64 pid = (int64)getpid();
char filename[256];
snprintf(filename, sizeof(filename), "/proc/%lld/io", pid);
string content = read_file(filename);
// getting wall time
struct timespec tp;
int res = clock_gettime(CLOCK_MONOTONIC, &tp);
data.walltime = tp.tv_sec * 1000 * 1000 * 1000 + tp.tv_nsec;
data.error = (res || content.empty() || !decode_file(content, data));
return data;
}
void ConsoleReporter::Report(const std::string &fullname, const Data &data) {
char buf[1024];
if (!data.error) {
snprintf(buf, sizeof(buf),
"%s\n"
"\trchar = %lld\n"
"\twchar = %lld\n"
"\tsyscr = %lld\n"
"\tsyscw = %lld\n"
"\tread_bytes = %lld\n"
"\twrite_bytes = %lld\n"
"\tcancelled_write_bytes = %lld\n"
"\twalltime = %lldns\n",
fullname.c_str(),
data.rchar, data.wchar, data.syscr, data.syscw, data.read_bytes, data.write_bytes,
data.cancelled_write_bytes, data.walltime);
printf("\e[0;32m%s\e[m\n", buf);
} else {
snprintf(buf, sizeof(buf), "%s\n", fullname.c_str());
printf("\e[0;31m%s\e[m\n", buf);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
Profiler &Profiler::TheOne() {
static Profiler thread_local s_profiler;
return s_profiler;
}
Profiler::Profiler() :
m_collector(make_shared<LocalDiskCollector>()),
m_reporter(make_shared<ConsoleReporter>()) {
}
Profiler::~Profiler() {
}
void Profiler::Initialize(const std::string &name,
const std::shared_ptr<Collector> &collector,
const std::shared_ptr<Reporter> &reporter) {
assert(collector);
m_name = name;
m_collector = collector;
m_reporter = reporter;
}
void Profiler::PushScope(const std::string &name) {
m_stack.push_back(name);
}
void Profiler::PopScope() {
m_stack.pop_back();
}
std::string Profiler::GetScope() const {
return m_stack.empty() ? m_name : m_stack.back();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
Scope::Scope(const std::string &name) :
m_name(name) {
auto &profiler = Profiler::TheOne();
profiler.PushScope(name);
m_start = profiler.GetCollector()->Collect();
}
void Scope::End() {
auto &profiler = Profiler::TheOne();
auto final = profiler.GetCollector()->Collect();
auto delta = final - m_start;
profiler.PopScope();
auto fullname = m_name;
auto scope = profiler.GetScope();
if (!scope.empty()) {
fullname += " <= " + scope;
}
profiler.GetReporter()->Report(fullname, delta);
}
| 26.551724 | 99 | 0.583333 | shampoo365 |
9d796f5468845dc023d999f368b0e9749df9d5c6 | 5,236 | cpp | C++ | src/Library/PhotonMapping/ShadowPhotonMap.cpp | aravindkrishnaswamy/rise | 297d0339a7f7acd1418e322a30a21f44c7dbbb1d | [
"BSD-2-Clause"
] | 1 | 2018-12-20T19:31:02.000Z | 2018-12-20T19:31:02.000Z | src/Library/PhotonMapping/ShadowPhotonMap.cpp | aravindkrishnaswamy/rise | 297d0339a7f7acd1418e322a30a21f44c7dbbb1d | [
"BSD-2-Clause"
] | null | null | null | src/Library/PhotonMapping/ShadowPhotonMap.cpp | aravindkrishnaswamy/rise | 297d0339a7f7acd1418e322a30a21f44c7dbbb1d | [
"BSD-2-Clause"
] | null | null | null | //////////////////////////////////////////////////////////////////////
//
// ShadowPhotonMap.cpp - Implements the shadow photon map
//
// Author: Aravind Krishnaswamy
// Date of Birth: May 14, 2004
// Tabs: 4
// Comments:
//
// License Information: Please see the attached LICENSE.TXT file
//
//////////////////////////////////////////////////////////////////////
#include "pch.h"
#include "ShadowPhotonMap.h"
#include <algorithm>
#include "../Interfaces/ILog.h"
using namespace RISE;
using namespace RISE::Implementation;
ShadowPhotonMap::ShadowPhotonMap(
const unsigned int max_photons,
const IPhotonTracer* tracer
) :
PhotonMapCore<ShadowPhoton>( max_photons, tracer )
{
}
ShadowPhotonMap::~ShadowPhotonMap()
{
}
bool ShadowPhotonMap::Store(
const Point3& pos,
const bool shadow
)
{
if( vphotons.size() >= nMaxPhotons ) {
return false;
}
ShadowPhoton p;
p.ptPosition = pos;
p.shadow = shadow;
bbox.Include( p.ptPosition );
vphotons.push_back( p );
maxPower = nMaxPhotons*nMaxPhotons;
return true;
}
// Computes the irradiance estimate at a given surface position
void ShadowPhotonMap::RadianceEstimate(
RISEPel& rad, // returned radiance
const RayIntersectionGeometric& ri, // ray-surface intersection information
const IBSDF& brdf // BRDF of the surface to estimate irradiance from
) const
{
rad = RISEPel( 0, 0, 0 );
}
void ShadowPhotonMap::LocateShadowPhotons(
const Point3& loc, // the location from which to search for photons
const Scalar maxDist, // the maximum radius to look for photons
const int from, // index to search from
const int to, // index to search to
bool& lit_found, // has a fully lit photon been found ?
bool& shadow_found // has a fully shadowed photon been found ?
) const
{
// sanity check
if( to-from < 0 ) {
return;
}
// Compute a new median
int median = 1;
while( (4*median) <= (to-from+1) ) {
median += median;
}
if( (3*median) <= (to-from+1) ) {
median += median;
median += from - 1;
} else {
median = to-median + 1;
}
// Compute the distance to the photon
Vector3 v = Vector3Ops::mkVector3( loc, vphotons[ median ].ptPosition );
Scalar distanceToPhoton = Vector3Ops::SquaredModulus(v);
if( distanceToPhoton < maxDist )
{
// Check this shadow photon
if( vphotons[median].shadow ) {
shadow_found = true;
} else {
lit_found = true;
}
}
if( shadow_found && lit_found ) {
return;
}
int axis = vphotons[median].plane;
Scalar distance2 = loc[axis] - vphotons[median].ptPosition[axis];
Scalar sqrD2 = distance2*distance2;
if( sqrD2 > maxDist ) {
if( distance2 <= 0 ) {
LocateShadowPhotons( loc, maxDist, from, median-1, lit_found, shadow_found );
} else {
LocateShadowPhotons( loc, maxDist, median+1, to, lit_found, shadow_found );
}
}
// Search both sides of the tree
if( sqrD2 < maxDist ) {
LocateShadowPhotons( loc, maxDist, from, median-1, lit_found, shadow_found );
LocateShadowPhotons( loc, maxDist, median+1, to, lit_found, shadow_found );
}
}
//! Estimates the shadowing amount
void ShadowPhotonMap::ShadowEstimate(
char& shadow, ///< [in] 0 = totally lit, 1 = totally shadowed, 2 = pieces of both
const Point3& pos ///< [in] Surface position
) const
{
// locate the nearest photons
bool shadow_found = false;
bool lit_found = false;
LocateShadowPhotons( pos, dGatherRadius, 0, vphotons.size()-1, lit_found, shadow_found );
shadow = 1;
if( shadow_found && !lit_found ) {
shadow = 1;
} else if( !shadow_found && lit_found ) {
shadow = 0;
} else if( shadow_found && lit_found ) {
shadow = 2;
}
}
void ShadowPhotonMap::Serialize(
IWriteBuffer& buffer ///< [in] Buffer to serialize to
) const
{
buffer.ResizeForMore( sizeof( unsigned int ) * 4 + sizeof( Scalar ) * 3 );
buffer.setUInt( nMaxPhotons );
buffer.setUInt( nPrevScale );
buffer.setDouble( dGatherRadius );
buffer.setDouble( dEllipseRatio );
buffer.setUInt( nMinPhotonsOnGather );
buffer.setUInt( nMaxPhotonsOnGather );
buffer.setDouble( maxPower );
// Serialize the bounding box
bbox.Serialize( buffer );
// Serialize number of stored photons
buffer.ResizeForMore( sizeof( unsigned int ) + sizeof( ShadowPhoton ) * vphotons.size() );
buffer.setUInt( vphotons.size() );
for( unsigned int i=0; i<vphotons.size(); i++ ) {
const ShadowPhoton& p = vphotons[i];
Point3Ops::Serialize( p.ptPosition, buffer );
buffer.setUChar( p.plane );
buffer.setChar( p.shadow );
}
}
void ShadowPhotonMap::Deserialize(
IReadBuffer& buffer ///< [in] Buffer to deserialize from
)
{
nMaxPhotons = buffer.getUInt();
nPrevScale = buffer.getUInt();
dGatherRadius = buffer.getDouble();
dEllipseRatio = buffer.getDouble();
nMinPhotonsOnGather = buffer.getUInt();
nMaxPhotonsOnGather = buffer.getUInt();
maxPower = buffer.getDouble();
bbox.Deserialize( buffer );
const unsigned int numphot = buffer.getUInt();
vphotons.reserve( numphot );
for( unsigned int i=0; i<numphot; i++ ) {
ShadowPhoton p;
Point3Ops::Deserialize( p.ptPosition, buffer );
p.plane = buffer.getUChar();
p.shadow = !!buffer.getChar();
vphotons.push_back( p );
}
}
| 24.815166 | 91 | 0.660237 | aravindkrishnaswamy |
9d7d1c3a289a993fcef79336b32d8e5b933ee73b | 1,394 | cpp | C++ | amazon_interview_practice/Arrange_given_numbers_to_form_the_biggest_number/problem/problem/solve.cpp | ldy121/algorithm | 7939cb4c15e2bc655219c934f00c2bb74ddb4eec | [
"Apache-2.0"
] | 1 | 2020-04-11T22:04:23.000Z | 2020-04-11T22:04:23.000Z | amazon_interview_practice/Arrange_given_numbers_to_form_the_biggest_number/problem/problem/solve.cpp | ldy121/algorithm | 7939cb4c15e2bc655219c934f00c2bb74ddb4eec | [
"Apache-2.0"
] | null | null | null | amazon_interview_practice/Arrange_given_numbers_to_form_the_biggest_number/problem/problem/solve.cpp | ldy121/algorithm | 7939cb4c15e2bc655219c934f00c2bb74ddb4eec | [
"Apache-2.0"
] | null | null | null | // Driver program to test above functions
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int strcmp(string &a, string &b)
{
int i;
for (i = 0; (i < a.size()) && (i < b.size()); ++i) {
if (a[i] < b[i]) {
return -1;
} else if (a[i] > b[i]) {
return 1;
}
}
if (i == a.size()) {
if (a[0] > b[i]) return 1;
else return -1;
} else {
if (a[i] > b[0]) return 1;
else return -1;
}
}
void qsort(vector<string>& str, vector<int>& vec, int left, int right)
{
if (left < right) {
int i, j, k;
for (i = left + 1, j = left; i <= right; ++i) {
if (strcmp(str[vec[left]], str[vec[i]]) < 0) {
++j;
k = vec[j];
vec[j] = vec[i];
vec[i] = k;
}
}
k = vec[j];
vec[j] = vec[left];
vec[left] = k;
qsort(str, vec, left, j - 1);
qsort(str, vec, j + 1, right);
}
}
void printLargest(vector<string>& arr)
{
vector<int> vec(arr.size());
for (int i = 0; i < vec.size(); ++i) {
vec[i] = i;
}
qsort(arr, vec, 0, vec.size() - 1);
for (int i = 0; i < vec.size(); ++i) {
cout << arr[vec[i]];
}
cout << endl;
}
int main()
{
vector<string> arr;
//output should be 6054854654
arr.push_back("54");
arr.push_back("546");
arr.push_back("548");
arr.push_back("60");
printLargest(arr);
return 0;
} | 17.425 | 71 | 0.494261 | ldy121 |
9d80ef607aa1cfa4d98b62bd57421f7494783ecb | 2,327 | cpp | C++ | src/datasync/rothreadedbackend/threadedclient.cpp | wangyangyangisme/QtDataSync | 0cc47ca4e8aeee2683aae52662c40f1a7c7b1d93 | [
"BSD-3-Clause"
] | 1 | 2022-02-22T07:18:33.000Z | 2022-02-22T07:18:33.000Z | src/datasync/rothreadedbackend/threadedclient.cpp | wyyrepo/QtDataSync | 0cc47ca4e8aeee2683aae52662c40f1a7c7b1d93 | [
"BSD-3-Clause"
] | null | null | null | src/datasync/rothreadedbackend/threadedclient.cpp | wyyrepo/QtDataSync | 0cc47ca4e8aeee2683aae52662c40f1a7c7b1d93 | [
"BSD-3-Clause"
] | 1 | 2018-12-20T04:31:16.000Z | 2018-12-20T04:31:16.000Z | #include "threadedclient_p.h"
#include "threadedserver_p.h"
#include <chrono>
using namespace std::chrono;
#if QT_HAS_INCLUDE(<chrono>)
#define scdtime(x) x
#else
#define scdtime(x) duration_cast<milliseconds>(x).count()
#endif
using namespace QtDataSync;
ThreadedClientIoDevice::ThreadedClientIoDevice(QObject *parent) :
ClientIoDevice(parent),
_buffer(new ExchangeBuffer(this)),
_connectTimer(new QTimer(this))
{
connect(_buffer, &ExchangeBuffer::partnerConnected,
this, &ThreadedClientIoDevice::deviceConnected);
connect(_buffer, &ExchangeBuffer::readyRead,
this, &ThreadedClientIoDevice::readyRead);
connect(_buffer, &ExchangeBuffer::partnerDisconnected,
this, &ThreadedClientIoDevice::deviceClosed);
_connectTimer->setSingleShot(true);
_connectTimer->setTimerType(Qt::VeryCoarseTimer);
_connectTimer->setInterval(scdtime(seconds(30)));
connect(_connectTimer, &QTimer::timeout,
this, &ThreadedClientIoDevice::connectTimeout);
}
ThreadedClientIoDevice::~ThreadedClientIoDevice()
{
_buffer->disconnect();
if(!isClosing())
close();
}
void ThreadedClientIoDevice::connectToServer()
{
if(isOpen() || !url().isValid())
return;
if(_buffer->isOpen())
_buffer->close();
if(url().scheme() != ThreadedServer::UrlScheme()) {
qCCritical(rothreadedbackend).noquote() << "Unsupported URL-Scheme:" << url().scheme();
return;
}
if(ThreadedServer::connectTo(url(), _buffer))
_connectTimer->start();
else
emit shouldReconnect(this);
}
bool ThreadedClientIoDevice::isOpen() const
{
return !isClosing() && _buffer->isOpen();
}
QIODevice *ThreadedClientIoDevice::connection() const
{
return _buffer;
}
void ThreadedClientIoDevice::doDisconnectFromServer()
{
if(_buffer->isOpen())
_buffer->close();
}
void ThreadedClientIoDevice::doClose()
{
if(_buffer->isOpen())
_buffer->close();
deleteLater();
}
void ThreadedClientIoDevice::deviceConnected()
{
_connectTimer->stop();
m_dataStream.setDevice(connection());
m_dataStream.resetStatus();
}
void ThreadedClientIoDevice::deviceClosed()
{
if(!isClosing()) {
qCWarning(rothreadedbackend) << "Partner device closed connection unexpected";
emit shouldReconnect(this);
}
}
void ThreadedClientIoDevice::connectTimeout()
{
qCWarning(rothreadedbackend) << "Connecting to partner device timed out";
emit shouldReconnect(this);
}
| 23.039604 | 89 | 0.752041 | wangyangyangisme |
9d8bb019fbd9e5011a5b60e831e028e972be644f | 3,710 | cxx | C++ | src/proc/gsx_process_cycle.cxx | ShixianGuo/gserver_framework | 02d5a1cd934eaa055b33eadbaa4827f161565c5a | [
"MIT"
] | 7 | 2020-04-02T14:12:46.000Z | 2020-05-03T09:16:51.000Z | src/proc/gsx_process_cycle.cxx | ShixianGuo/gserver_framework | 02d5a1cd934eaa055b33eadbaa4827f161565c5a | [
"MIT"
] | null | null | null | src/proc/gsx_process_cycle.cxx | ShixianGuo/gserver_framework | 02d5a1cd934eaa055b33eadbaa4827f161565c5a | [
"MIT"
] | 1 | 2020-08-17T05:20:11.000Z | 2020-08-17T05:20:11.000Z |
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include "gsx_func.h"
#include "gsx_macro.h"
#include "gsx_c_conf.h"
static void gsx_start_worker_processes(int threadnums);
static int gsx_spawn_process(int threadnums, const char *pprocname);
static void gsx_worker_process_cycle(int inum, const char *pprocname);
static void gsx_worker_process_init(int inum);
static u_char master_process[] = "master process";
void gsx_master_process_cycle()
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigaddset(&set, SIGALRM);
sigaddset(&set, SIGIO);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGHUP);
sigaddset(&set, SIGUSR1);
sigaddset(&set, SIGUSR2);
sigaddset(&set, SIGWINCH);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGQUIT);
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1)
{
gsx_log_error_core(GSX_LOG_ALERT, errno, "gsx_master_process_cycle()中sigprocmask()失败!");
}
size_t size;
int i;
size = sizeof(master_process);
size += g_argvneedmem;
if (size < 1000)
{
char title[1000] = {0};
strcpy(title, (const char *)master_process);
strcat(title, " ");
for (i = 0; i < g_os_argc; i++)
{
strcat(title, g_os_argv[i]);
}
gsx_setproctitle(title);
gsx_log_error_core(GSX_LOG_NOTICE, 0, "%s %P 【master进程】启动并开始运行......!", title, gsx_pid);
}
CConfig *p_config = CConfig::GetInstance();
int workprocess = p_config->GetIntDefault("WorkerProcesses", 1);
gsx_start_worker_processes(workprocess);
sigemptyset(&set);
for (;;)
{
sigsuspend(&set);
sleep(1);
}
return;
}
static void gsx_start_worker_processes(int threadnums)
{
int i;
for (i = 0; i < threadnums; i++)
{
gsx_spawn_process(i, "worker process");
}
return;
}
static int gsx_spawn_process(int inum, const char *pprocname)
{
pid_t pid;
pid = fork();
switch (pid)
{
case -1:
gsx_log_error_core(GSX_LOG_ALERT, errno, "gsx_spawn_process()fork()产生子进程num=%d,procname=\"%s\"失败!", inum, pprocname);
return -1;
case 0:
gsx_parent = gsx_pid;
gsx_pid = getpid();
gsx_worker_process_cycle(inum, pprocname);
break;
default:
break;
}
return pid;
}
static void gsx_worker_process_cycle(int inum, const char *pprocname)
{
gsx_process = GSX_PROCESS_WORKER;
gsx_worker_process_init(inum);
gsx_setproctitle(pprocname);
gsx_log_error_core(GSX_LOG_NOTICE, 0, "%s %P 【worker进程】启动并开始运行......!", pprocname, gsx_pid);
for (;;)
{
gsx_process_events_and_timers();
/*if(false)
{
g_stopEvent = 1;
break;
}*/
}
g_threadpool.StopAll();
g_socket.Shutdown_subproc();
return;
}
static void gsx_worker_process_init(int inum)
{
sigset_t set;
sigemptyset(&set);
if (sigprocmask(SIG_SETMASK, &set, NULL) == -1)
{
gsx_log_error_core(GSX_LOG_ALERT, errno, "gsx_worker_process_init()中sigprocmask()失败!");
}
CConfig *p_config = CConfig::GetInstance();
int tmpthreadnums = p_config->GetIntDefault("ProcMsgRecvWorkThreadCount", 5);
if (g_threadpool.Create(tmpthreadnums) == false)
{
exit(-2);
}
sleep(1);
if (g_socket.Initialize_subproc() == false)
{
exit(-2);
}
g_socket.gsx_epoll_init();
return;
}
| 23.043478 | 126 | 0.597574 | ShixianGuo |
9d8dd2949f2c736abf96fb58ce758df08dfda28b | 2,210 | cpp | C++ | src/gen_res/main.cpp | suijingfeng/libhut | e0d5dd29d66f7fb40c09e58f570ed40787ed1a2f | [
"Unlicense",
"MIT"
] | null | null | null | src/gen_res/main.cpp | suijingfeng/libhut | e0d5dd29d66f7fb40c09e58f570ed40787ed1a2f | [
"Unlicense",
"MIT"
] | null | null | null | src/gen_res/main.cpp | suijingfeng/libhut | e0d5dd29d66f7fb40c09e58f570ed40787ed1a2f | [
"Unlicense",
"MIT"
] | 1 | 2021-06-24T16:22:45.000Z | 2021-06-24T16:22:45.000Z | #include <algorithm>
#include <chrono>
#include <cstring>
#include <experimental/filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include "hut/utils.hpp"
using namespace std;
using namespace std::experimental::filesystem::v1;
using namespace std::chrono;
using namespace hut;
constexpr auto line_size = 0x10;
int main(int argc, char **argv) {
auto start = steady_clock::now();
if (argc <= 3)
throw runtime_error(sstream("usage: ") << argv[0] << " <namespace> <output> <list of input...>");
path output_path = argv[2];
if (!exists(output_path.parent_path()))
create_directories(output_path.parent_path());
ofstream output(output_path, ios::out | ios::trunc);
if (!output.is_open())
throw runtime_error(sstream("can't open ") << output_path << ": " << strerror(errno));
output << "// This is an autogenerated file.\n";
output << "#pragma once\n";
output << "#include <array>\n";
output << "namespace hut {\n";
output << "namespace " << argv[1] << " {\n";
for (auto i = 3; i < argc; i++) {
path input_path = argv[i];
ifstream input(input_path, ios::ate | ios::binary);
if (!input.is_open())
throw runtime_error(sstream("can't open ") << input_path << ": " << strerror(errno));
string symbol = input_path.filename().string();
std::replace(symbol.begin(), symbol.end(), '.', '_');
auto found_size = input.tellg();
auto written = 0;
output << "const std::array<uint8_t, " << dec << input.tellg() << "> " << symbol << " = {\n";
input.seekg(0);
while (!input.eof()) {
uint8_t line[line_size];
input.read((char *)line, line_size);
output << "\t/*" << hex << setw(6) << setfill('0') << written << "*/ ";
for (auto c = 0; c < input.gcount(); c++)
output << "0x" << setw(2) << (uint32_t)line[c] << ", ";
written += input.gcount();
output << "\n";
}
output << "}; // " << symbol << "\n\n";
}
output << "} // namespace " << argv[1] << '\n';
output << "} // namespace hut" << std::endl;
std::cout << "Generated " << output_path << " in "
<< duration<double, std::milli>(steady_clock::now() - start).count() << "ms." << std::endl;
}
| 31.126761 | 103 | 0.583258 | suijingfeng |
9d8f0252c682ea825d710cf6aeb95d2e9776c108 | 1,664 | hpp | C++ | include/ring.hpp | lebarsfa/vpython-wx | 38df062e5532b79f632f4f2a1abae86754c264a9 | [
"BSL-1.0"
] | 68 | 2015-01-17T05:41:58.000Z | 2021-04-24T08:35:24.000Z | include/ring.hpp | lebarsfa/vpython-wx | 38df062e5532b79f632f4f2a1abae86754c264a9 | [
"BSL-1.0"
] | 16 | 2015-01-02T19:36:06.000Z | 2018-09-09T21:01:25.000Z | include/ring.hpp | lebarsfa/vpython-wx | 38df062e5532b79f632f4f2a1abae86754c264a9 | [
"BSL-1.0"
] | 37 | 2015-02-04T04:23:00.000Z | 2020-06-07T03:24:41.000Z | #ifndef VPYTHON_RING_HPP
#define VPYTHON_RING_HPP
// Copyright (c) 2000, 2001, 2002, 2003 by David Scherer and others.
// Copyright (c) 2003, 2004 by Jonathan Brandmeyer and others.
// See the file license.txt for complete license terms.
// See the file authors.txt for a complete list of contributors.
#include "axial.hpp"
#ifdef __GNUC__
# define NONNULL __attribute__((nonnull))
#else
# define NONNULL
#endif
namespace cvisual {
// This model representation is intended to be "sort of like" what a next generation
// two phase renderer would use. Eventually, therefore, it should be replaced with
// the real thing.
struct fvertex {
union {
float v[3];
struct { float x, y, z; };
};
fvertex() {} // uninitialized!
fvertex( const vector& v ) : x(v.x), y(v.y), z(v.z) {}
};
class model {
public:
std::vector< unsigned short > indices;
std::vector< fvertex > vertex_pos;
std::vector< fvertex > vertex_normal;
};
class ring : public axial
{
private:
// The radius of the ring's body. If not specified, it is set to 1/10 of
// the radius of the body.
double thickness;
PRIMITIVE_TYPEINFO_DECL;
bool degenerate();
cvisual::model model;
int model_rings, model_bands;
double model_radius, model_thickness;
public:
ring();
virtual ~ring();
void set_thickness( double t);
double get_thickness();
protected:
virtual void gl_pick_render(view&);
virtual void gl_render(view&);
virtual void grow_extent( extent&);
void get_material_matrix(const view&, tmatrix& out);
void create_model( int rings, int bands, class model& m );
};
} // !namespace cvisual
#endif
| 24.115942 | 85 | 0.688101 | lebarsfa |
9d91945cc1b84f8a162c39bbd9b2b9a111b38f20 | 21,835 | cpp | C++ | class/controladores/controlador_juego.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | class/controladores/controlador_juego.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | class/controladores/controlador_juego.cpp | TheMarlboroMan/winter-fgj5 | 28cd4bd4ae37230e51c1a9963bcd293e674cdc3c | [
"Beerware"
] | null | null | null | #include "controlador_juego.h"
Controlador_juego::Controlador_juego(Director_estados &DI, Localizador& loc, Configuracion_base& config,const std::vector<App_Niveles::Sala>& salas, App_Graficos::Animaciones& anim)
:Controlador_base(DI, loc, config),
estado(estados::normal),
estado_dinamicas(config.acc_volumen_musica()),
camara(0, 0, App_Definiciones::definiciones::w_vista, App_Definiciones::definiciones::h_vista),
representador(anim),
jugador(200, 200),
salas(salas),
sala_actual(salas.at(0)),
indice_sala(0), siguiente_sala(0), sala_finalizada(0)
{
}
void Controlador_juego::reiniciar_estado_inicial()
{
//Reiniciar parámetros...
estado_dinamicas=App_Definiciones::Estado_dinamicas(acc_configuracion().acc_volumen_musica());
datos_juego=App_Definiciones::Datos_juego();
indice_sala=0;
siguiente_sala=0;
sala_finalizada=0;
representador.resetar_animaciones();
Audio::establecer_volumen_musica(acc_configuracion().acc_volumen_musica());
//Reiniciar estado de salas...
estados_salas.clear();
estados_salas.insert(std::begin(estados_salas), salas.size(), false);
//Cargar la sala 0.
cargar_sala(INDICE_SALA_HUB, true);
}
void Controlador_juego::procesar_cambio_presentacion()
{
switch(datos_juego.cambios_efectuados)
{
case 0:
LOG<<"Cambio presentación sin efecto"<<std::endl;
break;
case 1: //Primer cambio... Se cae el fondo.
LOG<<"Cambio caida fondo inicado"<<std::endl;
estado=estados::animacion;
break;
case 2: //Segundo cambio... Se cambia la presentación...
LOG<<"Cambio color inicado"<<std::endl;
estado=estados::animacion;
break;
case 3: //Tercer cambio... Cambia la música...
LOG<<"Cambio música inicado"<<std::endl;
estado=estados::animacion;
break;
}
}
void Controlador_juego::cargar_sala(
size_t s,
bool _is_new_entry
) {
is_new_room=_is_new_entry;
if(s==INDICE_SALA_HUB) {
procesar_cambio_presentacion();
}
sala_finalizada=indice_sala;
indice_sala=s;
sala_actual=salas.at(indice_sala);
humos.clear();
proyectiles.clear();
proyectiles_enemigos.clear();
ajustar_camara_a_sala(sala_actual);
//Bloquear las entradas que ya han sido accedidas.
auto &salidas=sala_actual.ref_salidas();
for(auto& s: salidas)
{
size_t indice=s.acc_indice_sala();
if(estados_salas[indice]) s.bloquear();
}
//Limpiar cosas según dinámicas...
if(!estado_dinamicas.con_disparo)
{
sala_actual.eliminar_dinamica_disparos();
}
if(!estado_dinamicas.con_bonus)
{
sala_actual.eliminar_dinamica_bonus();
}
const auto& entrada=sala_actual.acc_entrada();
jugador.restaurar_a_inicio_nivel(entrada.acc_espaciable_cx() - (entrada.acc_espaciable_w() / 2), entrada.acc_espaciable_fy()-jugador.acc_espaciable_h()-1);
evaluar_enfoque_camara();
//Cuando no quedan dinámicas de juego podemos insertar la última salida a pelo, que lleva al final del juego...
if(!estado_dinamicas.con_bonus && !estado_dinamicas.con_disparo && !estado_dinamicas.con_vidas)
{
App_Juego::Salida salida(369, 512, 9999, false);
sala_actual.insertar_objeto(salida);
}
//The last check is the special case for the hub, in which the animation
//has priority over the title, which always plays later.
if(is_new_room && 0!=sala_actual.get_name_index() && estado!=estados::animacion) {
show_title();
}
}
void Controlador_juego::preloop(Input_base& input, float delta)
{
}
void Controlador_juego::postloop(Input_base& input, float delta)
{
}
void Controlador_juego::loop(Input_base& input, float delta)
{
if(input.es_senal_salida())
{
abandonar_aplicacion();
}
else
{
App_Graficos::Animaciones::turno(delta);
Audio::procesar_cola_sonido();
using namespace App_Input;
if(input.es_input_down(Input::I_ESCAPE))
{
estado=estados::normal;
solicitar_cambio_estado(Director_estados::t_estados::intro);
}
else switch(estado)
{
case estados::normal:
{
Recogedor_input ri;
Input_usuario iu=ri.recoger_input_usuario(input);
procesar_jugador(jugador, delta, iu);
procesar_proyectiles(delta);
procesar_mundo(delta);
procesar_borrados();
}
break;
case estados::animacion_muerte:
procesar_animacion_muerte(delta, jugador);
break;
case estados::animacion:
switch(datos_juego.cambios_efectuados)
{
case 1: procesar_animacion_caida_fondo(delta, input); break;
case 2: procesar_animacion_cambio_color(delta, input); break;
case 3: procesar_animacion_cambio_musica(delta, input); break;
default: break;
}
break;
case estados::show_title:
if(representador.is_show_title_done()) {
estado=estados::normal;
}
else {
representador.tick_show_title(delta);
}
break;
};
}
}
void Controlador_juego::procesar_animacion_muerte(float delta, App_Juego::Jugador& jugador)
{
auto v=jugador.acc_vector();
jugador.desplazar_caja(0.0, v.y * delta);
jugador.accion_gravedad(delta, 1.0f);
if(jugador.acc_espaciable_y() > camara.acc_y()+(camara.acc_caja_pos().h*1.5f))
{
if(estado_dinamicas.con_vidas) --datos_juego.vidas;
if(!datos_juego.vidas)
{
estado=estados::normal;
solicitar_cambio_estado(Director_estados::t_estados::game_over);
}
else
{
estado=estados::normal;
cargar_sala(indice_sala, false);
datos_juego.disparos=App_Definiciones::Datos_juego::DISPAROS_DEFECTO;
}
}
}
void Controlador_juego::procesar_animacion_caida_fondo(float delta, Input_base& input)
{
if(!representador.es_animacion_fondo_finalizada())
{
representador.procesar_animacion_fondo(delta);
}
else
{
if(input.hay_eventos_teclado_down())
{
show_title();
}
}
}
void Controlador_juego::procesar_animacion_cambio_color(float delta, Input_base& input)
{
//Recibir señales flicker del representador.
if(!representador.es_animacion_color_finalizada())
{
representador.procesar_animacion_color(delta);
if(representador.es_flicker_animacion_color())
{
estado_dinamicas.colores_originales=!estado_dinamicas.colores_originales;
DLibV::Gestor_texturas::swap(App::Recursos_graficos::rt_celdas, App::Recursos_graficos::rt_celdas_bn);
DLibV::Gestor_texturas::swap(App::Recursos_graficos::rt_sprites, App::Recursos_graficos::rt_sprites_bn);
}
}
else
{
if(input.hay_eventos_teclado_down())
{
show_title();
}
}
}
void Controlador_juego::procesar_animacion_cambio_musica(float delta, Input_base& input)
{
if(!estado_dinamicas.volumen_musica && input.hay_eventos_teclado_down())
{
Audio::detener_musica();
show_title();
}
else
{
estado_dinamicas.volumen_musica-=delta * 20.f;
if(estado_dinamicas.volumen_musica < 0.f) estado_dinamicas.volumen_musica=0.f;
Audio::establecer_volumen_musica(estado_dinamicas.volumen_musica);
}
}
void Controlador_juego::procesar_mundo(float delta)
{
struct Obtener_bloqueos_enemigo
{
void operator()(std::vector<const App_Niveles::Celda *>& resultado)
{
auto comprobar=[](const App_Niveles::Celda * cel) ->bool {return !cel->es_bloqueo_enemigo();};
std::vector<const App_Niveles::Celda *>::iterator fin=std::remove_if(resultado.begin(), resultado.end(), comprobar);
resultado.erase(fin, resultado.end());
};
}obtener_bloqueos_enemigo;
using namespace App_Colisiones;
auto con_turno=sala_actual.acc_con_turno();
for(auto &cp: con_turno)
{
Calculador_colisiones CC;
auto colisiones=CC.solidos_en_caja_sala(cp->copia_caja_con_turno(), sala_actual, obtener_bloqueos_enemigo);
cp->turno(delta, jugador, colisiones);
if(cp->es_disparar()) crear_proyectil_enemigo(cp->obtener_estructura_disparo(jugador));
}
for(auto &h : humos)
{
h.turno(delta);
}
}
void Controlador_juego::procesar_proyectiles(float delta)
{
struct Bloqueos_proyectil
{
Bloqueos_proyectil(const App_Interfaces::Espaciable::t_caja& c):caja(c) {}
const App_Interfaces::Espaciable::t_caja& caja;
void operator()(std::vector<const App_Niveles::Celda *>& resultado)
{
auto comprobar=[this](const App_Niveles::Celda * cel) ->bool {return !cel->es_bloqueo_proyectil(caja);};
std::vector<const App_Niveles::Celda *>::iterator fin=std::remove_if(resultado.begin(), resultado.end(), comprobar);
resultado.erase(fin, resultado.end());
};
};
for(auto &p: proyectiles)
{
//Movimiento.
const auto& v=p.acc_vector();
p.turno(delta);
p.desplazar_caja(v.x * delta, v.y * delta);
auto disparables=sala_actual.acc_disparables();
for(auto &d : disparables)
{
if(d->es_colision_proyectil(p))
{
p.mut_borrar(true);
d->recibir_disparo(p.acc_potencia());
if(d->es_disparable_borrar())
{
datos_juego.puntuacion+=d->acc_puntos();
generar_humo(*d);
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_destruir))));
}
continue;
}
}
//Si colisiona con una celda, fuera...
auto caja=p.copia_caja();
auto bp=Bloqueos_proyectil(caja);
App_Colisiones::Calculador_colisiones CC;
auto coli=CC.celdas_en_caja(caja, sala_actual, bp); //Comprobamos sólo colisones con celdas.
if(coli.size())
{
p.mut_borrar(true);
continue;
}
}
for(auto &p: proyectiles_enemigos)
{
//Movimiento.
const auto& v=p.acc_vector();
p.turno(delta);
p.desplazar_caja(v.x * delta, v.y * delta);
//Si colisiona con una celda, fuera...
auto caja=p.copia_caja();
auto bp=Bloqueos_proyectil(caja);
App_Colisiones::Calculador_colisiones CC;
auto coli=CC.celdas_en_caja(caja, sala_actual, bp); //Comprobamos sólo colisones con celdas.
if(coli.size()) p.mut_borrar(true);
}
}
void Controlador_juego::procesar_borrados()
{
//Eliminar los proyectiles marcados para borrar.
{
auto ini=std::begin(proyectiles);
while(ini < std::end(proyectiles))
{
if(ini->es_borrar()) ini=proyectiles.erase(ini);
else ++ini;
}
}
{
auto ini=std::begin(proyectiles_enemigos);
while(ini < std::end(proyectiles_enemigos))
{
if(ini->es_borrar()) ini=proyectiles_enemigos.erase(ini);
else ++ini;
}
}
{
auto ini=std::begin(humos);
while(ini < std::end(humos))
{
if(ini->es_borrar()) ini=humos.erase(ini);
else ++ini;
}
}
sala_actual.actualizar_borrados();
}
void Controlador_juego::dibujar(DLibV::Pantalla& pantalla)
{
DLibH::Caja<float, int> caja_fondo(camara.acc_caja_pos().x, camara.acc_caja_pos().y, camara.acc_caja_pos().w, camara.acc_caja_pos().h);
representador.generar_fondo(pantalla, caja_fondo, camara.acc_x(), camara.acc_y(), sala_actual.acc_w() * App_Definiciones::definiciones::dim_celda, sala_actual.acc_h() * App_Definiciones::definiciones::dim_celda);
std::vector<const App_Interfaces::Representable *> vr=sala_actual.obtener_vector_representables();
for(const auto &p : humos) vr.push_back(&p);
for(const auto &p : proyectiles) vr.push_back(&p);
for(const auto &p : proyectiles_enemigos) vr.push_back(&p);
vr.push_back(&jugador);
struct Ordenador_representables
{
public:
bool operator()(const App_Interfaces::Representable* a, const App_Interfaces::Representable* b) const
{
return a->obtener_profundidad_ordenacion() < b->obtener_profundidad_ordenacion();
}
}ord;
std::sort(std::begin(vr), std::end(vr), ord);
//Generar vista.
if(estado==estados::normal) evaluar_enfoque_camara();
representador.generar_vista(pantalla, camara, vr);
representador.generar_hud(pantalla, estado_dinamicas, datos_juego);
//Generar mensaje, si procede...
if(estado==estados::animacion)
{
std::string txt("");
switch(sala_finalizada)
{
case INDICE_SALA_FIN_DISPARO: txt=texto_localizado(App_Definiciones::definiciones_loc::txt_disparo); break;
case INDICE_SALA_FIN_BONUS: txt=texto_localizado(App_Definiciones::definiciones_loc::txt_bonus); break;
case INDICE_SALA_FIN_VIDAS: txt=texto_localizado(App_Definiciones::definiciones_loc::txt_vidas); break;
}
representador.generar_mensaje(pantalla, txt);
}
if(estado==estados::show_title) {
int index=sala_actual.get_name_index();
//especial hub...
if(index==100) {
switch(datos_juego.cambios_efectuados) {
case 0: index=26; break;
case 1: index=27; break;
case 2: index=28; break;
case 3: index=29; break;
}
}
representador.show_title(pantalla, index);
}
}
void Controlador_juego::procesar_jugador(App_Juego::Jugador& j, float delta, App_Input::Input_usuario iu)
{
using namespace App_Colisiones;
auto pos_anterior=jugador.acc_posicion_anterior();
//Functor para detectar si colisionamos con alguna celda letal.
struct Hay_celda_letal_y_trunca_no_celdas
{
int es_letal;
void operator()(std::vector<const App_Niveles::Celda *>& resultado)
{
//Mirar si hay alguna letal.
bool hay_letal=std::count_if(std::begin(resultado), std::end(resultado), [](const App_Niveles::Celda * cel) ->bool {return cel->es_letal();});
//Truncar aquellas que no sean sólidas, letales o plataformas.
std::vector<const App_Niveles::Celda *>::iterator fin=std::remove_if(resultado.begin(), resultado.end(), [](const App_Niveles::Celda * cel) {return cel->es_jugador_ignora();});
resultado.erase(fin, resultado.end());
//Letal es cuando no hay contacto con otra cosa que algo letal.
es_letal=resultado.size() && hay_letal==resultado.size();
};
}hay_celda_letal_y_trunca_no_celdas;
//////
//Inicio.
j.recoger_input(iu);
//Comprobar si el jugador está cayendo...
if(jugador.es_en_suelo())
{
Calculador_colisiones CC;
auto colisiones_caida=CC.solidos_en_caja_sala(jugador.caja_comprobar_caida(), sala_actual);
if(!colisiones_caida.size())
{
jugador.establecer_en_caida();
}
}
//Intentar saltar...
if(iu.salto==App_Input::Input_usuario::t_estados::down && jugador.puede_saltar())
{
jugador.saltar();
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_salto))));
}
//Añadir control de altura del salto: si está saltando y se suelta el botón...
else if(iu.salto==App_Input::Input_usuario::t_estados::nada && jugador.es_saltando_control())
{
jugador.cancelar_control_salto();
}
//Intentar disparar.
if(estado_dinamicas.con_disparo && iu.disparo==App_Input::Input_usuario::t_estados::down && datos_juego.disparos && jugador.puede_disparar())
{
jugador.iniciar_disparo();
crear_proyectil_jugador(jugador);
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_disparo))));
--datos_juego.disparos;
}
//Interpretar input.
j.turno(delta);
//Procesar movimiento tras turno. Se comprueban las colisiones con las celdas
//y con los objetos de juego sólidos. Por cada parte se comprobará también
//si ha colisionado con celdas letales.
bool celda_letal=false;
auto v=j.acc_vector();
if(v.y)
{
jugador.desplazar_caja(0.0, v.y * delta);
Calculador_colisiones CC;
Ajustador AJ;
auto colisiones=CC.solidos_en_caja_sala(jugador.copia_caja(), sala_actual, hay_celda_letal_y_trunca_no_celdas);
//Eliminar todos aquellos que sean "es_plataforma" que estén por debajo del jugador".
//ojo: !es_sobre != es_bajo...
//Otra forma de decirlo: para tener en cuenta a una plataforma, la posición anterior tiene que haber estado "encima".
auto fin=std::remove_if(colisiones.begin(), colisiones.end(), [&pos_anterior](const App_Interfaces::Espaciable* e)
{
return e->es_plataforma() && !App_Interfaces::Espaciable::es_sobre(pos_anterior, e->copia_caja());
});
colisiones.erase(fin, colisiones.end());
if(colisiones.size()) AJ.ajustar_colisiones_eje_y_actor_movil_con_espaciables(jugador, colisiones);
celda_letal=celda_letal || hay_celda_letal_y_trunca_no_celdas.es_letal;
}
if(v.x)
{
jugador.desplazar_caja(v.x * delta, 0.0);
Calculador_colisiones CC;
Ajustador AJ;
auto colisiones=CC.solidos_en_caja_sala(jugador.copia_caja(), sala_actual, hay_celda_letal_y_trunca_no_celdas);
//Eliminar todos aquellos que sean "es_plataforma" que estén por debajo del jugador".
auto fin=std::remove_if(colisiones.begin(), colisiones.end(), [&pos_anterior](const App_Interfaces::Espaciable* e)
{
return e->es_plataforma() && !App_Interfaces::Espaciable::es_sobre(pos_anterior, e->copia_caja());
});
colisiones.erase(fin, colisiones.end());
if(colisiones.size()) AJ.ajustar_colisiones_eje_x_actor_movil_con_espaciables(jugador, colisiones);
celda_letal=celda_letal || hay_celda_letal_y_trunca_no_celdas.es_letal;
}
//Las colisiones con objetos de juego se evaluan en la posición final.
auto &bonus=sala_actual.ref_bonus();
for(auto &b : bonus)
{
if(b.en_colision_con(jugador)) recoger_bonus(b);
}
//Comprobar colisiones con objetos letales... Con las celdas ya está calculado.
if(celda_letal)
{
perder_vida();
}
else
{
//Son espaciables...
const auto& letales=sala_actual.acc_objetos_letales();
for(auto &l: letales)
{
if(l->en_colision_con(jugador))
{
perder_vida();
return;
}
}
//Aquí los proyectiles enemigos.-
for(auto &l: proyectiles_enemigos)
{
if(l.en_colision_con(jugador))
{
perder_vida();
return;
}
}
}
//Y ahora las salidas de las salas...
const auto &salidas=sala_actual.acc_salidas();
for(const auto& s: salidas)
{
if(jugador.es_dentro_de(s))
{
if(s.es_bloqueada()) continue;
size_t indice=s.acc_indice_sala();
if(indice==9999) //Lool... Hack.
{
finalizar_juego();
return;
}
else
{
//Marcar la sala como finalizada: para que las puertas
//a esa sala ya no sean accesibles. La salida en si
//tendrá una propiedad "bloqueable" que se establece en
//el editor que actúa como "override".
estados_salas[indice_sala]=true;
evaluar_fin_sala(indice_sala);
siguiente_sala=indice;
cargar_sala(siguiente_sala, true);
return;
}
}
}
}
void Controlador_juego::perder_vida()
{
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_perder_vida))));
jugador.perder_vida();
estado=estados::animacion_muerte;
}
void Controlador_juego::evaluar_enfoque_camara()
{
const auto& c_foco=camara.acc_caja_foco();
int x=jugador.acc_espaciable_x()-(c_foco.w / 2 );
int y=jugador.acc_espaciable_y()-(c_foco.h / 2);
camara.enfocar_a(x, y);
}
/**
* Establece los límites de la cámara según la sala. Adicionalmente puede cambiar
* el tamaño y la posición de la cámara para salas más pequeñas que la misma.
*/
void Controlador_juego::ajustar_camara_a_sala(const App_Niveles::Sala& s)
{
using namespace App_Definiciones;
const int w_sala=sala_actual.acc_w()*definiciones::dim_celda;
const int h_sala=sala_actual.acc_h()*definiciones::dim_celda;
camara.establecer_limites(0, 0, w_sala, h_sala);
//TODO: Todo esto de la cámara es una mierda. Mejorar la librería.
int w_pos=definiciones::w_vista, h_pos=definiciones::h_vista, x_pos=0, y_pos=0;
if(w_sala < definiciones::w_vista || h_sala < definiciones::h_vista)
{
if(w_sala < definiciones::w_vista)
{
w_pos=w_sala;
x_pos=(definiciones::w_vista - w_sala) / 2;
}
if(h_sala < definiciones::h_vista)
{
h_pos=h_sala;
y_pos=(definiciones::h_vista - h_sala) / 2;
}
}
camara.mut_w_pos(w_pos);
camara.mut_h_pos(h_pos);
camara.mut_pos_x(x_pos);
camara.mut_pos_y(y_pos);
camara.restaurar_enfoque();
}
void Controlador_juego::crear_proyectil_jugador(const App_Juego::Jugador& j)
{
float vx=j.es_encarando_direccion(App_Definiciones::direcciones::derecha) ? 1.0f : -1.0f;
proyectiles.push_back(App_Juego::Proyectil(j.acc_espaciable_cx(), j.acc_espaciable_cy(), vx));
}
void Controlador_juego::crear_proyectil_enemigo(const App_Interfaces::Con_turno::Estructura_disparo& ed)
{
proyectiles_enemigos.push_back(App_Juego::Proyectil_enemigo(ed.x, ed.y, ed.v, ed.peso));
}
/**
* Evalúa las dinámicas que se eliminarán al finalizar una sala en concreto.
*/
void Controlador_juego::evaluar_fin_sala(size_t indice)
{
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_nivel_finalizado))));
switch(indice)
{
case INDICE_SALA_FIN_DISPARO:
estado_dinamicas.con_disparo=false;
++datos_juego.cambios_efectuados;
break;
case INDICE_SALA_FIN_BONUS:
estado_dinamicas.con_bonus=false;
++datos_juego.cambios_efectuados;
break;
case INDICE_SALA_FIN_VIDAS:
estado_dinamicas.con_vidas=false;
++datos_juego.cambios_efectuados;
break;
}
}
void Controlador_juego::recoger_bonus(App_Juego::Bonus& b)
{
if(b.es_disparos())
{
datos_juego.disparos+=3;
if(datos_juego.disparos > App_Definiciones::Datos_juego::MAX_DISPAROS) datos_juego.disparos=App_Definiciones::Datos_juego::MAX_DISPAROS;
}
else if(b.es_puntos())
{
datos_juego.puntuacion+=b.acc_puntos();
}
Audio::insertar_sonido(DLibA::Estructura_sonido((DLibA::Gestor_recursos_audio::obtener_sonido(App::Recursos_audio::rs_item))));
b.mut_borrar(true);
}
void Controlador_juego::generar_humo(const App_Interfaces::Disparable& d)
{
const auto caja=d.caja_disparable();
float cx=caja.origen.x+(caja.w/2), cy=caja.origen.y+(caja.h/2);
humos.push_back(App_Juego::Humo(cx, cy, DLibH::Vector_2d(-100.f, -100.f)));
humos.push_back(App_Juego::Humo(cx, cy, DLibH::Vector_2d(100.f, -100.f)));
humos.push_back(App_Juego::Humo(cx, cy, DLibH::Vector_2d(-100.f, 100.f)));
humos.push_back(App_Juego::Humo(cx, cy, DLibH::Vector_2d(100.f, 100.f)));
}
void Controlador_juego::restaurar_estado_visual()
{
if(!estado_dinamicas.colores_originales)
{
DLibV::Gestor_texturas::swap(App::Recursos_graficos::rt_celdas, App::Recursos_graficos::rt_celdas_bn);
DLibV::Gestor_texturas::swap(App::Recursos_graficos::rt_sprites, App::Recursos_graficos::rt_sprites_bn);
}
}
void Controlador_juego::finalizar_juego()
{
estado=estados::normal;
solicitar_cambio_estado(Director_estados::t_estados::the_end);
}
void Controlador_juego::show_title() {
representador.reset_show_title();
estado=estados::show_title;
}
| 28.247089 | 213 | 0.739638 | TheMarlboroMan |
9d968328ce1490e82735c0b4dd3e378adbdda456 | 1,619 | cpp | C++ | visualization/vortex.cpp | Kerkil/arrayfire_examples | cfcaf4cea6907dee33090e88904208a12a52ac92 | [
"BSD-3-Clause"
] | 1 | 2019-12-07T19:48:23.000Z | 2019-12-07T19:48:23.000Z | visualization/vortex.cpp | Kerkil/arrayfire_examples | cfcaf4cea6907dee33090e88904208a12a52ac92 | [
"BSD-3-Clause"
] | null | null | null | visualization/vortex.cpp | Kerkil/arrayfire_examples | cfcaf4cea6907dee33090e88904208a12a52ac92 | [
"BSD-3-Clause"
] | null | null | null | #include <stdio.h>
#include <string.h>
#include <arrayfire.h>
#include "../common/progress.h"
using namespace af;
static void vortex(bool console)
{
// seconds to run demo
double time_total = 10;
// initialize parameters
unsigned particles = 10000;
float revolutions = 5.0;
float xAx = 0.7f;
float yAx = 0.3f;
float zD = -0.0025f;
float zero = 0;
array Z = randu(particles);
array T = randu(particles) * 2 * af::Pi;
array X = xAx * Z * cos(T) + 0.5;
array Y = yAx * Z * sin(T) + 0.5;
unsigned iter = 0;
timer t = timer::start();
// While time has not elapsed
while (progress(iter, t, time_total)) {
Z = Z + zD;
// Remove old points and add new points
Z = array(Z < zero) + Z * array(Z >= zero);
// Update the X and Y points
array TEMP = T + 2 * af::Pi * revolutions * .00025 * (iter++);
X = xAx * Z * cos(TEMP) + 0.5;
Y = yAx * Z * sin(TEMP) + 0.5;
if (!console) plot3(X, Z, Y);
else eval(X, Y, Z);
}
}
int main(int argc, char* argv[])
{
int device = argc > 1 ? atoi(argv[1]) : 0;
bool console = argc > 2 ? argv[2][0] == '-' : false;
try {
af::deviceset(device);
af::info();
printf("simulation of a vortex of particles\n");
vortex(console);
} catch (af::exception& e) {
fprintf(stderr, "%s\n", e.what());
throw;
}
#ifdef WIN32 // pause in Windows
if (!console) {
printf("hit [enter]...");
fflush(stdout);
getchar();
}
#endif
return 0;
}
| 21.878378 | 70 | 0.518839 | Kerkil |
9d9687d04424a3a8affb0c5057ac1e8a8e7f261c | 1,740 | hxx | C++ | include/delayed_task.hxx | catFurr/cornerstone | 77601d6beb447e371a181ac692dc2c079ddd8cb9 | [
"BSL-1.0",
"Apache-2.0"
] | 219 | 2016-10-13T11:03:19.000Z | 2022-03-25T07:20:27.000Z | include/delayed_task.hxx | catFurr/cornerstone | 77601d6beb447e371a181ac692dc2c079ddd8cb9 | [
"BSL-1.0",
"Apache-2.0"
] | 8 | 2017-10-08T01:20:25.000Z | 2021-03-02T05:13:53.000Z | include/delayed_task.hxx | catFurr/cornerstone | 77601d6beb447e371a181ac692dc2c079ddd8cb9 | [
"BSL-1.0",
"Apache-2.0"
] | 56 | 2016-10-29T15:14:32.000Z | 2022-03-28T03:59:20.000Z | /*
* Copyright (c) 2016 - present Alpha Infra Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _DELAYED_TASK_HXX_
#define _DELAYED_TASK_HXX_
namespace cornerstone {
class delayed_task {
public:
delayed_task()
: cancelled_(false), impl_ctx_(nilptr), impl_ctx_del_() {}
virtual ~delayed_task() {
if (impl_ctx_ != nilptr) {
if (impl_ctx_del_) {
impl_ctx_del_(impl_ctx_);
}
}
}
__nocopy__(delayed_task)
public:
void execute() {
if (!cancelled_.load()) {
exec();
}
}
void cancel() {
cancelled_.store(true);
}
void reset() {
cancelled_.store(false);
}
void* get_impl_context() const {
return impl_ctx_;
}
void set_impl_context(void* ctx, std::function<void(void*)> del) {
impl_ctx_ = ctx;
impl_ctx_del_ = del;
}
protected:
virtual void exec() = 0;
private:
std::atomic<bool> cancelled_;
void* impl_ctx_;
std::function<void(void*)> impl_ctx_del_;
};
}
#endif | 25.588235 | 75 | 0.57931 | catFurr |
9d98ef5887b2aa469ea05d52a1d4915eb721da7a | 10,517 | cpp | C++ | packages/ogdf.js/ogdf/test/src/planarity/crossing-minimizer.cpp | ZJUVAI/ogdf.js | 6670d20b6c630a46593ac380d1edf91d2c9aabe8 | [
"MIT"
] | 3 | 2021-09-14T08:11:37.000Z | 2022-03-04T15:42:07.000Z | packages/ogdf.js/ogdf/test/src/planarity/crossing-minimizer.cpp | JackieAnxis/ogdf.js | 6670d20b6c630a46593ac380d1edf91d2c9aabe8 | [
"MIT"
] | 2 | 2021-12-04T17:09:53.000Z | 2021-12-16T08:57:25.000Z | packages/ogdf.js/ogdf/test/src/planarity/crossing-minimizer.cpp | ZJUVAI/ogdf.js | 6670d20b6c630a46593ac380d1edf91d2c9aabe8 | [
"MIT"
] | 2 | 2021-06-22T08:21:54.000Z | 2021-07-07T06:57:22.000Z | /** \file
* \brief Tests for various crossing minimization modules.
*
* \author Tilo Wiedera
*
* \par License:
* This file is part of the Open Graph Drawing Framework (OGDF).
*
* \par
* Copyright (C)<br>
* See README.md in the OGDF root directory for details.
*
* \par
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* Version 2 or 3 as published by the Free Software Foundation;
* see the file LICENSE.txt included in the packaging of this file
* for details.
*
* \par
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* \par
* You should have received a copy of the GNU General Public
* License along with this program; if not, see
* http://www.gnu.org/copyleft/gpl.html
*/
#include <set>
#include <ogdf/basic/graph_generators.h>
#include <ogdf/basic/simple_graph_alg.h>
#include <ogdf/basic/extended_graph_alg.h>
#include <ogdf/planarity/SubgraphPlanarizer.h>
#include <ogdf/planarity/FixedEmbeddingInserter.h>
#include <ogdf/planarity/MultiEdgeApproxInserter.h>
#include <ogdf/planarity/VariableEmbeddingInserter.h>
#include <ogdf/planarity/VariableEmbeddingInserterDyn.h>
#include <ogdf/energybased/FMMMLayout.h>
#include <resources.h>
constexpr edge none = nullptr;
/**
* Verifies that \p graph resembles a planarization of the original graph.
*
* \param graph a supposed planarization to be verified
* \param cost a pointer to the cost of each edge in the original graph
* \return the weighted crossing number of the given planarization
*/
int verifyCrossings(const GraphCopy &graph, const EdgeArray<int> *cost) {
int result = 0;
const Graph &original = graph.original();
int numberOfDummies = graph.numberOfNodes() - original.numberOfNodes();
AssertThat(graph.numberOfEdges() - original.numberOfEdges(), Equals(2*numberOfDummies));
int dummyCounter = 0;
for(node v : graph.nodes) {
if(graph.isDummy(v)) {
dummyCounter++;
AssertThat(v->degree(), Equals(4));
AssertThat(v->indeg(), Equals(2));
std::set<edge> set;
edge e = graph.original(v->firstAdj()->theEdge());
edge f = graph.original(v->lastAdj()->theEdge());
set.insert(e);
set.insert(f);
set.insert(graph.original(v->firstAdj()->cyclicSucc()->theEdge()));
set.insert(graph.original(v->lastAdj()->cyclicPred()->theEdge()));
AssertThat(set.size(), Equals(2u));
List<edge> inEdges;
v->inEdges(inEdges);
AssertThat(graph.original(inEdges.front()), !Equals(graph.original(inEdges.back())));
AssertThat(e, !Equals(none));
AssertThat(f, !Equals(none));
result += cost ? (*cost)[*set.begin()] * (*cost)[*set.rbegin()] : 1;
}
}
AssertThat(dummyCounter, Equals(numberOfDummies));
for(edge e : graph.edges) {
node s = e->source();
node t = e->target();
AssertThat(graph.isDummy(e), IsFalse());
if(!graph.isDummy(s)) {
AssertThat(s, Equals(graph.copy(graph.original(e)->source())));
}
if(!graph.isDummy(t)) {
AssertThat(t, Equals(graph.copy(graph.original(e)->target())));
}
}
return result;
}
/**
* Tests a planarization algorithm on a single instance.
*
* \param cmm an algorithm to be tested
* \param graph a graph that should be planarized
* \param expected the crossing number of the input graph
* \param isOptimal whether the algorithm is supposed to yield an optimal solution for this instance
* \param cost costs of all edges. If \c nullptr is given each edge is assumed to have cost 1
*/
void testComputation(CrossingMinimizationModule &cmm, const Graph &graph, int expected, bool isOptimal, const EdgeArray<int> *cost = nullptr) {
using ReturnType = CrossingMinimizationModule::ReturnType;
PlanRep planRep(graph);
planRep.initCC(0);
int actual(17); // an arbitrary nonzero number
ReturnType result = cmm.call(planRep, 0, actual, cost);
if(isOptimal) {
AssertThat(result, Equals(ReturnType::Optimal));
} else {
AssertThat(result, Equals(ReturnType::Optimal) || Equals(ReturnType::Feasible) || Equals(ReturnType::TimeoutFeasible));
}
if(isOptimal) {
AssertThat(actual, Equals(expected));
} else {
AssertThat(actual, !IsLessThan(expected));
}
bool planar = planarEmbed(planRep);
// optimal algorithms don't need to return planarizations
if(!isOptimal) {
AssertThat(planar, IsTrue());
}
if(planar) {
AssertThat(verifyCrossings(planRep, cost), Equals(actual));
}
if(planar && isLoopFree(graph)) {
AssertThat(isLoopFree(planRep), IsTrue());
}
}
/**
* Tests a ::CrossingMinimizationModule \p cmm for correctness.
*
* \param cmm an algorithm to be tested
* \param title a human-readable title of the algorithm
* \param isOptimal whether the algorithm is optimal
*/
void testModule(CrossingMinimizationModule &cmm, const std::string title, bool isOptimal) {
describe(title, [&]() {
Graph graph;
it("works on a K4", [&]() {
completeGraph(graph, 4);
testComputation(cmm, graph, 0, isOptimal);
});
it("works on a K5", [&]() {
completeGraph(graph, 5);
testComputation(cmm, graph, 1, isOptimal);
});
it("works on a K6", [&]() {
completeGraph(graph, 6);
testComputation(cmm, graph, 3, isOptimal);
});
it("works on a K3,3", [&]() {
completeBipartiteGraph(graph, 3, 3);
testComputation(cmm, graph, 1, isOptimal);
});
it("works on a K4,3", [&]() {
completeBipartiteGraph(graph, 4, 3);
testComputation(cmm, graph, 2, isOptimal);
});
it("works on a K4,4", [&]() {
completeBipartiteGraph(graph, 4, 4);
testComputation(cmm, graph, 4, isOptimal);
});
it("works on a petersen graph", [&]() {
petersenGraph(graph, 5, 2);
testComputation(cmm, graph, 2, isOptimal);
});
it("works on a generalized petersen graph (9,2)", [&]() {
petersenGraph(graph, 9, 2);
testComputation(cmm, graph, 3, isOptimal);
});
it("works on a weighted K3,3", [&]() {
completeBipartiteGraph(graph, 3, 3);
EdgeArray<int> cost(graph, 2);
testComputation(cmm, graph, 4, isOptimal, &cost);
cost[graph.chooseEdge()] = 1;
testComputation(cmm, graph, 2, isOptimal, &cost);
});
// TODO test forbidden edges ?
if(isOptimal) {
#ifdef OGDF_USE_ASSERT_EXCEPTIONS
// optimal algorithms should throw exceptions on non-pre-processed instances
it("aborts if the graph contains self-loops", [&](){
completeGraph(graph, 5);
node v = graph.chooseNode();
graph.newEdge(v, v);
AssertThrows(AssertionFailed, testComputation(cmm, graph, 1, true));
});
it("aborts if the graph contains parallel edges", [&](){
completeGraph(graph, 5);
graph.newEdge(graph.firstNode(), graph.lastNode());
AssertThrows(AssertionFailed, testComputation(cmm, graph, 1, true));
});
it("aborts if the graph contains nodes with degree 2", [&](){
completeGraph(graph, 5);
node v = graph.newNode();
graph.newEdge(graph.chooseNode(), v);
graph.newEdge(graph.chooseNode(), v);
AssertThrows(AssertionFailed, testComputation(cmm, graph, 1, true));
});
it("aborts if the graph isn't biconnected", [&](){
completeGraph(graph, 5);
List<node> nodes = { graph.chooseNode() };
for(int i = 0; i < 4; i++) {
nodes.pushBack(graph.newNode());
}
for(node v : nodes) {
for(node w : nodes) {
if(w->index() < v->index()) {
graph.newEdge(v, w);
}
}
}
AssertThrows(AssertionFailed, testComputation(cmm, graph, 1, true));
});
#endif
} else {
// we assume non-optimal algorithms to be faster
it("works on a generalized petersen graph (15,3)", [&]() {
petersenGraph(graph, 15, 3);
testComputation(cmm, graph, 5, isOptimal);
});
it("works on a K10", [&]() {
completeGraph(graph, 10);
testComputation(cmm, graph, 60, false);
});
std::vector<string> instances = {
"rome/grafo3703.45.lgr.gml.pun",
"rome/grafo5745.50.lgr.gml.pun"
};
for_each_graph_it("works", instances,
[&](Graph &gr) {
testComputation(cmm, gr, -1, false);
});
}
});
}
template<typename EdgeInserter>
void setRemoveReinsert(EdgeInserter &edgeInserter, RemoveReinsertType rrType) {
edgeInserter.removeReinsert(rrType);
}
template<>
void setRemoveReinsert(MultiEdgeApproxInserter &edgeInserter, RemoveReinsertType rrType) {
edgeInserter.removeReinsertVar(rrType);
edgeInserter.removeReinsertFix(rrType);
}
/**
* Test the ::SubgraphPlanarizer with a specific type of edge remove-reinsert post-processing.
*/
template<typename EdgeInserter>
void testSPRRType(SubgraphPlanarizer &heuristic, EdgeInserter *edgeInserter, RemoveReinsertType rrType, const std::string name, bool skipMe) {
auto performTest = [&]() {
setRemoveReinsert(*edgeInserter, rrType);
heuristic.permutations(1);
testModule(heuristic, "single run", false);
heuristic.permutations(4);
testModule(heuristic, "4 permutations", false);
};
string title = "remove-reinsert: " + name;
if(skipMe) {
describe_skip(title, performTest);
} else {
describe(title, performTest);
}
}
/**
* Test the ::SubgraphPlanarizer with a specific ::EdgeInsertionModule .
*/
template<typename EdgeInserter>
void testSPEdgeInserter(EdgeInserter *edgeInserter, const std::string name, bool skipMe = false) {
describe("edge insertion: " + name, [&]() {
SubgraphPlanarizer heuristic;
heuristic.setInserter(edgeInserter);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::None, "none", skipMe);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::Inserted, "inserted", skipMe);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::MostCrossed, "most-crossed", skipMe);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::All, "all", skipMe);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::Incremental, "incremental", skipMe);
testSPRRType(heuristic, edgeInserter, RemoveReinsertType::IncInserted, "inc-inserted", skipMe);
});
}
/**
* Test variants of the ::SubgraphPlanarizer .
*/
void testSubgraphPlanarizer() {
describe("SubgraphPlanarizer", []() {
testSPEdgeInserter(new FixedEmbeddingInserter, "FixedEmbedding");
testSPEdgeInserter(new MultiEdgeApproxInserter, "MultiEdgeApprox");
testSPEdgeInserter(new VariableEmbeddingInserter, "VariableEmbedding");
testSPEdgeInserter(new VariableEmbeddingInserterDyn, "VariableEmbeddingDyn");
});
}
go_bandit([]() {
testSubgraphPlanarizer();
});
| 29.962963 | 143 | 0.697157 | ZJUVAI |
9da1479a4a4e4b41b444f02e0467c52bdc3d47c1 | 7,083 | cpp | C++ | tests/datamap_test.cpp | r3dl3g/guipp | 3d3179be3022935b46b59f1b988a029abeabfcbf | [
"MIT"
] | null | null | null | tests/datamap_test.cpp | r3dl3g/guipp | 3d3179be3022935b46b59f1b988a029abeabfcbf | [
"MIT"
] | null | null | null | tests/datamap_test.cpp | r3dl3g/guipp | 3d3179be3022935b46b59f1b988a029abeabfcbf | [
"MIT"
] | null | null | null |
#include <gui/draw/datamap.h>
#include <gui/draw/graphics.h>
#include <testlib/testlib.h>
// --------------------------------------------------------------------------
void test_bw () {
using namespace gui;
using namespace gui::draw;
bwmap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 1);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::BW);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(2, 4), pixel_format_t::BW));
image_data<pixel_format_t::BW> raw = img.get_data();
auto row = raw.row(0);
pixel::mono px = row[0];
EXPECT_EQUAL(static_cast<int>(px), 0);
row[0] = pixel::mono::black;
px = row[0];
EXPECT_EQUAL(px, pixel::mono::black);
row[0] = pixel::mono::white;
px = row[0];
EXPECT_EQUAL(px, pixel::mono::white);
px = static_cast<const bwmap&>(img).get_data().pixel(0, 0);
EXPECT_EQUAL(px, pixel::mono::white);
}
// --------------------------------------------------------------------------
void test_gray () {
using namespace gui;
using namespace gui::draw;
graymap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 8);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::GRAY);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(2, 4), pixel_format_t::GRAY));
image_data<pixel_format_t::GRAY> raw = img.get_data();
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::gray>::black);
raw.pixel(0, 0) = pixel::color<pixel::gray>::white;
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::gray>::white);
EXPECT_EQUAL(raw.pixel(1, 1), pixel::color<pixel::gray>::black);
}
// --------------------------------------------------------------------------
void test_rgb () {
using namespace gui;
using namespace gui::draw;
rgbmap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 24);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::RGB);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(6, 8), pixel_format_t::RGB));
auto raw = img.get_data();
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::rgb>::black);
raw.pixel(0, 0) = pixel::color<pixel::rgb>::white;
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::rgb>::white);
EXPECT_EQUAL(raw.pixel(1, 1), pixel::color<pixel::rgb>::black);
}
// --------------------------------------------------------------------------
void test_bgr () {
using namespace gui;
using namespace gui::draw;
bgrmap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 24);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::BGR);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(6, 8), pixel_format_t::BGR));
auto raw = img.get_data();
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::bgr>::black);
raw.pixel(0, 0) = pixel::color<pixel::bgr>::white;
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::bgr>::white);
EXPECT_EQUAL(raw.pixel(1, 1), pixel::color<pixel::bgr>::black);
}
// --------------------------------------------------------------------------
void test_rgba () {
using namespace gui;
using namespace gui::draw;
rgbamap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 24);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::RGBA);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, 8, pixel_format_t::RGBA));
auto raw = img.get_data();
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::rgba>::black);
raw.pixel(0, 0) = pixel::color<pixel::rgba>::white;
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::rgba>::white);
EXPECT_EQUAL(raw.pixel(1, 1), pixel::color<pixel::rgba>::black);
}
// --------------------------------------------------------------------------
void test_bgra () {
using namespace gui;
using namespace gui::draw;
bgramap img(2, 2);
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 24);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::BGRA);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, 8, pixel_format_t::BGRA));
auto raw = img.get_data();
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::bgra>::black);
raw.pixel(0, 0) = pixel::color<pixel::bgra>::white;
EXPECT_EQUAL(raw.pixel(0, 0), pixel::color<pixel::bgra>::white);
EXPECT_EQUAL(raw.pixel(1, 1), pixel::color<pixel::bgra>::black);
}
// --------------------------------------------------------------------------
void test_gray2rgb () {
using namespace gui;
using namespace gui::draw;
graymap img(2, 2);
img.fill({core::byte(0x7F)});
auto rgb = img.convert<pixel_format_t::RGB>();
EXPECT_TRUE(rgb.is_valid());
EXPECT_EQUAL(rgb.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(rgb.depth(), 24);
EXPECT_EQUAL(rgb.pixel_format(), pixel_format_t::RGB);
EXPECT_EQUAL(rgb.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(6, 8), pixel_format_t::RGB));
auto raw = rgb.get_data();
pixel::rgb expected = {0x7F, 0x7F, 0x7F};
EXPECT_EQUAL(raw.pixel(0, 0), expected);
}
// --------------------------------------------------------------------------
void test_rgb2gray () {
using namespace gui;
using namespace gui::draw;
rgbmap rgb(2, 2);
rgb.fill({0x20, 0x40, 0x60});
auto img = rgb.convert<pixel_format_t::GRAY>();
EXPECT_TRUE(img.is_valid());
EXPECT_EQUAL(img.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(img.depth(), 8);
EXPECT_EQUAL(img.pixel_format(), pixel_format_t::GRAY);
EXPECT_EQUAL(img.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(2, 4), pixel_format_t::GRAY));
auto raw = img.get_data();
pixel::gray expected = {core::byte(0x40)};
EXPECT_EQUAL(raw.pixel(0, 0), expected);
}
// --------------------------------------------------------------------------
void test_rgb2bgr () {
using namespace gui;
using namespace gui::draw;
rgbmap rgb(2, 2);
rgb.fill({0x20, 0x40, 0x60});
auto bgr = rgb.convert<pixel_format_t::BGR>();
EXPECT_TRUE(bgr.is_valid());
EXPECT_EQUAL(bgr.native_size(), core::native_size(2, 2));
EXPECT_EQUAL(bgr.depth(), 24);
EXPECT_EQUAL(bgr.pixel_format(), pixel_format_t::BGR);
EXPECT_EQUAL(bgr.get_info(), bitmap_info(2, 2, IF_WIN32_ELSE(6, 8), pixel_format_t::BGR));
auto raw = bgr.get_data();
pixel::bgr expected = {0x60, 0x40, 0x20};
EXPECT_EQUAL(raw.pixel(0, 0), expected);
}
// --------------------------------------------------------------------------
void test_main (const testing::start_params& params) {
testing::init_gui(params);
testing::log_info("Running datamap_test");
run_test(test_bw);
run_test(test_gray);
run_test(test_rgb);
run_test(test_bgr);
run_test(test_rgba);
run_test(test_bgra);
run_test(test_gray2rgb);
run_test(test_rgb2gray);
run_test(test_rgb2bgr);
}
// --------------------------------------------------------------------------
| 32.791667 | 93 | 0.60497 | r3dl3g |
9da5e885b2e00e59c7bdde042f401345fe0898cf | 1,408 | cpp | C++ | src/plugins/blasq/plugins/vangog/vangog.cpp | Maledictus/leechcraft | 79ec64824de11780b8e8bdfd5d8a2f3514158b12 | [
"BSL-1.0"
] | 120 | 2015-01-22T14:10:39.000Z | 2021-11-25T12:57:16.000Z | src/plugins/blasq/plugins/vangog/vangog.cpp | Maledictus/leechcraft | 79ec64824de11780b8e8bdfd5d8a2f3514158b12 | [
"BSL-1.0"
] | 8 | 2015-02-07T19:38:19.000Z | 2017-11-30T20:18:28.000Z | src/plugins/blasq/plugins/vangog/vangog.cpp | Maledictus/leechcraft | 79ec64824de11780b8e8bdfd5d8a2f3514158b12 | [
"BSL-1.0"
] | 33 | 2015-02-07T16:59:55.000Z | 2021-10-12T00:36:40.000Z | /**********************************************************************
* LeechCraft - modular cross-platform feature rich internet client.
* Copyright (C) 2010-2013 Oleg Linkin <[email protected]>
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
**********************************************************************/
#include "vangog.h"
#include <QIcon>
#include <util/util.h>
#include "picasaservice.h"
namespace LC
{
namespace Blasq
{
namespace Vangog
{
void Plugin::Init (ICoreProxy_ptr proxy)
{
Util::InstallTranslator ("blasq_vangog");
Service_ = new PicasaService (proxy);
}
void Plugin::SecondInit ()
{
}
QByteArray Plugin::GetUniqueID () const
{
return "org.LeechCraft.Blasq.Vangog";
}
void Plugin::Release ()
{
Service_->Release ();
}
QString Plugin::GetName () const
{
return "Blasq Vangog";
}
QString Plugin::GetInfo () const
{
return tr ("Picasa support module for Blasq.");
}
QIcon Plugin::GetIcon () const
{
return QIcon ();
}
QSet<QByteArray> Plugin::GetPluginClasses () const
{
QSet<QByteArray> result;
result << "org.LeechCraft.Blasq.ServicePlugin";
return result;
}
QList<IService*> Plugin::GetServices () const
{
return { Service_ };
}
}
}
}
LC_EXPORT_PLUGIN (leechcraft_blasq_vangog, LC::Blasq::Vangog::Plugin);
| 19.830986 | 83 | 0.628551 | Maledictus |
9da7a43d33d6acaa76d28af715a924e1cdd7d6a3 | 4,770 | cpp | C++ | lab07b.cpp | DaltonMcCart/csc232-lab07 | 9f06e073a8faa8eb894dbf7a2eb0ca5c6f8b92e0 | [
"MIT"
] | null | null | null | lab07b.cpp | DaltonMcCart/csc232-lab07 | 9f06e073a8faa8eb894dbf7a2eb0ca5c6f8b92e0 | [
"MIT"
] | null | null | null | lab07b.cpp | DaltonMcCart/csc232-lab07 | 9f06e073a8faa8eb894dbf7a2eb0ca5c6f8b92e0 | [
"MIT"
] | null | null | null | /**
* CSC232 - Data Structures
* Missouri State University, Fall 2018.
*
* @file lab10b.cpp
* @author Dalton McCart <[email protected]>
* CSC232-LAB10 - Updated authors tag in lab10b.cpp
*/
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "Song.h"
using std::cout;
using std::endl;
using std::make_shared;
using std::shared_ptr;
using std::vector;
void demoCreation();
void demoShareSwap();
void demoSharedPtrsWithSTL();
int main(int argc, char** argv) {
// TODO: Part 2, Step 2a - Uncomment the following call to demoCreation()
//demoCreation();
// TODO: Part 2, Step 3a - Uncomment the following call to demoShareSwap()
demoShareSwap();
// TODO: Part 2, Step 4 - Uncomment the following call to demoSharedPtrsWithSTL()
demoSharedPtrsWithSTL();
return EXIT_SUCCESS;
}
/**
* Whenever possible, use the make_shared function to create a shared_ptr when
* the memory resource is created for the first time. make_shared is exception-safe.
* It uses the same call to allocate the memory for the control block and the
* resource, and thereby reduces the construction overhead. If you do not use
* make_shared, then you have to use an explicit new expression to create the
* object before you pass it to the shared_ptr constructor. The following
* example shows various ways to declare and initialize a shared_ptr together
* with a new object.
*/
void demoCreation() {
// Use make_shared function when possible.
auto sp1 = make_shared<Song>("The Beatles", "Im Happy Just to Dance With You");
cout << sp1->getArtist() << ", ";
cout << sp1->getTitle() << endl;
// Ok, but slightly less efficient.
// Note: Using new expression as constructor argument
// creates no named variable for other code to access.
shared_ptr<Song> sp2(new Song("Lady Gaga", "Just Dance"));
cout << sp2->getArtist() << ", ";
cout << sp2->getTitle() << endl;
// When initialization must be separate from declaration, e.g. class members,
// initialize with nullptr to make your programming intent explicit.
shared_ptr<Song> sp5(nullptr);
//Equivalent to: shared_ptr<Song> sp5;
//...
sp5 = make_shared<Song>("Elton John", "I'm Still Standing");
cout << sp5->getArtist() << ", ";
cout << sp5->getTitle() << endl;
// TODO: Part 2, Step 2b - Assign sp2 to sp5 on the next line, prior to the cout
sp5 = sp2;
cout << sp5->getArtist() << ", ";
cout << sp5->getTitle() << endl;
}
/**
* The following example shows how to declare and initialize shared_ptr instances
* that take on shared ownership of an object that has already been allocated by
* another shared_ptr.
*/
void demoShareSwap() {
//Initialize with copy constructor. Increments ref count.
auto sp1 = make_shared<Song>("The Beatles", "Im Happy Just to Dance With You");
shared_ptr<Song> sp2(new Song("Lady Gaga", "Just Dance"));
auto sp3(sp2);
cout << sp3->getArtist() << ", ";
cout << sp3->getTitle() << endl;
//Initialize via assignment. Increments ref count.
auto sp4 = sp2;
cout << sp4->getArtist() << ", ";
cout << sp4->getTitle() << endl;
//Initialize with nullptr. sp7 is empty.
shared_ptr<Song> sp7(nullptr);
// TODO: Part 2, Step 3b - Uncomment out the next two lines
//cout << sp7->getArtist() << ", ";
//cout << sp7->getTitle() << endl;
// TODO: Part 2, Step 3c - Recomment out the above two lines.
// Initialize with another shared_ptr. sp1 and sp2
// swap pointers as well as ref counts.
sp1.swap(sp2);
cout << sp1->getArtist() << ", ";
cout << sp1->getTitle() << endl;
}
/**
* shared_ptr is also helpful in Standard Template Library (STL) containers when
* you are using algorithms that copy elements. You can wrap elements in a shared_ptr,
* and then copy it into other containers with the understanding that the underlying
* memory is valid as long as you need it, and no longer. The following example
* shows how to use the replace_copy_if algorithm on shared_ptr instances in a vector.
*/
void demoSharedPtrsWithSTL() {
vector<shared_ptr<Song>> v;
v.push_back(make_shared<Song>("Bob Dylan", "The Times They Are A Changing"));
v.push_back(make_shared<Song>("Aretha Franklin", "Bridge Over Troubled Water"));
v.push_back(make_shared<Song>("Thala", "Entre El Mar y Una Estrella"));
vector<shared_ptr<Song>> v2;
remove_copy_if(v.begin(), v.end(), back_inserter(v2), [] (shared_ptr<Song> s)
{
return s->getArtist().compare("Bob Dylan") == 0;
});
for (const auto& s : v2)
{
cout << s->getArtist() << ":" << s->getTitle() << endl;
}
}
| 35.597015 | 86 | 0.67044 | DaltonMcCart |
9daafcd6831478a024c2040e1fd1867fb43ff711 | 10,746 | cpp | C++ | src/bindings/Scriptdev2/scripts/northrend/icecrown_citadel/icecrown_citadel/boss_blood_queen_lanathel.cpp | mfooo/wow | 3e5fad4cfdf0fd1c0a2fd7c9844e6f140a1bb32d | [
"OpenSSL"
] | 1 | 2017-11-16T19:04:07.000Z | 2017-11-16T19:04:07.000Z | src/bindings/Scriptdev2/scripts/northrend/icecrown_citadel/icecrown_citadel/boss_blood_queen_lanathel.cpp | mfooo/wow | 3e5fad4cfdf0fd1c0a2fd7c9844e6f140a1bb32d | [
"OpenSSL"
] | null | null | null | src/bindings/Scriptdev2/scripts/northrend/icecrown_citadel/icecrown_citadel/boss_blood_queen_lanathel.cpp | mfooo/wow | 3e5fad4cfdf0fd1c0a2fd7c9844e6f140a1bb32d | [
"OpenSSL"
] | null | null | null | /* Copyright (C) 2006 - 2010 ScriptDev2 <https://scriptdev2.svn.sourceforge.net/>
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* ScriptData
SDName: boss_blood_queen_lanathel
SD%Complete: 70%
SDComment: by /dev/rsa
SDCategory: Icecrown Citadel
EndScriptData */
// Need correct work of spells and timers
#include "precompiled.h"
#include "def_spire.h"
enum BossSpells
{
SPELL_BERSERK = 47008,
SPELL_SHROUD_OF_SORROW = 72981,
SPELL_DELRIOUS_SLASH = 71623,
SPELL_BLOOD_MIRROR = 70445,
SPELL_BLOOD_MIRROR_MARK = 70451,
SPELL_VAMPIRIC_BITE = 71726,
SPELL_ESSENCE_OF_BLOOD_QWEEN = 70867,
SPELL_ESSENCE_OF_BLOOD_QWEEN_2 = 70871,
SPELL_FRENZIED_BLOODTHIRST = 70877,
SPELL_UNCONTROLLABLE_FRENZY = 70923,
SPELL_PACT_OF_DARKFALLEN = 71340,
SPELL_SWARMING_SHADOWS = 71264,
SPELL_TWILIGHT_BLOODBOLT = 71446,
SPELL_BLOODBOLT_WHIRL = 71772,
SPELL_PRESENCE_OF_DARKFALLEN = 71952,
NPC_SWARMING_SHADOWS = 38163,
SPELL_SWARMING_SHADOWS_VISUAL = 71267,
QUEST_24756 = 72934,
};
static Locations SpawnLoc[]=
{
{4595.640137f, 2769.195557f, 400.137054f}, // 0 Phased
{4595.904785f, 2769.315918f, 421.838623f}, // 1 Fly
};
struct MANGOS_DLL_DECL boss_blood_queen_lanathelAI : public BSWScriptedAI
{
boss_blood_queen_lanathelAI(Creature* pCreature) : BSWScriptedAI(pCreature)
{
pInstance = (ScriptedInstance*)pCreature->GetInstanceData();
Reset();
}
ScriptedInstance *pInstance;
uint8 stage;
uint8 nextPoint;
uint8 bloodbolts;
uint32 UpdateTimer;
bool movementstarted;
void Reset()
{
if(!pInstance)
return;
if (m_creature->isAlive())
pInstance->SetData(TYPE_LANATHEL, NOT_STARTED);
stage = 0;
UpdateTimer = 1000;
bloodbolts = 0;
movementstarted = false;
resetTimers();
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_0, 0);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
}
void JustReachedHome()
{
if (pInstance) pInstance->SetData(TYPE_LANATHEL, FAIL);
}
void KilledUnit(Unit* pVictim)
{
switch (urand(0,1))
{
case 0:
DoScriptText(-1631330,m_creature,pVictim);
break;
case 1:
DoScriptText(-1631331,m_creature,pVictim);
break;
}
if (pVictim && pVictim->HasAura(SPELL_BLOOD_MIRROR))
doRemove(SPELL_BLOOD_MIRROR,pVictim);
if (pVictim && pVictim->HasAura(SPELL_BLOOD_MIRROR_MARK))
doRemove(SPELL_BLOOD_MIRROR_MARK,pVictim);
}
void MovementInform(uint32 type, uint32 id)
{
if (type != POINT_MOTION_TYPE || !movementstarted) return;
if (id == nextPoint)
{
movementstarted = false;
m_creature->GetMotionMaster()->MovementExpired();
}
}
void StartMovement(uint32 id)
{
nextPoint = id;
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MovePoint(id, SpawnLoc[id].x, SpawnLoc[id].y, SpawnLoc[id].z);
movementstarted = true;
}
void Aggro(Unit *who)
{
if(!pInstance) return;
pInstance->SetData(TYPE_LANATHEL, IN_PROGRESS);
doCast(SPELL_SHROUD_OF_SORROW);
DoScriptText(-1631321,m_creature,who);
if (Unit* pTarget = doSelectRandomPlayer(SPELL_BLOOD_MIRROR_MARK, false, 100.0f))
{
if (doCast(SPELL_BLOOD_MIRROR_MARK,pTarget) == CAST_OK)
{
if (Unit* pTarget1 = doSelectRandomPlayer(SPELL_BLOOD_MIRROR_MARK, false, 100.0f))
pTarget->CastSpell(pTarget1,getSpellWithDifficulty(SPELL_BLOOD_MIRROR), true);
};
};
}
void JustDied(Unit *killer)
{
if(!pInstance)
return;
pInstance->SetData(TYPE_LANATHEL, DONE);
DoScriptText(-1631333,m_creature,killer);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_0, 0);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
doRemoveFromAll(getSpellWithDifficulty(SPELL_ESSENCE_OF_BLOOD_QWEEN));
doRemoveFromAll(SPELL_ESSENCE_OF_BLOOD_QWEEN_2);
doRemoveFromAll(SPELL_PACT_OF_DARKFALLEN);
doRemoveFromAll(SPELL_BLOOD_MIRROR);
doRemoveFromAll(SPELL_BLOOD_MIRROR_MARK);
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
switch(stage)
{
case 0:
if (timedQuery(SPELL_TWILIGHT_BLOODBOLT, diff))
bloodbolts = 1;
if (timedQuery(SPELL_DELRIOUS_SLASH, diff))
if (Unit* pTarget= m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,1))
doCast(SPELL_DELRIOUS_SLASH, pTarget);
timedCast(SPELL_PACT_OF_DARKFALLEN, diff);
timedCast(SPELL_SWARMING_SHADOWS, diff);
if (timedQuery(SPELL_VAMPIRIC_BITE,diff))
{
switch (urand(0,1))
{
case 0:
DoScriptText(-1631322,m_creature);
break;
case 1:
DoScriptText(-1631323,m_creature);
break;
}
doCast(SPELL_VAMPIRIC_BITE);
}
if (timedQuery(SPELL_BLOODBOLT_WHIRL,diff) && m_creature->GetHealthPercent() > 10.0f)
{
stage = 1;
};
DoMeleeAttackIfReady();
break;
case 1: // Go in fly phase
m_creature->AttackStop();
SetCombatMovement(false);
StartMovement(1);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_0, 50331648);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 50331648);
m_creature->AddSplineFlag(SPLINEFLAG_FLYING);
stage = 2;
break;
case 2:
if (movementstarted)
return;
DoScriptText(-1631327,m_creature);
doCast(SPELL_BLOODBOLT_WHIRL);
stage = 3;
return;
case 3:
if (m_creature->IsNonMeleeSpellCasted(false))
return;
if (timedQuery(SPELL_TWILIGHT_BLOODBOLT,diff) || m_creature->GetHealthPercent() < 10.0f)
{
stage = 4;
// DoScriptText(-1631325,m_creature);
bloodbolts = 3;
};
break;
case 4: // Go in grownd phase
m_creature->AttackStop();
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_0, 0);
m_creature->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
m_creature->RemoveSplineFlag(SPLINEFLAG_FLYING);
StartMovement(0);
stage = 5;
break;
case 5:
if (movementstarted) return;
DoScriptText(-1631325,m_creature);
stage = 0;
SetCombatMovement(true);
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
return;
default:
break;
}
if (bloodbolts > 0)
{
doCast(SPELL_TWILIGHT_BLOODBOLT);
--bloodbolts;
};
if (timedQuery(SPELL_BERSERK, diff))
{
doCast(SPELL_BERSERK);
DoScriptText(-1631332,m_creature);
};
}
};
CreatureAI* GetAI_boss_blood_queen_lanathel(Creature* pCreature)
{
return new boss_blood_queen_lanathelAI(pCreature);
}
struct MANGOS_DLL_DECL mob_swarming_shadowsAI : public ScriptedAI
{
mob_swarming_shadowsAI(Creature *pCreature) : ScriptedAI(pCreature)
{
m_pInstance = (ScriptedInstance*)pCreature->GetInstanceData();
Reset();
}
ScriptedInstance* m_pInstance;
uint32 m_lifetimer;
void Reset()
{
m_creature->SetDisplayId(11686);
m_creature->SetRespawnDelay(7*DAY);
SetCombatMovement(false);
m_creature->SetInCombatWithZone();
m_lifetimer = 10000;
DoCast(m_creature, SPELL_SWARMING_SHADOWS_VISUAL);
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_pInstance || m_pInstance->GetData(TYPE_LANATHEL) != IN_PROGRESS)
m_creature->ForcedDespawn();
if (!m_creature->HasAura(SPELL_SWARMING_SHADOWS_VISUAL))
DoCast(m_creature, SPELL_SWARMING_SHADOWS_VISUAL);
if (m_lifetimer <= uiDiff)
m_creature->ForcedDespawn();
else m_lifetimer -= uiDiff;
}
};
CreatureAI* GetAI_mob_swarming_shadows(Creature* pCreature)
{
return new mob_swarming_shadowsAI (pCreature);
}
void AddSC_boss_blood_queen_lanathel()
{
Script *newscript;
newscript = new Script;
newscript->Name = "boss_blood_queen_lanathel";
newscript->GetAI = &GetAI_boss_blood_queen_lanathel;
newscript->RegisterSelf();
newscript = new Script;
newscript->Name = "mob_swarming_shadows";
newscript->GetAI = &GetAI_mob_swarming_shadows;
newscript->RegisterSelf();
}
| 32.465257 | 108 | 0.564489 | mfooo |
9dadfa6f2f17ef58abfba9d36c7f3920565b8153 | 3,005 | cpp | C++ | src/AppInstallerCLICore/Commands/RootCommand.cpp | JSY1988/winget | 4f73d7cfff75d478176cf31d4abad0b8b5ff8dd4 | [
"MIT"
] | 3 | 2020-05-19T17:10:32.000Z | 2020-07-21T14:13:13.000Z | src/AppInstallerCLICore/Commands/RootCommand.cpp | JSY1988/winget | 4f73d7cfff75d478176cf31d4abad0b8b5ff8dd4 | [
"MIT"
] | null | null | null | src/AppInstallerCLICore/Commands/RootCommand.cpp | JSY1988/winget | 4f73d7cfff75d478176cf31d4abad0b8b5ff8dd4 | [
"MIT"
] | null | null | null | // Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
#include "pch.h"
#include "RootCommand.h"
#include "InstallCommand.h"
#include "ShowCommand.h"
#include "SourceCommand.h"
#include "SearchCommand.h"
#include "HashCommand.h"
#include "ValidateCommand.h"
#include "Resources.h"
namespace AppInstaller::CLI
{
std::vector<std::unique_ptr<Command>> RootCommand::GetCommands() const
{
return InitializeFromMoveOnly<std::vector<std::unique_ptr<Command>>>({
std::make_unique<InstallCommand>(FullName()),
std::make_unique<ShowCommand>(FullName()),
std::make_unique<SourceCommand>(FullName()),
std::make_unique<SearchCommand>(FullName()),
std::make_unique<HashCommand>(FullName()),
std::make_unique<ValidateCommand>(FullName()),
});
}
std::vector<Argument> RootCommand::GetArguments() const
{
return
{
Argument{ "version", 'v', Execution::Args::Type::ListVersions, Resources::GetInstance().ResolveWingetString(L"ToolVersionArgumentDescription").c_str(), ArgumentType::Flag, Visibility::Help },
Argument{ "info", APPINSTALLER_CLI_ARGUMENT_NO_SHORT_VER, Execution::Args::Type::Info, Resources::GetInstance().ResolveWingetString(L"ToolInfoArgumentDescription").c_str(), ArgumentType::Flag, Visibility::Help },
};
}
std::string RootCommand::GetLongDescription() const
{
return Resources::GetInstance().ResolveWingetString(L"ToolDescription");
}
std::string RootCommand::HelpLink() const
{
return "https://aka.ms/winget-command-help";
}
void RootCommand::ExecuteInternal(Execution::Context& context) const
{
if (context.Args.Contains(Execution::Args::Type::Info))
{
OutputIntroHeader(context.Reporter);
auto info = context.Reporter.Info();
info << std::endl <<
"Windows: " << Runtime::GetOSVersion() << std::endl;
if (Runtime::IsRunningInPackagedContext())
{
info << "Package: " << Runtime::GetPackageVersion() << std::endl;
};
info << std::endl <<
"Links:" << std::endl <<
" Privacy Statement: https://aka.ms/winget-privacy" << std::endl <<
" License agreement: https://aka.ms/winget-license" << std::endl <<
" 3rd Party Notices: https://aka.ms/winget-3rdPartyNotice" << std::endl <<
" Homepage: https://aka.ms/winget" << std::endl;
}
else if (context.Args.Contains(Execution::Args::Type::ListVersions))
{
context.Reporter.Info() << 'v' << Runtime::GetClientVersion() << ' ' << Resources::GetInstance().ResolveWingetString(L"PreviewVersion");
}
else
{
OutputHelp(context.Reporter);
}
}
}
| 37.5625 | 225 | 0.591015 | JSY1988 |
9db0985ee30904c452e85977ccdd5192becd327b | 5,609 | cpp | C++ | swap-ssdb-1.9.2/src/ssdb/options.cpp | TimothyZhang023/swapdb | e40c1ddf46892e698acf54f26b02927f0505ea84 | [
"BSD-2-Clause"
] | 242 | 2017-12-14T00:31:28.000Z | 2022-02-16T02:00:15.000Z | swap-ssdb-1.9.2/src/ssdb/options.cpp | javaperson/swapdb | 66efd9f919dfaa56dcefd9b39a8bdabe57624546 | [
"BSD-2-Clause"
] | 7 | 2017-12-14T08:34:43.000Z | 2020-12-19T02:53:03.000Z | swap-ssdb-1.9.2/src/ssdb/options.cpp | javaperson/swapdb | 66efd9f919dfaa56dcefd9b39a8bdabe57624546 | [
"BSD-2-Clause"
] | 47 | 2017-12-26T03:11:26.000Z | 2022-01-26T07:46:45.000Z | /*
Copyright (c) 2012-2014 The SSDB Authors. All rights reserved.
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
*/
#include "options.h"
#include "../util/strings.h"
#ifdef USE_LEVELDB
Options::Options(){
Config c;
this->load(c);
}
#else
#endif
void Options::load(Config *conf) {
if (conf == nullptr) {
return;
}
c = conf;
#ifdef USE_LEVELDB
cache_size = (size_t)conf->get_num("leveldb.cache_size");
block_size = (size_t)conf->get_num("leveldb.block_size");
compaction_speed = conf->get_num("leveldb.compaction_speed");
max_open_files = (size_t)conf->get_num("leveldb.max_open_files");
write_buffer_size = (size_t)conf->get_num("leveldb.write_buffer_size");
compression = conf->get_str("leveldb.compression");
if(cache_size <= 0){
cache_size = 16;
}
if(block_size <= 0){
block_size = 16;
}
if(write_buffer_size <= 0){
write_buffer_size = 16;
}
if(max_open_files <= 0){
max_open_files = 1000;
}
if(compaction_readahead_size <= 0){
compaction_readahead_size = 4 * UNIT_MB;
}
if(max_bytes_for_level_base <= 0){
max_bytes_for_level_base = 256 * UNIT_MB;
}
if(max_bytes_for_level_multiplier <= 0){
max_bytes_for_level_multiplier = 10;
}
#else
expire_enable = conf->get_bool("server.expire_enable", false);
cache_size = (size_t) conf->get_num("rocksdb.cache_size", 16);
sim_cache = (size_t) conf->get_num("rocksdb.sim_cache", 0);
block_size = (size_t) conf->get_num("rocksdb.block_size", 16);
max_open_files = conf->get_num("rocksdb.max_open_files", 1000);
write_buffer_size = conf->get_num("rocksdb.write_buffer_size", 16);
compression = conf->get_bool("rocksdb.compression");
rdb_compression = conf->get_bool("rocksdb.rdb_compression", false);
transfer_compression = conf->get_bool("rocksdb.transfer_compression");
level_compaction_dynamic_level_bytes = conf->get_bool("rocksdb.level_compaction_dynamic_level_bytes");
use_direct_reads = conf->get_bool("rocksdb.use_direct_reads", false);
optimize_filters_for_hits = conf->get_bool("rocksdb.optimize_filters_for_hits", false);
cache_index_and_filter_blocks = conf->get_bool("rocksdb.cache_index_and_filter_blocks", false);
compaction_readahead_size = (size_t) conf->get_num("rocksdb.compaction_readahead_size", 4);
max_bytes_for_level_base = (size_t) conf->get_num("rocksdb.max_bytes_for_level_base", 256);
max_bytes_for_level_multiplier = (size_t) conf->get_num("rocksdb.max_bytes_for_level_multiplier", 10);
target_file_size_base = (size_t) conf->get_num("rocksdb.target_file_size_base", 64);
min_write_buffer_number_to_merge = conf->get_num("rocksdb.min_write_buffer_number_to_merge", 2);
max_write_buffer_number = conf->get_num("rocksdb.max_write_buffer_number", 3);
max_background_flushes = conf->get_num("rocksdb.max_background_flushes", 4);
max_background_compactions = conf->get_num("rocksdb.max_background_compactions", 4);
level0_file_num_compaction_trigger = conf->get_num("rocksdb.level0_file_num_compaction_trigger", 4);
level0_slowdown_writes_trigger = conf->get_num("rocksdb.level0_slowdown_writes_trigger", 20);
level0_stop_writes_trigger = conf->get_num("rocksdb.level0_stop_writes_trigger", 36);
upstream_ip = conf->get_str("upstream.ip");
upstream_port = conf->get_num("upstream.port", 0);
#endif
}
std::ostream &operator<<(std::ostream &os, const Options &options) {
os
<< "\n create_if_missing: " << options.create_if_missing
<< "\n create_missing_column_families: " << options.create_missing_column_families
<< "\n write_buffer_size: " << options.write_buffer_size
<< "\n max_open_files: " << options.max_open_files
<< "\n compression: " << options.compression
<< "\n rdb_compression: " << options.rdb_compression
<< "\n transfer_compression: " << options.transfer_compression
<< "\n level_compaction_dynamic_level_bytes: " << options.level_compaction_dynamic_level_bytes
<< "\n use_direct_reads: " << options.use_direct_reads
<< "\n optimize_filters_for_hits: " << options.optimize_filters_for_hits
<< "\n expire_enable: " << options.expire_enable
<< "\n max_write_buffer_number: " << options.max_write_buffer_number
<< "\n max_background_flushes: " << options.max_background_flushes
<< "\n max_background_compactions: " << options.max_background_compactions
<< "\n sim_cache: " << options.sim_cache
<< "\n cache_size: " << options.cache_size
<< "\n block_size: " << options.block_size
<< "\n compaction_readahead_size: " << options.compaction_readahead_size
<< "\n max_bytes_for_level_base: " << options.max_bytes_for_level_base
<< "\n max_bytes_for_level_multiplier: " << options.max_bytes_for_level_multiplier
<< "\n target_file_size_base: " << options.target_file_size_base
<< "\n level0_file_num_compaction_trigger: " << options.level0_file_num_compaction_trigger
<< "\n level0_slowdown_writes_trigger: " << options.level0_slowdown_writes_trigger
<< "\n level0_stop_writes_trigger: " << options.level0_stop_writes_trigger
<< "\n upstream_ip: " << options.upstream_ip
<< "\n upstream_port: " << options.upstream_port
<< "\n c: " << options.c;
return os;
}
| 40.644928 | 106 | 0.68818 | TimothyZhang023 |
9db2d549a8c03a24537d80ccf1aa48a3217c0913 | 158 | hpp | C++ | src/calculator/include/calculator/calculator_api.hpp | d8euAI8sMs/qa-1-all | f38c282b6c7548373342e03635e9d4673e3eff0b | [
"Apache-2.0"
] | null | null | null | src/calculator/include/calculator/calculator_api.hpp | d8euAI8sMs/qa-1-all | f38c282b6c7548373342e03635e9d4673e3eff0b | [
"Apache-2.0"
] | null | null | null | src/calculator/include/calculator/calculator_api.hpp | d8euAI8sMs/qa-1-all | f38c282b6c7548373342e03635e9d4673e3eff0b | [
"Apache-2.0"
] | null | null | null | #pragma once
#ifdef CALCULATOR_EXPORTS
# define CALCULATOR_API __declspec(dllexport)
#else
# define CALCULATOR_API __declspec(dllimport)
#endif
| 19.75 | 49 | 0.759494 | d8euAI8sMs |
9db4d4ca68b95b225a772780b6e8605f49c10d1f | 24,287 | cpp | C++ | src/num_put.cpp | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | src/num_put.cpp | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | src/num_put.cpp | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | /***************************************************************************
*
* num_put.cpp
*
* $Id: //stdlib/dev/source/stdlib/num_put.cpp#51 $
*
***************************************************************************
*
* Copyright (c) 1994-2005 Quovadx, Inc., acting through its Rogue Wave
* Software division. Licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0. Unless required by
* applicable law or agreed to in writing, software distributed under
* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License
* for the specific language governing permissions and limitations under
* the License.
*
**************************************************************************/
#define _RWSTD_LIB_SRC
#include <rw/_defs.h>
#ifndef _RWSTD_NO_V3_LOCALE
#include <limits> // for numeric_limits
#include <stdio.h> // for snprintf()
#include <string.h> // for memmove(), memset()
#include <loc/_num_put.h>
#include "strtol.h" // for __rw_digit_map
#ifndef _RWSTD_NO_SNPRINTF
// cast away constness of the format argument to prevent errors
// on platforms such as HP-UX 11.00 that incorrectly declare it
// without the const qualifier
# define _SNPRINTF(buf, size, fmt, arg) \
snprintf (buf, size, _RWSTD_CONST_CAST (char*, fmt), arg)
#else // _RWSTD_NO_SNPRINTF
# ifndef _RWSTD_NO_SNPRINTF_IN_LIBC
# undef snprintf
# define snprintf _RWSTD_LIBC_SYM (snprintf)
# define _SNPRINTF(buf, size, fmt, arg) snprintf (buf, size, fmt, arg)
extern "C" {
_RWSTD_DLLIMPORT int
snprintf (char*, _RWSTD_SIZE_T, const char*, ...) _LIBC_THROWS ();
} // extern "C"
# else // if defined (_RWSTD_NO_SNPRINTF_IN_LIBC)
# define _SNPRINTF(buf, ignore, fmt, arg) sprintf (buf, fmt, arg)
# endif // _RWSTD_NO_SNPRINTF_IN_LIBC
#endif // _RWSTD_NO_SNPRINTF
_RWSTD_NAMESPACE (__rw) {
static const char __rw_digits[] =
"0123456789abcdefghijklmnopqrstuvwxyz"
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char*
__rw_get_stdio_fmat (char buf [32], int type, unsigned fmtflags, int prec);
#ifdef _RWSTD_LONG_LONG
typedef _RWSTD_LONG_LONG _LLong;
typedef unsigned _RWSTD_LONG_LONG _ULLong;
static _RWSTD_SIZE_T
__rw_btoa (char *buf, _ULLong i, unsigned base)
{
_RWSTD_ASSERT (base && base <= 36);
const _RWSTD_SIZE_T dig = _STD::numeric_limits<_ULLong>::digits + 0U;
char* end = buf + dig;
const char* const begin = end;
_ULLong tmp;
do {
tmp = i / base;
// PA RISC has no integer divide, optimize the modulo operator
// this is also faster than computing the modulo on i86, and
// faster than calling ldiv()
*--end = __rw_digits [i - tmp * base];
} while ((i = tmp));
const _RWSTD_SIZE_T len = begin - end;
memmove (buf, end, len);
return len;
}
static _RWSTD_SIZE_T
__rw_dtoa (char *buf, _ULLong i, unsigned flags)
{
// get the maximum number of decimal digits for an unsigned long
// with the largest magnitude, plus 1 for the (optional) sign
const _RWSTD_SIZE_T dig10 = _STD::numeric_limits<_ULLong>::digits10 + 2U;
char* end = buf + dig10;
const char* const begin = end;
_ULLong tmp;
do {
tmp = i / 10;
// PA RISC has no integer divide, optimize the modulo operator
// this is also faster than computing the modulo on i86, and
// faster than calling ldiv()
*--end = __rw_digits [i - tmp * 10];
} while ((i = tmp));
if (flags & _RWSTD_IOS_SHOWPOS)
*--end = '+';
const _RWSTD_SIZE_T len = begin - end;
memmove (buf, end, len);
return len;
}
static inline _RWSTD_SIZE_T
__rw_dtoa (char *buf, _LLong i, unsigned flags)
{
if (i < 0) {
flags &= ~_RWSTD_IOS_SHOWPOS;
*buf++ = '-';
return 1 + __rw_dtoa (buf, _RWSTD_STATIC_CAST (_ULLong, -i), flags);
}
return __rw_dtoa (buf, _RWSTD_STATIC_CAST (_ULLong, i), flags);
}
static _RWSTD_SIZE_T
__rw_itoa (char *buf, _ULLong i, unsigned flags)
{
const char* const pdigs = flags & _RWSTD_IOS_UPPERCASE ?
__rw_digits + 36 : __rw_digits;
const _LLong base = (flags >> _RWSTD_IOS_BASEOFF) - _LLong (1);
int bits;
char *end = buf;
switch (base) {
case 1: bits = 1; break;
case 3: bits = 2; break;
case 7:
bits = 3;
if (i && flags & _RWSTD_IOS_SHOWBASE)
*end++ = '0';
break;
case 9:
return __rw_dtoa (end, i, flags);
case 15:
bits = 4;
if (i && flags & _RWSTD_IOS_SHOWBASE) {
*end++ = '0';
*end++ = pdigs [33]; // 'X' or 'x'
}
break;
case 31: bits = 5; break;
default:
_RWSTD_ASSERT (base >= 0 && base <= _RWSTD_UINT_MAX);
return __rw_btoa (buf, i, unsigned (base));
}
// maximum number of base-digits
const int digits =
(_STD::numeric_limits<_ULLong>::digits + bits - 1) / bits;
int j;
// skip leading zeros
if (i) {
for (j = digits - 1; j && !(i & (base << j * bits)); --j);
}
else
j = 0;
// format the remaining digits
do {
const int dig = int ((i & (base << j * bits)) >> j * bits);
_RWSTD_ASSERT (dig >= 0 && dig < 36);
*end++ = pdigs [dig];
} while (j--);
return end - buf;
}
static inline _RWSTD_SIZE_T
__rw_itoa (char *buf, _LLong i, unsigned flags)
{
if (10 == flags >> _RWSTD_IOS_BASEOFF)
return __rw_dtoa (buf, i, flags);
return __rw_itoa (buf, _RWSTD_STATIC_CAST (_ULLong, i), flags);
}
#endif // _RWSTD_LONG_LONG
static _RWSTD_SIZE_T
__rw_btoa (char *buf, unsigned long i, unsigned base)
{
_RWSTD_ASSERT (base && base <= 36);
const _RWSTD_SIZE_T dig = _STD::numeric_limits<unsigned long>::digits + 0U;
char* end = buf + dig;
const char* const begin = end;
unsigned long tmp;
do {
tmp = i / base;
// PA RISC has no integer divide, optimize the modulo operator
// this is also faster than computing the modulo on i86, and
// faster than calling ldiv()
*--end = __rw_digits [i - tmp * base];
} while ((i = tmp));
const _RWSTD_SIZE_T len = begin - end;
memmove (buf, end, len);
return len;
}
static inline _RWSTD_SIZE_T
__rw_dtoa (char *buf, unsigned long i, unsigned flags)
{
// get the maximum number of decimal digits for an unsigned long
// with the largest magnitude, plus 1 for the (optional) sign
const _RWSTD_SIZE_T dig10 =
_STD::numeric_limits<unsigned long>::digits10 + 2U;
char* end = buf + dig10;
const char* const begin = end;
unsigned long tmp;
do {
tmp = i / 10;
// PA RISC has no integer divide, optimize the modulo operator
// this is also faster than computing the modulo on i86, and
// faster than calling ldiv()
*--end = __rw_digits [i - tmp * 10];
} while ((i = tmp));
// prepend a sign if necessary
if (flags & _RWSTD_IOS_SHOWPOS)
*--end = '+';
// move the contents of the buffer to the beginning
const _RWSTD_SIZE_T len = begin - end;
memmove (buf, end, len);
return len;
}
static inline _RWSTD_SIZE_T
__rw_dtoa (char *buf, long i, unsigned flags)
{
if (i < 0) {
flags &= ~_RWSTD_IOS_SHOWPOS;
*buf++ = '-';
return 1 + __rw_dtoa (buf, _RWSTD_STATIC_CAST (unsigned long, -i),
flags);
}
return __rw_dtoa (buf, _RWSTD_STATIC_CAST (unsigned long, i), flags);
}
// convert unsigned long to a roman number
static _RWSTD_SIZE_T
__rw_utor (char *buf, unsigned long i, unsigned flags)
{
// 01234560123456
static const char lit [] = "ivxlcdmIVXLCDM";
if (0 == i || i > 4999)
return __rw_dtoa (buf, i, flags);
const char* const pdigs = flags & _RWSTD_IOS_UPPERCASE ? lit + 7 : lit;
const char *begin = buf;
for (; i >= 1000; i -= 1000)
*buf++ = pdigs [6]; // 'M'
for (unsigned long j = 0, ord = 100; j != 6; j += 2, ord /= 10) {
unsigned long fact;
if (i >= (fact = 9 * ord)) {
*buf++ = pdigs [4 - j]; // {C,X,I}
*buf++ = pdigs [6 - j]; // {M,C,X}
i -= fact;
}
else if (i >= (fact = 5 * ord)) {
*buf++ = pdigs [5 - j]; // {D,L,V}
for (i -= fact; i >= ord; i -= ord)
*buf++ = pdigs [4 - j]; // {C,X,I}
}
else if (i >= (fact = 4 * ord)) {
*buf++ = pdigs [4 - j]; // {C,X,I}
*buf++ = pdigs [5 - j]; // {D,L,V}
i -= fact;
}
else {
for (; i >= ord; i -= ord)
*buf++ = pdigs [4 - j]; // {C,X,I}
}
}
return buf - begin;
}
static _RWSTD_SIZE_T
__rw_itoa (char *buf, unsigned long i, unsigned flags)
{
const char* const pdigs = flags & _RWSTD_IOS_UPPERCASE ?
__rw_digits + 36 : __rw_digits;
const int basemask = (flags >> _RWSTD_IOS_BASEOFF) - 1;
int bits;
char *end = buf;
switch (basemask) {
case -1: case 9:
return __rw_dtoa (end, i, flags);
case 0:
return __rw_utor (end, i, flags);
case 1: bits = 1; break;
case 3: bits = 2; break;
case 7:
bits = 3;
if (i && flags & _RWSTD_IOS_SHOWBASE)
*end++ = '0';
break;
case 15:
bits = 4;
if (i && flags & _RWSTD_IOS_SHOWBASE) {
*end++ = '0';
*end++ = pdigs [33]; // 'X' or 'x'
}
break;
case 31:
bits = 5; break;
default:
return __rw_btoa (buf, i, basemask + 1);
}
int j;
// skip leading zeros
if (i) {
// maximum number of digits in the given base (basemask + 1)
const int digits =
(_STD::numeric_limits<unsigned long>::digits + bits - 1) / bits;
for (j = digits - 1; !(i & (long (basemask) << j * bits)); --j);
}
else
j = 0;
do {
const int dig = (i >> (j * bits)) & basemask;
_RWSTD_ASSERT (dig >= 0 && dig <= basemask);
*end++ = pdigs [dig];
} while (j--);
return end - buf;
}
static inline _RWSTD_SIZE_T
__rw_itoa (char *buf, long i, unsigned flags)
{
if (10 == flags >> _RWSTD_IOS_BASEOFF)
return __rw_dtoa (buf, i, flags);
return __rw_itoa (buf, _RWSTD_STATIC_CAST (unsigned long, i), flags);
}
_RWSTD_EXPORT _RWSTD_SIZE_T
__rw_put_groups (char **pbuf, _RWSTD_SIZE_T len, _RWSTD_SIZE_T bufsize,
const char *end, const char *grouping)
{
_RWSTD_ASSERT (0 != *pbuf);
_RWSTD_ASSERT (0 != grouping);
_RWSTD_UNUSED (bufsize);
if (end) {
// for floats, find the decimal point or one of { 'e', 'E' }
end = strchr (*pbuf, '.');
if (!end) {
// try the comma in case sprintf() was used after
// a call setlocale() that changed '.' to ','
end = strchr (*pbuf, ',');
if (!end)
end = strpbrk (*pbuf, "Ee");
}
}
if (!end) {
// no decimal point for all other types
end = *pbuf + len;
}
typedef unsigned char UChar;
char *pd = *pbuf; // pointer to the integral part (past any prefix)
if (43 /* '-' or '+' */ == __rw_digit_map [UChar (*pd)])
++pd;
else if ('0' == *pd) {
++pd;
if (33 /* 'X' or 'x' */ == __rw_digit_map [UChar (*pd)])
++pd;
}
_RWSTD_SIZE_T ngrps = 0; // number of complete groups
_RWSTD_SIZE_T grplen = 0; // length of complete groups
// compute the amount of buffer space needed for group separators
const char *pg = grouping;
for ( ; ; ++ngrps) {
UChar grp = UChar (*pg);
if (0 == grp) {
// '\0' causes the last grouping to be repeated
grp = UChar (pg [-1]);
}
else if (_RWSTD_CHAR_MAX == grp) {
// _RWSTD_CHAR_MAX terminates the grouping algorithm
break;
}
else
++pg;
if (grplen + grp >= _RWSTD_STATIC_CAST (_RWSTD_SIZE_T, end - pd))
break;
grplen += grp;
}
pg = grouping; // reset to point to the first grouping
end += ngrps; // adjust the new position of the decimal point
len += ngrps; // adjust the length of buffer
grplen = *pg++; // length of the first grouping
const bool no_groups = '\0' == **pbuf;
// copy buffer onto itself starting with the rightmost digit,
// inserting thousands_sep placeholders (';') according to
// `grouping' in the integral portion of the number
// using ';' rather than ',' to prevent potential collisions
// with a comma inserted by sprintf() in some locales
for (pd = *pbuf + (len - 1); pd != *pbuf && ngrps; --pd) {
if (pd >= end) {
// copy the fractional part (if any) of the number
*pd = pd [-_RWSTD_STATIC_CAST (_RWSTD_PTRDIFF_T, ngrps)];
}
else {
if ((_RWSTD_SIZE_T)(end - pd) == grplen + 1) {
// insert throusands separator and compute
// the offset of the next separator
*pd = ';';
--ngrps;
if (_RWSTD_CHAR_MAX == *pg)
break;
// '\0' forces the repetition of the last grouping
grplen += (*pg ? *pg++ : pg [-1]) + 1;
}
else {
// copy the integral part
*pd = pd [-_RWSTD_STATIC_CAST (_RWSTD_PTRDIFF_T, ngrps)];
}
}
}
if (no_groups) {
pd = *pbuf;
// replace each group including the thousands_sep placeholder
// in the buffer with its size
for (char *ps = *pbuf, *last = *pbuf; ; ++pd) {
if (pd == *pbuf + len) {
// append the size of the last group, set `len', and break
*ps++ = char (pd - last);
len = ps - *pbuf;
break;
}
if (';' == *pd) {
// replace group with it size
*ps++ = char (pd - last);
last = pd + 1;
}
}
}
return len;
}
static inline void
__rw_fix_flt (char *&end, _RWSTD_SIZE_T &len, unsigned flags)
{
#if defined (_WIN32) || defined (_WIN64)
if (len > 5) {
// make Win32 output conform to C99 printf() requirements
// on the exponent: The exponent always contains at least
// two digits, and only as many more digits as necessary
// to represent the exponent.
if (('e' == end [-5] || 'E' == end [-5]) && '0' == end [-3]) {
end [-3] = end [-2];
end [-2] = end [-1];
--len;
--end;
}
else if ('#' == end [-4]) {
// normalize the format of infinity to conform to C99
const char str[] = "iInNfF";
const bool cap = !!(flags & _RWSTD_IOS_UPPERCASE);
end [-6] = str [cap + 0];
end [-5] = str [cap + 2];
end [-4] = str [cap + 4];
end -= 3;
len -= 3;
}
else if ('#' == end [-5]) {
// normalize the format of NaN to conform to C99
const char str[] = "nNaA";
const bool cap = !!(flags & _RWSTD_IOS_UPPERCASE);
end [-7] = str [cap + 0];
end [-6] = str [cap + 2];
end [-5] = str [cap + 0];
end -= 4;
len -= 4;
}
}
#else
// normalize the format of infinity and NaN to one of
// { INF, inf, NAN, nan, NANQ, nanq, NANS, nans }
// for portability
char* beg = end - len;
typedef unsigned char UChar;
if (43 /* '+' or '-' */ == __rw_digit_map [UChar (*beg)])
++beg;
const char* pstr;
switch (__rw_digit_map [UChar (*beg)]) {
case 18 /* 'I' or 'i' */ : pstr = "iInNfF\0\0"; break;
case 23 /* 'N' or 'n' */ : {
// distinguish between quiet and signaling NaN
// FIXME: do this portably, regardless of printf output
// (some libc, such as Solaris, output the same string
// for both quiet and signaling NaN; others, such as
// AIX, output NaNQ and NaNS, respectively)
const UChar last = __rw_digit_map [UChar (*(end - 1))];
if (26 /* 'Q' or 'q' */ == last)
pstr = "nNaAnNqQ";
else if (28 /* 'S' or 's' */ == last)
pstr = "nNaAnNsS";
else
pstr = "nNaAnN\0\0";
break;
}
default:
return;
}
const bool cap = !!(flags & _RWSTD_IOS_UPPERCASE);
beg [0] = pstr [cap + 0];
beg [1] = pstr [cap + 2];
beg [2] = pstr [cap + 4];
beg [3] = pstr [cap + 6];
beg [4] = '\0';
end = beg + 3 + ('0' != beg [3]);
#endif // _WIN{32,64}
}
_RWSTD_EXPORT _RWSTD_SIZE_T
__rw_put_num (char **pbuf, _RWSTD_SIZE_T bufsize,
unsigned flags, int type, _RWSTD_STREAMSIZE prec,
const void *pval, const char *grouping)
{
char fmtbuf [32]; // buffer for stdio format specifier
const char *fmt = 0; // stdio format specifier
char* const buf = *pbuf; // saved value of *pbuf
char *end = 0; // decimal point
_RWSTD_SIZE_T len; // length of formatted number
_RWSTD_STREAMSIZE fpr; // special case floating point precision
typedef _RWSTD_SIZE_T SizeT;
switch (type) {
case __rw_facet::_C_bool:
if (flags & _RWSTD_IOS_BOOLALPHA) {
// no output
len = 0;
*buf = '\0';
break;
}
// else fall through...
case __rw_facet::_C_short:
case __rw_facet::_C_int:
case __rw_facet::_C_long:
len = __rw_itoa (buf, _RWSTD_REINTERPRET_CAST (long, pval), flags);
break;
case __rw_facet::_C_ushort:
case __rw_facet::_C_uint:
case __rw_facet::_C_ulong:
// unsigned output behaves analogously printf() with %u
// note that the plus in "%+u" is meaningless (i.e., the
// sign is only used in signed conversions; 7.19 6.1, p6
// of C99: The result of a signed conversion always begins
// with a plus or minus sign.)
len = __rw_itoa (buf, _RWSTD_REINTERPRET_CAST (unsigned long, pval),
flags & ~_RWSTD_IOS_SHOWPOS);
break;
#ifdef _RWSTD_LONG_LONG
case __rw_facet::_C_llong:
len = __rw_itoa (buf, *(const _LLong*)pval, flags);
break;
case __rw_facet::_C_ullong:
len = __rw_itoa (buf, *(const _ULLong*)pval,
flags & ~_RWSTD_IOS_SHOWPOS);
break;
#endif // _RWSTD_LONG_LONG
case __rw_facet::_C_float | __rw_facet::_C_ptr:
fpr = prec < 0 && flags & _RWSTD_IOS_FIXED ? 0 : prec;
fmt = __rw_get_stdio_fmat (fmtbuf, type & ~__rw_facet::_C_ptr,
flags, fpr);
for (; ;) {
len = SizeT (_SNPRINTF (*pbuf, bufsize, fmt,
*(const float*)pval));
if (len >= bufsize) {
if (*pbuf != buf)
delete[] *pbuf;
*pbuf = new char [bufsize = len + 1 ? len + 1 : bufsize * 2];
}
else {
_RWSTD_ASSERT (len > 0);
break;
}
}
end = *pbuf + len;
// fix up output to conform to C99
__rw_fix_flt (end, len, flags);
break;
case __rw_facet::_C_double | __rw_facet::_C_ptr:
fpr = prec < 0 && flags & _RWSTD_IOS_FIXED ? 0 : prec;
fmt = __rw_get_stdio_fmat (fmtbuf, type & ~__rw_facet::_C_ptr,
flags, fpr);
for ( ; ; ) {
len = SizeT (_SNPRINTF (*pbuf, bufsize, fmt,
*(const double*)pval));
if (len >= bufsize) {
if (*pbuf != buf)
delete[] *pbuf;
*pbuf = new char [bufsize = len + 1 ? len + 1 : bufsize * 2];
}
else {
_RWSTD_ASSERT (len > 0);
break;
}
}
end = *pbuf + len;
// fix up output to conform to C99
__rw_fix_flt (end, len, flags);
break;
#ifndef _RWSTD_NO_LONG_DOUBLE
case __rw_facet::_C_ldouble | __rw_facet::_C_ptr:
fpr = prec < 0 && flags & _RWSTD_IOS_FIXED ? 0 : prec;
fmt = __rw_get_stdio_fmat (fmtbuf, type & ~__rw_facet::_C_ptr,
flags, fpr);
for ( ; ; ) {
len = SizeT (_SNPRINTF (*pbuf, bufsize, fmt,
*(const long double*)pval));
if (len >= bufsize) {
if (*pbuf != buf)
delete[] *pbuf;
*pbuf = new char [bufsize = len + 1 ? len + 1 : bufsize * 2];
}
else {
_RWSTD_ASSERT (len > 0);
break;
}
}
end = *pbuf + len;
// fix up output to conform to C99
__rw_fix_flt (end, len, flags);
break;
#endif // _RWSTD_NO_LONG_DOUBLE
case __rw_facet::_C_pvoid:
if (pval) {
fmt = __rw_get_stdio_fmat (fmtbuf, type, flags, prec);
len = SizeT (_SNPRINTF (buf, bufsize, fmt, pval));
}
else {
// prevent GNU libc from formatting null pointers as "(nil)"
*buf = '0';
len = 1;
}
// prevent grouping
grouping = "";
break;
default:
_RWSTD_ASSERT (!"logic error: bad type");
len = 0; // silence used before initialized warnings
}
if (prec < 0 && flags & _RWSTD_IOS_FIXED) {
// extension: when ios::fixed is set, negative precision inserts
// a decimal_point placeholder `prec' positions before the least
// significant digit
const bool sign = '-' == **pbuf || '+' == **pbuf;
char* const beg = *pbuf + sign;
char *src; // first of the digits to move
char *dst; // where to move the first digit
char *dp; // where to insert the decimal point
const _RWSTD_PTRDIFF_T ndigs = len - sign;
_RWSTD_SIZE_T nfill; // the number of 0's to insert
_RWSTD_SIZE_T nmove; // the number of digits to move
if (-prec >= ndigs) {
// insert 0's in addition to the decimal point
// e.g., "1234" with prec == -6 yields "0.01234"
nmove = ndigs;
nfill = -prec - ndigs + 2;
dst = beg + nfill;
src = beg;
dp = beg + 1;
// adjust the length of the block
len += nfill;
}
else {
// insert decimal point into the string of digits
// e.g., "1234" with prec == -3 yields "1.234"
nfill = 0;
nmove = SizeT (-prec);
src = beg + (ndigs + prec);
dst = src + 1;
dp = src;
++len; // grow the length
}
// move a block of digits to make room for 0's, if any,
// and the decimal point placeholder
memmove (dst, src, nmove);
memset (beg, '0', nfill);
*dp = '.';
end = *pbuf + len;
}
// insert commas as thousands separators if grouping is required
// integral and floating point types only (i.e., not for pointers)
if (len > 1 && *grouping && _RWSTD_CHAR_MAX != *grouping)
len = __rw_put_groups (pbuf, len, bufsize, end, grouping);
// verify that the buffer hasn't overrun
_RWSTD_ASSERT (len <= bufsize);
return len;
}
} // namespace __rw
#endif // _V3_LOCALE
| 27.015573 | 79 | 0.522008 | Hower91 |
9db5d96ce4a0177c662802a648dabfd39065bd42 | 953 | hpp | C++ | aligned_deleter.hpp | nyamadan/hello_embree | 8ea086fb1a10e0e025fbd3ab45cbea281146162b | [
"MIT"
] | null | null | null | aligned_deleter.hpp | nyamadan/hello_embree | 8ea086fb1a10e0e025fbd3ab45cbea281146162b | [
"MIT"
] | null | null | null | aligned_deleter.hpp | nyamadan/hello_embree | 8ea086fb1a10e0e025fbd3ab45cbea281146162b | [
"MIT"
] | null | null | null | #pragma once
#ifdef _WIN32
#define aligned_alloc _aligned_malloc
#define aligned_free _aligned_free
#else
#define aligned_free free
#endif
template <typename T = void>
struct AlignedDeleter {
constexpr AlignedDeleter() noexcept = default;
template <typename U,
typename std::enable_if<std::is_convertible<U *, T *>::value,
std::nullptr_t>::type = nullptr>
AlignedDeleter(const AlignedDeleter<U> &) noexcept {}
void operator()(T *ptr) const { aligned_free(ptr); }
};
template <typename T>
struct AlignedDeleter<T[]> {
constexpr AlignedDeleter() noexcept = default;
template <typename U, typename std::enable_if<
std::is_convertible<U (*)[], T (*)[]>::value,
std::nullptr_t>::type = nullptr>
AlignedDeleter(const AlignedDeleter<U[]> &) noexcept {}
void operator()(T *ptr) const { aligned_free(ptr); }
};
| 28.878788 | 75 | 0.625393 | nyamadan |
9dbe2bfffe2b971bb770bf6d6ff43582d8f7c136 | 625 | cpp | C++ | mogupro/game/src/Network/Packet/Request/cReqInRoom.cpp | desspert/mogupro | ac39f5ec3fb670cf5044ef501951270d7d92a748 | [
"MIT"
] | null | null | null | mogupro/game/src/Network/Packet/Request/cReqInRoom.cpp | desspert/mogupro | ac39f5ec3fb670cf5044ef501951270d7d92a748 | [
"MIT"
] | null | null | null | mogupro/game/src/Network/Packet/Request/cReqInRoom.cpp | desspert/mogupro | ac39f5ec3fb670cf5044ef501951270d7d92a748 | [
"MIT"
] | null | null | null | #include <Network/Packet/Request/cReqInRoom.h>
namespace Network
{
namespace Packet
{
namespace Request
{
cReqInRoom::cReqInRoom( ) : mRoomID(-1), mNetworkHandle("",0)
{
}
cReqInRoom::cReqInRoom( int roomID) : mRoomID(roomID), mNetworkHandle("", 0)
{
}
void cReqInRoom::packetImport(cNetworkHandle networkHandle, ubyte2 transferredBytes, char const* const data)
{
mNetworkHandle = networkHandle;
int offset = 0;
importInt(mRoomID, data, offset, 4);
}
ubyte2 cReqInRoom::packetExport( char* const data )
{
int offset = 0;
exportInt(mRoomID, data, offset, 4);
return offset;
}
}
}
} | 18.382353 | 109 | 0.6912 | desspert |
9dbf62bca53512b2875882d6d2c16a8984519c73 | 2,390 | cpp | C++ | source/xinput/State.cpp | HeavenWu/slimdx | e014bb34b89bbf694d01c8f6d6b6dfa3cba58aac | [
"MIT"
] | 85 | 2015-04-06T05:37:10.000Z | 2022-03-22T19:53:03.000Z | source/xinput/State.cpp | HeavenWu/slimdx | e014bb34b89bbf694d01c8f6d6b6dfa3cba58aac | [
"MIT"
] | 10 | 2016-03-17T11:18:24.000Z | 2021-05-11T09:21:43.000Z | source/xinput/State.cpp | HeavenWu/slimdx | e014bb34b89bbf694d01c8f6d6b6dfa3cba58aac | [
"MIT"
] | 45 | 2015-09-14T03:54:01.000Z | 2022-03-22T19:53:09.000Z | #include "stdafx.h"
/*
* Copyright (c) 2007-2012 SlimDX Group
*
* 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 <windows.h>
#include <xinput.h>
#include "State.h"
using namespace System;
namespace SlimDX
{
namespace XInput
{
State::State( const XINPUT_STATE& native )
{
m_PacketNumber = native.dwPacketNumber;
m_Gamepad = XInput::Gamepad( native.Gamepad );
}
UInt32 State::PacketNumber::get()
{
return m_PacketNumber;
}
XInput::Gamepad State::Gamepad::get()
{
return m_Gamepad;
}
bool State::operator == ( State left, State right )
{
return State::Equals( left, right );
}
bool State::operator != ( State left, State right )
{
return !State::Equals( left, right );
}
int State::GetHashCode()
{
return m_PacketNumber.GetHashCode() + m_Gamepad.GetHashCode();
}
bool State::Equals( Object^ value )
{
if( value == nullptr )
return false;
if( value->GetType() != GetType() )
return false;
return Equals( safe_cast<State>( value ) );
}
bool State::Equals( State value )
{
return ( m_PacketNumber == value.m_PacketNumber && m_Gamepad == value.m_Gamepad );
}
bool State::Equals( State% value1, State% value2 )
{
return ( value1.m_PacketNumber == value2.m_PacketNumber && value1.m_Gamepad == value2.m_Gamepad );
}
}
} | 27.471264 | 101 | 0.694561 | HeavenWu |
9dc0fb56db281e46a4cffc6ea3ff0240f52dba03 | 2,904 | hh | C++ | src/interface/menus/Menu.hh | zermingore/warevolved | efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52 | [
"MIT"
] | 1 | 2019-09-23T18:16:27.000Z | 2019-09-23T18:16:27.000Z | src/interface/menus/Menu.hh | zermingore/warevolved | efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52 | [
"MIT"
] | 2 | 2018-11-12T18:48:03.000Z | 2018-11-15T21:10:02.000Z | src/interface/menus/Menu.hh | zermingore/warevolved | efd0c506658ce6e4ecb6c7eb5bb7d620bc05fd52 | [
"MIT"
] | null | null | null | /**
* \file
* \date July 24, 2013
* \author Zermingore
* \namespace interface
* \brief Interface generic Menu class declaration
*/
#ifndef MENU_HH_
# define MENU_HH_
# include <cstddef>
# include <memory>
# include <vector>
# include <interface/menus/MenuEntry.hh>
# include <interface/InterfaceElement.hh>
enum class e_state;
namespace graphics {
class Sprite;
}
namespace interface {
class MenuEntry;
}
namespace interface {
/**
* \class Menu
* \brief Generic Menu (abstract class)
* \note Mother of InGameMenu class
*/
class Menu: public InterfaceElement
{
public:
/**
* \brief Default constructor. Initializes the graphic attributes
*/
Menu();
/**
* \brief increments _selectedEntry modulo number of Entries
* \note Allow cycling
*/
void incrementSelectedEntry() { ++_selectedEntry %= _entries.size(); }
/**
* \brief decrements _selectedEntry modulo _nbEntries
* allowing cycling
*/
void decrementSelectedEntry();
/**
* \brief sets origin menu to the right cursor relative position
* \todo set the menu at optimal position
*/
virtual void setOrigin(const Coords origin);
/**
* \brief draws the menu its entries and the current entry highlighter
*/
void draw() override;
/**
* \brief sets _selectedEntry to 0
*/
void resetSelectedEntry() { _selectedEntry = 0; }
/**
* \brief builds the selection menu, filling _entries
*/
virtual void build() = 0;
/**
* \brief Move the selection cursor up
*/
virtual void moveUp() {}
/**
* \brief Move the selection cursor down
*/
virtual void moveDown() {}
/**
* \brief Move the selection cursor to the left
*/
virtual void moveLeft() {}
/**
* \brief Move the selection cursor to the right
*/
virtual void moveRight() {}
/**
* \brief executes action matching _selectedEntry
*/
virtual void validate() = 0;
/**
* \brief Resume the current menu
* as a default behavior, updates the cursor coordinates to the menu ones
*/
virtual void resume();
/**
* \brief list of entries getter
* \return a pointer over _entries array
* \note this function is used to retrieve
* informations from menu stack (see Status class)
*/
auto getEntries() const { return _entries; }
/**
* \brief selected entry getter
* \return current selected entry
* \note this function is used to retrieve
* informations from menu stack (see Status class)
*/
size_t selectedEntry() { return _selectedEntry; }
protected:
std::vector<std::shared_ptr<MenuEntry>> _entries; ///< Entries list
Coords _origin; ///< menu origin
/// Current selected entry (the first entry [index 0], is at the bottom)
size_t _selectedEntry;
/// Emphasis of the selected entry
std::shared_ptr<graphics::Sprite> _imageSelection;
};
} // namespace interface
#endif /* !MENU_HH_ */
| 20.450704 | 77 | 0.6677 | zermingore |
e38393c3be27182c5c77a7be5eadb150abb128ae | 575 | cpp | C++ | CodeFights/areSimilarNumbers.cpp | AREA44/competitive-programming | 00cede478685bf337193bce4804f13c4ff170903 | [
"MIT"
] | null | null | null | CodeFights/areSimilarNumbers.cpp | AREA44/competitive-programming | 00cede478685bf337193bce4804f13c4ff170903 | [
"MIT"
] | null | null | null | CodeFights/areSimilarNumbers.cpp | AREA44/competitive-programming | 00cede478685bf337193bce4804f13c4ff170903 | [
"MIT"
] | null | null | null | // Call two integers a and b similar if divisor divides both a and b or if it doesn't divide either.
// Given integers a, b and divisor, check if a and b are similar.
// Example
// * For a = 10, b = 12 and divisor = 2, the output should be
// areSimilarNumbers(a, b, divisor) = true;
// * For a = 10, b = 12 and divisor = 3, the output should be
// areSimilarNumbers(a, b, divisor) = false.
bool areSimilarNumbers(int a, int b, int divisor) {
if (a % divisor == 0 && b % divisor == 0
|| a % divisor != 0 && b % divisor != 0) {
return true;
}
return false;
}
| 35.9375 | 100 | 0.631304 | AREA44 |
e3844b4222588524f57b083c73956587df693b88 | 1,857 | hpp | C++ | ares/ngp/system/system.hpp | CasualPokePlayer/ares | 58690cd5fc7bb6566c22935c5b80504a158cca29 | [
"BSD-3-Clause"
] | 153 | 2020-07-25T17:55:29.000Z | 2021-10-01T23:45:01.000Z | ares/ngp/system/system.hpp | CasualPokePlayer/ares | 58690cd5fc7bb6566c22935c5b80504a158cca29 | [
"BSD-3-Clause"
] | 245 | 2021-10-08T09:14:46.000Z | 2022-03-31T08:53:13.000Z | ares/ngp/system/system.hpp | CasualPokePlayer/ares | 58690cd5fc7bb6566c22935c5b80504a158cca29 | [
"BSD-3-Clause"
] | 44 | 2020-07-25T08:51:55.000Z | 2021-09-25T16:09:01.000Z | struct System {
Node::System node;
Node::Setting::Boolean fastBoot;
VFS::Pak pak;
Memory::Readable<n8> bios;
struct Controls {
Node::Object node;
Node::Input::Button up;
Node::Input::Button down;
Node::Input::Button left;
Node::Input::Button right;
Node::Input::Button a;
Node::Input::Button b;
Node::Input::Button option;
Node::Input::Button debugger;
Node::Input::Button power;
//controls.cpp
auto load(Node::Object) -> void;
auto poll() -> void;
bool yHold = 0;
bool upLatch = 0;
bool downLatch = 0;
bool xHold = 0;
bool leftLatch = 0;
bool rightLatch = 0;
} controls;
struct Debugger {
System& self;
//debugger.cpp
auto load(Node::Object) -> void;
auto unload(Node::Object) -> void;
struct Memory {
Node::Debugger::Memory bios;
} memory;
} debugger{*this};
enum class Model : u32 { NeoGeoPocket, NeoGeoPocketColor };
auto name() const -> string { return information.name; }
auto model() const -> Model { return information.model; }
auto frequency() const -> f64 { return 6'144'000; }
//system.cpp
auto game() -> string;
auto run() -> void;
auto load(Node::System& node, string name) -> bool;
auto save() -> void;
auto unload() -> void;
auto power(bool reset = false) -> void;
//serialization.cpp
auto serialize(bool synchronize) -> serializer;
auto unserialize(serializer&) -> bool;
private:
struct Information {
string name;
Model model = Model::NeoGeoPocket;
} information;
//serialization.cpp
auto serialize(serializer&, bool synchronize) -> void;
};
extern System system;
auto Model::NeoGeoPocket() -> bool { return system.model() == System::Model::NeoGeoPocket; }
auto Model::NeoGeoPocketColor() -> bool { return system.model() == System::Model::NeoGeoPocketColor; }
| 24.434211 | 102 | 0.64405 | CasualPokePlayer |
e3850ee919679fc9a94b237a1d14cc9d18c465ed | 353 | cpp | C++ | Codeforces/problems/0158/A/158A.cpp | object-oriented-human/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | 2 | 2021-07-27T10:46:47.000Z | 2021-07-27T10:47:57.000Z | Codeforces/problems/0158/A/158A.cpp | foooop/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | null | null | null | Codeforces/problems/0158/A/158A.cpp | foooop/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t=0; cin >> n >> k;
vector<int> v;
for (int i = 0; i < n; i++) {
int x; cin >> x;
v.push_back(x);
}
int score = v[k-1];
for (int i = 0; i < n; i++) {
if (v[i] >= score && v[i] > 0) {
t++;
}
}
cout << t;
} | 16.809524 | 40 | 0.373938 | object-oriented-human |
e3873df1c3a86771969d65c925133c6d637406de | 3,244 | cpp | C++ | massociativearray.cpp | alediaferia/morph-framework | 702b4faba9bf659676f5583bdb6a739ba96ea121 | [
"MIT"
] | null | null | null | massociativearray.cpp | alediaferia/morph-framework | 702b4faba9bf659676f5583bdb6a739ba96ea121 | [
"MIT"
] | null | null | null | massociativearray.cpp | alediaferia/morph-framework | 702b4faba9bf659676f5583bdb6a739ba96ea121 | [
"MIT"
] | null | null | null | #include "massociativearray.h"
class MAssociativeArray::MAssociativeArrayPrivate
{
public:
MAssociativeArrayPrivate(MAssociativeArray *m)
: m(m),
values(MList::alloc())
{}
MAssociativeArrayPrivate(const MAssociativeArrayPrivate& copy)
: m(copy.m),
values(copy.values)
{}
MAssociativeArray *m;
MList::MRef values;
};
MAssociativeArray::MAssociativeArray() : MObject(),
d(new MAssociativeArrayPrivate(this))
{
}
MAssociativeArray::MAssociativeArray(const MAssociativeArray& copy) : MObject(),
d(new MAssociativeArrayPrivate(*copy.d))
{}
MAssociativeArray::~MAssociativeArray()
{}
int MAssociativeArray::size() const
{
return d->values->size();
}
bool MAssociativeArray::hasKey(mref key) const
{
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef pair = it.value();
if (pair->left == key) {
return true;
}
}
return false;
}
void MAssociativeArray::insert(mref key, mref value)
{
d->values->append(MPair::alloc(key, value));
}
mref& MAssociativeArray::operator[](mref key)
{
MList::Iterator it = d->values->begin();
for (; it != d->values->end(); ++it) {
MPair::MRef pair = it.value();
if (pair->left == key) {
return pair->right;
}
}
d->values->append(MPair::alloc(key, mref()));
MPair::MRef &pair = (MPair::MRef&)d->values->operator [](d->values->size() - 1);
return pair->right;
}
mref MAssociativeArray::value(mref key) const
{
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef item = it.value();
if (item->left == key) {
return item->right;
}
}
return mref();
}
MList::MRef MAssociativeArray::values(mref key) const
{
MList::MRef list = MList::alloc();
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef pair = it.value();
if (pair->left == key) {
list->append(pair->right);
}
}
return list;
}
mref MAssociativeArray::pick(mref key)
{
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef pair = it.value();
if (pair->left == key) {
mref data = pair->right;
d->values->remove(it);
return data;
}
}
return mref();
}
MList::MRef MAssociativeArray::pickAll(mref key)
{
MList::MRef list = MList::alloc();
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef pair = it.value();
if (pair->left == key) {
mref data = pair->right;
it = d->values->remove(it);
list->append(data);
}
}
return list;
}
MList::MRef MAssociativeArray::values() const
{
MList::MRef list = MList::alloc();
MList::ConstIterator it = d->values->constBegin();
for (; it != d->values->constEnd(); ++it) {
MPair::MRef pair = it.value();
list->append(pair->right);
}
return list;
}
| 21.202614 | 84 | 0.570284 | alediaferia |
e3897ad230aafa9ec56bf760b871bf13d3866e29 | 3,633 | cpp | C++ | src/xalanc/PlatformSupport/XalanNLSMessageLoader.cpp | kidaa/xalan-c | bb666d0ab3d0a192410823e6857c203d83c27b16 | [
"Apache-2.0"
] | null | null | null | src/xalanc/PlatformSupport/XalanNLSMessageLoader.cpp | kidaa/xalan-c | bb666d0ab3d0a192410823e6857c203d83c27b16 | [
"Apache-2.0"
] | 1 | 2021-08-18T12:32:31.000Z | 2021-08-18T12:32:31.000Z | src/xalanc/PlatformSupport/XalanNLSMessageLoader.cpp | AaronNGray/xalan | 6741bbdcb64a9d33df8bd7e21b558d66bb4292ec | [
"Apache-2.0"
] | null | null | null | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined XALAN_NLS_MSG_LOADER
// Class header file.
#include "XalanNLSMessageLoader.hpp"
#include <xercesc/util/XMLMsgLoader.hpp>
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <cstring>
#include <cerrno>
XALAN_CPP_NAMESPACE_BEGIN
XALAN_USING_XERCES(XMLMsgLoader)
static const char* const MSG_FILE_NAME = "XalanMsg_";
#define MAX_LOCALTION_NAME 1024
static const char* const s_errorMessage = "Message can't be located in the NLS catalog.";
XalanNLSMessageLoader::~XalanNLSMessageLoader()
{
if ((int)m_catalogHandle != -1)
{
catclose(m_catalogHandle);
}
}
XalanNLSMessageLoader::XalanNLSMessageLoader(MemoryManager& theManager) :
m_catalogHandle(nl_catd(-1)),
m_memoryManager(theManager)
{
char fileName[50];
fileName[0] = 0;
sprintf(fileName,"%s", MSG_FILE_NAME);
const char* Locale = XMLMsgLoader::getLocale();
if(Locale == 0)
{
Locale = "en_US";
}
strcat(fileName, Locale);
strcat(fileName, ".cat");
/**
* To open user-specified locale specific cat file
* and default cat file if necessary
*/
m_catalogHandle = catopen(fileName, 0);
if (reinterpret_cast<int>(m_catalogHandle) == -1)
{
// Probably have to call panic here
// the user will get an error with retrieving messages
assert(0);
}
}
bool
XalanNLSMessageLoader::loadMsg(
XalanMessages::Codes msgToLoad
XalanDOMChar* toFill
XalanSize_t maxChars)
{
bool bRetValue = false;
if (toFill == 0 || maxChars == 0)
{
return bRetValue;
}
if (static_cast<int>(m_catalogHandle) == -1)
{
// for transcoding to Unicode
const XalanDOMString errorMsg("Message can't be retrieved: the message catalog is not open.", m_memoryManager );
if(errorMsg.length() < maxChars)
{
XalanCopy(errorMsg.c_str(), errorMsg.c_str()+ errorMsg.length() + 1 , toFill);
}
}
else
{
const char* const catMessage =
catgets(
m_catalogHandle,
1,
static_cast<int>(msgToLoad) + 2,
s_errorMessage);
// catgets returns a pointer to msgString if it fails to locate the message
// from the message catalog
if (catMessage != 0)
{
const XalanDOMString errorMsg(catMessage, m_memoryManager);
if (errorMsg.length() < maxChars)
{
XalanCopy(errorMsg.c_str(), errorMsg.c_str() + errorMsg.length() +1 , toFill);
bRetValue = true;
}
}
}
return bRetValue;
}
XALAN_CPP_NAMESPACE_END
#endif // XALAN_NLS_MSG_LOADER
| 24.883562 | 123 | 0.633911 | kidaa |
e39070ba8786a21dbf4cc08bde2b98a664a0eff9 | 268 | cpp | C++ | noduplicates.cpp | Embrikht/Kattis | bffccda2f0f487dc4dffb3ab3dcb82ed0c7be374 | [
"CC0-1.0"
] | null | null | null | noduplicates.cpp | Embrikht/Kattis | bffccda2f0f487dc4dffb3ab3dcb82ed0c7be374 | [
"CC0-1.0"
] | null | null | null | noduplicates.cpp | Embrikht/Kattis | bffccda2f0f487dc4dffb3ab3dcb82ed0c7be374 | [
"CC0-1.0"
] | null | null | null | #include<bits/stdc++.h>
using namespace std;
int main(){
string s;
set<string> maps;
bool rep = false;
while (cin >> s && !rep){
if (!maps.count(s)) maps.insert(s);
else rep = true;
}
if (rep) cout << "no" << endl;
else cout << "yes" << endl;
return 0;
}
| 16.75 | 37 | 0.578358 | Embrikht |
e39230bf1d7b6bd92b64d4d18d487428f94d9b9d | 1,863 | cpp | C++ | C++/coordinat.cpp | H-M-Noman123/hacktoberfest2021-7 | fcd2c9e440a8146c8a62e1c5cc122d855ed41a12 | [
"MIT"
] | 2 | 2021-12-01T03:35:20.000Z | 2022-02-11T01:10:22.000Z | C++/coordinat.cpp | H-M-Noman123/hacktoberfest2021-7 | fcd2c9e440a8146c8a62e1c5cc122d855ed41a12 | [
"MIT"
] | null | null | null | C++/coordinat.cpp | H-M-Noman123/hacktoberfest2021-7 | fcd2c9e440a8146c8a62e1c5cc122d855ed41a12 | [
"MIT"
] | 1 | 2021-10-17T16:24:21.000Z | 2021-10-17T16:24:21.000Z | #include <iostream>
#include <cmath>
using namespace std;
#define PI 3.1415926
class Polar; // Forward declaration
class Rectangular {
private:
float x, y;
public:
Rectangular() {} // default constructor
Rectangular(float mv_x, float mv_y) {
x = mv_x;
y = mv_y;
}
void showData() const;
Polar rect_to_pol();
float& get_x() {
return x;
}
float& get_y() {
return y;
}
};
void Rectangular::showData() const {
cout << "--Rectangular--" << endl;
cout << "x: " << x << "\t" <<"y: " << y << endl;
}
class Polar {
private:
float r;
float theta;
public:
Polar() {} // default constructor
Polar(float mv_r, float mv_theta) {
r = mv_r;
theta = mv_theta;
}
void showData();
Rectangular pol_to_rect();
float& get_r(){
return r;
}
float& get_theta() {
return theta;
}
};
void Polar::showData() {
cout << "--Polar--" << endl;
cout << "r:" << r << "\t" << "Theta(Radians):" << theta << endl;
}
Rectangular Polar::pol_to_rect() {
Rectangular temp;
temp.get_x() = r * cos(theta*(PI/180.0)); // in degrees
temp.get_y() = r * sin(theta*(PI/180.0));
return temp;
}
Polar Rectangular::rect_to_pol() {
Polar temp;
temp.get_r() = sqrt(pow(x, 2) + pow(y, 2));
temp.get_theta() = atan2(y, x);
return temp;
}
int main()
{
Rectangular r1(-1, -1), r2;
Polar p1(12.0, 30.0), p2;
r1.showData();
p2 = r1.rect_to_pol();
cout << "After Conversion (RECT TO POLAR)->" << endl;
p2.showData();
p1.showData();
r2 = p1.pol_to_rect();
cout << "After Conversion (POLAR TO RECT)" << endl;
r2.showData();
return 0;
} | 19.610526 | 68 | 0.505636 | H-M-Noman123 |
e396bc034641bb84f629d58e945c063bc1940819 | 604 | cpp | C++ | test/mod2/mod2.cpp | FigmentBoy/lilac | f3927d4725c9403a147d7fd38a57ac0da248fcfe | [
"MIT"
] | null | null | null | test/mod2/mod2.cpp | FigmentBoy/lilac | f3927d4725c9403a147d7fd38a57ac0da248fcfe | [
"MIT"
] | null | null | null | test/mod2/mod2.cpp | FigmentBoy/lilac | f3927d4725c9403a147d7fd38a57ac0da248fcfe | [
"MIT"
] | null | null | null | #include "mod2.hpp"
bool __fastcall GJGarageLayer_init(GJGarageLayer* self) {
if (!self->init())
return false;
if (Loader::get()->isModLoaded("com.lilac.test_one")) {
TestMod1::get()->logMessage("Hi from TestMod2");
} else {
TestMod2::get()->log() << "TestMod1 is not loaded :(" << lilac::endl;
}
return true;
}
void TestMod2::setup() {
this->addHook(
gd_base + 0x1255d0,
&GJGarageLayer_init
);
}
TestMod2* TestMod2::get() {
auto g_mod = new TestMod2;
return g_mod;
}
LILAC_LOAD(TestMod2);
| 20.827586 | 78 | 0.566225 | FigmentBoy |
e39a4b3fa52a89658fbd5070a5e23430cf58c5d8 | 1,394 | cc | C++ | tools/generate_math_constants.cc | jpcima/coreutil | 8ec6acec90738919116e71e3a7ea5fe012793ad4 | [
"BSL-1.0"
] | null | null | null | tools/generate_math_constants.cc | jpcima/coreutil | 8ec6acec90738919116e71e3a7ea5fe012793ad4 | [
"BSL-1.0"
] | null | null | null | tools/generate_math_constants.cc | jpcima/coreutil | 8ec6acec90738919116e71e3a7ea5fe012793ad4 | [
"BSL-1.0"
] | null | null | null | #include <boost/multiprecision/gmp.hpp>
#include <boost/format.hpp>
#include <iostream>
namespace mp = boost::multiprecision;
typedef mp::mpf_float_1000 MPFloat;
struct MPConstant {
const char *name {};
const char *expr {};
MPFloat value;
};
int main() {
const MPFloat one(1);
const MPFloat two(2);
const MPFloat ten(10);
const MPFloat e = mp::exp(one);
const MPFloat ln2 = mp::log(two);
const MPFloat ln10 = mp::log(ten);
const MPFloat pi = 4 * mp::atan(one);
const MPFloat sqrtpi = mp::sqrt(pi);
const MPFloat sqrt2 = mp::sqrt(two);
const MPConstant constants[] = {
{"E", "e", e},
{"LOG2E", "log2(e)", mp::log2(e)},
{"LOG10E", "log10(e)", mp::log10(e)},
{"LN2", "log(2)", mp::log(two)},
{"LN10", "log(10)", mp::log(ten)},
{"PI", "pi", pi},
{"2PI", "2*pi", 2 * pi},
{"4PI", "4*pi", 4 * pi},
{"PI_2", "pi/2", pi / 2},
{"PI_4", "pi/4", pi / 4},
{"1_PI", "1/pi", 1 / pi},
{"2_PI", "2/pi", 2 / pi},
{"4_PI", "4/pi", 4 / pi},
{"1_SQRTPI", "1/sqrt(pi)", 1 / sqrtpi},
{"2_SQRTPI", "2/sqrt(pi)", 2 / sqrtpi},
{"SQRT2", "sqrt(2)", sqrt2},
{"1_SQRT2", "1/sqrt(2)", 1 / sqrt2},
};
for (const MPConstant &c: constants) {
std::cout << "#define " <<
boost::format("K_%s%|15t|::coreutil::math_constant(%s)%|85t|// %s\n")
% c.name % (c.value.str(36) + 'L') % c.expr;
}
return 0;
}
| 26.301887 | 77 | 0.533716 | jpcima |
e39b0552cc8f6140e14bab800508515e63019e56 | 908 | hpp | C++ | PnC/NaoPnC/NaoStateMachine/SwingControl.hpp | BharathMasetty/PnC | 3800bd7e3c5dd5ffa00e6a5f09d48d21c405206f | [
"MIT"
] | null | null | null | PnC/NaoPnC/NaoStateMachine/SwingControl.hpp | BharathMasetty/PnC | 3800bd7e3c5dd5ffa00e6a5f09d48d21c405206f | [
"MIT"
] | null | null | null | PnC/NaoPnC/NaoStateMachine/SwingControl.hpp | BharathMasetty/PnC | 3800bd7e3c5dd5ffa00e6a5f09d48d21c405206f | [
"MIT"
] | null | null | null | #pragma once
#include <Utils/Math/BSplineBasic.h>
#include <PnC/StateMachine.hpp>
#include <PnC/NaoPnC/NaoStateProvider.hpp>
class NaoControlArchitecture;
class NaoTaskAndForceContainer;
class NaoMainController;
class SwingControl : public StateMachine {
public:
SwingControl(const StateIdentifier state_identifier_in, const int _leg_side,
NaoControlArchitecture* _ctrl_arch, RobotSystem* _robot);
~SwingControl();
void oneStep();
void firstVisit();
void lastVisit();
bool endOfState();
void initialization(const YAML::Node& node);
StateIdentifier getNextState();
protected:
NaoStateProvider* sp_;
NaoControlArchitecture* val_ctrl_arch_;
NaoTaskAndForceContainer* taf_container_;
int leg_side_;
double ctrl_start_time_;
double end_time_;
double swing_time_percent_early_contact_check_;
double early_contact_force_threshold_;
void _taskUpdate();
};
| 23.282051 | 78 | 0.779736 | BharathMasetty |
e39db9e83d53b46f3f5577f65fa360c7c7ed5055 | 5,048 | hpp | C++ | src/nanomsgpp/message.hpp | cjgdev/nanomsgpp | 69062bbd03e9ced0ed0ffc5fd91a95e3b94d7921 | [
"MIT"
] | 3 | 2017-06-01T09:18:30.000Z | 2019-04-09T21:05:05.000Z | src/nanomsgpp/message.hpp | cjgdev/nanomsgpp | 69062bbd03e9ced0ed0ffc5fd91a95e3b94d7921 | [
"MIT"
] | null | null | null | src/nanomsgpp/message.hpp | cjgdev/nanomsgpp | 69062bbd03e9ced0ed0ffc5fd91a95e3b94d7921 | [
"MIT"
] | 1 | 2022-01-06T04:14:36.000Z | 2022-01-06T04:14:36.000Z | /*
* Copyright (C) 2014 Christopher Gilbert <[email protected]>
*
* 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 NANOMSGPP_MESSAGE_HPP_INCLUDED
#define NANOMSGPP_MESSAGE_HPP_INCLUDED
#include <nanomsg/nn.h>
#include <iostream>
#include <memory>
#include <vector>
namespace nanomsgpp {
// A custom deleter for freeing memory allocated for nn_msghdr.
struct msghdr_free {
void operator()(void* x) {
std::free(static_cast<nn_msghdr*>(x)->msg_iov);
std::free(x);
}
};
typedef std::unique_ptr<nn_msghdr, msghdr_free> msghdr_unique_ptr;
// A part represents a message buffer, which is either allocated using nn_allocmsg or malloc.
class part {
void* d_msg;
size_t d_size;
bool d_malloc;
public:
// move constructor
part(part&& other);
// construct from pointer and size. specify a pointer to existing memory and a size
// and the constructor will copy the data to a malloc'd internal buffer. otherwise
// specify a nullptr and NN_MSG size to create a placeholder part for receiving
// messages
part(const void* ptr, size_t size, bool deep_copy = true);
// construct from size and type, will allocate (nn_allocmsg), used for creating
// zero-copy messages
part(size_t size, int type);
// construct from size, will allocate (malloc), used for creating multi-part messages
part(size_t size);
// destructor
~part();
// move assignment operator
part& operator=(part &&other);
// MANIPULATORS
// cast to void* operator
operator void*() { return &d_msg; }
// convenience method to return the data as a pointer to the given type
template<typename T>
T* as() { return static_cast<T*>(d_msg); }
// get size of memory pointed to d_msg
size_t size() const { return d_size; }
// transfer ownership of d_msg
void* release();
private:
// NOT IMPLEMENTED
part(const part& other) = delete;
part& operator=(const part &other) = delete;
};
typedef std::vector<part> parts;
// Messages are used to transfer data and events via sockets. Messages are comprised of one or
// more parts.
class message {
parts d_parts;
public:
// default constructor
message();
// copy constructor
message(const message &other) = default;
// move constructor
message(message &&other) = default;
// construct from parts
message(parts&& msgparts);
// destructor
~message();
// copy assignment operator
message& operator=(const message &other) = default;
// move assignment operator
message& operator=(message &&other) = default;
// MANIPULATORS
// add a new part to the message
void add_part(part&& p);
// stream operator add message part
message& operator<<(part&& p);
// generic write method, will add a message part initialised with a copy of the data parameter
template<typename T>
void write(const T& data);
// generic stream write operator
template<typename T>
message& operator<<(const T& data);
// generate a nn_msghdr from d_parts
msghdr_unique_ptr gen_nn_msghdr();
// get an iterator to the beginning of d_parts
parts::iterator begin() { return d_parts.begin(); }
// get a const iterator to the beginning of d_parts
parts::const_iterator cbegin() const { return d_parts.cbegin(); }
// get an iterator to the end of d_parts
parts::iterator end() { return d_parts.end(); }
// get a const iterator to the end of d_parts
parts::const_iterator cend() const { return d_parts.cend(); }
// get the number of parts of the message
size_t size() const { return d_parts.size(); }
// get a message part by index
part& at(size_t index) { return d_parts.at(index); }
// transfer ownership of message
void release();
};
// INLINE FUNCTION DEFINITIONS
template<typename T>
void message::write(const T& data) {
add_part(part(&data, sizeof(T)));
}
template<>
void message::write(const std::string& data);
template<typename T>
message& message::operator<<(const T& data) {
write(data);
return (*this);
}
}
#endif
| 27.889503 | 96 | 0.713748 | cjgdev |
e3a0f402d45ecb6ca249d02aa920014721d102b1 | 1,061 | cpp | C++ | src/Mesh_Computational_Geometry/mainwindow.cpp | AdrKacz/ecl-mso36-calcul-modelisation-geometrique | bb3744df90a7b49a0964c17acaf2245d1f89646f | [
"MIT"
] | null | null | null | src/Mesh_Computational_Geometry/mainwindow.cpp | AdrKacz/ecl-mso36-calcul-modelisation-geometrique | bb3744df90a7b49a0964c17acaf2245d1f89646f | [
"MIT"
] | null | null | null | src/Mesh_Computational_Geometry/mainwindow.cpp | AdrKacz/ecl-mso36-calcul-modelisation-geometrique | bb3744df90a7b49a0964c17acaf2245d1f89646f | [
"MIT"
] | null | null | null | #include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mesh.h" // Model
#include<QFile>
#include<QDebug>
#include<QString>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::on_loadFileButton_released()
{
return;
// file load on start instead
}
void MainWindow::on_zoomInButton_released() {
ui->widget->zoom_in();
}
void MainWindow::on_zoomOutButton_released() {
ui->widget->zoom_out();
}
void MainWindow::on_colorButton_released() {
if (colorButton_faces) {
ui->colorButton->setText("Faces");
} else {
ui->colorButton->setText("Vertices");
}
colorButton_faces = !colorButton_faces;
ui->widget->_geomWorld.set_use_face_color(colorButton_faces);
}
void MainWindow::on_reduceMesh_released() {
ui->widget->_geomWorld._mesh.reduce();
}
void MainWindow::on_colorSlider_valueChanged() {
ui->widget->_geomWorld.set_norm_factor(ui->colorSlider->value());
}
| 19.648148 | 69 | 0.693685 | AdrKacz |
e3a885b871665e6ead25571915f77eab1e30a5f2 | 5,766 | cpp | C++ | src/NasNas/tilemapping/ObjectLayer.cpp | Madour/NasNas | c6072d3d34116eca4ebff41899e14141d3009c03 | [
"Zlib"
] | 148 | 2020-04-08T13:45:34.000Z | 2022-01-29T13:52:10.000Z | src/NasNas/tilemapping/ObjectLayer.cpp | Madour/NasNas | c6072d3d34116eca4ebff41899e14141d3009c03 | [
"Zlib"
] | 5 | 2020-09-15T12:34:31.000Z | 2022-02-14T20:59:12.000Z | src/NasNas/tilemapping/ObjectLayer.cpp | Madour/NasNas | c6072d3d34116eca4ebff41899e14141d3009c03 | [
"Zlib"
] | 3 | 2020-10-03T22:35:20.000Z | 2020-10-05T04:55:45.000Z | /**
* Created by Modar Nasser on 22/08/2020.
**/
#include "NasNas/tilemapping/ObjectLayer.hpp"
using namespace ns;
using namespace ns::tm;
ns::tm::ObjectLayer::ObjectLayer(const pugi::xml_node& xml_node, tm::TiledMap* tiledmap) :
Layer(xml_node, tiledmap)
{
if (xml_node.attribute("color"))
m_color = hexToColor(std::string(xml_node.attribute("color").as_string()));
int points_count = 0, rectangles_count = 0, ellipses_count = 0,
polylines_count = 0, polygons_count = 0, tiles_count = 0;
for (const auto& xml_object : xml_node.children("object")) {
if(xml_object.child("ellipse"))
ellipses_count++;
else if(xml_object.child("polyline"))
polylines_count++;
else if(xml_object.child("polygon"))
polygons_count++;
else if(xml_object.attribute("gid"))
tiles_count++;
else if (xml_object.child("point"))
points_count++;
else
rectangles_count++;
}
m_points.reserve(points_count);
m_rectangles.reserve(rectangles_count);
m_ellipses.reserve(ellipses_count);
m_polylines.reserve(polylines_count);
m_polygons.reserve(polygons_count);
m_tiles.reserve(tiles_count);
for (const auto& xml_object : xml_node.children("object")) {
if(xml_object.child("ellipse")) {
m_ellipses.emplace_back(xml_object, m_color);
m_objects.emplace_back(m_ellipses.back());
}
else if(xml_object.child("polyline")) {
m_polylines.emplace_back(xml_object, m_color);
m_objects.emplace_back(m_polylines.back());
}
else if(xml_object.child("polygon")) {
m_polygons.emplace_back(xml_object, m_color);
m_objects.emplace_back(m_polygons.back());
}
else if(xml_object.attribute("gid")) {
m_tiles.emplace_back(xml_object, m_color, tiledmap);
m_objects.emplace_back(m_tiles.back());
}
else if (xml_object.child("point")) {
m_points.emplace_back(xml_object, m_color);
m_objects.emplace_back(m_points.back());
}
else {
m_rectangles.emplace_back(xml_object, m_color);
m_objects.emplace_back(m_rectangles.back());
}
}
for (Object& object : m_objects) {
if (!object.type.empty()) {
m_objects_by_type[object.type].emplace_back(object);
}
if (!object.name.empty()) {
m_objects_by_name[object.name].emplace_back(object);
}
}
}
auto ObjectLayer::getObjectsWithType(const std::string& type) const -> const std::vector<std::reference_wrapper<Object>>& {
if (m_objects_by_type.count(type) > 0)
return m_objects_by_type.at(type);
return m_empty_object_vector;
}
auto ObjectLayer::getObjectsWithName(const std::string& name) const -> const std::vector<std::reference_wrapper<Object>>& {
if (m_objects_by_name.count(name) > 0)
return m_objects_by_name.at(name);
return m_empty_object_vector;
}
auto ObjectLayer::allPoints() const -> const std::vector<PointObject>& {
return m_points;
}
auto ObjectLayer::allRectangles() const -> const std::vector<RectangleObject>& {
return m_rectangles;
}
auto ObjectLayer::allEllipses() const -> const std::vector<EllipseObject>& {
return m_ellipses;
}
auto ObjectLayer::allPolygons() const -> const std::vector<PolygonObject>& {
return m_polygons;
}
auto ObjectLayer::allPolylines() const -> const std::vector<PolylineObject>& {
return m_polylines;
}
auto ObjectLayer::getRectangle(unsigned int id) const -> const RectangleObject& {
for (auto& object : m_rectangles) {
if (object.id == id) return object;
}
std::cout << "ObjectLayer «" << getName() << "» does not have a Rectangle object id " << id << "." << std::endl;
std::exit(-1);
}
auto ObjectLayer::getPoint(unsigned int id) const -> const PointObject& {
for (auto& object : m_points) {
if (object.id == id) return object;
}
std::cout << "ObjectLayer «" << getName() << "» does not have a Point object id " << id << "." << std::endl;
std::exit(-1);
}
auto ObjectLayer::getEllipse(unsigned int id) const -> const EllipseObject& {
for (auto& object : m_ellipses) {
if (object.id == id) return object;
}
std::cout << "ObjectLayer «" << getName() << "» does not have a Ellipse object id " << id << "." << std::endl;
std::exit(-1);
}
auto ObjectLayer::getPolygon(unsigned int id) const -> const PolygonObject& {
for (auto& object : m_polygons) {
if (object.id == id) return object;
}
std::cout << "ObjectLayer «" << getName() << "» does not have a Polygon object id " << id << "." << std::endl;
std::exit(-1);
}
auto ObjectLayer::getPolyline(unsigned int id) const -> const PolylineObject& {
for (auto& object : m_polylines) {
if (object.id == id) return object;
}
std::cout << "ObjectLayer «" << getName() << "» does not have a Polyline object id " << id << "." << std::endl;
std::exit(-1);
}
void ObjectLayer::draw(sf::RenderTarget& target, sf::RenderStates states) const {
states.transform *= getTransform();
for (const auto& point : m_points)
target.draw(point.getShape(), states);
for (const auto& rect : m_rectangles)
target.draw(rect.getShape(), states);
for (const auto& ellipse : m_ellipses)
target.draw(ellipse.getShape(), states);
for (const auto& polyline : m_polylines)
target.draw(polyline.getShape(), states);
for (const auto& polygon : m_polygons)
target.draw(polygon.getShape(), states);
for (const auto& tile : m_tiles)
target.draw(tile.getShape(), states);
}
| 33.719298 | 123 | 0.632848 | Madour |
e3aaaa400e15e572a00231840b31736c5a631eb9 | 134 | hpp | C++ | src/utils/glm_ext.hpp | axis7818/RayTracer | 157bc958fde873eeacc3e7c03607daedca088a4f | [
"MIT"
] | null | null | null | src/utils/glm_ext.hpp | axis7818/RayTracer | 157bc958fde873eeacc3e7c03607daedca088a4f | [
"MIT"
] | null | null | null | src/utils/glm_ext.hpp | axis7818/RayTracer | 157bc958fde873eeacc3e7c03607daedca088a4f | [
"MIT"
] | null | null | null | #include <glm/vec3.hpp>
static const glm::vec3 VEC3_ZERO = glm::vec3(0, 0, 0);
static const glm::vec3 VEC3_ONE = glm::vec3(1, 1, 1);
| 26.8 | 54 | 0.671642 | axis7818 |
e3af4dc7dcfb5f874f60dfc9b6826f47220815f0 | 4,122 | hpp | C++ | objc-bridge/inc/m4c0/objc/casts.hpp | m4c0/m4c0-stl | 5e47439528faee466270706534143c87b4af8cbb | [
"MIT"
] | null | null | null | objc-bridge/inc/m4c0/objc/casts.hpp | m4c0/m4c0-stl | 5e47439528faee466270706534143c87b4af8cbb | [
"MIT"
] | null | null | null | objc-bridge/inc/m4c0/objc/casts.hpp | m4c0/m4c0-stl | 5e47439528faee466270706534143c87b4af8cbb | [
"MIT"
] | null | null | null | #pragma once
#include <objc/message.h>
#include <objc/runtime.h>
#include <utility>
// ARM64, for reasons
#if !defined(__i386__) && !defined(__x86_64__)
#define objc_msgSend_stret objc_msgSend
#define objc_msgSend_fpret objc_msgSend
#endif
namespace m4c0::objc {
namespace details {
// This only works because we have three options (as of 2021) in Apple's world of things:
// x86 (which may be history by now), x86_64 (where it "just works") and arm64 (works
// because "stret" isn't a thing on ARM)
template<class Tp>
static constexpr const auto fits_in_intel_return_v = (sizeof(Tp) <= 2 * sizeof(void *));
template<>
static constexpr const auto fits_in_intel_return_v<void> = true;
template<typename Ret, typename... Args>
static Ret call(void (*fn)(), void * obj, const char * sel_name, Args... args) {
SEL sel = sel_getUid(sel_name);
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return reinterpret_cast<Ret (*)(void *, SEL, Args...)>(fn)(obj, sel, args...);
}
}
template<typename Ret, typename... Args>
static auto objc_msg_send(void * obj, const char * sel_name, Args... args)
-> std::enable_if_t<!std::is_floating_point_v<Ret> && !std::is_class_v<Ret>, Ret> {
return details::call<Ret>(&objc_msgSend, obj, sel_name, args...);
}
template<typename Ret, typename... Args>
static auto objc_msg_send(void * obj, const char * sel_name, Args... args)
-> std::enable_if_t<std::is_floating_point_v<Ret>, Ret> {
return details::call<Ret>(&objc_msgSend_fpret, obj, sel_name, args...);
}
// Welcome to the true dynamic nature of objc_msgSend: the ObjC compiler adds a lot of sugar to the syntax of
// messages. One of them regards how to deal with "structs" in return signatures while being C-compatible. The answer
// is: I'm glad this ABI is compatible with C++ for the same requirement. In a nutshell, anything smaller than two
// Intel CPU registers is returned inside registers (RAX+DAX and XMM0+XMM1) - anything bigger becomes a pointer to the
// caller's stack (i.e. require the stret call).
template<typename Ret, typename... Args>
static auto objc_msg_send(void * obj, const char * sel_name, Args... args)
-> std::enable_if_t<std::is_class_v<Ret> && details::fits_in_intel_return_v<Ret>, Ret> {
return details::call<Ret>(&objc_msgSend, obj, sel_name, args...);
}
template<typename Ret, typename... Args>
static auto objc_msg_send(void * obj, const char * sel_name, Args... args)
-> std::enable_if_t<std::is_class_v<Ret> && !details::fits_in_intel_return_v<Ret>, Ret> {
return details::call<Ret>(&objc_msgSend_stret, obj, sel_name, args...);
}
template<typename Ret, typename... Args>
static Ret objc_msg_send_super(const char * super_class, void * obj, const char * sel_name, Args... args) {
id self = static_cast<id>(obj);
SEL sel = sel_getUid(sel_name);
objc_super s {};
s.super_class = objc_getClass(super_class); // We can't infer if calling from super itself
s.receiver = self;
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return reinterpret_cast<Ret (*)(objc_super *, SEL, Args...)>(objc_msgSendSuper)(&s, sel, args...);
}
template<class Tp>
static Tp object_get_ivar(void * self, const char * ivar_name) {
id self_id = static_cast<id>(self);
Ivar ivar = object_getInstanceVariable(self_id, ivar_name, nullptr);
if (!ivar) return Tp {};
return *reinterpret_cast<Tp *>(static_cast<std::byte *>(self) + ivar_getOffset(ivar)); // NOLINT
}
template<class Tp>
static void object_set_ivar(void * self, const char * ivar_name, Tp ptr) {
id self_id = static_cast<id>(self);
Ivar ivar = object_getInstanceVariable(self_id, ivar_name, nullptr);
if (!ivar) return;
*reinterpret_cast<Tp *>(static_cast<std::byte *>(self) + ivar_getOffset(ivar)) = ptr; // NOLINT
}
template<typename Ret, typename... Args>
static IMP to_imp(Ret (*fn)(Args...)) {
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return *reinterpret_cast<IMP *>(&fn);
}
}
| 44.804348 | 120 | 0.693595 | m4c0 |
e3b3611ca279cfca580d6d27682df8baf18fe79b | 5,010 | cpp | C++ | ui/CxRun/OleMessageFilter2.cpp | johnzcdGitHub/SuperCxHMI | e897b7bdf30cfe3bfeb5b8738e10c7205ebcd665 | [
"MIT"
] | 118 | 2015-05-19T09:19:01.000Z | 2022-02-24T15:18:51.000Z | ui/CxRun/OleMessageFilter2.cpp | PythonYanshenguan/SuperCxHMI | 19f681583fca56c528b51b5821fe842c80bcae24 | [
"MIT"
] | 1 | 2016-10-24T02:48:03.000Z | 2020-04-20T01:53:31.000Z | ui/CxRun/OleMessageFilter2.cpp | PythonYanshenguan/SuperCxHMI | 19f681583fca56c528b51b5821fe842c80bcae24 | [
"MIT"
] | 98 | 2015-02-11T07:16:47.000Z | 2022-02-24T02:15:27.000Z | // OleMessageFilter2.cpp: implementation of the COleMessageFilter2 class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CxRun.h"
#include "OleMessageFilter2.h"
#include "DcomErrorDlg.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
COleMessageFilter2::COleMessageFilter2()
{
}
COleMessageFilter2::~COleMessageFilter2()
{
}
BOOL COleMessageFilter2::Register2()
{
ASSERT_VALID(this);
ASSERT(!m_bRegistered); // calling Register twice?
if (::CoRegisterMessageFilter(&m_xMessageFilter2, NULL) == S_OK)
{
m_bRegistered = TRUE;
return TRUE;
}
return FALSE;
}
int COleMessageFilter2::OnNotRespondingDialog(HTASK htaskBusy)
{
CDcomErrorDlg dlg;
int nResult = dlg.DoModal();
return nResult;
}
/////////////////////////////////////////////////////////////////////////////
// COleMessageFilter2 OLE interface implementation
BEGIN_INTERFACE_MAP(COleMessageFilter2, CCmdTarget)
INTERFACE_PART(COleMessageFilter2, IID_IMessageFilter, MessageFilter2)
END_INTERFACE_MAP()
STDMETHODIMP_(ULONG) COleMessageFilter2::XMessageFilter2::AddRef()
{
METHOD_PROLOGUE_EX_(COleMessageFilter2, MessageFilter2)
return pThis->ExternalAddRef();
}
STDMETHODIMP_(ULONG) COleMessageFilter2::XMessageFilter2::Release()
{
METHOD_PROLOGUE_EX_(COleMessageFilter2, MessageFilter2)
return pThis->ExternalRelease();
}
STDMETHODIMP COleMessageFilter2::XMessageFilter2::QueryInterface(
REFIID iid, LPVOID* ppvObj)
{
METHOD_PROLOGUE_EX_(COleMessageFilter2, MessageFilter2)
return pThis->ExternalQueryInterface(&iid, ppvObj);
}
STDMETHODIMP_(DWORD) COleMessageFilter2::XMessageFilter2::HandleInComingCall(
DWORD dwCallType, HTASK /*htaskCaller*/,
DWORD /*dwTickCount*/, LPINTERFACEINFO /*lpInterfaceInfo*/)
{
METHOD_PROLOGUE_EX_(COleMessageFilter2, MessageFilter2)
// check for application busy first...
if (pThis->m_nBusyCount == 0)
{
if (dwCallType == CALLTYPE_TOPLEVEL ||
dwCallType == CALLTYPE_TOPLEVEL_CALLPENDING)
{
// make sure CWinThread::OnIdle has a chance to run later
MSG msg;
if (!::PeekMessage(&msg, NULL, WM_KICKIDLE, WM_KICKIDLE, PM_NOREMOVE))
::PostThreadMessage(GetCurrentThreadId(), WM_KICKIDLE, 0, 0);
}
return SERVERCALL_ISHANDLED;
}
if (dwCallType == CALLTYPE_TOPLEVEL ||
dwCallType == CALLTYPE_TOPLEVEL_CALLPENDING)
{
// application is busy and we have rejectable CALLTYPE
return pThis->m_nBusyReply;
}
// application is busy, but CALLTYPE indicates that it *must* be handled
return SERVERCALL_ISHANDLED;
}
STDMETHODIMP_(DWORD) COleMessageFilter2::XMessageFilter2::RetryRejectedCall(
HTASK htaskCallee, DWORD dwTickCount, DWORD dwRejectType)
{
METHOD_PROLOGUE_EX(COleMessageFilter2, MessageFilter2)
ASSERT_VALID(pThis);
// rejected calls get cancelled regardless of timeout
if (dwRejectType == SERVERCALL_REJECTED)
return (DWORD)-1;
// if insignificant time has passed, don't panic -- just retry
if (dwTickCount <= pThis->m_nRetryReply)
return 0; // retry right away (0-100 are retry immediate)
// too much time has passed, do something more drastic
if (pThis->m_bEnableBusy)
{
// show busy dialog
int selType = pThis->OnBusyDialog(htaskCallee);
// take action depending on selection
switch (selType)
{
case -1:
return (DWORD)-1; // cancel outgoing call
case COleBusyDialog::retry:
return 0; // retry immediately
}
}
return pThis->m_nRetryReply; // use standard retry timeout
}
STDMETHODIMP_(DWORD) COleMessageFilter2::XMessageFilter2::MessagePending(
HTASK htaskCallee, DWORD dwTickCount, DWORD /*dwPendingType*/)
{
METHOD_PROLOGUE_EX(COleMessageFilter2, MessageFilter2)
ASSERT_VALID(pThis);
MSG msg;
if (dwTickCount > pThis->m_nTimeout && !pThis->m_bUnblocking &&
pThis->IsSignificantMessage(&msg))
{
if (pThis->m_bEnableNotResponding)
{
pThis->m_bUnblocking = TRUE; // avoid reentrant calls
// eat all mouse messages in our queue
while (PeekMessage(&msg, NULL, WM_MOUSEFIRST, WM_MOUSELAST,
PM_REMOVE|PM_NOYIELD))
;
// eat all keyboard messages in our queue
while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST,
PM_REMOVE|PM_NOYIELD))
;
// show not responding dialog
int nResult = pThis->OnNotRespondingDialog(htaskCallee);
pThis->m_bUnblocking = FALSE;
if (nResult == IDABORT)
ExitProcess(0);
else if (nResult == IDIGNORE)
return PENDINGMSG_CANCELCALL;
return PENDINGMSG_WAITNOPROCESS;
}
}
// don't process re-entrant messages
if (pThis->m_bUnblocking)
return PENDINGMSG_WAITDEFPROCESS;
// allow application to process pending message
if (::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE|PM_NOYIELD))
pThis->OnMessagePending(&msg);
// by default we return pending MSG wait
return PENDINGMSG_WAITNOPROCESS;
}
| 26.507937 | 77 | 0.709381 | johnzcdGitHub |
e3b5143edc5d470c960d64542c6a3255671ee3fc | 35 | hpp | C++ | src/boost_iostreams_get.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 10 | 2018-03-17T00:58:42.000Z | 2021-07-06T02:48:49.000Z | src/boost_iostreams_get.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 2 | 2021-03-26T15:17:35.000Z | 2021-05-20T23:55:08.000Z | src/boost_iostreams_get.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 4 | 2019-05-28T21:06:37.000Z | 2021-07-06T03:06:52.000Z | #include <boost/iostreams/get.hpp>
| 17.5 | 34 | 0.771429 | miathedev |
e3b839b051d8548bb3fd6ebbf67c8d48b0dde0ef | 2,550 | cpp | C++ | Lesson 4 (Counting Elements)/MaxCounters.cpp | Constantine-L01/Codility | 741c71414ed7efb3304310d2b78d4a8cfc1c2b69 | [
"MIT"
] | null | null | null | Lesson 4 (Counting Elements)/MaxCounters.cpp | Constantine-L01/Codility | 741c71414ed7efb3304310d2b78d4a8cfc1c2b69 | [
"MIT"
] | null | null | null | Lesson 4 (Counting Elements)/MaxCounters.cpp | Constantine-L01/Codility | 741c71414ed7efb3304310d2b78d4a8cfc1c2b69 | [
"MIT"
] | null | null | null | Task description
You are given N counters, initially set to 0, and you have two possible operations on them:
increase(X) − counter X is increased by 1,
max counter − all counters are set to the maximum value of any counter.
A non-empty array A of M integers is given. This array represents consecutive operations:
if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),
if A[K] = N + 1 then operation K is max counter.
For example, given integer N = 5 and array A such that:
A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4
the values of the counters after each consecutive operation will be:
(0, 0, 1, 0, 0)
(0, 0, 1, 1, 0)
(0, 0, 1, 2, 0)
(2, 2, 2, 2, 2)
(3, 2, 2, 2, 2)
(3, 2, 2, 3, 2)
(3, 2, 2, 4, 2)
The goal is to calculate the value of every counter after all operations.
Write a function:
vector<int> solution(int N, vector<int> &A);
that, given an integer N and a non-empty array A consisting of M integers, returns a sequence of integers representing the values of the counters.
Result array should be returned as a vector of integers.
For example, given:
A[0] = 3
A[1] = 4
A[2] = 4
A[3] = 6
A[4] = 1
A[5] = 4
A[6] = 4
the function should return [3, 2, 2, 4, 2], as explained above.
Write an efficient algorithm for the following assumptions:
N and M are integers within the range [1..100,000];
each element of array A is an integer within the range [1..N + 1].
==Solution==
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int N, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
int currentMax = 0;
int lastUpdate = 0;
vector<int> counters(N, 0);
for(int i = 0; i < A.size(); i++){
int currVal = A[i];
if(currVal == N + 1){
lastUpdate = currentMax;
}
else {
int pos = currVal - 1;
if (counters[pos] < lastUpdate){
counters[pos] = lastUpdate + 1;
}
else {
counters[pos]++;
}
if(counters[pos] > currentMax){
currentMax = counters[pos];
}
}
}
for(int i = 0; i < N; i++){
if(counters[i] < lastUpdate){
counters[i] = lastUpdate;
}
}
return counters;
}
| 26.020408 | 146 | 0.557647 | Constantine-L01 |
e3b9b9a31d2cd865d04c99dbcb3da3df69d05b82 | 17,669 | cpp | C++ | src/eepp/network/uri.cpp | SpartanJ/eepp | 21e8ae53af9bc5eb3fd1043376f2b3a4b3ff5fac | [
"MIT"
] | 37 | 2020-01-20T06:21:24.000Z | 2022-03-21T17:44:50.000Z | src/eepp/network/uri.cpp | SpartanJ/eepp | 21e8ae53af9bc5eb3fd1043376f2b3a4b3ff5fac | [
"MIT"
] | null | null | null | src/eepp/network/uri.cpp | SpartanJ/eepp | 21e8ae53af9bc5eb3fd1043376f2b3a4b3ff5fac | [
"MIT"
] | 9 | 2019-03-22T00:33:07.000Z | 2022-03-01T01:35:59.000Z | #include <eepp/network/uri.hpp>
namespace EE { namespace Network {
static void AppendHex( std::string& str, int value, int width ) {
eeASSERT( width > 0 && width < 64 );
char buffer[64];
std::sprintf( buffer, "%0*X", width, value );
str.append( buffer );
}
static std::string FormatHex( int value, int width ) {
std::string result;
AppendHex( result, value, width );
return result;
}
const std::string URI::RESERVED_PATH = "?#";
const std::string URI::RESERVED_QUERY = "#";
const std::string URI::RESERVED_FRAGMENT = "";
const std::string URI::ILLEGAL = "%<>{}|\\\"^`";
URI::URI() : mPort( 0 ) {}
URI::URI( const std::string& uri ) : mPort( 0 ) {
parse( uri );
}
URI::URI( const char* uri ) : mPort( 0 ) {
parse( std::string( uri ) );
}
URI::URI( const std::string& scheme, const std::string& pathEtc ) : mScheme( scheme ), mPort( 0 ) {
String::toLowerInPlace( mScheme );
mPort = getWellKnownPort();
std::string::const_iterator beg = pathEtc.begin();
std::string::const_iterator end = pathEtc.end();
parsePathEtc( beg, end );
}
URI::URI( const std::string& scheme, const std::string& authority, const std::string& pathEtc ) :
mScheme( scheme ) {
String::toLowerInPlace( mScheme );
std::string::const_iterator beg = authority.begin();
std::string::const_iterator end = authority.end();
parseAuthority( beg, end );
beg = pathEtc.begin();
end = pathEtc.end();
parsePathEtc( beg, end );
}
URI::URI( const std::string& scheme, const std::string& authority, const std::string& path,
const std::string& query ) :
mScheme( scheme ), mPath( path ), mQuery( query ) {
String::toLowerInPlace( mScheme );
std::string::const_iterator beg = authority.begin();
std::string::const_iterator end = authority.end();
parseAuthority( beg, end );
}
URI::URI( const std::string& scheme, const std::string& authority, const std::string& path,
const std::string& query, const std::string& fragment ) :
mScheme( scheme ), mPath( path ), mQuery( query ), mFragment( fragment ) {
String::toLowerInPlace( mScheme );
std::string::const_iterator beg = authority.begin();
std::string::const_iterator end = authority.end();
parseAuthority( beg, end );
}
URI::URI( const URI& uri ) :
mScheme( uri.mScheme ),
mUserInfo( uri.mUserInfo ),
mHost( uri.mHost ),
mPort( uri.mPort ),
mPath( uri.mPath ),
mQuery( uri.mQuery ),
mFragment( uri.mFragment ) {}
URI::URI( const URI& baseURI, const std::string& relativeURI ) :
mScheme( baseURI.mScheme ),
mUserInfo( baseURI.mUserInfo ),
mHost( baseURI.mHost ),
mPort( baseURI.mPort ),
mPath( baseURI.mPath ),
mQuery( baseURI.mQuery ),
mFragment( baseURI.mFragment ) {
resolve( relativeURI );
}
URI::~URI() {}
URI& URI::operator=( const URI& uri ) {
if ( &uri != this ) {
mScheme = uri.mScheme;
mUserInfo = uri.mUserInfo;
mHost = uri.mHost;
mPort = uri.mPort;
mPath = uri.mPath;
mQuery = uri.mQuery;
mFragment = uri.mFragment;
}
return *this;
}
URI& URI::operator=( const std::string& uri ) {
clear();
parse( uri );
return *this;
}
URI& URI::operator=( const char* uri ) {
clear();
parse( std::string( uri ) );
return *this;
}
void URI::swap( URI& uri ) {
std::swap( mScheme, uri.mScheme );
std::swap( mUserInfo, uri.mUserInfo );
std::swap( mHost, uri.mHost );
std::swap( mPort, uri.mPort );
std::swap( mPath, uri.mPath );
std::swap( mQuery, uri.mQuery );
std::swap( mFragment, uri.mFragment );
}
void URI::clear() {
mScheme.clear();
mUserInfo.clear();
mHost.clear();
mPort = 0;
mPath.clear();
mQuery.clear();
mFragment.clear();
}
std::string URI::toString() const {
std::string uri;
if ( isRelative() ) {
encode( mPath, RESERVED_PATH, uri );
} else {
uri = mScheme;
uri += ':';
std::string auth = getAuthority();
if ( !auth.empty() || mScheme == "file" ) {
uri.append( "//" );
uri.append( auth );
}
if ( !mPath.empty() ) {
if ( !auth.empty() && mPath[0] != '/' )
uri += '/';
encode( mPath, RESERVED_PATH, uri );
} else if ( !mQuery.empty() || !mFragment.empty() ) {
uri += '/';
}
}
if ( !mQuery.empty() ) {
uri += '?';
uri.append( mQuery );
}
if ( !mFragment.empty() ) {
uri += '#';
encode( mFragment, RESERVED_FRAGMENT, uri );
}
return uri;
}
void URI::setScheme( const std::string& scheme ) {
mScheme = scheme;
String::toLowerInPlace( mScheme );
if ( mPort == 0 )
mPort = getWellKnownPort();
}
void URI::setUserInfo( const std::string& userInfo ) {
mUserInfo.clear();
decode( userInfo, mUserInfo );
}
void URI::setHost( const std::string& host ) {
mHost = host;
}
unsigned short URI::getPort() const {
if ( mPort == 0 )
return getWellKnownPort();
else
return mPort;
}
void URI::getPort( unsigned short port ) {
mPort = port;
}
std::string URI::getAuthority() const {
std::string auth;
if ( !mUserInfo.empty() ) {
auth.append( mUserInfo );
auth += '@';
}
if ( mHost.find( ':' ) != std::string::npos ) {
auth += '[';
auth += mHost;
auth += ']';
} else
auth.append( mHost );
if ( mPort && !isWellKnownPort() ) {
auth += ':';
auth += String::toString( mPort );
}
return auth;
}
void URI::setAuthority( const std::string& authority ) {
mUserInfo.clear();
mHost.clear();
mPort = 0;
std::string::const_iterator beg = authority.begin();
std::string::const_iterator end = authority.end();
parseAuthority( beg, end );
}
std::string URI::getSchemeAndAuthority() const {
return getScheme() + "://" + getAuthority();
}
void URI::getPath( const std::string& path ) {
mPath.clear();
decode( path, mPath );
}
void URI::setRawQuery( const std::string& query ) {
mQuery = query;
}
void URI::setQuery( const std::string& query ) {
mQuery.clear();
encode( query, RESERVED_QUERY, mQuery );
}
std::string URI::getQuery() const {
std::string query;
decode( mQuery, query );
return query;
}
void URI::getFragment( const std::string& fragment ) {
mFragment.clear();
decode( fragment, mFragment );
}
void URI::setPathEtc( const std::string& pathEtc ) {
mPath.clear();
mQuery.clear();
mFragment.clear();
std::string::const_iterator beg = pathEtc.begin();
std::string::const_iterator end = pathEtc.end();
parsePathEtc( beg, end );
}
std::string URI::getPathEtc() const {
std::string pathEtc;
encode( mPath, RESERVED_PATH, pathEtc );
if ( !mQuery.empty() ) {
pathEtc += '?';
pathEtc += mQuery;
}
if ( !mFragment.empty() ) {
pathEtc += '#';
encode( mFragment, RESERVED_FRAGMENT, pathEtc );
}
return pathEtc;
}
std::string URI::getPathAndQuery() const {
std::string pathAndQuery;
encode( mPath, RESERVED_PATH, pathAndQuery );
if ( !mQuery.empty() ) {
pathAndQuery += '?';
pathAndQuery += mQuery;
}
return pathAndQuery;
}
void URI::resolve( const std::string& relativeURI ) {
URI ParsedURI( relativeURI );
resolve( ParsedURI );
}
void URI::resolve( const URI& relativeURI ) {
if ( !relativeURI.mScheme.empty() ) {
mScheme = relativeURI.mScheme;
mUserInfo = relativeURI.mUserInfo;
mHost = relativeURI.mHost;
mPort = relativeURI.mPort;
mPath = relativeURI.mPath;
mQuery = relativeURI.mQuery;
removeDotSegments();
} else {
if ( !relativeURI.mHost.empty() ) {
mUserInfo = relativeURI.mUserInfo;
mHost = relativeURI.mHost;
mPort = relativeURI.mPort;
mPath = relativeURI.mPath;
mQuery = relativeURI.mQuery;
removeDotSegments();
} else {
if ( relativeURI.mPath.empty() ) {
if ( !relativeURI.mQuery.empty() )
mQuery = relativeURI.mQuery;
} else {
if ( relativeURI.mPath[0] == '/' ) {
mPath = relativeURI.mPath;
removeDotSegments();
} else {
mergePath( relativeURI.mPath );
}
mQuery = relativeURI.mQuery;
}
}
}
mFragment = relativeURI.mFragment;
}
bool URI::isRelative() const {
return mScheme.empty();
}
bool URI::empty() const {
return mScheme.empty() && mHost.empty() && mPath.empty() && mQuery.empty() && mFragment.empty();
}
bool URI::operator==( const URI& uri ) const {
return equals( uri );
}
bool URI::operator==( const std::string& uri ) const {
URI ParsedURI( uri );
return equals( ParsedURI );
}
bool URI::operator!=( const URI& uri ) const {
return !equals( uri );
}
bool URI::operator!=( const std::string& uri ) const {
URI ParsedURI( uri );
return !equals( ParsedURI );
}
bool URI::equals( const URI& uri ) const {
return mScheme == uri.mScheme && mUserInfo == uri.mUserInfo && mHost == uri.mHost &&
getPort() == uri.getPort() && mPath == uri.mPath && mQuery == uri.mQuery &&
mFragment == uri.mFragment;
}
void URI::normalize() {
removeDotSegments( !isRelative() );
}
void URI::removeDotSegments( bool removeLeading ) {
if ( mPath.empty() )
return;
bool leadingSlash = *( mPath.begin() ) == '/';
bool trailingSlash = *( mPath.rbegin() ) == '/';
std::vector<std::string> segments;
std::vector<std::string> NormalizedSegments;
getPathSegments( segments );
for ( std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end();
++it ) {
if ( *it == ".." ) {
if ( !NormalizedSegments.empty() ) {
if ( NormalizedSegments.back() == ".." )
NormalizedSegments.push_back( *it );
else
NormalizedSegments.pop_back();
} else if ( !removeLeading ) {
NormalizedSegments.push_back( *it );
}
} else if ( *it != "." ) {
NormalizedSegments.push_back( *it );
}
}
buildPath( NormalizedSegments, leadingSlash, trailingSlash );
}
void URI::getPathSegments( std::vector<std::string>& segments ) {
getPathSegments( mPath, segments );
}
std::string URI::getLastPathSegment() {
std::vector<std::string> segments;
getPathSegments( segments );
if ( !segments.empty() ) {
return segments[segments.size() - 1];
}
return "";
}
void URI::getPathSegments( const std::string& path, std::vector<std::string>& segments ) {
std::string::const_iterator it = path.begin();
std::string::const_iterator end = path.end();
std::string seg;
while ( it != end ) {
if ( *it == '/' ) {
if ( !seg.empty() ) {
segments.push_back( seg );
seg.clear();
}
} else
seg += *it;
++it;
}
if ( !seg.empty() )
segments.push_back( seg );
}
void URI::encode( const std::string& str, const std::string& reserved, std::string& encodedStr ) {
for ( std::string::const_iterator it = str.begin(); it != str.end(); ++it ) {
char c = *it;
if ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) || ( c >= '0' && c <= '9' ) ||
c == '-' || c == '_' || c == '.' || c == '~' ) {
encodedStr += c;
} else if ( c <= 0x20 || c >= 0x7F || ILLEGAL.find( c ) != std::string::npos ||
reserved.find( c ) != std::string::npos ) {
encodedStr += '%';
encodedStr += FormatHex( (unsigned)(unsigned char)c, 2 );
} else
encodedStr += c;
}
}
void URI::decode( const std::string& str, std::string& decodedStr ) {
std::string::const_iterator it = str.begin();
std::string::const_iterator end = str.end();
while ( it != end ) {
char c = *it++;
if ( c == '%' ) {
if ( it == end ) {
return; // throw SyntaxException("URI encoding: no hex digit following percent
// sign", str);
}
char hi = *it++;
if ( it == end ) {
return; // throw SyntaxException("URI encoding: two hex digits must follow percent
// sign", str);
}
char lo = *it++;
if ( hi >= '0' && hi <= '9' )
c = hi - '0';
else if ( hi >= 'A' && hi <= 'F' )
c = hi - 'A' + 10;
else if ( hi >= 'a' && hi <= 'f' )
c = hi - 'a' + 10;
else {
return; // throw SyntaxException("URI encoding: not a hex digit");
}
c *= 16;
if ( lo >= '0' && lo <= '9' )
c += lo - '0';
else if ( lo >= 'A' && lo <= 'F' )
c += lo - 'A' + 10;
else if ( lo >= 'a' && lo <= 'f' )
c += lo - 'a' + 10;
else {
return; // throw SyntaxException("URI encoding: not a hex digit");
}
}
decodedStr += c;
}
}
std::string URI::encode( const std::string& str ) {
std::string uri;
for ( std::string::const_iterator it = str.begin(); it != str.end(); ++it ) {
char c = *it;
if ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) || ( c >= '0' && c <= '9' ) ||
c == '-' || c == '_' || c == '.' || c == '~' ) {
uri += c;
} else {
uri += '%';
uri += FormatHex( (unsigned)(unsigned char)c, 2 );
}
}
return uri;
}
std::string URI::decode( const std::string& str ) {
std::string uri;
decode( str, uri );
return uri;
}
bool URI::isWellKnownPort() const {
return mPort == getWellKnownPort();
}
unsigned short URI::getWellKnownPort() const {
if ( mScheme == "ftp" )
return 21;
else if ( mScheme == "ssh" )
return 22;
else if ( mScheme == "telnet" )
return 23;
else if ( mScheme == "http" )
return 80;
else if ( mScheme == "nntp" )
return 119;
else if ( mScheme == "ldap" )
return 389;
else if ( mScheme == "https" )
return 443;
else if ( mScheme == "rtsp" )
return 554;
else if ( mScheme == "sip" )
return 5060;
else if ( mScheme == "sips" )
return 5061;
else if ( mScheme == "xmpp" )
return 5222;
else
return 0;
}
void URI::parse( const std::string& uri ) {
std::string::const_iterator it = uri.begin();
std::string::const_iterator end = uri.end();
if ( it == end )
return;
if ( *it != '/' && *it != '.' && *it != '?' && *it != '#' ) {
std::string scheme;
while ( it != end && *it != ':' && *it != '?' && *it != '#' && *it != '/' )
scheme += *it++;
if ( it != end && *it == ':' ) {
++it;
if ( it == end ) {
return; // throw SyntaxException("URI scheme must be followed by authority or path",
// uri);
}
setScheme( scheme );
if ( *it == '/' ) {
++it;
if ( it != end && *it == '/' ) {
++it;
parseAuthority( it, end );
} else
--it;
}
parsePathEtc( it, end );
} else {
it = uri.begin();
parsePathEtc( it, end );
}
} else {
parsePathEtc( it, end );
}
}
void URI::parseAuthority( std::string::const_iterator& it,
const std::string::const_iterator& end ) {
std::string userInfo;
std::string part;
while ( it != end && *it != '/' && *it != '?' && *it != '#' ) {
if ( *it == '@' ) {
userInfo = part;
part.clear();
} else
part += *it;
++it;
}
std::string::const_iterator pbeg = part.begin();
std::string::const_iterator pend = part.end();
parseHostAndPort( pbeg, pend );
mUserInfo = userInfo;
}
void URI::parseHostAndPort( std::string::const_iterator& it,
const std::string::const_iterator& end ) {
if ( it == end )
return;
std::string host;
if ( *it == '[' ) {
// IPv6 address
++it;
while ( it != end && *it != ']' )
host += *it++;
if ( it == end ) {
return; // throw SyntaxException("unterminated IPv6 address");
}
++it;
} else {
while ( it != end && *it != ':' )
host += *it++;
}
if ( it != end && *it == ':' ) {
++it;
std::string port;
while ( it != end )
port += *it++;
if ( !port.empty() ) {
int nport = 0;
if ( String::fromString<int>( nport, port ) && nport > 0 && nport < 65536 ) {
mPort = (unsigned short)nport;
} else {
return; // throw SyntaxException("bad or invalid port number", port);
}
} else {
mPort = getWellKnownPort();
}
} else {
mPort = getWellKnownPort();
}
mHost = host;
String::toLowerInPlace( mHost );
}
void URI::parsePath( std::string::const_iterator& it, const std::string::const_iterator& end ) {
std::string path;
while ( it != end && *it != '?' && *it != '#' )
path += *it++;
decode( path, mPath );
}
void URI::parsePathEtc( std::string::const_iterator& it, const std::string::const_iterator& end ) {
if ( it == end )
return;
if ( *it != '?' && *it != '#' )
parsePath( it, end );
if ( it != end && *it == '?' ) {
++it;
parseQuery( it, end );
}
if ( it != end && *it == '#' ) {
++it;
parseFragment( it, end );
}
}
void URI::parseQuery( std::string::const_iterator& it, const std::string::const_iterator& end ) {
mQuery.clear();
while ( it != end && *it != '#' )
mQuery += *it++;
}
void URI::parseFragment( std::string::const_iterator& it, const std::string::const_iterator& end ) {
std::string fragment;
while ( it != end )
fragment += *it++;
decode( fragment, mFragment );
}
void URI::mergePath( const std::string& path ) {
std::vector<std::string> segments;
std::vector<std::string> NormalizedSegments;
bool addLeadingSlash = false;
if ( !mPath.empty() ) {
getPathSegments( segments );
bool endsWithSlash = *( mPath.rbegin() ) == '/';
if ( !endsWithSlash && !segments.empty() )
segments.pop_back();
addLeadingSlash = mPath[0] == '/';
}
getPathSegments( path, segments );
addLeadingSlash = addLeadingSlash || ( !path.empty() && path[0] == '/' );
bool hasTrailingSlash = ( !path.empty() && *( path.rbegin() ) == '/' );
bool addTrailingSlash = false;
for ( std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end();
++it ) {
if ( *it == ".." ) {
addTrailingSlash = true;
if ( !NormalizedSegments.empty() )
NormalizedSegments.pop_back();
} else if ( *it != "." ) {
addTrailingSlash = false;
NormalizedSegments.push_back( *it );
} else
addTrailingSlash = true;
}
buildPath( NormalizedSegments, addLeadingSlash, hasTrailingSlash || addTrailingSlash );
}
void URI::buildPath( const std::vector<std::string>& segments, bool leadingSlash,
bool trailingSlash ) {
mPath.clear();
bool first = true;
for ( std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end();
++it ) {
if ( first ) {
first = false;
if ( leadingSlash )
mPath += '/';
else if ( mScheme.empty() && ( *it ).find( ':' ) != std::string::npos )
mPath.append( "./" );
} else
mPath += '/';
mPath.append( *it );
}
if ( trailingSlash )
mPath += '/';
}
}} // namespace EE::Network
| 24.885915 | 100 | 0.596242 | SpartanJ |
e3bf9705ca79ecc27135a90b6f6aa53e5bd1ed6a | 10,125 | cpp | C++ | Cbc/Cbc/examples/sample5.cpp | fadi-alkhoury/coin-or-cbc-with-cmake | b4a216118d8e773b694b44c5f27cd75a251cc2cb | [
"MIT"
] | null | null | null | Cbc/Cbc/examples/sample5.cpp | fadi-alkhoury/coin-or-cbc-with-cmake | b4a216118d8e773b694b44c5f27cd75a251cc2cb | [
"MIT"
] | null | null | null | Cbc/Cbc/examples/sample5.cpp | fadi-alkhoury/coin-or-cbc-with-cmake | b4a216118d8e773b694b44c5f27cd75a251cc2cb | [
"MIT"
] | null | null | null | // $Id: sample5.cpp 2469 2019-01-06 23:17:46Z unxusr $
// Copyright (C) 2002, International Business Machines
// Corporation and others. All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
#include "CbcConfig.h"
#include "CoinPragma.hpp"
#include <cassert>
#include <iomanip>
// For Branch and bound
#include "OsiSolverInterface.hpp"
#include "CbcModel.hpp"
#include "CbcBranchUser.hpp"
#include "CbcCompareUser.hpp"
#include "CbcCutGenerator.hpp"
#include "CbcHeuristicLocal.hpp"
#include "OsiClpSolverInterface.hpp"
// Cuts
#include "CglGomory.hpp"
#include "CglProbing.hpp"
#include "CglKnapsackCover.hpp"
#include "CglOddHole.hpp"
#include "CglClique.hpp"
#include "CglFlowCover.hpp"
#include "CglMixedIntegerRounding.hpp"
// Heuristics
#include "CbcHeuristic.hpp"
// Methods of building
#include "CoinBuild.hpp"
#include "CoinModel.hpp"
#include "CoinTime.hpp"
/************************************************************************
This main program creates an integer model and then solves it
It then sets up some Cgl cut generators and calls branch and cut.
Branching is simple binary branching on integer variables.
Node selection is depth first until first solution is found and then
based on objective and number of unsatisfied integer variables.
In this example the functionality is the same as default but it is
a user comparison function.
Variable branching selection is on maximum minimum-of-up-down change
after strong branching on 5 variables closest to 0.5.
A simple rounding heuristic is used.
************************************************************************/
int main(int argc, const char *argv[])
{
/* Define your favorite OsiSolver.
CbcModel clones the solver so use solver1 up to the time you pass it
to CbcModel then use a pointer to cloned solver (model.solver())
*/
OsiClpSolverInterface solver1;
/* From now on we can build model in a solver independent way.
You can add rows one at a time but for large problems this is slow so
this example uses CoinBuild or CoinModel
*/
OsiSolverInterface *solver = &solver1;
// Data (is exmip1.mps in Mps/Sample
// Objective
double objValue[] = { 1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0 };
// Lower bounds for columns
double columnLower[] = { 2.5, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0 };
// Upper bounds for columns
double columnUpper[] = { COIN_DBL_MAX, 4.1, 1.0, 1.0, 4.0,
COIN_DBL_MAX, COIN_DBL_MAX, 4.3 };
// Lower bounds for row activities
double rowLower[] = { 2.5, -COIN_DBL_MAX, -COIN_DBL_MAX, 1.8, 3.0 };
// Upper bounds for row activities
double rowUpper[] = { COIN_DBL_MAX, 2.1, 4.0, 5.0, 15.0 };
// Matrix stored packed
int column[] = { 0, 1, 3, 4, 7,
1, 2,
2, 5,
3, 6,
4, 7 };
double element[] = { 3.0, 1.0, -2.0, -1.0, -1.0,
2.0, 1.1,
1.0, 1.0,
2.8, -1.2,
1.0, 1.9 };
int starts[] = { 0, 5, 7, 9, 11, 13 };
// Integer variables (note upper bound already 1.0)
int whichInt[] = { 2, 3 };
int numberRows = (int)(sizeof(rowLower) / sizeof(double));
int numberColumns = (int)(sizeof(columnLower) / sizeof(double));
#define BUILD 2
#if BUILD == 1
// Using CoinBuild
// First do columns (objective and bounds)
int i;
// We are not adding elements
for (i = 0; i < numberColumns; i++) {
solver->addCol(0, NULL, NULL, columnLower[i], columnUpper[i],
objValue[i]);
}
// mark as integer
for (i = 0; i < (int)(sizeof(whichInt) / sizeof(int)); i++)
solver->setInteger(whichInt[i]);
// Now build rows
CoinBuild build;
for (i = 0; i < numberRows; i++) {
int startRow = starts[i];
int numberInRow = starts[i + 1] - starts[i];
build.addRow(numberInRow, column + startRow, element + startRow,
rowLower[i], rowUpper[i]);
}
// add rows into solver
solver->addRows(build);
#else
/* using CoinModel - more flexible but still beta.
Can do exactly same way but can mix and match much more.
Also all operations are on building object
*/
CoinModel build;
// First do columns (objective and bounds)
int i;
for (i = 0; i < numberColumns; i++) {
build.setColumnBounds(i, columnLower[i], columnUpper[i]);
build.setObjective(i, objValue[i]);
}
// mark as integer
for (i = 0; i < (int)(sizeof(whichInt) / sizeof(int)); i++)
build.setInteger(whichInt[i]);
// Now build rows
for (i = 0; i < numberRows; i++) {
int startRow = starts[i];
int numberInRow = starts[i + 1] - starts[i];
build.addRow(numberInRow, column + startRow, element + startRow,
rowLower[i], rowUpper[i]);
}
// add rows into solver
solver->loadFromCoinModel(build);
#endif
// Pass to solver
CbcModel model(*solver);
model.solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);
// Set up some cut generators and defaults
// Probing first as gets tight bounds on continuous
CglProbing generator1;
generator1.setUsingObjective(true);
generator1.setMaxPass(3);
generator1.setMaxProbe(100);
generator1.setMaxLook(50);
generator1.setRowCuts(3);
// generator1.snapshot(*model.solver());
//generator1.createCliques(*model.solver(),2,1000,true);
//generator1.setMode(0);
CglGomory generator2;
// try larger limit
generator2.setLimit(300);
CglKnapsackCover generator3;
CglOddHole generator4;
generator4.setMinimumViolation(0.005);
generator4.setMinimumViolationPer(0.00002);
// try larger limit
generator4.setMaximumEntries(200);
CglClique generator5;
generator5.setStarCliqueReport(false);
generator5.setRowCliqueReport(false);
CglMixedIntegerRounding mixedGen;
CglFlowCover flowGen;
// Add in generators
model.addCutGenerator(&generator1, -1, "Probing");
model.addCutGenerator(&generator2, -1, "Gomory");
model.addCutGenerator(&generator3, -1, "Knapsack");
model.addCutGenerator(&generator4, -1, "OddHole");
model.addCutGenerator(&generator5, -1, "Clique");
model.addCutGenerator(&flowGen, -1, "FlowCover");
model.addCutGenerator(&mixedGen, -1, "MixedIntegerRounding");
OsiClpSolverInterface *osiclp = dynamic_cast< OsiClpSolverInterface * >(model.solver());
// go faster stripes
if (osiclp->getNumRows() < 300 && osiclp->getNumCols() < 500) {
osiclp->setupForRepeatedUse(2, 0);
printf("trying slightly less reliable but faster version (? Gomory cuts okay?)\n");
printf("may not be safe if doing cuts in tree which need accuracy (level 2 anyway)\n");
}
// Allow rounding heuristic
CbcRounding heuristic1(model);
model.addHeuristic(&heuristic1);
// And local search when new solution found
CbcHeuristicLocal heuristic2(model);
model.addHeuristic(&heuristic2);
// Redundant definition of default branching (as Default == User)
CbcBranchUserDecision branch;
model.setBranchingMethod(&branch);
// Definition of node choice
CbcCompareUser compare;
model.setNodeComparison(compare);
// Do initial solve to continuous
model.initialSolve();
// Could tune more
model.setMinimumDrop(CoinMin(1.0,
fabs(model.getMinimizationObjValue()) * 1.0e-3 + 1.0e-4));
if (model.getNumCols() < 500)
model.setMaximumCutPassesAtRoot(-100); // always do 100 if possible
else if (model.getNumCols() < 5000)
model.setMaximumCutPassesAtRoot(100); // use minimum drop
else
model.setMaximumCutPassesAtRoot(20);
//model.setMaximumCutPasses(5);
// Switch off strong branching if wanted
// model.setNumberStrong(0);
// Do more strong branching if small
if (model.getNumCols() < 5000)
model.setNumberStrong(10);
model.solver()->setIntParam(OsiMaxNumIterationHotStart, 100);
// If time is given then stop after that number of minutes
if (argc > 2) {
int minutes = atoi(argv[2]);
std::cout << "Stopping after " << minutes << " minutes" << std::endl;
assert(minutes >= 0);
model.setDblParam(CbcModel::CbcMaximumSeconds, 60.0 * minutes);
}
// Switch off most output
if (model.getNumCols() < 3000) {
model.messageHandler()->setLogLevel(1);
//model.solver()->messageHandler()->setLogLevel(0);
} else {
model.messageHandler()->setLogLevel(2);
model.solver()->messageHandler()->setLogLevel(1);
}
double time1 = CoinCpuTime();
// Do complete search
model.branchAndBound();
std::cout << " Branch and cut took " << CoinCpuTime() - time1 << " seconds, "
<< model.getNodeCount() << " nodes with objective "
<< model.getObjValue()
<< (!model.status() ? " Finished" : " Not finished")
<< std::endl;
// Print more statistics
std::cout << "Cuts at root node changed objective from " << model.getContinuousObjective()
<< " to " << model.rootObjectiveAfterCuts() << std::endl;
int numberGenerators = model.numberCutGenerators();
for (int iGenerator = 0; iGenerator < numberGenerators; iGenerator++) {
CbcCutGenerator *generator = model.cutGenerator(iGenerator);
std::cout << generator->cutGeneratorName() << " was tried "
<< generator->numberTimesEntered() << " times and created "
<< generator->numberCutsInTotal() << " cuts of which "
<< generator->numberCutsActive() << " were active after adding rounds of cuts"
<< std::endl;
}
// Print solution if any - we can't get names from Osi!
if (model.getMinimizationObjValue() < 1.0e50) {
int numberColumns = model.solver()->getNumCols();
const double *solution = model.solver()->getColSolution();
int iColumn;
std::cout << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setw(14);
std::cout << "--------------------------------------" << std::endl;
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
double value = solution[iColumn];
if (fabs(value) > 1.0e-7 && model.solver()->isInteger(iColumn))
std::cout << std::setw(6) << iColumn << " " << value << std::endl;
}
std::cout << "--------------------------------------" << std::endl;
std::cout << std::resetiosflags(std::ios::fixed | std::ios::showpoint | std::ios::scientific);
}
return 0;
}
| 32.451923 | 98 | 0.660346 | fadi-alkhoury |
e3c1816d91d7faa2bcf93f381ed482e9d6bc7388 | 15,427 | hpp | C++ | Siv3D/include/Siv3D/Image.hpp | azaika/OpenSiv3D | 2e8258ea15741b7dafa6637b50b43637f7b9923a | [
"MIT"
] | null | null | null | Siv3D/include/Siv3D/Image.hpp | azaika/OpenSiv3D | 2e8258ea15741b7dafa6637b50b43637f7b9923a | [
"MIT"
] | null | null | null | Siv3D/include/Siv3D/Image.hpp | azaika/OpenSiv3D | 2e8258ea15741b7dafa6637b50b43637f7b9923a | [
"MIT"
] | 1 | 2019-10-06T17:09:26.000Z | 2019-10-06T17:09:26.000Z | //-----------------------------------------------
//
// This file is part of the Siv3D Engine.
//
// Copyright (c) 2008-2018 Ryo Suzuki
// Copyright (c) 2016-2018 OpenSiv3D Project
//
// Licensed under the MIT License.
//
//-----------------------------------------------
# pragma once
# include <memory.h>
# include "Fwd.hpp"
# include "Array.hpp"
# include "Color.hpp"
# include "NamedParameter.hpp"
# include "PointVector.hpp"
# include "Grid.hpp"
# include "ImageFormat.hpp"
namespace s3d
{
/// <summary>
/// 画像
/// </summary>
/// <remarks>
/// メモリ上に確保される画像データです。
/// ピクセル単位のアクセスや、変形、エフェクト処理を適用できます。
/// イメージを描画する場合は Texture に変換する必要があります。
/// </remarks>
class Image
{
private:
Array<Color> m_data;
uint32 m_width = 0;
uint32 m_height = 0;
static Image Generate(const size_t width, const size_t height, std::function<Color(void)> generator);
template <class Fty>
static Image Generate(const size_t width, const size_t height, Fty generator)
{
Image new_image(width, height);
if (!new_image.isEmpty())
{
Color* pDst = new_image[0];
for (uint32 y = 0; y < height; ++y)
{
for (uint32 x = 0; x < width; ++x)
{
(*pDst++) = generator({ x, y });
}
}
}
return new_image;
}
static Image Generate0_1(const size_t width, const size_t height, std::function<Color(Vec2)> generator);
static constexpr int32 Mod(int32 x, int32 y) noexcept
{
return x % y + ((x < 0) ? y : 0);
}
public:
/// <summary>
/// 画像の最大サイズ
/// </summary>
static constexpr int32 MaxWidth = 8192;
static constexpr int32 MaxHeight = 8192;
using iterator = Array<Color>::iterator;
using const_iterator = Array<Color>::const_iterator;
using reverse_iterator = Array<Color>::reverse_iterator;
using const_reverse_iterator = Array<Color>::const_reverse_iterator;
/// <summary>
/// デフォルトコンストラクタ
/// </summary>
Image() = default;
/// <summary>
/// 画像を別の画像からコピーして作成します。
/// </summary>
/// <param name="image">
/// コピーする画像
/// </param>
Image(const Image& image) = default;
/// <summary>
/// 画像を別の画像からムーブして作成します。
/// </summary>
/// <param name="image">
/// ムーブする画像
/// </param>
Image(Image&& image) noexcept;
/// <summary>
/// 指定したサイズの画像を作成します。
/// </summary>
/// <param name="size">
/// 画像のサイズ（ピクセル）
/// </param>
explicit Image(const Size& size)
: Image(size.x, size.y) {}
/// <summary>
/// 指定した色、サイズで塗りつぶされた画像を作成します。
/// </summary>
/// <param name="size">
/// 画像のサイズ（ピクセル）
/// </param>
/// <param name="color">
/// 塗りつぶしの色
/// </param>
Image(const Size& size, const Color& color)
: Image(size.x, size.y, color) {}
Image(const Size& size, Arg::generator_<std::function<Color(void)>> generator)
: Image(size.x, size.y, generator) {}
Image(const Size& size, Arg::generator_<std::function<Color(Point)>> generator)
: Image(size.x, size.y, generator) {}
Image(const Size& size, Arg::generator_<std::function<Color(Vec2)>> generator)
: Image(size.x, size.y, generator) {}
Image(const Size& size, Arg::generator0_1_<std::function<Color(Vec2)>> generator)
: Image(size.x, size.y, generator) {}
/// <summary>
/// 指定したサイズの画像を作成します。
/// </summary>
/// <param name="width">
/// 画像の幅（ピクセル）
/// </param>
/// <param name="height">
/// 画像の高さ（ピクセル）
/// </param>
Image(size_t width, size_t height);
Image(size_t width, size_t height, Arg::generator_<std::function<Color(void)>> generator)
: Image(Generate(width, height, *generator)) {}
Image(size_t width, size_t height, Arg::generator_<std::function<Color(Point)>> generator)
: Image(Generate(width, height, *generator)) {}
Image(size_t width, size_t height, Arg::generator_<std::function<Color(Vec2)>> generator)
: Image(Generate(width, height, *generator)) {}
Image(size_t width, size_t height, Arg::generator0_1_<std::function<Color(Vec2)>> generator)
: Image(Generate0_1(width, height, *generator)) {}
/// <summary>
/// 指定した色、サイズで塗りつぶされた画像を作成します。
/// </summary>
/// <param name="width">
/// 画像の幅（ピクセル）
/// </param>
/// <param name="height">
/// 画像の高さ（ピクセル）
/// </param>
/// <param name="color">
/// 塗りつぶしの色
/// </param>
Image(size_t width, size_t height, const Color& color);
/// <summary>
/// 画像ファイルから画像を作成します。
/// </summary>
/// <param name="path">
/// 画像ファイルのパス
/// </param>
explicit Image(const FilePath& path);
/// <summary>
/// Reader から画像を作成します。
/// </summary>
/// <param name="reader">
/// Reader
/// </param>
/// <param name="format">
/// 画像のフォーマット
/// </param>
explicit Image(IReader&& reader, ImageFormat format = ImageFormat::Unspecified);
/// <summary>
/// 2 つの画像ファイルから画像を作成します。
/// </summary>
/// <param name="rgb">
/// RGB を読み込む画像ファイルのパス
/// </param>
/// <param name="alpha">
/// アルファ値を読み込む画像ファイルのパス
/// </param>
Image(const FilePath& rgb, const FilePath& alpha);
/// <summary>
/// 画像ファイルからアルファ値を作成し、画像を作成します。
/// </summary>
/// <param name="rgb">
/// RGB 成分の色
/// </param>
/// <param name="alpha">
/// アルファ値を読み込む画像ファイルのパス
/// </param>
/// <remarks>
/// alpha の画像の R 成分を、テクスチャのアルファ値に設定します。
/// 画像ファイルの読み込みに失敗した場合、空のテクスチャを作成します。
/// </remarks>
Image(const Color& rgb, const FilePath& alpha);
explicit Image(const Emoji& emoji);
explicit Image(const Icon& icon);
explicit Image(const Grid<Color>& grid);
explicit Image(const Grid<ColorF>& grid);
template <class Type, class Fty>
explicit Image(const Grid<Type>& grid, Fty converter)
: Image(grid.width(), grid.height())
{
if (m_data.empty())
{
return;
}
const Type* pSrc = grid.data();
const Type* const pSrcEnd = pSrc + grid.size_elements();
Color* pDst = &m_data[0];
while (pSrc != pSrcEnd)
{
*pDst++ = converter(*pSrc++);
}
}
/// <summary>
/// 新しい画像を代入します。
/// </summary>
/// <param name="str">
/// 新しい画像
/// </param>
/// <returns>
/// *this
/// </returns>
Image& operator =(const Image& image) = default;
/// <summary>
/// 新しい画像を代入します。
/// </summary>
/// <param name="str">
/// 新しい画像
/// </param>
/// <returns>
/// *this
/// </returns>
Image& operator =(Image&& image);
Image& assign(const Image& image)
{
return operator =(image);
}
Image& assign(Image&& image)
{
return operator =(std::move(image));
}
/// <summary>
/// 画像の幅（ピクセル）
/// </summary>
int32 width() const noexcept
{
return m_width;
}
/// <summary>
/// 画像の高さ（ピクセル）
/// </summary>
int32 height() const noexcept
{
return m_height;
}
/// <summary>
/// 画像の幅と高さ（ピクセル）
/// </summary>
Size size() const noexcept
{
return{ m_width, m_height };
}
/// <summary>
/// 画像の各行のデータサイズ
/// </summary>
uint32 stride() const noexcept
{
return m_width * sizeof(Color);
}
/// <summary>
/// 画像のピクセル数
/// </summary>
uint32 num_pixels() const noexcept
{
return m_width * m_height;
}
/// <summary>
/// 画像のデータサイズ
/// </summary>
uint32 size_bytes() const
{
return stride() * m_height;
}
/// <summary>
/// 画像が空かどうかを示します。
/// </summary>
bool isEmpty() const
{
return m_data.empty();
}
/// <summary>
/// 画像が空ではないかを返します。
/// </summary>
/// <returns>
/// 画像が空ではない場合 true, それ以外の場合は false
/// </returns>
explicit operator bool() const
{
return !isEmpty();
}
/// <summary>
/// 画像の不要なメモリ消費を削除します。
/// </summary>
/// <returns>
/// なし
/// </returns>
void shrink_to_fit()
{
m_data.shrink_to_fit();
}
/// <summary>
/// 画像を消去し、空の画像にします。
/// </summary>
/// <remarks>
/// メモリを解放したい場合は shrink_to_fit() を呼びます。
/// </remarks>
/// <returns>
/// なし
/// </returns>
void clear()
{
m_data.clear();
m_width = m_height = 0;
}
void release()
{
clear();
shrink_to_fit();
}
/// <summary>
/// 画像を別の画像と交換します。
/// </summary>
/// <param name="image">
/// 交換する画像
/// </param>
/// <returns>
/// なし
/// </returns>
void swap(Image& image) noexcept
{
m_data.swap(image.m_data);
std::swap(m_width, image.m_width);
std::swap(m_height, image.m_height);
}
/// <summary>
/// 画像をコピーした新しい画像を返します。
/// </summary>
/// <returns>
/// コピーした新しい画像
/// </returns>
Image cloned() const
{
return *this;
}
/// <summary>
/// 指定した行の先頭ポインタを返します。
/// </summary>
/// <param name="y">
/// 位置(行)
/// </param>
/// <returns>
/// image[y][x] で指定したピクセルにアクセスします。
/// </returns>
/// <returns>
/// 指定した行の先頭ポインタ
/// </returns>
Color* operator[](size_t y)
{
return &m_data[m_width * y];
}
Color& operator[](const Point& pos)
{
return m_data[m_width * pos.y + pos.x];
}
/// <summary>
/// 指定した行の先頭ポインタを返します。
/// </summary>
/// <param name="y">
/// 位置(行)
/// </param>
/// <returns>
/// image[y][x] で指定したピクセルにアクセスします。
/// </returns>
/// <returns>
/// 指定した行の先頭ポインタ
/// </returns>
const Color* operator[](size_t y) const
{
return &m_data[m_width * y];
}
const Color& operator[](const Point& pos) const
{
return m_data[m_width * pos.y + pos.x];
}
/// <summary>
/// 画像データの先頭のポインタを返します。
/// </summary>
/// <returns>
/// 画像データの先頭へのポインタ
/// </returns>
Color* data()
{
return &m_data[0];
}
/// <summary>
/// 画像データの先頭のポインタを返します。
/// </summary>
/// <returns>
/// 画像データの先頭へのポインタ
/// </returns>
const Color* data() const
{
return &m_data[0];
}
/// <summary>
/// 画像データの先頭のポインタを返します。
/// </summary>
/// <returns>
/// 画像データの先頭へのポインタ
/// </returns>
uint8* dataAsUint8()
{
return static_cast<uint8*>(static_cast<void*>(&m_data[0]));
}
/// <summary>
/// 画像データの先頭のポインタを返します。
/// </summary>
/// <returns>
/// 画像データの先頭へのポインタ
/// </returns>
const uint8* dataAsUint8() const
{
return static_cast<const uint8*>(static_cast<const void*>(&m_data[0]));
}
/// <summary>
/// 画像の先頭位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭位置のイテレータ
/// </returns>
iterator begin() noexcept { return m_data.begin(); }
/// <summary>
/// 画像の先頭位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭位置のイテレータ
/// </returns>
const_iterator begin() const noexcept { return m_data.begin(); }
/// <summary>
/// 画像の先頭位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭位置のイテレータ
/// </returns>
const_iterator cbegin() const noexcept { return m_data.cbegin(); }
/// <summary>
/// 画像の終了位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の終了位置のイテレータ
/// </returns>
iterator end() noexcept { return m_data.end(); }
/// <summary>
/// 画像の終了位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の終了位置のイテレータ
/// </returns>
const_iterator end() const noexcept { return m_data.end(); }
/// <summary>
/// 画像の終了位置のイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の終了位置のイテレータ
/// </returns>
const_iterator cend() const noexcept { return m_data.cend(); }
/// <summary>
/// 画像の末尾へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の末尾へのリバースイテレータ
/// </returns>
reverse_iterator rbegin() noexcept { return m_data.rbegin(); }
/// <summary>
/// 画像の末尾へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の末尾へのリバースイテレータ
/// </returns>
const_reverse_iterator rbegin() const noexcept { return m_data.rbegin(); }
/// <summary>
/// 画像の末尾へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の末尾へのリバースイテレータ
/// </returns>
const_reverse_iterator crbegin() const noexcept { return m_data.crbegin(); }
/// <summary>
/// 画像の先頭の前へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭の前へのリバースイテレータ
/// </returns>
reverse_iterator rend() noexcept { return m_data.rend(); }
/// <summary>
/// 画像の先頭の前へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭の前へのリバースイテレータ
/// </returns>
const_reverse_iterator rend() const noexcept { return m_data.rend(); }
/// <summary>
/// 画像の先頭の前へのリバースイテレータを取得します。
/// </summary>
/// <returns>
/// 画像の先頭の前へのリバースイテレータ
/// </returns>
const_reverse_iterator crend() const noexcept { return m_data.crend(); }
/// <summary>
/// 画像を指定した色で塗りつぶします。
/// </summary>
/// <param name="color">
/// 塗りつぶしの色
/// </param>
/// <returns>
/// なし
/// </returns>
void fill(const Color& color)
{
for (auto& pixel : m_data)
{
pixel = color;
}
}
/// <summary>
/// 画像のサイズを変更します。
/// </summary>
/// <param name="width">
/// 新しい幅(ピクセル)
/// </param>
/// <param name="height">
/// 新しい高さ(ピクセル)
/// </param>
/// <remarks>
/// サイズの変更が必要ないときは何もしません。
/// サイズが変更された場合、すべての要素の値が不定になります。
/// 画像を拡大縮小する場合は scale() を使ってください。
/// </remarks>
/// <returns>
/// なし
/// </returns>
void resize(size_t width, size_t height);
/// <summary>
/// 画像のサイズを変更します。
/// </summary>
/// <param name="size">
/// 新しいサイズ(ピクセル)
/// </param>
/// <remarks>
/// サイズの変更が必要ないときは何もしません。
/// サイズが変更された場合、すべての要素の値が不定になります。
/// 画像を拡大縮小する場合は scale() を使ってください。
/// </remarks>
/// <returns>
/// なし
/// </returns>
void resize(const Size& size)
{
resize(size.x, size.y);
}
/// <summary>
/// 画像のサイズを変更します。
/// </summary>
/// <param name="width">
/// 新しい幅(ピクセル)
/// </param>
/// <param name="height">
/// 新しい高さ(ピクセル)
/// </param>
/// <param name="fillColor">
/// 塗りつぶしの色
/// </param>
/// <remarks>
/// サイズの変更が必要ないときは何もしません。
/// サイズが変更された場合、すべての要素が fillColor で塗りつぶされます。
/// 画像を拡大縮小する場合は scale() を使ってください。
/// </remarks>
/// <returns>
/// なし
/// </returns>
void resize(size_t width, size_t height, const Color& fillColor);
/// <summary>
/// 画像のサイズを変更します。
/// </summary>
/// <param name="size">
/// 新しいサイズ(ピクセル)
/// </param>
/// <param name="fillColor">
/// 塗りつぶしの色
/// </param>
/// <remarks>
/// サイズの変更が必要ないときは何もしません。
/// サイズが変更された場合、すべての要素が fillColor で塗りつぶされます。
/// 画像を拡大縮小する場合は scale() を使ってください。
/// </remarks>
/// <returns>
/// なし
/// </returns>
void resize(const Size& size, const Color& fillColor)
{
resize(size.x, size.y, fillColor);
}
void resizeRows(size_t rows, const Color& fillColor);
const Color& getPixel_Repeat(int32 x, int32 y) const
{
return m_data[m_width * Mod(y, m_height) + Mod(x, m_width)];
}
const Color& getPixel_Repeat(const Point& pos) const
{
return getPixel_Repeat(pos.x, pos.y);
}
/// <summary>
/// すべてのピクセルに変換関数を適用します。
/// </summary>
/// <param name="function">
/// 変換関数
/// </param>
/// <returns>
/// *this
/// </returns>
Image& forEach(std::function<void(Color&)> function)
{
for (auto& pixel : m_data)
{
function(pixel);
}
return *this;
}
Image& swapRB()
{
for (auto& pixel : m_data)
{
const uint32 t = pixel.r;
pixel.r = pixel.b;
pixel.b = t;
}
return *this;
}
bool applyAlphaFromRChannel(const FilePath& alpha);
Image& mirror();
Image& flip();
bool save(const FilePath& path, ImageFormat format = ImageFormat::Unspecified) const;
bool savePNG(const FilePath& path, PNGFilter::Flag filterFlag = PNGFilter::Default) const;
bool saveJPEG(const FilePath& path, int32 quality = 90) const;
bool savePPM(const FilePath& path, PPMType format = PPMType::AsciiRGB) const;
MemoryWriter encode(ImageFormat format = ImageFormat::PNG) const;
};
}
namespace std
{
inline void swap(s3d::Image& a, s3d::Image& b) noexcept
{
a.swap(b);
}
}
| 20.113429 | 106 | 0.586504 | azaika |
e3c4285bb9425bbeb1007299cd46aba3dc459ba1 | 1,832 | hpp | C++ | src/base/factory/AtmosphereFactory.hpp | ddj116/gmat | 39673be967d856f14616462fb6473b27b21b149f | [
"NASA-1.3"
] | 1 | 2020-05-16T16:58:21.000Z | 2020-05-16T16:58:21.000Z | src/base/factory/AtmosphereFactory.hpp | ddj116/gmat | 39673be967d856f14616462fb6473b27b21b149f | [
"NASA-1.3"
] | null | null | null | src/base/factory/AtmosphereFactory.hpp | ddj116/gmat | 39673be967d856f14616462fb6473b27b21b149f | [
"NASA-1.3"
] | null | null | null | //$Id: AtmosphereFactory.hpp 10639 2012-07-12 15:21:10Z djcinsb $
//------------------------------------------------------------------------------
// AtmosphereFactory
//------------------------------------------------------------------------------
// GMAT: General Mission Analysis Tool
//
// Copyright (c) 2002-2011 United States Government as represented by the
// Administrator of The National Aeronautics and Space Administration.
// All Other Rights Reserved.
//
// Developed jointly by NASA/GSFC and Thinking Systems, Inc. under contract
// number S-67573-G
//
// Author: Wendy Shoan
// Created: 2004/08/12
//
/**
* This class is the factory class for Atmospheres.
*/
//------------------------------------------------------------------------------
#ifndef AtmosphereFactory_hpp
#define AtmosphereFactory_hpp
#include "gmatdefs.hpp"
#include "Factory.hpp"
#include "AtmosphereModel.hpp"
class GMAT_API AtmosphereFactory : public Factory
{
public:
AtmosphereModel* CreateAtmosphereModel(const std::string &ofType,
const std::string &withName = "",
const std::string &forBody = "Earth");
// method to return list of types of objects that this factory can create
virtual StringArray GetListOfCreatableObjects(
const std::string &qualifier = "Earth");
// default constructor
AtmosphereFactory();
// constructor
AtmosphereFactory(StringArray createList);
// copy constructor
AtmosphereFactory(const AtmosphereFactory& fact);
// assignment operator
AtmosphereFactory& operator= (const AtmosphereFactory& fact);
// destructor
~AtmosphereFactory();
protected:
// protected data
private:
};
#endif // AtmosphereFactory_hpp
| 28.625 | 81 | 0.582969 | ddj116 |
e3ca57227dce7f550a974332d997d4e6a380c9d8 | 1,664 | hpp | C++ | src/winthread.hpp | leavinel/BPG-Plugins | 1a017906bc1162779b95967f034d3b83bb730359 | [
"MIT"
] | 21 | 2015-09-09T13:45:08.000Z | 2021-11-24T05:56:00.000Z | src/winthread.hpp | leavinel/bpg_plugins | 1a017906bc1162779b95967f034d3b83bb730359 | [
"MIT"
] | 9 | 2015-11-23T12:46:36.000Z | 2017-12-18T09:50:26.000Z | src/winthread.hpp | leavinel/bpg_plugins | 1a017906bc1162779b95967f034d3b83bb730359 | [
"MIT"
] | 1 | 2017-01-23T23:38:33.000Z | 2017-01-23T23:38:33.000Z | /**
* @file
*
*
* @author Leav Wu ([email protected])
*/
#ifndef _WINTHREAD_HPP_
#define _WINTHREAD_HPP_
#include <windows.h>
#include <list>
#include <functional>
/**
* Subset of windows thread synchronization C++ wrapper
*/
namespace winthread {
/**
* Wrapper of windows HANDLE
*/
class handle
{
protected:
HANDLE h;
public:
handle(): h(NULL) {}
~handle();
void wait (DWORD timeout = INFINITE);
};
class mutex: private handle
{
public:
mutex();
void lock() { wait(); }
void unlock();
};
class lock_guard
{
private:
mutex &mtx;
public:
lock_guard (mutex &mtx): mtx(mtx) {
mtx.lock();
}
~lock_guard() {
mtx.unlock();
}
};
class event: private handle
{
public:
enum {
OPT_MANUAL_RESET = 1 << 0,
OPT_INIT_SIGNALED = 1 << 1,
};
event (int opts = 0);
void wait() { handle::wait(); }
void signal();
void reset();
};
class cond_var
{
private:
mutex waitMtx;
std::list<event*> waitList;
public:
cond_var() {}
/** Mutex must be locked before call */
void wait (mutex &mtx);
void notify_one();
void notify_all();
};
class thread: private handle
{
private:
std::function<void()> task;
volatile bool b_joinable;
unsigned threadId;
mutex joinMtx;
event beginEv;
public:
thread(): b_joinable(false), threadId(0), beginEv(event::OPT_MANUAL_RESET) {}
virtual ~thread();
bool joinable();
void start (std::function<void()> &task);
void join();
private:
unsigned procedure();
static unsigned WINAPI _procedure (void *_thiz);
};
}
#endif /* _WINTHREAD_HPP_ */
| 13.528455 | 81 | 0.59976 | leavinel |
e3ca99b624052f24f397568dc621e294be99c1b5 | 23,102 | hh | C++ | Core/MarchingCubes.hh | ThibaultReuille/raindance | 79f1f6aeeaf6cbe378e911cd510e6550ae34eb75 | [
"BSD-2-Clause"
] | 12 | 2015-01-15T03:30:10.000Z | 2022-02-24T21:25:29.000Z | Core/MarchingCubes.hh | ThibaultReuille/raindance | 79f1f6aeeaf6cbe378e911cd510e6550ae34eb75 | [
"BSD-2-Clause"
] | 1 | 2017-06-06T15:39:21.000Z | 2017-06-06T15:39:21.000Z | Core/MarchingCubes.hh | ThibaultReuille/raindance | 79f1f6aeeaf6cbe378e911cd510e6550ae34eb75 | [
"BSD-2-Clause"
] | 4 | 2015-07-02T22:06:56.000Z | 2022-02-24T21:25:30.000Z | #pragma once
#include <raindance/Core/Headers.hh>
static int g_EdgeTable[256]=
{
0x0 , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0
};
static int g_TriTable[256][16] =
{
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
{3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
{4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
{9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
{10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
{5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
{8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
{2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
{11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
{5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
{11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
{11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
{9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
{6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
{6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
{8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
{7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
{3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
{9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
{8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
{0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
{6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
{10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
{10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
{0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
{3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
{9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
{8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
{3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
{10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
{10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
{7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
{1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
{11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
{8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
{0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
{7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
{7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
{10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
{0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
{7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
{9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
{6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
{4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
{10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
{8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
{1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
{10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
{10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
{9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
{7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
{3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
{7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
{3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
{6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
{9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
{1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
{4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
{7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
{6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
{0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
{6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
{0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
{11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
{6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
{5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
{9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
{1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
{10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
{0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
{5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
{11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
{9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
{7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
{2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
{9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
{1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
{10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
{2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
{0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
{0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
{9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
{5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
{5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
{9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
{1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
{3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
{4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
{9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
{11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
{2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
{9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
{3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
{1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
{4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
{0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
{1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
};
class MarchingCubes
{
public:
struct Cell
{
float Scalar;
};
class Grid
{
public:
Grid(unsigned int x, unsigned int y, unsigned int z, const glm::vec3& min, const glm::vec3& max)
{
m_Dimension[0] = x;
m_Dimension[1] = y;
m_Dimension[2] = z;
m_Min = min;
m_Max = max;
m_Step.x = fabs(max.x - min.x) / (float) x;
m_Step.y = fabs(max.y - min.y) / (float) y;
m_Step.z = fabs(max.z - min.z) / (float) z;
m_Cells = new Cell[x * y * z];
}
~Grid()
{
if (m_Cells != NULL)
delete[] m_Cells;
}
inline Cell& cell(unsigned x, unsigned int y, unsigned int z)
{
return m_Cells[x + y * m_Dimension[0] + z * m_Dimension[0] * m_Dimension[1]];
}
inline glm::vec3 getPosition(unsigned x, unsigned int y, unsigned int z)
{
return m_Min + glm::vec3((float) x, (float) y, (float) z) * m_Step;
}
glm::vec3 interpolatePoints (unsigned int x, unsigned int y, unsigned int z, const unsigned int p1[3], const unsigned int p2[3], float isolevel)
{
const float epsilon = std::numeric_limits<float>::epsilon();
glm::vec3 v1, v2;
float w1, w2;
v1 = getPosition(x + p1[0], y + p1[1], z + p1[2]);
v2 = getPosition(x + p2[0], y + p2[1], z + p2[2]);
w1 = cell(x + p1[0], y + p1[1], z + p1[2]).Scalar;
w2 = cell(x + p2[0], y + p2[1], z + p2[2]).Scalar;
if (fabs (isolevel - w1) < epsilon)
return v1;
if (fabs (isolevel - w2) < epsilon)
return v2;
if (fabs (w1 - w2) < epsilon)
return (v1);
return v1 + ((isolevel - w1) / (w2 - w1)) * (v2 - v1);
}
inline unsigned int getWidth() { return m_Dimension[0]; }
inline unsigned int getHeight() { return m_Dimension[1]; }
inline unsigned int getDepth() { return m_Dimension[2]; }
inline glm::vec3 getStep() { return m_Step; }
private:
Cell* m_Cells;
unsigned int m_Dimension[3];
glm::vec3 m_Min;
glm::vec3 m_Max;
glm::vec3 m_Step;
};
MarchingCubes()
{
m_Grid = NULL;
}
virtual ~MarchingCubes()
{
SAFE_DELETE(m_Grid);
}
void buildGrid(PointCloud* isovolume, unsigned int dimension[3], const glm::vec3& min, const glm::vec3& max)
{
LOG("[MARCHINGCUBES] Building Grid : dim (%u, %u, %u), min(%f, %f, %f), max(%f, %f, %f) ...\n", dimension[0], dimension[1], dimension[2], min.x, min.y, min.z, max.x, max.x, max.z);
SAFE_DELETE(m_Grid);
m_Grid = new Grid(dimension[0], dimension[1], dimension[2], min, max);
glm::vec3 pos;
for (unsigned int z = 0; z < dimension[2]; z++)
for (unsigned int y = 0; y < dimension[1]; y++)
for (unsigned int x = 0; x < dimension[0]; x++)
{
pos = m_Grid->getPosition(x, y, z);
m_Grid->cell(x, y, z).Scalar = isovolume->computeScalar(pos);
LOG("Grid(%u, %u, %u) : pos(%f, %f, %f) = %f\n", x, y, z, pos.x, pos.y, pos.z, m_Grid->cell(x, y, z).Scalar);
}
}
void polygonize(float isolevel, Mesh& mesh)
{
LOG("[MARCHINGCUBES] Polygonizing (isolevel = %f) ...\n", isolevel);
const unsigned int points[8][3] =
{
{0, 0, 0},
{1, 0, 0},
{1, 0, 1},
{0, 0, 1},
{0, 1, 0},
{1, 1, 0},
{1, 1, 1},
{0, 1, 1}
};
for (unsigned int z = 0; z < m_Grid->getDepth() - 1; z++)
for (unsigned int y = 0; y < m_Grid->getHeight() - 1; y++)
for (unsigned int x = 0; x < m_Grid->getWidth() - 1; x++)
{
// Determine the index into the edge table which
// tells us which vertices are inside of the surface
int cubeindex = 0;
for (int i = 0; i < 8; i++)
if (m_Grid->cell(x + points[i][0], y + points[i][1], z + points[i][2]).Scalar < isolevel)
cubeindex |= 1 << i;
LOG("Cell (%u, %u, %u) : cubeindex = %u\n", x, y, z, cubeindex);
// Cube is entirely in/out of the surface
if (g_EdgeTable[cubeindex] == 0)
continue;
glm::vec3 v[8];
for (int i = 0 ; i < 8; i++)
v[i] = m_Grid->getPosition(x + points[i][0], y + points[i][1], z + points[i][2]);
glm::vec3 ce[12];
if (g_EdgeTable[cubeindex] & 1)
ce[0] = m_Grid->interpolatePoints(x, y, z, points[0], points[1], isolevel);
if (g_EdgeTable[cubeindex] & 2)
ce[1] = m_Grid->interpolatePoints(x, y, z, points[1], points[2], isolevel);
if (g_EdgeTable[cubeindex] & 4)
ce[2] = m_Grid->interpolatePoints(x, y, z, points[2], points[3], isolevel);
if (g_EdgeTable[cubeindex] & 8)
ce[3] = m_Grid->interpolatePoints(x, y, z, points[3], points[0], isolevel);
if (g_EdgeTable[cubeindex] & 16)
ce[4] = m_Grid->interpolatePoints(x, y, z, points[4], points[5], isolevel);
if (g_EdgeTable[cubeindex] & 32)
ce[5] = m_Grid->interpolatePoints(x, y, z, points[5], points[6], isolevel);
if (g_EdgeTable[cubeindex] & 64)
ce[6] = m_Grid->interpolatePoints(x, y, z, points[6], points[7], isolevel);
if (g_EdgeTable[cubeindex] & 128)
ce[7] = m_Grid->interpolatePoints(x, y, z, points[7], points[4], isolevel);
if (g_EdgeTable[cubeindex] & 256)
ce[8] = m_Grid->interpolatePoints(x, y, z, points[0], points[4], isolevel);
if (g_EdgeTable[cubeindex] & 512)
ce[9] = m_Grid->interpolatePoints(x, y, z, points[1], points[5], isolevel);
if (g_EdgeTable[cubeindex] & 1024)
ce[10] = m_Grid->interpolatePoints(x, y, z, points[2], points[6], isolevel);
if (g_EdgeTable[cubeindex] & 2048)
ce[11] = m_Grid->interpolatePoints(x, y, z, points[3], points[7], isolevel);
for (int i = 0; g_TriTable[cubeindex][i] != -1 ; i += 3)
{
glm::vec3 p1 = ce[g_TriTable[cubeindex][i]];
glm::vec3 p2 = ce[g_TriTable[cubeindex][i + 1]];
glm::vec3 p3 = ce[g_TriTable[cubeindex][i + 2]];
glm::vec3 n = glm::cross(p3 - p1, p2 - p1);
Mesh::Vertex::ID v1 = mesh.addVertex(Mesh::Vertex(p1, n));
LOG("addVertex(%f, %f, %f)\n", p1.x, p1.y, p1.z);
Mesh::Vertex::ID v2 = mesh.addVertex(Mesh::Vertex(p2, n));
LOG("addVertex(%f, %f, %f)\n", p2.x, p2.y, p2.z);
Mesh::Vertex::ID v3 = mesh.addVertex(Mesh::Vertex(p3, n));
LOG("addVertex(%f, %f, %f)\n", p3.x, p3.y, p3.z);
Mesh::Triangle::ID t = mesh.addTriangle(Mesh::Triangle(v1, v2, v3));
LOG("addTriangle(%u, %u, %u) : %u\n", v1, v2, v3, t);
}
}
}
private:
Grid* m_Grid;
};
| 45.928429 | 182 | 0.407194 | ThibaultReuille |
e3cd0ee0048780f429888ecae49256d4ef095d7c | 3,856 | hpp | C++ | include/UnityEngine/EventSystems/AxisEventData.hpp | darknight1050/BeatSaber-Quest-Codegen | a6eeecc3f0e8f6079630f9a9a72b3121ac7b2032 | [
"Unlicense"
] | null | null | null | include/UnityEngine/EventSystems/AxisEventData.hpp | darknight1050/BeatSaber-Quest-Codegen | a6eeecc3f0e8f6079630f9a9a72b3121ac7b2032 | [
"Unlicense"
] | null | null | null | include/UnityEngine/EventSystems/AxisEventData.hpp | darknight1050/BeatSaber-Quest-Codegen | a6eeecc3f0e8f6079630f9a9a72b3121ac7b2032 | [
"Unlicense"
] | null | null | null | // Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "extern/beatsaber-hook/shared/utils/typedefs.h"
// Including type: UnityEngine.EventSystems.BaseEventData
#include "UnityEngine/EventSystems/BaseEventData.hpp"
// Including type: UnityEngine.Vector2
#include "UnityEngine/Vector2.hpp"
// Including type: UnityEngine.EventSystems.MoveDirection
#include "UnityEngine/EventSystems/MoveDirection.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-properties.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-fields.hpp"
#include "extern/beatsaber-hook/shared/utils/utils.h"
// Completed includes
// Begin forward declares
// Forward declaring namespace: UnityEngine::EventSystems
namespace UnityEngine::EventSystems {
// Forward declaring type: EventSystem
class EventSystem;
}
// Completed forward declares
// Type namespace: UnityEngine.EventSystems
namespace UnityEngine::EventSystems {
// Size: 0x2C
#pragma pack(push, 1)
// Autogenerated type: UnityEngine.EventSystems.AxisEventData
class AxisEventData : public UnityEngine::EventSystems::BaseEventData {
public:
// [CompilerGeneratedAttribute] Offset: 0xDC8B1C
// private UnityEngine.Vector2 <moveVector>k__BackingField
// Size: 0x8
// Offset: 0x20
UnityEngine::Vector2 moveVector;
// Field size check
static_assert(sizeof(UnityEngine::Vector2) == 0x8);
// [CompilerGeneratedAttribute] Offset: 0xDC8B2C
// private UnityEngine.EventSystems.MoveDirection <moveDir>k__BackingField
// Size: 0x4
// Offset: 0x28
UnityEngine::EventSystems::MoveDirection moveDir;
// Field size check
static_assert(sizeof(UnityEngine::EventSystems::MoveDirection) == 0x4);
// Creating value type constructor for type: AxisEventData
AxisEventData(UnityEngine::Vector2 moveVector_ = {}, UnityEngine::EventSystems::MoveDirection moveDir_ = {}) noexcept : moveVector{moveVector_}, moveDir{moveDir_} {}
// public UnityEngine.Vector2 get_moveVector()
// Offset: 0x1412178
UnityEngine::Vector2 get_moveVector();
// public System.Void set_moveVector(UnityEngine.Vector2 value)
// Offset: 0x1412180
void set_moveVector(UnityEngine::Vector2 value);
// public UnityEngine.EventSystems.MoveDirection get_moveDir()
// Offset: 0x1412188
UnityEngine::EventSystems::MoveDirection get_moveDir();
// public System.Void set_moveDir(UnityEngine.EventSystems.MoveDirection value)
// Offset: 0x1412190
void set_moveDir(UnityEngine::EventSystems::MoveDirection value);
// public System.Void .ctor(UnityEngine.EventSystems.EventSystem eventSystem)
// Offset: 0x1412198
// Implemented from: UnityEngine.EventSystems.BaseEventData
// Base method: System.Void BaseEventData::.ctor(UnityEngine.EventSystems.EventSystem eventSystem)
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static AxisEventData* New_ctor(UnityEngine::EventSystems::EventSystem* eventSystem) {
static auto ___internal__logger = ::Logger::get().WithContext("UnityEngine::EventSystems::AxisEventData::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<AxisEventData*, creationType>(eventSystem)));
}
}; // UnityEngine.EventSystems.AxisEventData
#pragma pack(pop)
static check_size<sizeof(AxisEventData), 40 + sizeof(UnityEngine::EventSystems::MoveDirection)> __UnityEngine_EventSystems_AxisEventDataSizeCheck;
static_assert(sizeof(AxisEventData) == 0x2C);
}
DEFINE_IL2CPP_ARG_TYPE(UnityEngine::EventSystems::AxisEventData*, "UnityEngine.EventSystems", "AxisEventData");
| 51.413333 | 170 | 0.741961 | darknight1050 |
e3d8ca87b7ffd8735aa24d0b5e6d7f87e6cae262 | 5,434 | cc | C++ | drivers/bluetooth/lib/l2cap/pdu.cc | kong1191/garnet | 609c727895e477ac086db38c1cee654dc10f2008 | [
"BSD-3-Clause"
] | null | null | null | drivers/bluetooth/lib/l2cap/pdu.cc | kong1191/garnet | 609c727895e477ac086db38c1cee654dc10f2008 | [
"BSD-3-Clause"
] | null | null | null | drivers/bluetooth/lib/l2cap/pdu.cc | kong1191/garnet | 609c727895e477ac086db38c1cee654dc10f2008 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "pdu.h"
#include "garnet/drivers/bluetooth/lib/common/log.h"
#include "garnet/drivers/bluetooth/lib/hci/acl_data_packet.h"
namespace btlib {
namespace l2cap {
PDU::Reader::Reader(const PDU* pdu)
: offset_(sizeof(BasicHeader)),
frag_offset_(sizeof(BasicHeader)),
pdu_(pdu) {
ZX_DEBUG_ASSERT(pdu_);
ZX_DEBUG_ASSERT(pdu_->is_valid());
cur_fragment_ = pdu_->fragments_.cbegin();
}
bool PDU::Reader::ReadNext(size_t size, const ReadFunc& func) {
ZX_DEBUG_ASSERT(func);
if (!size)
return false;
if (cur_fragment_ == pdu_->fragments_.cend() ||
offset_ + size > pdu_->length() + sizeof(BasicHeader)) {
return false;
}
// Return a view to avoid copying if the fragment boundary is not being
// crossed.
size_t frag_size = cur_fragment_->view().payload_size();
if (frag_offset_ + size <= frag_size) {
auto data_view =
cur_fragment_->view().payload_data().view(frag_offset_, size);
offset_ += size;
frag_offset_ += size;
if (frag_offset_ == frag_size) {
frag_offset_ = 0u;
++cur_fragment_;
}
func(data_view);
return true;
}
// TODO(armansito): This will work fine for small sizes but we'll need to
// dynamically allocate for packets that are large. Fix this once L2CAP slab
// allocators have been wired up.
if (size > 1024) {
bt_log(WARN, "l2cap", "need to dynamically allocate buffer (size: %zu)",
size);
return false;
}
uint8_t buffer[size];
common::MutableBufferView out(buffer, size);
size_t remaining = size;
while (cur_fragment_ != pdu_->fragments_.cend() && remaining) {
// Calculate how much to copy from the current fragment.
auto payload = cur_fragment_->view().payload_data();
size_t copy_size = std::min(payload.size() - frag_offset_, remaining);
out.Write(payload.data() + frag_offset_, copy_size, size - remaining);
offset_ += copy_size;
frag_offset_ += copy_size;
remaining -= copy_size;
// Reset fragment offset if we processed an entire fragment.
ZX_DEBUG_ASSERT(frag_offset_ <= payload.size());
if (frag_offset_ == payload.size()) {
frag_offset_ = 0u;
++cur_fragment_;
}
}
func(out);
return true;
}
PDU::PDU() : fragment_count_(0u) {}
// NOTE: The order in which these are initialized matters, as
// other.ReleaseFragments() resets |other.fragment_count_|.
PDU::PDU(PDU&& other)
: fragment_count_(other.fragment_count_),
fragments_(other.ReleaseFragments()) {}
PDU& PDU::operator=(PDU&& other) {
// NOTE: The order in which these are initialized matters, as
// other.ReleaseFragments() resets |other.fragment_count_|.
fragment_count_ = other.fragment_count_;
fragments_ = other.ReleaseFragments();
return *this;
}
size_t PDU::Copy(common::MutableByteBuffer* out_buffer, size_t pos,
size_t size) const {
ZX_DEBUG_ASSERT(out_buffer);
ZX_DEBUG_ASSERT(pos < length());
ZX_DEBUG_ASSERT(is_valid());
size_t remaining = std::min(size, length() - pos);
ZX_DEBUG_ASSERT(out_buffer->size() >= remaining);
bool found = false;
size_t offset = 0u;
for (auto iter = fragments_.begin(); iter != fragments_.end() && remaining;
++iter) {
auto payload = iter->view().payload_data();
// Skip the Basic L2CAP header for the first fragment.
if (iter == fragments_.begin()) {
payload = payload.view(sizeof(BasicHeader));
}
// We first find the beginning fragment based on |pos|.
if (!found) {
size_t fragment_size = payload.size();
if (pos >= fragment_size) {
pos -= fragment_size;
continue;
}
// The beginning fragment has been found.
found = true;
}
// Calculate how much to read from the current fragment
size_t write_size = std::min(payload.size() - pos, remaining);
// Read the fragment into out_buffer->mutable_data() + offset.
out_buffer->Write(payload.data() + pos, write_size, offset);
// Clear |pos| after using it on the first fragment as all successive
// fragments are read from the beginning.
if (pos)
pos = 0u;
offset += write_size;
remaining -= write_size;
}
return offset;
}
const common::BufferView PDU::ViewFirstFragment(size_t size) const {
ZX_DEBUG_ASSERT(is_valid());
return fragments_.begin()->view().payload_data().view(sizeof(BasicHeader),
size);
}
PDU::FragmentList PDU::ReleaseFragments() {
auto out_list = std::move(fragments_);
fragment_count_ = 0u;
ZX_DEBUG_ASSERT(!is_valid());
return out_list;
}
const BasicHeader& PDU::basic_header() const {
ZX_DEBUG_ASSERT(!fragments_.is_empty());
const auto& fragment = *fragments_.begin();
ZX_DEBUG_ASSERT(fragment.packet_boundary_flag() !=
hci::ACLPacketBoundaryFlag::kContinuingFragment);
return fragment.view().payload<BasicHeader>();
}
void PDU::AppendFragment(hci::ACLDataPacketPtr fragment) {
ZX_DEBUG_ASSERT(fragment);
ZX_DEBUG_ASSERT(!is_valid() || fragments_.begin()->connection_handle() ==
fragment->connection_handle());
fragments_.push_back(std::move(fragment));
fragment_count_++;
}
} // namespace l2cap
} // namespace btlib
| 29.215054 | 78 | 0.667464 | kong1191 |
e3deaf89af220730a8d634c149ac01b7ac64f888 | 1,215 | cpp | C++ | SPOJ/BLINNET.cpp | Alipashaimani/Competitive-programming | 5d55567b71ea61e69a6450cda7323c41956d3cb9 | [
"MIT"
] | null | null | null | SPOJ/BLINNET.cpp | Alipashaimani/Competitive-programming | 5d55567b71ea61e69a6450cda7323c41956d3cb9 | [
"MIT"
] | null | null | null | SPOJ/BLINNET.cpp | Alipashaimani/Competitive-programming | 5d55567b71ea61e69a6450cda7323c41956d3cb9 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
const int MAX = 10001;
vector< pair< int, pair<int , int > > > adj;
int parent[MAX];
int find(int u);
int main() {
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
adj.clear();
for (int i = 1; i <= n; i++) {
int weight, k , v;
string X;
cin >> X >> k;
parent[i] = i;
while(k--) {
cin >> v >> weight;
if(v > i)
adj.push_back({weight,{i, v}});
}
}
sort(adj.begin(), adj.end());
int cost = 0;
for (int i = 0; i < adj.size(); i++){
int x,y,z;
x = find(adj[i].S.F);
y = find(adj[i].S.S);
z = adj[i].F;
if(x != y){
cost += z;
parent[x] = y;
}
}
cout << cost << '\n' ;
}
return 0;
}
int find(int u){
if(u != parent[u])
parent[u] = find(parent[u]);
return parent[u];
}
| 17.608696 | 51 | 0.33251 | Alipashaimani |
e3e26925d34bd5cffa298f585bdd1bb7138735d7 | 976 | cpp | C++ | sources/2020/2020_25.cpp | tbielak/AoC_cpp | 69f36748536e60a1b88f9d44a285feff20df8470 | [
"MIT"
] | 2 | 2021-02-01T13:19:37.000Z | 2021-02-25T10:39:46.000Z | sources/2020/2020_25.cpp | tbielak/AoC_cpp | 69f36748536e60a1b88f9d44a285feff20df8470 | [
"MIT"
] | null | null | null | sources/2020/2020_25.cpp | tbielak/AoC_cpp | 69f36748536e60a1b88f9d44a285feff20df8470 | [
"MIT"
] | null | null | null | #include "2020_24.h"
namespace Day25_2020
{
uintmax_t find_loop_size(uintmax_t key)
{
uintmax_t v = 1;
uintmax_t sn = 7;
uintmax_t i = 0;
while (1)
{
v = (v * sn) % 20201227;
i++;
if (v == key)
return i;
}
}
uintmax_t calculate(uintmax_t key, uintmax_t loop)
{
uintmax_t v = 1;
for (uintmax_t i = 0; i < loop; i++)
v = (v * key) % 20201227;
return v;
}
uintmax_t part_one(uintmax_t card_public_key, uintmax_t door_public_key)
{
return calculate(door_public_key, find_loop_size(card_public_key));
}
t_output main(const t_input& input)
{
uintmax_t card_public_key = stoi(input[0]);
uintmax_t door_public_key = stoi(input[1]);
auto t0 = chrono::steady_clock::now();
auto p1 = part_one(card_public_key, door_public_key);
auto t1 = chrono::steady_clock::now();
vector<string> solutions;
solutions.push_back(to_string(p1));
return make_pair(solutions, chrono::duration<double>((t1 - t0) * 1000).count());
}
}
| 20.765957 | 82 | 0.671107 | tbielak |
e3e71ac9a0114c2d0e799298dbaf28d42e4e8ffc | 3,205 | cpp | C++ | bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/Trajectory/Orbit/Model.cpp | oygx210/open-space-toolkit-astrodynamics | 81b76d78bbe76719a34801778d4fb685cc67648f | [
"Apache-2.0"
] | 13 | 2020-05-11T02:22:15.000Z | 2022-01-27T09:42:18.000Z | bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/Trajectory/Orbit/Model.cpp | oygx210/open-space-toolkit-astrodynamics | 81b76d78bbe76719a34801778d4fb685cc67648f | [
"Apache-2.0"
] | 10 | 2018-09-11T05:27:04.000Z | 2020-01-06T03:48:28.000Z | bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/Trajectory/Orbit/Model.cpp | open-space-collective/open-space-toolkit-astrodynamics | d709f5237f25e5ef40eafa5f87e39c00b8acbae1 | [
"Apache-2.0"
] | 4 | 2020-03-05T18:19:03.000Z | 2021-06-24T04:25:05.000Z | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @project Open Space Toolkit ▸ Astrodynamics
/// @file bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/Trajectory/Orbit/Model.cpp
/// @author Lucas Brémond <[email protected]>
/// @license Apache License 2.0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <OpenSpaceToolkit/Astrodynamics/Trajectory/Orbit/Models/SGP4.hpp>
#include <OpenSpaceToolkit/Astrodynamics/Trajectory/Orbit/Models/Kepler.hpp>
#include <OpenSpaceToolkit/Astrodynamics/Trajectory/Orbit/Model.hpp>
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
inline void OpenSpaceToolkitAstrodynamicsPy_Trajectory_Orbit_Model ( pybind11::module& aModule )
{
using namespace pybind11 ;
// using BaseModel = ostk::astro::trajectory::Model ;
using ostk::astro::trajectory::orbit::Model ;
using ostk::astro::trajectory::orbit::models::Kepler ;
using ostk::astro::trajectory::orbit::models::SGP4 ;
// scope in_Model = class_<Model, bases<ostk::astro::trajectory::Model>, boost::noncopyable>("OrbitModel", no_init)
// scope in_Model = class_<Model, bases<ostk::astro::trajectory::Model>>("OrbitModel", no_init)
class_<Model>(aModule, "OrbitModel")
// no init
// .def(self == self)
// .def(self != self)
.def("__eq__", [](const Model &self, const Model &other){ return self == other; })
.def("__ne__", [](const Model &self, const Model &other){ return self != other; })
.def("__str__", &(shiftToString<Model>))
.def("is_defined", &Model::isDefined)
.def("is_kepler", +[] (const Model& aModel) -> bool { return aModel.is<Kepler>() ; })
.def("is_sgp4", +[] (const Model& aModel) -> bool { return aModel.is<SGP4>() ; })
// .def("as_kepler", +[] (const Model& aModel) -> const Kepler& { return aModel.as<Kepler>() ; }, return_value_policy<reference_existing_object>())
// .def("as_sgp4", +[] (const Model& aModel) -> const SGP4& { return aModel.as<SGP4>() ; }, return_value_policy<reference_existing_object>())
.def("as_kepler", +[] (const Model& aModel) -> const Kepler& { return aModel.as<Kepler>() ; }, return_value_policy::reference)
.def("as_sgp4", +[] (const Model& aModel) -> const SGP4& { return aModel.as<SGP4>() ; }, return_value_policy::reference)
.def("get_epoch", &Model::getEpoch)
.def("get_revolution_number_at_epoch", &Model::getRevolutionNumberAtEpoch)
.def("calculate_state_at", &Model::calculateStateAt)
.def("calculate_revolution_number_at", &Model::calculateRevolutionNumberAt)
;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
| 53.416667 | 161 | 0.516381 | oygx210 |
e3feed3e7e64309efcf1cac87b03a060c0ee7d56 | 2,004 | hpp | C++ | core/base/log.hpp | bartbalaz/gentroller | b40c4fb5661619e9540f0d4b88f6f22aafb9156c | [
"BSD-3-Clause"
] | null | null | null | core/base/log.hpp | bartbalaz/gentroller | b40c4fb5661619e9540f0d4b88f6f22aafb9156c | [
"BSD-3-Clause"
] | null | null | null | core/base/log.hpp | bartbalaz/gentroller | b40c4fb5661619e9540f0d4b88f6f22aafb9156c | [
"BSD-3-Clause"
] | null | null | null | #ifndef BX_LOG_HPP
#define BX_LOG_HPP
#include <string>
#include <vector>
#include <fstream>
#include <error.h>
#include "parameters.hpp"
#include "exception.hpp"
namespace Bx {
namespace Base {
class Log {
public:
typedef enum {
ftl = 0,
err = 1,
wrn = 2,
inf = 3,
dbg = 4
} logLevel_t;
static void level(const char* logLevel);
static void level(std::string& logLevel);
static void level(logLevel_t logLevel);
inline static logLevel_t level() { return _logInstance._logLevel; };
static void file(std::string& name);
static void file(const char* name);
static void log(logLevel_t logLevel, int error, const char* pFileName,
const int lineNum, const char* pFormat, ...);
static std::string& logLevelHelp();
static std::string& defaultLogLevel();
private:
enum {
core_msg_size = 100
};
Log();
~Log();
static Log _logInstance;
static std::vector<std::string> _levelVec;
static std::string _logLevelHelp;
static std::string _defaultLogLevel;
std::ofstream _logFile;
logLevel_t _logLevel;
};
}
}
#define LOG_DBG Bx::Base::Log::dbg
#define LOG_INF Bx::Base::Log::inf
#define LOG_WRN Bx::Base::Log::wrn
#define LOG_ERR Bx::Base::Log::err
#define LOG_FTL Bx::Base::Log::ftl
#define BX_LOG(LVL, ARGS...) \
if (LVL <= Bx::Base::Log::level()) { Bx::Base::Log::log(LVL, \
-1, __FILE__, __LINE__, ARGS); }
#define BX_LOG_E(LVL, ARGS...) \
if (LVL <= Bx::Base::Log::level()) { Bx::Base::Log::log(LVL, \
errno, __FILE__, __LINE__, ARGS); }
#define BX_LOG_EX(EXCEPTION) \
Bx::Base::Log::log(LOG_FTL, -1, __FILE__, __LINE__, \
EXCEPTION.what());
#define BX_LOG_E_EX(EXCEPTION) \
Bx::Base::Log::log(LOG_FTL, errno, __FILE__, __LINE__, \
EXCEPTION.what());
#endif /* BX_LOG_HPP */
| 21.319149 | 78 | 0.590319 | bartbalaz |
540e937786d34e7246402afeef5e7c46e8c65296 | 2,046 | cpp | C++ | tests/pizza_tests.cpp | Harmos274/Plazza | ade41711f9d945f944276732a9df96442b2b4af8 | [
"MIT"
] | null | null | null | tests/pizza_tests.cpp | Harmos274/Plazza | ade41711f9d945f944276732a9df96442b2b4af8 | [
"MIT"
] | null | null | null | tests/pizza_tests.cpp | Harmos274/Plazza | ade41711f9d945f944276732a9df96442b2b4af8 | [
"MIT"
] | null | null | null | /*
** EPITECH PROJECT, 2020
** plazza
** File description:
** unit test for pizzas
*/
#include "include/catch2.hpp"
#include "pizzas/Ingredient.hpp"
#include "pizzas/Pizza.hpp"
#include "Marmiton.hpp"
#include <chrono>
#include <sstream>
#include <string>
TEST_CASE("Ingredient enum", "operators")
{
using plazza::pizzas::ingredient;
SECTION("| operator")
{
ingredient ing = ingredient::DOE;
CHECK(static_cast<int>((ing | ingredient::TOMATO)) == 3);
REQUIRE(static_cast<int>((ing | ingredient::TOMATO | ingredient::GRUYERE |
ingredient::HAM)) == 15);
}
SECTION("<< operator")
{
std::stringstream sstream;
ingredient bitst = ingredient::DOE | ingredient::TOMATO |
ingredient::GRUYERE | ingredient::HAM;
sstream << bitst;
REQUIRE(sstream.str() == "🦌💀🍅🧀🐷💀");
}
}
TEST_CASE("Pizzas", "Pizza class")
{
using namespace std::literals::chrono_literals;
using namespace plazza;
using namespace plazza::pizzas;
using plazza::pizzas::ingredient;
auto ptest = Pizza("test", ingredient::DOE | ingredient::GRUYERE | ingredient::HAM, 1s, size::XL);
SECTION("Baking time")
{
REQUIRE(ptest.getBakingTime() == 1s);
}
SECTION("Name")
{
REQUIRE(ptest.getName() == "test");
}
SECTION("Serializing")
{
REQUIRE(ptest.pack() == "test XL : 🦌💀🧀🐷💀");
}
}
TEST_CASE("Recipe", "Using the recipes")
{
using namespace plazza;
using namespace plazza::pizzas;
SECTION("Using string to access a recipe")
{
auto const& recipe = "americana" >> marmiton;
REQUIRE(recipe.getName() == "americana");
}
SECTION("Using invalid string to access a recipe")
{
CHECK_THROWS("Americanus" >> marmiton);
}
SECTION("Create a pizza from a recipe")
{
auto const& recipe = "margarita" >> marmiton;
auto pizza = recipe(size::XL);
REQUIRE(pizza.pack() == "margarita XL : 🦌💀🍅🧀");
}
}
| 22.483516 | 102 | 0.591398 | Harmos274 |
5411fb6f49e5e29620b3644cd482e5d4f1e07abb | 1,059 | cpp | C++ | Exercicios-Simples/ex05.cpp | raphaelcarmo/Praticando-C | ba2c926d2eeb4a00f24fef73281de1f937c90769 | [
"MIT"
] | null | null | null | Exercicios-Simples/ex05.cpp | raphaelcarmo/Praticando-C | ba2c926d2eeb4a00f24fef73281de1f937c90769 | [
"MIT"
] | null | null | null | Exercicios-Simples/ex05.cpp | raphaelcarmo/Praticando-C | ba2c926d2eeb4a00f24fef73281de1f937c90769 | [
"MIT"
] | null | null | null | #include <iomanip> /*A biblioteca <iomanip> fornece recursos para manipular a formatação de saída, como a base usada ao formatar inteiros e a precisão dos valores de ponto flutuante .*/
#include <iostream> /*Cabeçalho que define os objetos de fluxo de entrada / saída padrão*/
using namespace std;
/* Exercicio de Média 2.
Neste exercicio é pra calcular a média, ler a media, multiplica pelo peso. neste aqui temos 3 médias, para calcular, mas o processo é o mesmo.
O "cout.precision(1)" vai imprimir apenas 1 casas após a virgula.
desta vez eu declarei todas as variáveis como double para ter um precisão melhor.
*/
int main() {
double nota1,nota2,nota3,Media,peso1,peso2,peso3,total1,total2,total3,total4;
cin>>nota1;
cin>>nota2;
cin>>nota3;
peso1 = 2;
peso2 = 3;
peso3 = 5;
total1 = nota1 * peso1;
total2 = nota2 * peso2;
total3 = nota3 * peso3;
total4 = total1 + total2 + total3;
Media = total4 / 10;
cout << fixed << showpoint;
cout << setprecision(1);
cout << "MEDIA = " << Media << endl;
return 0;
} | 29.416667 | 185 | 0.694995 | raphaelcarmo |
5414ced84d682975ff6aaa1dff8bd48cf592384a | 12,463 | cpp | C++ | test/song_reader_test.cpp | joao18araujo/ly_parser | 4daff56b5e86fb6616d6f71977a5e218edc88174 | [
"MIT"
] | 2 | 2019-03-18T12:25:17.000Z | 2020-12-06T19:53:18.000Z | test/song_reader_test.cpp | joao18araujo/pierluigi | 4daff56b5e86fb6616d6f71977a5e218edc88174 | [
"MIT"
] | null | null | null | test/song_reader_test.cpp | joao18araujo/pierluigi | 4daff56b5e86fb6616d6f71977a5e218edc88174 | [
"MIT"
] | null | null | null | #include "catch.hpp"
#include "song_reader.h"
#include "note.h"
TEST_CASE("Song Reader can receive a string in lilypond format and return a note", "[single-file]"){
SECTION("when notes are without accidental"){
Note note = SongReader::string_to_note(Note(), "c'4");
REQUIRE(note.midi_number == 60);
REQUIRE(note.note_number == 35);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "d'4");
REQUIRE(note.midi_number == 62);
REQUIRE(note.note_number == 36);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "e'4");
REQUIRE(note.midi_number == 64);
REQUIRE(note.note_number == 37);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "f'4");
REQUIRE(note.midi_number == 65);
REQUIRE(note.note_number == 38);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "g'4");
REQUIRE(note.midi_number == 67);
REQUIRE(note.note_number == 39);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "a'4");
REQUIRE(note.midi_number == 69);
REQUIRE(note.note_number == 40);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "b'4");
REQUIRE(note.midi_number == 71);
REQUIRE(note.note_number == 41);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "c''4");
REQUIRE(note.midi_number == 72);
REQUIRE(note.note_number == 42);
REQUIRE(note.octave == 5);
note = SongReader::string_to_note(Note(), "c4");
REQUIRE(note.midi_number == 48);
REQUIRE(note.note_number == 28);
REQUIRE(note.octave == 3);
note = SongReader::string_to_note(Note(), "c,4");
REQUIRE(note.midi_number == 36);
REQUIRE(note.note_number == 21);
REQUIRE(note.octave == 2);
note = SongReader::string_to_note(Note(), "c,,4");
REQUIRE(note.midi_number == 24);
REQUIRE(note.note_number == 14);
REQUIRE(note.octave == 1);
}
SECTION("when notes are with accidental"){
Note note = SongReader::string_to_note(Note(), "cis'4");
REQUIRE(note.midi_number == 61);
REQUIRE(note.note_number == 35);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "ces'4");
REQUIRE(note.midi_number == 59);
REQUIRE(note.note_number == 35);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "cisis'4");
REQUIRE(note.midi_number == 62);
REQUIRE(note.note_number == 35);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "ceses'4");
REQUIRE(note.midi_number == 58);
REQUIRE(note.note_number == 35);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "des'4");
REQUIRE(note.midi_number == 61);
REQUIRE(note.note_number == 36);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "eis'4");
REQUIRE(note.midi_number == 65);
REQUIRE(note.note_number == 37);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "fes'4");
REQUIRE(note.midi_number == 64);
REQUIRE(note.note_number == 38);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "gis'4");
REQUIRE(note.midi_number == 68);
REQUIRE(note.note_number == 39);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "ais'4");
REQUIRE(note.midi_number == 70);
REQUIRE(note.note_number == 40);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "bis'4");
REQUIRE(note.midi_number == 72);
REQUIRE(note.note_number == 41);
REQUIRE(note.octave == 4);
note = SongReader::string_to_note(Note(), "c''4");
REQUIRE(note.midi_number == 72);
REQUIRE(note.note_number == 42);
REQUIRE(note.octave == 5);
}
SECTION("when notes have duration"){
Note note = SongReader::string_to_note(Note(), "c'1");
REQUIRE(note.duration == 32);
note = SongReader::string_to_note(Note(), "c'2");
REQUIRE(note.duration == 16);
note = SongReader::string_to_note(Note(), "c'4");
REQUIRE(note.duration == 8);
note = SongReader::string_to_note(Note(), "c'8");
REQUIRE(note.duration == 4);
note = SongReader::string_to_note(Note(), "c'16");
REQUIRE(note.duration == 2);
note = SongReader::string_to_note(Note(), "c'32");
REQUIRE(note.duration == 1);
}
SECTION("when notes are dotted"){
Note note = SongReader::string_to_note(Note(), "c'2.");
REQUIRE(note.duration == 24);
note = SongReader::string_to_note(Note(), "c'2..");
REQUIRE(note.duration == 28);
note = SongReader::string_to_note(Note(), "c'4.");
REQUIRE(note.duration == 12);
note = SongReader::string_to_note(Note(), "c'4..");
REQUIRE(note.duration == 14);
}
SECTION("when notes have duration from previous note"){
Note note = SongReader::string_to_note(Note(), "c'2");
Note note_2 = SongReader::string_to_note(note, "c");
REQUIRE(note.duration == note_2.duration);
note = SongReader::string_to_note(Note(), "c'4");
note_2 = SongReader::string_to_note(note, "c");
REQUIRE(note.duration == note_2.duration);
}
SECTION("when is a rest"){
Note note = SongReader::string_to_note(Note(), "r4");
REQUIRE(note.note == "r");
REQUIRE(note.rest() == true);
REQUIRE(note.midi_number == 0);
REQUIRE(note.note_number == 0);
REQUIRE(note.octave == 0);
}
}
TEST_CASE("Song Reader can receive a note and return a string", "[single-file]"){
SECTION("when notes are without accidental"){
Note note = Note("c", "", 3, 8);
string s = SongReader::note_to_string(note);
REQUIRE(s == "c4");
note = Note("c", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "c'4");
note = Note("d", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "d'4");
note = Note("e", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "e'4");
note = Note("f", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "f'4");
note = Note("g", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "g'4");
note = Note("a", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "a'4");
note = Note("b", "", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "b'4");
note = Note("c", "", 5, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "c''4");
}
SECTION("when notes are with accidental"){
Note note = Note("c", "#", 4, 8);
string s = SongReader::note_to_string(note);
REQUIRE(s == "cis'4");
note = Note("c", "\u266D", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "ces'4");
note = Note("d", "##", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "disis'4");
note = Note("e", "\u266D\u266D", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "eeses'4");
note = Note("f", "#", 4, 2);
s = SongReader::note_to_string(note);
REQUIRE(s == "fis'16");
note = Note("g", "##", 4, 32);
s = SongReader::note_to_string(note);
REQUIRE(s == "gisis'1");
note = Note("a", "\u266D\u266D", 4, 8);
s = SongReader::note_to_string(note);
REQUIRE(s == "aeses'4");
note = Note("b", "#", 4, 16);
s = SongReader::note_to_string(note);
REQUIRE(s == "bis'2");
note = Note("c", "#", 5, 4);
s = SongReader::note_to_string(note);
REQUIRE(s == "cis''8");
}
SECTION("when notes are dotted"){
Note note = Note("c", "", 3, 24);
string s = SongReader::note_to_string(note);
REQUIRE(s == "c2.");
note = Note("c", "", 3, 28);
s = SongReader::note_to_string(note);
REQUIRE(s == "c2..");
note = Note("c", "", 3, 12);
s = SongReader::note_to_string(note);
REQUIRE(s == "c4.");
note = Note("c", "", 3, 14);
s = SongReader::note_to_string(note);
REQUIRE(s == "c4..");
}
}
TEST_CASE("Song Reader can receive a string and return a scale", "[single-file]"){
Scale scale;
scale = SongReader::string_to_scale("\\key c \\major");
REQUIRE(scale.is_valid_note(Note("c")) == true);
REQUIRE(scale.is_valid_note(Note("c#")) == false);
REQUIRE(scale.is_valid_note(Note("d")) == true);
REQUIRE(scale.is_valid_note(Note("d#")) == false);
REQUIRE(scale.is_valid_note(Note("e")) == true);
REQUIRE(scale.is_valid_note(Note("f")) == true);
REQUIRE(scale.is_valid_note(Note("f#")) == false);
REQUIRE(scale.is_valid_note(Note("g")) == true);
REQUIRE(scale.is_valid_note(Note("g#")) == false);
REQUIRE(scale.is_valid_note(Note("a")) == true);
REQUIRE(scale.is_valid_note(Note("a#")) == false);
REQUIRE(scale.is_valid_note(Note("b")) == true);
scale = SongReader::string_to_scale("\\key a \\minor");
REQUIRE(scale.is_valid_note(Note("c")) == true);
REQUIRE(scale.is_valid_note(Note("c#")) == false);
REQUIRE(scale.is_valid_note(Note("d")) == true);
REQUIRE(scale.is_valid_note(Note("d#")) == false);
REQUIRE(scale.is_valid_note(Note("e")) == true);
REQUIRE(scale.is_valid_note(Note("f")) == true);
REQUIRE(scale.is_valid_note(Note("f#")) == false);
REQUIRE(scale.is_valid_note(Note("g")) == true);
REQUIRE(scale.is_valid_note(Note("g#")) == false);
REQUIRE(scale.is_valid_note(Note("a")) == true);
REQUIRE(scale.is_valid_note(Note("a#")) == false);
REQUIRE(scale.is_valid_note(Note("b")) == true);
scale = SongReader::string_to_scale("\\key f \\major");
REQUIRE(scale.is_valid_note(Note("f")) == true);
REQUIRE(scale.is_valid_note(Note("g")) == true);
REQUIRE(scale.is_valid_note(Note("g#")) == false);
REQUIRE(scale.is_valid_note(Note("a")) == true);
REQUIRE(scale.is_valid_note(Note("a#")) == false);
REQUIRE(scale.is_valid_note(Note("b\u266D")) == true);
REQUIRE(scale.is_valid_note(Note("b")) == false);
REQUIRE(scale.is_valid_note(Note("c")) == true);
REQUIRE(scale.is_valid_note(Note("c#")) == false);
REQUIRE(scale.is_valid_note(Note("d")) == true);
REQUIRE(scale.is_valid_note(Note("d#")) == false);
REQUIRE(scale.is_valid_note(Note("e")) == true);
REQUIRE(scale.is_valid_note(Note("e#")) == false);
scale = SongReader::string_to_scale("\\key g \\major");
REQUIRE(scale.is_valid_note(Note("g")) == true);
REQUIRE(scale.is_valid_note(Note("a")) == true);
REQUIRE(scale.is_valid_note(Note("a#")) == false);
REQUIRE(scale.is_valid_note(Note("b")) == true);
REQUIRE(scale.is_valid_note(Note("b#")) == false);
REQUIRE(scale.is_valid_note(Note("c")) == true);
REQUIRE(scale.is_valid_note(Note("c#")) == false);
REQUIRE(scale.is_valid_note(Note("d")) == true);
REQUIRE(scale.is_valid_note(Note("d#")) == false);
REQUIRE(scale.is_valid_note(Note("e")) == true);
REQUIRE(scale.is_valid_note(Note("f")) == false);
REQUIRE(scale.is_valid_note(Note("f#")) == true);
}
TEST_CASE("Song Reader can receive a string and return a compass time", "[single-file]"){
CompassTime compass_time;
compass_time = SongReader::string_to_compass_time("\\time 4/4");
REQUIRE(compass_time.times == 4);
REQUIRE(compass_time.base_note == 4);
REQUIRE(compass_time.base_note_duration() == 8);
REQUIRE(compass_time.compass_duration() == 32);
compass_time = SongReader::string_to_compass_time("\\time 3/4");
REQUIRE(compass_time.times == 3);
REQUIRE(compass_time.base_note == 4);
REQUIRE(compass_time.base_note_duration() == 8);
REQUIRE(compass_time.compass_duration() == 24);
compass_time = SongReader::string_to_compass_time("\\time 2/4");
REQUIRE(compass_time.times == 2);
REQUIRE(compass_time.base_note == 4);
REQUIRE(compass_time.base_note_duration() == 8);
REQUIRE(compass_time.compass_duration() == 16);
compass_time = SongReader::string_to_compass_time("\\time 2/2");
REQUIRE(compass_time.times == 2);
REQUIRE(compass_time.base_note == 2);
REQUIRE(compass_time.base_note_duration() == 16);
REQUIRE(compass_time.compass_duration() == 32);
compass_time = SongReader::string_to_compass_time("\\time 5/4");
REQUIRE(compass_time.times == 5);
REQUIRE(compass_time.base_note == 4);
REQUIRE(compass_time.base_note_duration() == 8);
REQUIRE(compass_time.compass_duration() == 40);
compass_time = SongReader::string_to_compass_time("\\time 9/8");
REQUIRE(compass_time.times == 9);
REQUIRE(compass_time.base_note == 8);
REQUIRE(compass_time.base_note_duration() == 4);
REQUIRE(compass_time.compass_duration() == 36);
}
| 33.502688 | 100 | 0.631389 | joao18araujo |
5414d22f87d16d2e0af57cec858db609321fdbb0 | 996 | hpp | C++ | rsa_utils/include/wrapping_iterator.hpp | j-dax/functional-rsa | 4e0a62fb7fd4b44b0ac925bfd9b2e757c58a45de | [
"MIT"
] | null | null | null | rsa_utils/include/wrapping_iterator.hpp | j-dax/functional-rsa | 4e0a62fb7fd4b44b0ac925bfd9b2e757c58a45de | [
"MIT"
] | null | null | null | rsa_utils/include/wrapping_iterator.hpp | j-dax/functional-rsa | 4e0a62fb7fd4b44b0ac925bfd9b2e757c58a45de | [
"MIT"
] | null | null | null | #pragma once
#include <iterator>
namespace rsa {
template <typename T>
class WrappingIterator : std::forward_iterator<T> {
private:
T *begin_it, *end_it;
size_t index;
public:
// WrappingIterator(); // don't allow default
WrappingIterator(T container) {
begin_it = std::begin(container);
end_it = std::end(container);
index = 0;
}
WrappingIterator(T container, size_t start_index) {
begin_it = std::begin(container);
end_it = std::end(container);
index = start_index;
}
~WrappingIterator() {
delete begin_it;
delete end_it;
}
T* begin() {
return begin_it;
}
T* end() {
return end_it;
}
T* operator++() {
index++;
index %= (end_it - begin_it);
return (begin_it + index);
}
};
}; | 22.636364 | 59 | 0.480924 | j-dax |
541cc344174e53a72fb73bf72c9cf51c30c9d973 | 765 | cpp | C++ | Codeforces/545A Toy Cars.cpp | sreejonK19/online-judge-solutions | da65d635cc488c8f305e48b49727ad62649f5671 | [
"MIT"
] | null | null | null | Codeforces/545A Toy Cars.cpp | sreejonK19/online-judge-solutions | da65d635cc488c8f305e48b49727ad62649f5671 | [
"MIT"
] | null | null | null | Codeforces/545A Toy Cars.cpp | sreejonK19/online-judge-solutions | da65d635cc488c8f305e48b49727ad62649f5671 | [
"MIT"
] | 2 | 2018-11-06T19:37:56.000Z | 2018-11-09T19:05:46.000Z | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
int A[MAXN+2][MAXN+2];
vector < int > index;
int main( int argc, char ** argv ) {
// freopen( "input.txt", "r", stdin );
int n;
cin >> n;
for( int i = 1 ; i <= n ; ++i ) {
for( int j = 1 ; j <= n ; ++j ) {
cin >> A[i][j];
}
}
for( int i = 1 ; i <= n ; ++i ) {
bool flag = true;
for( int j = 1 ; j <= n ; ++j )
if( A[i][j] == 1 || A[i][j] == 3 ) flag = false;
if( flag ) index.push_back( i );
}
cout << index.size() << endl;
if( index.size() ) {
for( int i = 0 ; i < index.size() ; ++i ) {
cout << index[i] << " ";
}
cout << endl;
}
return 0;
} | 19.615385 | 60 | 0.393464 | sreejonK19 |
541cd13da1421a0e21f92485651c4b9eb0ccf9b2 | 1,419 | cpp | C++ | android-31/android/net/TelephonyNetworkSpecifier.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/net/TelephonyNetworkSpecifier.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-30/android/net/TelephonyNetworkSpecifier.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #include "../os/Parcel.hpp"
#include "../../JObject.hpp"
#include "../../JString.hpp"
#include "./TelephonyNetworkSpecifier.hpp"
namespace android::net
{
// Fields
JObject TelephonyNetworkSpecifier::CREATOR()
{
return getStaticObjectField(
"android.net.TelephonyNetworkSpecifier",
"CREATOR",
"Landroid/os/Parcelable$Creator;"
);
}
// QJniObject forward
TelephonyNetworkSpecifier::TelephonyNetworkSpecifier(QJniObject obj) : android::net::NetworkSpecifier(obj) {}
// Constructors
// Methods
jint TelephonyNetworkSpecifier::describeContents() const
{
return callMethod<jint>(
"describeContents",
"()I"
);
}
jboolean TelephonyNetworkSpecifier::equals(JObject arg0) const
{
return callMethod<jboolean>(
"equals",
"(Ljava/lang/Object;)Z",
arg0.object<jobject>()
);
}
jint TelephonyNetworkSpecifier::getSubscriptionId() const
{
return callMethod<jint>(
"getSubscriptionId",
"()I"
);
}
jint TelephonyNetworkSpecifier::hashCode() const
{
return callMethod<jint>(
"hashCode",
"()I"
);
}
JString TelephonyNetworkSpecifier::toString() const
{
return callObjectMethod(
"toString",
"()Ljava/lang/String;"
);
}
void TelephonyNetworkSpecifier::writeToParcel(android::os::Parcel arg0, jint arg1) const
{
callMethod<void>(
"writeToParcel",
"(Landroid/os/Parcel;I)V",
arg0.object(),
arg1
);
}
} // namespace android::net
| 19.985915 | 110 | 0.691332 | YJBeetle |
541ddb032cf6b50125093b4bdd76f49fc615081e | 2,328 | cpp | C++ | tests/vklayertests_best_practices.cpp | h3r2tic/Vulkan-ValidationLayers | 4fde9b75099271ded2de6d1a5903cb57a0e93931 | [
"Apache-2.0"
] | 1 | 2021-07-15T23:36:20.000Z | 2021-07-15T23:36:20.000Z | tests/vklayertests_best_practices.cpp | h3r2tic/Vulkan-ValidationLayers | 4fde9b75099271ded2de6d1a5903cb57a0e93931 | [
"Apache-2.0"
] | null | null | null | tests/vklayertests_best_practices.cpp | h3r2tic/Vulkan-ValidationLayers | 4fde9b75099271ded2de6d1a5903cb57a0e93931 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2015-2019 The Khronos Group Inc.
* Copyright (c) 2015-2019 Valve Corporation
* Copyright (c) 2015-2019 LunarG, Inc.
* Copyright (c) 2015-2019 Google, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Author: Camden Stocker <[email protected]>
*/
#include "cast_utils.h"
#include "layer_validation_tests.h"
void VkBestPracticesLayerTest::InitBestPracticesFramework() {
VkValidationFeatureEnableEXT enables[] = {VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT};
VkValidationFeaturesEXT features = {};
features.sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
features.enabledValidationFeatureCount = 1;
features.pEnabledValidationFeatures = enables;
InitFramework(myDbgFunc, m_errorMonitor, &features);
}
TEST_F(VkBestPracticesLayerTest, CmdClearAttachmentTest) {
TEST_DESCRIPTION("Test for validating usage of vkCmdClearAttachments");
InitBestPracticesFramework();
InitState();
ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
m_commandBuffer->begin();
m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
// Main thing we care about for this test is that the VkImage obj we're
// clearing matches Color Attachment of FB
// Also pass down other dummy params to keep driver and paramchecker happy
VkClearAttachment color_attachment;
color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
color_attachment.clearValue.color.float32[0] = 1.0;
color_attachment.clearValue.color.float32[1] = 1.0;
color_attachment.clearValue.color.float32[2] = 1.0;
color_attachment.clearValue.color.float32[3] = 1.0;
color_attachment.colorAttachment = 0;
VkClearRect clear_rect = {{{0, 0}, {(uint32_t)m_width, (uint32_t)m_height}}, 0, 1};
// Call for full-sized FB Color attachment prior to issuing a Draw
m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
"UNASSIGNED-CoreValidation-DrawState-ClearCmdBeforeDraw");
vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
m_errorMonitor->VerifyFound();
}
| 40.842105 | 99 | 0.743557 | h3r2tic |
541e705ab721be349fd37bd00818face09224a09 | 1,055 | cpp | C++ | src/pWolfEncrypt/WolfEncryptMain.cpp | scottsideleau/moos-ivp-umassd | fb7f533d907208b438e5489e98f92615a6bb3246 | [
"Apache-2.0"
] | 6 | 2017-01-02T16:40:04.000Z | 2019-01-22T04:55:22.000Z | src/pWolfEncrypt/WolfEncryptMain.cpp | scottsideleau/moos-ivp-umassd | fb7f533d907208b438e5489e98f92615a6bb3246 | [
"Apache-2.0"
] | null | null | null | src/pWolfEncrypt/WolfEncryptMain.cpp | scottsideleau/moos-ivp-umassd | fb7f533d907208b438e5489e98f92615a6bb3246 | [
"Apache-2.0"
] | 2 | 2017-06-02T18:31:07.000Z | 2021-12-15T10:09:40.000Z | /****************************************************************************/
/* WolfEncryptMain.cpp */
/****************************************************************************/
// WolfEncrypt Includes
#include "WolfEncrypt.h"
/*************************************************************************//**
* The main function, which is responsible for starting the WolfEncrypt
* MOOS Application and properly handing it the .moos file.
*
* @return the number of errors
*/
int main(int argc , char *argv[])
{
// Set a default, blank mission file
const char *sMissionFile = "pWolfEncrypt.moos";
// Set a default process name
const char *sMOOSName = "pWolfEncrypt";
// Handle command line arguments
switch(argc)
{
case 3:
sMOOSName = argv[2]; // alternate process name provided
case 2:
sMissionFile = argv[1]; // alternate mission file provided
}
// Iniitialize and start the extended MOOSApp class
CMOOSWolfEncrypt MOOSWolfEncrypt;
MOOSWolfEncrypt.Run(sMOOSName, sMissionFile);
return 0;
}
| 27.051282 | 78 | 0.543128 | scottsideleau |
542b037a3a3ecbb79e02b2580f03fde45c53b18a | 1,685 | cpp | C++ | other_contest/yuruhuwa_onsite_3/d.cpp | zaurus-yusya/atcoder | 5fc345b3da50222fa1366d1ce52ae58799488cef | [
"MIT"
] | 3 | 2020-05-27T16:27:12.000Z | 2021-01-27T12:47:12.000Z | other_contest/yuruhuwa_onsite_3/d.cpp | zaurus-yusya/Competitive-Programming | c72e13a11f76f463510bd4a476b86631d9d1b13a | [
"MIT"
] | null | null | null | other_contest/yuruhuwa_onsite_3/d.cpp | zaurus-yusya/Competitive-Programming | c72e13a11f76f463510bd4a476b86631d9d1b13a | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(n);i++)
#define repr(i,n) for(ll i=(n-1);i>=0;i--)
#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define br cout << endl;
using namespace std;
const int INF = 1e9;
const int MOD = 1e9+7;
using Graph = vector<vector<ll>>;
template<class T> inline bool chmin(T &a, T b) { if(a > b){ a = b; return true;} return false;}
template<class T> inline bool chmax(T &a, T b) { if(a < b){ a = b; return true;} return false;}
int main() {
ll h, w;
cin >> h >> w;
vector<vector<ll>> vec(2*h, vector<ll>(w));
rep(i,h){
rep(j,w){
cin >> vec.at(i).at(j);
vec.at(i+h).at(j) = vec.at(i).at(j);
}
}
/*
rep(i,2*h){
rep(j,w){
cout << vec.at(i).at(j);
}
cout << "" << endl;
}
*/
//cout << "------" << endl;
vector<ll> first(h);
rep(i,h){
first.at(i) = vec.at(i).at(0);
}
vector<ll> ans(w);
ans.at(0) = 1;
for(ll j = 1; j < w; j++){
for(ll i = 0; i < h; i++){
ll flag = 0;
for(ll k = 0; k < h; k++){
//cout << first.at(i) << " " << vec.at(i+k).at(j) << endl;
if(first.at(k) != vec.at(i+k).at(j)){
flag = 1;
}
}
if(flag == 0){
ans.at(j) = 1;
}
}
}
ll ans_flag = 0;
rep(i,w){
if(ans.at(i) == 0){
ans_flag = 1;
cout << "No" << endl;
break;
}
}
if(ans_flag == 0){
cout << "Yes" << endl;
}
} | 21.883117 | 95 | 0.409496 | zaurus-yusya |
542ba87482e729829ee49a56bf852a3f823cd7bc | 914 | hpp | C++ | include/cppurses/widget/widgets/vertical_scrollbar.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | include/cppurses/widget/widgets/vertical_scrollbar.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | include/cppurses/widget/widgets/vertical_scrollbar.hpp | jktjkt/CPPurses | 652d702258db8fab55ae945f7bb38e0b7c29521b | [
"MIT"
] | null | null | null | #ifndef CPPURSES_WIDGET_WIDGETS_VERTICAL_SCROLLBAR_HPP
#define CPPURSES_WIDGET_WIDGETS_VERTICAL_SCROLLBAR_HPP
#include <signals/signal.hpp>
#include <cppurses/widget/layouts/vertical_layout.hpp>
#include <cppurses/widget/widget.hpp>
#include <cppurses/widget/widgets/push_button.hpp>
#include <cppurses/widget/widgets/textbox_base.hpp>
namespace cppurses {
class Vertical_scrollbar : public Vertical_layout {
public:
Vertical_scrollbar();
Vertical_scrollbar(Textbox_base& tb);
Push_button& up_button = this->make_child<Push_button>("▴");
Widget& middle = this->make_child<Widget>();
Push_button& down_button = this->make_child<Push_button>("▾");
// Signals
sig::Signal<void()>& up = up_button.clicked;
sig::Signal<void()>& down = down_button.clicked;
private:
void initialize();
};
} // namespace cppurses
#endif // CPPURSES_WIDGET_WIDGETS_VERTICAL_SCROLLBAR_HPP
| 29.483871 | 66 | 0.756018 | jktjkt |
542dca45b8b1dccfd04973871657bcadc3ffd782 | 304 | hpp | C++ | compat/cqit/qitype/anyfunction.hpp | arntanguy/libqi | 7f3e1394cb26126b26fa7ff54d2de1371a1c9f96 | [
"BSD-3-Clause"
] | 61 | 2015-01-08T08:05:28.000Z | 2022-01-07T16:47:47.000Z | compat/cqit/qitype/anyfunction.hpp | arntanguy/libqi | 7f3e1394cb26126b26fa7ff54d2de1371a1c9f96 | [
"BSD-3-Clause"
] | 30 | 2015-04-06T21:41:18.000Z | 2021-08-18T13:24:51.000Z | compat/cqit/qitype/anyfunction.hpp | arntanguy/libqi | 7f3e1394cb26126b26fa7ff54d2de1371a1c9f96 | [
"BSD-3-Clause"
] | 64 | 2015-02-23T20:01:11.000Z | 2022-03-14T13:31:20.000Z | /*
** Author(s):
** - Cedric GESTES <[email protected]>
**
** Copyright (C) 2014 Aldebaran
*/
#ifndef _QITYPE_ANYFUNCTION_HPP_
# define _QITYPE_ANYFUNCTION_HPP_
#include <qi/anyfunction.hpp>
#include <qi/macro.hpp>
QI_DEPRECATED_HEADER("Please use qi/anyfunction.hpp instead");
#endif
| 16.888889 | 62 | 0.740132 | arntanguy |
542ede783f441df6159ce024b3ce24ab47e43e44 | 315 | cpp | C++ | test/doublelinkedlist_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 17 | 2019-01-03T11:17:31.000Z | 2021-10-31T19:19:41.000Z | test/doublelinkedlist_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 106 | 2018-03-03T16:37:17.000Z | 2020-08-31T09:24:52.000Z | test/doublelinkedlist_test.cpp | thm-mni-ii/sea | 3d3f63c3d17ab91f0aaada3c4315ba98367a3460 | [
"MIT"
] | 4 | 2018-05-21T13:30:01.000Z | 2019-06-12T07:43:43.000Z | #include <gtest/gtest.h>
#include "../src/collection/largedoublelinkedlist.h"
using namespace Sealib; // NOLINT
TEST(DoubleLinkedListTest, basic) {
LargeDoubleLinkedList l(10);
EXPECT_FALSE(l.isEmpty());
EXPECT_EQ(l.get(), 0);
EXPECT_EQ(l.get(), 1);
l.remove(2);
EXPECT_EQ(l.get(), 3);
}
| 22.5 | 52 | 0.663492 | thm-mni-ii |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.