blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7911d5998bc4cf9565919978d17ed00f2ff86827 | b0121144869481635da4dd0c3c76079643ad05d5 | /src/sim/units/Cartesian.cpp | cfde88a16177b8b53f0ee89485f16d8fd235535a | [
"MIT"
] | permissive | kangzhangqi/mms | 742e9c4792e62cdf0c442ac0203f7b88cfb3b5e4 | 32059429547869d38184233b4610ef955fd3f2de | refs/heads/master | 2021-07-18T06:52:34.152888 | 2017-10-20T04:18:33 | 2017-10-20T04:20:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 986 | cpp | #include "Cartesian.h"
namespace mms {
Cartesian::Cartesian() {
m_x = Meters(0.0);
m_y = Meters(0.0);
}
Cartesian::Cartesian(const Distance& x, const Distance& y) {
m_x = x;
m_y = y;
}
Cartesian::Cartesian(const Coordinate& coordinate) {
m_x = coordinate.getX();
m_y = coordinate.getY();
}
Cartesian Cartesian::operator+(const Coordinate& coordinate) const {
return Cartesian(getX() + coordinate.getX(), getY() + coordinate.getY());
}
Cartesian Cartesian::operator-(const Coordinate& coordinate) const {
return Cartesian(getX() - coordinate.getX(), getY() - coordinate.getY());
}
Cartesian Cartesian::operator*(double factor) const {
return Cartesian(getX() * factor, getY() * factor);
}
Cartesian Cartesian::operator/(double factor) const {
return Cartesian(getX() / factor, getY() / factor);
}
void Cartesian::operator+=(const Coordinate& coordinate) {
m_x += coordinate.getX();
m_y += coordinate.getY();
}
} // namespace mms
| [
"mackorone@gmail.com"
] | mackorone@gmail.com |
b09a04896d0c22d505180115aad301e782d00eab | 3e871269d5b39f0eb20e9d2b5c5e0929c7c9f844 | /nodemcu/wifiscan/WiFiScan/WiFiScan.ino | 941ab29ce3950cbf236ab158fd7ad400e3fa0fc4 | [] | no_license | iamgoangle/golf-iot-projects | 4387e6e3f23287205505962b568f71620322f71b | 999a217458fc9e4f889cf731be6e42c647ffc064 | refs/heads/master | 2020-05-19T21:39:24.850292 | 2019-06-03T17:15:49 | 2019-06-03T17:15:49 | 185,228,642 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,303 | ino | /*
This sketch demonstrates how to scan WiFi networks.
The API is almost the same as with the WiFi Shield library,
the most obvious difference being the different file you need to include:
*/
#include "ESP8266WiFi.h"
void setup()
{
Serial.begin(115200);
// Set WiFi to station mode and disconnect from an AP if it was previously connected
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
Serial.println("Setup done");
}
void loop()
{
Serial.println("scan start");
// WiFi.scanNetworks will return the number of networks found
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0)
{
Serial.println("no networks found");
}
else
{
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i)
{
// Print SSID and RSSI for each network found
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? " " : "*");
// Print wifi channel
Serial.print("Channel: ");
Serial.print(WiFi.channel(i));
delay(10);
}
}
Serial.println("");
// Wait a bit before scanning again
delay(5000);
}
| [
"st.teerapong@gmail.com"
] | st.teerapong@gmail.com |
8f1188713874be13b8313b0799a2cfd36e2df629 | 303e592c312459bf9eb3ce231b1357c4de91124b | /pku/2491/2491.cpp | 348f199217c5b6d5b8dc262be793c5e63d2206ae | [] | no_license | kohyatoh/contests | 866c60a1687f8a59d440da3356c6117f9596e8ce | b3dffeaf15564d57aec5c306f5f84bd448bc791f | refs/heads/master | 2021-01-17T15:06:23.216232 | 2016-07-18T14:06:05 | 2016-07-18T14:06:05 | 2,369,261 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 797 | cpp | #include <stdio.h>
#include <iostream>
#include <set>
#include <map>
#include <string>
using namespace std;
#define rep(i, n) for(int i=0; i<(int)(n); i++)
int Q, n;
map<string, string> pr, nx;
map<string, int> vis;
void print(const string& s) {
if(vis[s]) return;
vis[s]=1;
if(pr.find(s)!=pr.end()) print(pr[s]);
cout << s << endl;
}
int main() {
cin >> Q;
rep(q, Q) {
string a, b;
pr.clear(), nx.clear(), vis.clear();
cin >> n;
rep(i, n-1) {
cin >> a >> b;
pr[b]=a;
nx[a]=b;
}
cout << "Scenario #" << q+1 << ":" << endl;
for(map<string, string>::iterator it=pr.begin(); it!=pr.end(); it++) {
print(it->first);
}
cout << endl;
}
return 0;
}
| [
"kohyatoh@yahoo.co.jp"
] | kohyatoh@yahoo.co.jp |
eb6159795bce74816ac4070a028ae6251ea33307 | 8eaece8f871eed7585adbf5833488077380f309b | /1149.cpp | ca478cd5afec0d3ca99e3176d1aee0e7461ab78c | [] | no_license | piuto1104/BeakJoon | 4d92bfc7e9bcd8f0d91fe02a0732f5ce8ac0f002 | 4b39de3720544c367ed91433cea6030147450b73 | refs/heads/master | 2020-07-18T02:38:40.402468 | 2016-08-25T05:53:37 | 2016-08-25T05:53:37 | 66,529,049 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 592 | cpp | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef struct w {
int a[3];
}w;
int main() {
int input;
int arr[1000][3];
cin >> input;
for (int i = 0; i < input; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
for (int i = 1; i < input; i++) {
for (int j = 0; j < 3; j++) {
arr[i][j] += min(arr[i - 1][(j + 1) % 3], arr[i - 1][(j + 2) % 3]);
}
}
int min = arr[input - 1][0];
for (int i = 0; i < 3; i++) {
if (min > arr[input - 1][i]) {
min = arr[input - 1][i];
}
}
cout << min;
return 0;
}
| [
"piuto1104@nate.com"
] | piuto1104@nate.com |
54eea132180eb8651befb4ac7d66c115b65fa22a | 856a442581fd6ad7ab44a98bfdb03785722da26e | /Ide/Eclipse/PixItAll/src/game/ColorButton.cpp | 5de4c0d99cd01bb739b34de1bd47fbb130e9d486 | [] | no_license | asmCode/PixItAllTizen | a1e8deb2eb74ceebf92361fb0fff36c4b1148ef8 | c44e224f7768690c9640156a13e99ea333835a2c | refs/heads/master | 2020-12-30T11:14:45.496751 | 2013-12-04T09:51:19 | 2013-12-04T09:51:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 488 | cpp | #include "ColorButton.h"
#include <GraphicsLibrary/SpriteBatch.h>
#include <GraphicsLibrary/Color.h>
ColorButton::ColorButton(int x, int y, const TexPart &bg, const Color &color) :
Control(x, y, bg), color(color)
{
this->color = color;
}
void ColorButton::OnDraw(float time, float ms)
{
sm::Vec2 globalPos = GetGlobalPos();
spriteBatch ->Draw(bg, color, (int)globalPos.x, (int)globalPos.y, width, height);
}
void ColorButton::SetColor(const Color &color)
{
this->color = color;
}
| [
"majakthecoder@gmail.com"
] | majakthecoder@gmail.com |
0a5b70c4f9c27206c6a02175234b45c7767b6b81 | 3dc008f3d6facdc3b1bcd93cc77267256497c2ed | /C++Training/NotesAndSamples/Examples 2/VirtualFunctions/VirtualFunctions/E46.cpp | bafceaed441b50e5b27f36171827a564f71b4106 | [] | no_license | sunny972538/c-_materials | 5f5348466bb8b76fdb5f34236ac1d3ffb288226d | 919a397b5a51e7a0f9d0c5caf6f6f1c61d76029b | refs/heads/master | 2020-05-18T16:32:27.675570 | 2019-05-02T06:04:36 | 2019-05-02T06:04:36 | 184,529,152 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 551 | cpp | #include<iostream>
using namespace std;
//<-- loose coupling
// ------------- begning of library -----------------------------
namespace Ex46
{
struct IX
{
virtual void fx()=0;
};
struct IY
{
virtual void fy()=0;
};
struct SA : IX,IY
{
void fx() { cout<<"fx fun"<<endl; }
void fy() { cout<<"fy fun"<<endl; }
};
IX* create()
{
return new SA;
}
};
// ------------- end of library -----------------------------
using namespace Ex46;
void main46()
{
IX* px =create();
px->fx();
IY* py= (IY*)px;
py->fy();
}
| [
"sunny972538@gmail.com"
] | sunny972538@gmail.com |
276a647d6c73b46647bc5526bbd638880c69dc2a | 12d637401ccfd0241a574a2caaca14cc06943c68 | /taskui.h | 7a39431572fdf55d642558d0bc209d07e02164d0 | [] | no_license | stlcours/karia2 | 8eb42950814aa3ace28221b71e3ded951012d2dd | 0dcbda4c79cdb9203e95879bf78919b494e0f06c | refs/heads/master | 2021-05-27T03:16:02.888881 | 2014-03-08T23:27:16 | 2014-03-08T23:27:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,735 | h | // taskui.h ---
//
// Author: liuguangzhao
// Copyright (C) 2007-2013 liuguangzhao@users.sf.net
// URL:
// Created: 2013-02-05 14:02:04 +0000
// Version: $Id: 4623e2d6ad87b998023ff5398476be9702a445e8 $
//
#ifndef _TASKUI_H_
#define _TASKUI_H_
#include "abstractui.h"
class TaskQueue;
class EAria2Man;
class TaskOption;
class TaskItemDelegate;
class TaskUi : public AbstractUi
{
Q_OBJECT;
public:
explicit TaskUi(Karia2 *pwin);
virtual ~TaskUi();
virtual bool init();
public slots:
int createTask(TaskOption*option);
int createTask(int taskId, TaskOption*option);
void onTaskShowColumnsChanged(QString columns);
void onSegmentListSelectChange(const QItemSelection & selected, const QItemSelection & deselected);
void onTaskListSelectChange (const QItemSelection & selected, const QItemSelection & deselected);
void onCatListSelectChange (const QItemSelection & selected, const QItemSelection & deselected);
void onAddTaskList(QStringList list); // add a list of tasks
void showNewDownloadDialog();
void showNewBittorrentFileDialog();
void showNewMetalinkFileDialog();
void showBatchDownloadDialog(); //添加批量下载对话框
void showProcessWebPageInputDiglog(); //处理WEB页面，取其中链接并下载
// void onShowConnectOption();
//void onShowDownloadRules();
// void onShowDefaultDownloadProperty(); ???
void onShowTaskProperty();
void onShowTaskProperty(int pTaskId);
void onShowTaskPropertyDigest(const QModelIndex & index);
void onShowTaskPropertyDigest( );
void onTaskListMenuPopup( /*const QPoint & pos = QPoint() */);
void onUpdateJobMenuEnableProperty();
void onLogListMenuPopup( const QPoint & pos);
void onSegListMenuPopup( const QPoint & pos);
void onCateMenuPopup( const QPoint & pos);
void onStorageOpened();
public:
static QString decodeQQdlUrl(QString enUrl);
static QString decodeThunderUrl(QString enUrl);
static QString decodeFlashgetUrl(QString enUrl);
static QString decodeEncodeUrl(QString enUrl);
private:
int getNextValidTaskId();
QPair<QString,QString> getFileTypeByFileName(QString fileName);
protected:
QTreeView *mTaskListView;
QTreeView *mSegListView;
QTreeView *mSegLogListView;
QTreeView *mCatView;
QTreeView *mSeedFileView;
//
QAbstractItemModel *mTaskTreeViewModel;
QAbstractItemModel *mCatViewModel;
TaskItemDelegate *mTaskItemDelegate;
// SeedFileItemDelegate *mSeedFileDelegate;
QString mCustomTaskShowColumns;
QPoint mSwapPoint;
QModelIndex mSwapModelIndex;
///pop menu
QMenu *mTaskPopupMenu;
QMenu *mLogPopupMenu;
QMenu *mCatPopupMenu;
// temporary
TaskQueue *mTaskMan;
EAria2Man *mEAria2Man;
};
#endif /* _TASKUI_H_ */
| [
"drswinghead@localhost"
] | drswinghead@localhost |
a0cab97efe0b31c9efccf371610e3d6f19edaeab | f5357204a7758cacd85ddfe895e1417c59bd665f | /vtkm/cont/CellSetSingleType.h | 60966fef615919c6b9b192b8b886f86cd7d71901 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | yisyuanliou/VTK-m | 37b273d5302a6ef790a0257b521e6e04eec11afd | cc483c8c2319a78b58b3ab849da8ca448e896220 | refs/heads/master | 2022-12-09T11:28:54.228020 | 2020-09-10T09:26:36 | 2020-09-10T09:26:36 | 285,628,280 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,225 | h | //============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_CellSetSingleType_h
#define vtk_m_cont_CellSetSingleType_h
#include <vtkm/CellShape.h>
#include <vtkm/CellTraits.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/CellSet.h>
#include <vtkm/cont/CellSetExplicit.h>
#include <map>
#include <utility>
namespace vtkm
{
namespace cont
{
//Only works with fixed sized cell sets
template <typename ConnectivityStorageTag = VTKM_DEFAULT_CONNECTIVITY_STORAGE_TAG>
class VTKM_ALWAYS_EXPORT CellSetSingleType
: public vtkm::cont::CellSetExplicit<
typename vtkm::cont::ArrayHandleConstant<vtkm::UInt8>::StorageTag, //ShapesStorageTag
ConnectivityStorageTag,
typename vtkm::cont::ArrayHandleCounting<vtkm::Id>::StorageTag //OffsetsStorageTag
>
{
using Thisclass = vtkm::cont::CellSetSingleType<ConnectivityStorageTag>;
using Superclass =
vtkm::cont::CellSetExplicit<typename vtkm::cont::ArrayHandleConstant<vtkm::UInt8>::StorageTag,
ConnectivityStorageTag,
typename vtkm::cont::ArrayHandleCounting<vtkm::Id>::StorageTag>;
public:
VTKM_CONT
CellSetSingleType()
: Superclass()
, ExpectedNumberOfCellsAdded(-1)
, CellShapeAsId(CellShapeTagEmpty::Id)
, NumberOfPointsPerCell(0)
{
}
VTKM_CONT
CellSetSingleType(const Thisclass& src)
: Superclass(src)
, ExpectedNumberOfCellsAdded(-1)
, CellShapeAsId(src.CellShapeAsId)
, NumberOfPointsPerCell(src.NumberOfPointsPerCell)
{
}
VTKM_CONT
CellSetSingleType(Thisclass&& src) noexcept : Superclass(std::forward<Superclass>(src)),
ExpectedNumberOfCellsAdded(-1),
CellShapeAsId(src.CellShapeAsId),
NumberOfPointsPerCell(src.NumberOfPointsPerCell)
{
}
VTKM_CONT
Thisclass& operator=(const Thisclass& src)
{
this->Superclass::operator=(src);
this->CellShapeAsId = src.CellShapeAsId;
this->NumberOfPointsPerCell = src.NumberOfPointsPerCell;
return *this;
}
VTKM_CONT
Thisclass& operator=(Thisclass&& src) noexcept
{
this->Superclass::operator=(std::forward<Superclass>(src));
this->CellShapeAsId = src.CellShapeAsId;
this->NumberOfPointsPerCell = src.NumberOfPointsPerCell;
return *this;
}
virtual ~CellSetSingleType() override {}
/// First method to add cells -- one at a time.
VTKM_CONT
void PrepareToAddCells(vtkm::Id numCells, vtkm::Id connectivityMaxLen)
{
this->CellShapeAsId = vtkm::CELL_SHAPE_EMPTY;
this->Data->CellPointIds.Connectivity.Allocate(connectivityMaxLen);
this->Data->NumberOfCellsAdded = 0;
this->Data->ConnectivityAdded = 0;
this->ExpectedNumberOfCellsAdded = numCells;
}
/// Second method to add cells -- one at a time.
template <typename IdVecType>
VTKM_CONT void AddCell(vtkm::UInt8 shapeId, vtkm::IdComponent numVertices, const IdVecType& ids)
{
using Traits = vtkm::VecTraits<IdVecType>;
VTKM_STATIC_ASSERT_MSG((std::is_same<typename Traits::ComponentType, vtkm::Id>::value),
"CellSetSingleType::AddCell requires vtkm::Id for indices.");
if (Traits::GetNumberOfComponents(ids) < numVertices)
{
throw vtkm::cont::ErrorBadValue("Not enough indices given to CellSetSingleType::AddCell.");
}
if (this->Data->ConnectivityAdded + numVertices >
this->Data->CellPointIds.Connectivity.GetNumberOfValues())
{
throw vtkm::cont::ErrorBadValue(
"Connectivity increased past estimated maximum connectivity.");
}
if (this->CellShapeAsId == vtkm::CELL_SHAPE_EMPTY)
{
if (shapeId == vtkm::CELL_SHAPE_EMPTY)
{
throw vtkm::cont::ErrorBadValue("Cannot create cells of type empty.");
}
this->CellShapeAsId = shapeId;
this->CheckNumberOfPointsPerCell(numVertices);
this->NumberOfPointsPerCell = numVertices;
}
else
{
if (shapeId != this->GetCellShape(0))
{
throw vtkm::cont::ErrorBadValue("Cannot have differing shapes in CellSetSingleType.");
}
if (numVertices != this->NumberOfPointsPerCell)
{
throw vtkm::cont::ErrorBadValue(
"Inconsistent number of points in cells for CellSetSingleType.");
}
}
auto conn = this->Data->CellPointIds.Connectivity.WritePortal();
for (vtkm::IdComponent iVert = 0; iVert < numVertices; ++iVert)
{
conn.Set(this->Data->ConnectivityAdded + iVert, Traits::GetComponent(ids, iVert));
}
this->Data->NumberOfCellsAdded++;
this->Data->ConnectivityAdded += numVertices;
}
/// Third and final method to add cells -- one at a time.
VTKM_CONT
void CompleteAddingCells(vtkm::Id numPoints)
{
this->Data->NumberOfPoints = numPoints;
this->CellPointIds.Connectivity.Shrink(this->ConnectivityAdded);
vtkm::Id numCells = this->NumberOfCellsAdded;
this->CellPointIds.Shapes =
vtkm::cont::make_ArrayHandleConstant(this->GetCellShape(0), numCells);
this->CellPointIds.IndexOffsets = vtkm::cont::make_ArrayHandleCounting(
vtkm::Id(0), static_cast<vtkm::Id>(this->NumberOfPointsPerCell), numCells);
this->CellPointIds.ElementsValid = true;
if (this->ExpectedNumberOfCellsAdded != this->GetNumberOfCells())
{
throw vtkm::cont::ErrorBadValue("Did not add the expected number of cells.");
}
this->NumberOfCellsAdded = -1;
this->ConnectivityAdded = -1;
this->ExpectedNumberOfCellsAdded = -1;
}
//This is the way you can fill the memory from another system without copying
VTKM_CONT
void Fill(vtkm::Id numPoints,
vtkm::UInt8 shapeId,
vtkm::IdComponent numberOfPointsPerCell,
const vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityStorageTag>& connectivity)
{
this->Data->NumberOfPoints = numPoints;
this->CellShapeAsId = shapeId;
this->CheckNumberOfPointsPerCell(numberOfPointsPerCell);
const vtkm::Id numCells = connectivity.GetNumberOfValues() / numberOfPointsPerCell;
VTKM_ASSERT((connectivity.GetNumberOfValues() % numberOfPointsPerCell) == 0);
this->Data->CellPointIds.Shapes = vtkm::cont::make_ArrayHandleConstant(shapeId, numCells);
this->Data->CellPointIds.Offsets = vtkm::cont::make_ArrayHandleCounting(
vtkm::Id(0), static_cast<vtkm::Id>(numberOfPointsPerCell), numCells + 1);
this->Data->CellPointIds.Connectivity = connectivity;
this->Data->CellPointIds.ElementsValid = true;
this->ResetConnectivity(TopologyElementTagPoint{}, TopologyElementTagCell{});
}
VTKM_CONT
vtkm::Id GetCellShapeAsId() const { return this->CellShapeAsId; }
VTKM_CONT
vtkm::UInt8 GetCellShape(vtkm::Id vtkmNotUsed(cellIndex)) const override
{
return static_cast<vtkm::UInt8>(this->CellShapeAsId);
}
VTKM_CONT
std::shared_ptr<CellSet> NewInstance() const override
{
return std::make_shared<CellSetSingleType>();
}
VTKM_CONT
void DeepCopy(const CellSet* src) override
{
const auto* other = dynamic_cast<const CellSetSingleType*>(src);
if (!other)
{
throw vtkm::cont::ErrorBadType("CellSetSingleType::DeepCopy types don't match");
}
this->Superclass::DeepCopy(other);
this->CellShapeAsId = other->CellShapeAsId;
this->NumberOfPointsPerCell = other->NumberOfPointsPerCell;
}
virtual void PrintSummary(std::ostream& out) const override
{
out << " CellSetSingleType: Type=" << this->CellShapeAsId << std::endl;
out << " CellPointIds:" << std::endl;
this->Data->CellPointIds.PrintSummary(out);
out << " PointCellIds:" << std::endl;
this->Data->PointCellIds.PrintSummary(out);
}
private:
template <typename CellShapeTag>
void CheckNumberOfPointsPerCell(CellShapeTag,
vtkm::CellTraitsTagSizeFixed,
vtkm::IdComponent numVertices) const
{
if (numVertices != vtkm::CellTraits<CellShapeTag>::NUM_POINTS)
{
throw vtkm::cont::ErrorBadValue("Passed invalid number of points for cell shape.");
}
}
template <typename CellShapeTag>
void CheckNumberOfPointsPerCell(CellShapeTag,
vtkm::CellTraitsTagSizeVariable,
vtkm::IdComponent vtkmNotUsed(numVertices)) const
{
// Technically, a shape with a variable number of points probably has a
// minimum number of points, but we are not being sophisticated enough to
// check that. Instead, just pass the check by returning without error.
}
void CheckNumberOfPointsPerCell(vtkm::IdComponent numVertices) const
{
switch (this->CellShapeAsId)
{
vtkmGenericCellShapeMacro(this->CheckNumberOfPointsPerCell(
CellShapeTag(), vtkm::CellTraits<CellShapeTag>::IsSizeFixed(), numVertices));
default:
throw vtkm::cont::ErrorBadValue("CellSetSingleType unable to determine the cell type");
}
}
vtkm::Id ExpectedNumberOfCellsAdded;
vtkm::Id CellShapeAsId;
vtkm::IdComponent NumberOfPointsPerCell;
};
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
/// @cond SERIALIZATION
namespace vtkm
{
namespace cont
{
template <typename ConnectivityST>
struct SerializableTypeString<vtkm::cont::CellSetSingleType<ConnectivityST>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "CS_Single<" +
SerializableTypeString<vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST>>::Get() + "_ST>";
return name;
}
};
}
} // vtkm::cont
namespace mangled_diy_namespace
{
template <typename ConnectivityST>
struct Serialization<vtkm::cont::CellSetSingleType<ConnectivityST>>
{
private:
using Type = vtkm::cont::CellSetSingleType<ConnectivityST>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
vtkmdiy::save(bb, cs.GetNumberOfPoints());
vtkmdiy::save(bb, cs.GetCellShape(0));
vtkmdiy::save(bb, cs.GetNumberOfPointsInCell(0));
vtkmdiy::save(
bb, cs.GetConnectivityArray(vtkm::TopologyElementTagCell{}, vtkm::TopologyElementTagPoint{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
vtkm::Id numberOfPoints = 0;
vtkmdiy::load(bb, numberOfPoints);
vtkm::UInt8 shape;
vtkmdiy::load(bb, shape);
vtkm::IdComponent count;
vtkmdiy::load(bb, count);
vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST> connectivity;
vtkmdiy::load(bb, connectivity);
cs = Type{};
cs.Fill(numberOfPoints, shape, count, connectivity);
}
};
} // diy
/// @endcond SERIALIZATION
#endif //vtk_m_cont_CellSetSingleType_h
| [
"y002783@gmail.com"
] | y002783@gmail.com |
193cc07dc46d1e16c922af77ef1465cea3fb5553 | 7dd4c2f71101f57729f19a16ffea42033e93788d | /test/unittest/layers/layers_standalone_common_tests.cpp | 9bca086292b7041db884024e9b84777318c9eb6a | [
"Apache-2.0",
"LicenseRef-scancode-free-unknown"
] | permissive | jijoongmoon/nntrainer | db12e169ea46feb00970a882be4152a37ad1ac89 | 3d77318779dd89d79820a0f6e34b1bce54b2a71a | refs/heads/main | 2023-08-17T23:29:02.585992 | 2023-07-13T00:10:11 | 2023-07-13T00:10:11 | 249,628,343 | 1 | 0 | Apache-2.0 | 2023-09-14T08:50:53 | 2020-03-24T06:17:04 | C++ | UTF-8 | C++ | false | false | 3,039 | cpp | // SPDX-License-Identifier: Apache-2.0
/**
* Copyright (C) 2020 Jihoon Lee <jhoon.it.lee@samsung.com>
*
* @file layer_common_tests.cpp
* @date 15 June 2021
* @brief Common test for nntrainer layers (Param Tests)
* @see https://github.com/nnstreamer/nntrainer
* @author Jihoon Lee <jhoon.it.lee@samsung.com>
* @bug No known bugs except for NYI items
*/
#include <layers_common_tests.h>
#include <layer_context.h>
#include <layer_devel.h>
#include <nntrainer_error.h>
#include <tensor_dim.h>
constexpr unsigned SAMPLE_TRIES = 10;
TEST_P(LayerSemantics, DISABLED_setProperties_p) {
/// @todo check if setProperties does not collide with layerNode designated
/// properties
EXPECT_EQ(1, 1); /**< no assert tc from TCM, this is disabled test */
}
TEST_P(LayerSemantics, setProperties_n) {
/** must not crash */
EXPECT_THROW(layer->setProperty({"unknown_props=2"}), std::invalid_argument);
}
TEST_P(LayerSemantics, DISABLED_setPropertiesValidWithInvalid_n) {
EXPECT_EQ(1, 1); /**< no assert tc from TCM, this is disabled test */
}
TEST_P(LayerPropertySemantics, setPropertiesValidInvalidOnly_n) {
EXPECT_THROW(layer->setProperty(valid_properties), std::invalid_argument);
}
TEST_P(LayerSemantics, gettersValidate_p) {
std::string type;
EXPECT_NO_THROW(type = layer->getType());
EXPECT_GT(type.size(), size_t(0));
EXPECT_NO_THROW(layer->supportInPlace());
EXPECT_NO_THROW(layer->requireLabel());
EXPECT_NO_THROW(layer->supportBackwarding());
}
TEST_P(LayerSemantics, finalizeValidate_p) {
ml::train::TensorDim in_dim({1, 1, 1, 1});
std::vector<ml::train::TensorDim> input_dims(num_inputs, in_dim);
nntrainer::InitLayerContext init_context =
nntrainer::InitLayerContext(input_dims, {true}, false, "layer");
EXPECT_EQ(init_context.validate(), true);
// set necessary properties only
EXPECT_NO_THROW(layer->setProperty(valid_properties));
if (!must_fail) {
EXPECT_NO_THROW(layer->finalize(init_context));
for (auto const &spec : init_context.getOutSpecs())
EXPECT_GT(spec.variable_spec.dim.getDataLen(), size_t(0));
for (auto const &ws : init_context.getWeightsSpec())
EXPECT_GT(std::get<0>(ws).getDataLen(), size_t(0));
for (auto const &ts : init_context.getTensorsSpec())
EXPECT_GT(std::get<0>(ts).getDataLen(), size_t(0));
} else {
EXPECT_THROW(layer->finalize(init_context),
nntrainer::exception::not_supported);
}
}
TEST_P(LayerSemantics, setBatchValidate_p) {
ml::train::TensorDim in_dim({1, 1, 1, 1});
std::vector<ml::train::TensorDim> input_dims(num_inputs, in_dim);
nntrainer::InitLayerContext init_context =
nntrainer::InitLayerContext(input_dims, {true}, false, "layer");
EXPECT_EQ(init_context.validate(), true);
// set necessary properties only
EXPECT_NO_THROW(layer->setProperty(valid_properties));
if (!must_fail) {
EXPECT_NO_THROW(layer->finalize(init_context));
} else {
EXPECT_THROW(layer->finalize(init_context),
nntrainer::exception::not_supported);
}
}
| [
"jijoong.moon@samsung.com"
] | jijoong.moon@samsung.com |
a349abb968327810f77013f9f35420ce97e395af | f96afe5208a0094b9b929b5aabe5ac6e9f0c6b67 | /segment tree 3.cpp | a8749c53279f936f7390fa039f66483bdf6c4764 | [] | no_license | nicklin96/DS-Practice | e3cdeb30cc25cb39ac39b6f685277b364e0b557b | 15cd766d58704cd44bd72ef53020458098eeeeea | refs/heads/master | 2021-08-14T10:40:50.805749 | 2017-11-15T12:08:24 | 2017-11-15T12:08:24 | 110,826,882 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 916 | cpp | /*
poj1184
*/
#include <iostream>
using namespace std;
#define MAXN 10000
int line[MAXN], ans[MAXN];
struct node {
int l, r, len;
}tree[MAXN*4];
void build(int node, int l, int r) {
int mid = (l + r) >> 1;
tree[node].len = r - l + 1;
tree[node].l = l;
tree[node].r = r;
if (l == r) return;
build(node * 2, l, mid);
build(node * 2 + 1, mid + 1, r);
}
int query(int node, int k) {
tree[node].len--;
if (tree[node].l == tree[node].r) {
return tree[node].l;
}
else if (tree[2 * node].len >= k) {
return query(2 * node, k);
}
else {
return query(2 * node + 1, k - tree[node * 2].len);
}
}
int main()
{
int n;
cin >> n;
line[1] = 0;
for (int i = 2; i <= n; i++) {
cin >> line[i];
}
build(1, 1, n);
for (int i = n; i >= 1; i--) {
ans[i] = query(1, line[i] + 1);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
return 0;
} | [
"noreply@github.com"
] | noreply@github.com |
e19ec63f1e1a389ce6584b4e14d4e162205fdf96 | 87a2896f868dc13f89ecbb629d897f0ffe8a57e6 | /Code/478c.cpp | 1949f8afb3593d7b7d5e021e5e70589aee2757c6 | [] | no_license | sahashoo/Daily | a20a4bce60b0903fde23bea9d5244c65a9ea3928 | c209cf800cbae850e2233a149d3cc8181b49fb5e | refs/heads/master | 2020-04-23T04:31:13.770829 | 2019-02-15T20:00:34 | 2019-02-15T20:00:34 | 170,910,172 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 161 | cpp | #include<bits/stdc++.h>
using namespace std;
long long r,b,g,a,z;
int main(){
cin>>r>>g>>b;
a=min(r+g,min(b+r,g+b));
z=(r+g+b)/3;
cout<<min(a,z);
} | [
"noreply@github.com"
] | noreply@github.com |
7769a7a3de232942dae722af6983c7e36a9375de | fafce52a38479e8391173f58d76896afcba07847 | /uppdev/uppCanvas/main.hpp | c228ece6dc01bc87c213f9739a5167afff82e331 | [] | no_license | Sly14/upp-mirror | 253acac2ec86ad3a3f825679a871391810631e61 | ed9bc6028a6eed422b7daa21139a5e7cbb5f1fb7 | refs/heads/master | 2020-05-17T08:25:56.142366 | 2015-08-24T18:08:09 | 2015-08-24T18:08:09 | 41,750,819 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 623 | hpp | #ifndef _main_hpp_
#define _main_hpp_
#include <CtrlLib/CtrlLib.h>
#define LAYOUTFILE <uppCanvas/uppCanvas.lay>
#include <CtrlCore/lay.h>
#include <uppCanvas/Canvas.hpp>
struct App : public WithMainWinLayout<TopWindow> {
typedef App CLASSNAME;
Canvas canvas;
Button BtnClose;
Button BtnClearSheet;
Button BtnBGColor;
ColorPopUp colorPopUp;
App();
//UserEvents
void BtnClearSheetClick();
void BtnCloseClick();
void BtnBGColorClick();
void OnColorSelect();
//Callbacks for the canvas
void OnCanvasPaint(Draw& w);
void OnCanvasMouseLeft(Point p, dword keyflags);
};
#endif
| [
"cxl@ntllib.org"
] | cxl@ntllib.org |
de03f6ac0e95f6a23a4ec398300b22d4a02d6c3b | 8d154eb1a41781c7d6982641c177283ae680798c | /Basic_programming/Character_Arrays/trim_spaces.cpp | 515a318255e95d41609b2f5f8fc5574349112064 | [] | no_license | manikdhupar/competitive-coding | 6392ab21ba23bb6d7e801b9ba0fc7168519e9f96 | 80bb1287b32b3b73ad24cc65d14119fe0aa45fca | refs/heads/master | 2020-03-31T01:28:16.914091 | 2019-10-01T21:52:00 | 2019-10-01T21:52:00 | 151,782,848 | 0 | 2 | null | 2019-10-03T18:01:10 | 2018-10-05T22:04:57 | C++ | UTF-8 | C++ | false | false | 499 | cpp | #include <iostream>
using namespace std;
void trimSpaces(char input[])
{
int count = 0;
for (int i = 0; input[i] != '\0'; i++)
{
count++;
}
for (int i = 0; i < count; i++)
{
while (input[i] == 32)
{
count--;
int j = i;
while (j < count)
{
input[j] = input[j + 1];
j++;
}
input[count] = '\0';
}
}
}
int main()
{
char input[1000000];
cin.getline(input, 1000000);
trimSpaces(input);
cout << input << endl;
}
| [
"manik.dhupar7@gmail.com"
] | manik.dhupar7@gmail.com |
a1c0abfb11ba9f80592e1a42b1fd336ecabb9cb0 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /third_party/webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h | 2e8a202113af94867b1b1a5868d60be5f0aec30c | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-google-patent-license-webm",
"LicenseRef-scancode-google-patent-license-webrtc",
"LicenseRef-scancode-takuya-ooura",
"LicenseRef-scancode-public-domai... | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 5,305 | h | /*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_INTERNAL_H_
#define MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_INTERNAL_H_
#include "modules/include/module_common_types.h"
#include "api/array_view.h"
namespace webrtc {
// Maximum number of media packets that can be protected
// by these packet masks.
constexpr size_t kUlpfecMaxMediaPackets = 48;
// Packet mask size in bytes (given L bit).
constexpr size_t kUlpfecPacketMaskSizeLBitClear = 2;
constexpr size_t kUlpfecPacketMaskSizeLBitSet = 6;
// Packet code mask maximum length. kFECPacketMaskMaxSize = MaxNumFECPackets *
// (kUlpfecMaxMediaPackets / 8), and MaxNumFECPackets is equal to maximum number
// of media packets (kUlpfecMaxMediaPackets)
constexpr size_t kFECPacketMaskMaxSize = 288;
// Convenience constants.
constexpr size_t kUlpfecMinPacketMaskSize = kUlpfecPacketMaskSizeLBitClear;
constexpr size_t kUlpfecMaxPacketMaskSize = kUlpfecPacketMaskSizeLBitSet;
namespace internal {
class PacketMaskTable {
public:
PacketMaskTable(FecMaskType fec_mask_type, int num_media_packets);
~PacketMaskTable();
rtc::ArrayView<const uint8_t> LookUp(int num_media_packets,
int num_fec_packets);
private:
static const uint8_t* PickTable(FecMaskType fec_mask_type,
int num_media_packets);
const uint8_t* table_;
uint8_t fec_packet_mask_[kFECPacketMaskMaxSize];
};
rtc::ArrayView<const uint8_t> LookUpInFecTable(const uint8_t* table,
int media_packet_index,
int fec_index);
// Returns an array of packet masks. The mask of a single FEC packet
// corresponds to a number of mask bytes. The mask indicates which
// media packets should be protected by the FEC packet.
// \param[in] num_media_packets The number of media packets to protect.
// [1, max_media_packets].
// \param[in] num_fec_packets The number of FEC packets which will
// be generated. [1, num_media_packets].
// \param[in] num_imp_packets The number of important packets.
// [0, num_media_packets].
// num_imp_packets = 0 is the equal
// protection scenario.
// \param[in] use_unequal_protection Enables unequal protection: allocates
// more protection to the num_imp_packets.
// \param[in] mask_table An instance of the |PacketMaskTable|
// class, which contains the type of FEC
// packet mask used, and a pointer to the
// corresponding packet masks.
// \param[out] packet_mask A pointer to hold the packet mask array,
// of size: num_fec_packets *
// "number of mask bytes".
void GeneratePacketMasks(int num_media_packets,
int num_fec_packets,
int num_imp_packets,
bool use_unequal_protection,
PacketMaskTable* mask_table,
uint8_t* packet_mask);
// Returns the required packet mask size, given the number of sequence numbers
// that will be covered.
size_t PacketMaskSize(size_t num_sequence_numbers);
// Inserts |num_zeros| zero columns into |new_mask| at position
// |new_bit_index|. If the current byte of |new_mask| can't fit all zeros, the
// byte will be filled with zeros from |new_bit_index|, but the next byte will
// be untouched.
void InsertZeroColumns(int num_zeros,
uint8_t* new_mask,
int new_mask_bytes,
int num_fec_packets,
int new_bit_index);
// Copies the left most bit column from the byte pointed to by
// |old_bit_index| in |old_mask| to the right most column of the byte pointed
// to by |new_bit_index| in |new_mask|. |old_mask_bytes| and |new_mask_bytes|
// represent the number of bytes used per row for each mask. |num_fec_packets|
// represent the number of rows of the masks.
// The copied bit is shifted out from |old_mask| and is shifted one step to
// the left in |new_mask|. |new_mask| will contain "xxxx xxn0" after this
// operation, where x are previously inserted bits and n is the new bit.
void CopyColumn(uint8_t* new_mask,
int new_mask_bytes,
uint8_t* old_mask,
int old_mask_bytes,
int num_fec_packets,
int new_bit_index,
int old_bit_index);
} // namespace internal
} // namespace webrtc
#endif // MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_INTERNAL_H_
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
a333f8c1105e4bbdfdd400abf6bf95bab3560ff6 | e95adb59feacfe95904c3a8e90a4159860b6c26a | /build/Android/Preview/outsideTheBox/app/src/main/include/Android.android.widget.SeekBarDLROnSeekBarChangeListener.h | 2f1465a6ed78c16aa0fc9e167e44613097042bbe | [] | no_license | deliloka/bethebox | 837dff20c1ff55db631db1e0f6cb51d935497e91 | f9bc71b8593dd54b8aaf86bc0a654d233432c362 | refs/heads/master | 2021-01-21T08:20:42.970891 | 2016-02-19T10:00:37 | 2016-02-19T10:00:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,560 | h | // This file was generated based on '/usr/local/share/uno/Packages/Android/0.23.1/Android/android/widget/$.uno'.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Android.Base.Wrappers.IJWrapper.h>
#include <Uno.Object.h>
namespace g{namespace Android{namespace android{namespace widget{struct SeekBar;}}}}
namespace g{
namespace Android{
namespace android{
namespace widget{
// public abstract extern interface SeekBarDLROnSeekBarChangeListener :28892
// {
uInterfaceType* SeekBarDLROnSeekBarChangeListener_typeof();
struct SeekBarDLROnSeekBarChangeListener
{
void(*fp_onProgressChanged)(uObject*, ::g::Android::android::widget::SeekBar*, int*, bool*);
void(*fp_onStartTrackingTouch)(uObject*, ::g::Android::android::widget::SeekBar*);
void(*fp_onStopTrackingTouch)(uObject*, ::g::Android::android::widget::SeekBar*);
static void onProgressChanged(const uInterface& __this, ::g::Android::android::widget::SeekBar* arg0, int arg1, bool arg2) { __this.VTable<SeekBarDLROnSeekBarChangeListener>()->fp_onProgressChanged(__this, arg0, &arg1, &arg2); }
static void onStartTrackingTouch(const uInterface& __this, ::g::Android::android::widget::SeekBar* arg0) { __this.VTable<SeekBarDLROnSeekBarChangeListener>()->fp_onStartTrackingTouch(__this, arg0); }
static void onStopTrackingTouch(const uInterface& __this, ::g::Android::android::widget::SeekBar* arg0) { __this.VTable<SeekBarDLROnSeekBarChangeListener>()->fp_onStopTrackingTouch(__this, arg0); }
};
// }
}}}} // ::g::Android::android::widget
| [
"Havard.Halse@nrk.no"
] | Havard.Halse@nrk.no |
07c2a65925de239e339c16d27a095ea7cf5c185f | 0e47f6e2d03cfc3b2621882c87db87c8df846bb6 | /Sandbox/src/ExampleLayer.cpp | a535af5f95a5a84e7e4a2b60a7010cee04a5cebe | [] | no_license | aryeh-nigri/Hazel | 94f90f2dc9047d491ca5f4c7d7ec7369b39af3af | c952215be26ec1d5668324e07333fbc3912f8b45 | refs/heads/master | 2020-08-21T23:49:22.322071 | 2020-01-14T16:02:36 | 2020-01-14T16:02:36 | 216,274,709 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,775 | cpp | #include "ExampleLayer.h"
#include <imgui/imgui.h>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
ExampleLayer::ExampleLayer()
: Layer("ExampleLayer"), m_CameraController(1280.0f / 720.0f)
{
m_VertexArray = Hazel::VertexArray::Create();
float vertices[3 * 7] = {
-0.5f, -0.5f, 0.0f, 0.8f, 0.2f, 0.8f, 1.0f,
0.5f, -0.5f, 0.0f, 0.2f, 0.3f, 0.8f, 1.0f,
0.0f, 0.5f, 0.0f, 0.8f, 0.8f, 0.2f, 1.0f
};
Hazel::Ref<Hazel::VertexBuffer> vertexBuffer = Hazel::VertexBuffer::Create(vertices, sizeof(vertices));
Hazel::BufferLayout layout = {
{ Hazel::ShaderDataType::Float3, "a_Position" },
{ Hazel::ShaderDataType::Float4, "a_Color" }
};
vertexBuffer->SetLayout(layout);
m_VertexArray->AddVertexBuffer(vertexBuffer);
uint32_t indices[3] = { 0, 1, 2 };
Hazel::Ref<Hazel::IndexBuffer> indexBuffer = Hazel::IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t));
m_VertexArray->SetIndexBuffer(indexBuffer);
m_SquareVA = Hazel::VertexArray::Create();
float squareVertices[5 * 4] = {
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f
};
Hazel::Ref<Hazel::VertexBuffer> squareVB = Hazel::VertexBuffer::Create(squareVertices, sizeof(squareVertices));
squareVB->SetLayout({
{ Hazel::ShaderDataType::Float3, "a_Position" },
{ Hazel::ShaderDataType::Float2, "a_TexCoord" }
});
m_SquareVA->AddVertexBuffer(squareVB);
uint32_t squareIndices[6] = { 0, 1, 2, 2, 3, 0 };
Hazel::Ref<Hazel::IndexBuffer> squareIB = Hazel::IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t));
m_SquareVA->SetIndexBuffer(squareIB);
std::string vertexSrc = R"(
#version 330 core
layout(location = 0) in vec3 a_Position;
layout(location = 1) in vec4 a_Color;
uniform mat4 u_ViewProjection;
uniform mat4 u_Transform;
out vec3 v_Position;
out vec4 v_Color;
void main()
{
v_Position = a_Position;
v_Color = a_Color;
gl_Position = u_ViewProjection * u_Transform * vec4(a_Position, 1.0);
}
)";
std::string fragmentSrc = R"(
#version 330 core
layout(location = 0) out vec4 color;
in vec3 v_Position;
in vec4 v_Color;
void main()
{
color = vec4(v_Position * 0.5 + 0.5, 1.0);
color = v_Color;
}
)";
m_Shader = Hazel::Shader::Create("VertexPosColor", vertexSrc, fragmentSrc);
std::string flatColorShaderVertexSrc = R"(
#version 330 core
layout(location = 0) in vec3 a_Position;
uniform mat4 u_ViewProjection;
uniform mat4 u_Transform;
out vec3 v_Position;
void main()
{
v_Position = a_Position;
gl_Position = u_ViewProjection * u_Transform * vec4(a_Position, 1.0);
}
)";
std::string flatColorShaderFragmentSrc = R"(
#version 330 core
layout(location = 0) out vec4 color;
in vec3 v_Position;
uniform vec3 u_Color;
void main()
{
color = vec4(u_Color, 1.0);
}
)";
m_FlatColorShader = Hazel::Shader::Create("FlatColor", flatColorShaderVertexSrc, flatColorShaderFragmentSrc);
auto textureShader = m_ShaderLibrary.Load("assets/shaders/Texture.glsl");
m_Texture = Hazel::Texture2D::Create("assets/textures/Checkerboard.png");
m_ChernoLogoTexture = Hazel::Texture2D::Create("assets/textures/ChernoLogo.png");
textureShader->Bind();
textureShader->SetInt("u_Texture", 0);
}
void ExampleLayer::OnAttach()
{
}
void ExampleLayer::OnDetach()
{
}
void ExampleLayer::OnUpdate(Hazel::Timestep ts)
{
// Update
m_CameraController.OnUpdate(ts);
// Render
Hazel::RenderCommand::SetClearColor({ 0.1f, 0.1f, 0.1f, 1 });
Hazel::RenderCommand::Clear();
Hazel::Renderer::BeginScene(m_CameraController.GetCamera());
glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));
m_FlatColorShader->Bind();
m_FlatColorShader->SetFloat3("u_Color", m_SquareColor);
for (int y = 0; y < 20; y++)
{
for (int x = 0; x < 20; x++)
{
glm::vec3 pos(x * 0.11f, y * 0.11f, 0.0f);
glm::mat4 transform = glm::translate(glm::mat4(1.0f), pos) * scale;
Hazel::Renderer::Submit(m_FlatColorShader, m_SquareVA, transform);
}
}
auto textureShader = m_ShaderLibrary.Get("Texture");
m_Texture->Bind();
Hazel::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
m_ChernoLogoTexture->Bind();
Hazel::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
// Triangle
// Hazel::Renderer::Submit(m_Shader, m_VertexArray);
Hazel::Renderer::EndScene();
}
void ExampleLayer::OnImGuiRender()
{
ImGui::Begin("Settings");
ImGui::ColorEdit3("Square Color", glm::value_ptr(m_SquareColor));
ImGui::End();
}
void ExampleLayer::OnEvent(Hazel::Event& e)
{
m_CameraController.OnEvent(e);
}
| [
"aryehnigri@gmail.com"
] | aryehnigri@gmail.com |
3591c9ad086f8db4df984cf4845359d186566d91 | 6238cb585938b96e413199d2e9cabb99dc0615b8 | /Sem VI Unix Systems Programming And Compiler Design Lab/Q3/Q3.cpp | 8ee83e064cb569efb8216fdc0cf93281aa8bd142 | [
"MIT"
] | permissive | vintageplayer/VTU_CSE_LABS | 1f1d82b7243c30a3e5f76164dea7afad090706c6 | 907cdc804c145ce511c81bad1e99a9d5f099033e | refs/heads/master | 2021-01-17T10:23:54.103416 | 2017-11-28T19:57:22 | 2017-11-28T19:57:22 | 58,856,752 | 1 | 0 | MIT | 2022-01-21T19:04:46 | 2016-05-15T10:49:55 | C | UTF-8 | C++ | false | false | 989 | cpp | #include<iostream>
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
using namespace std;
int main(int argc, char **argv)
{
int fd;
char arr[51];
struct flock var;
if(argc!=2)
{
cout<<"Invalid Arguments!!"<<endl;
cout<<"Usage : "<<argv[0]<<" <filename>"<<endl;
return 1;
}
fd = open(argv[1],O_RDWR);
var.l_type = F_WRLCK;
var.l_whence = SEEK_END;
var.l_start = -100;
var.l_len = 100;
fcntl(fd,F_GETLK,&var);
if(var.l_type == F_UNLCK)
{
cout<<"File is unlocked. Acquiring the lock..."<<endl;
var.l_type = F_WRLCK;
if(fcntl(fd,F_SETLK,&var)!=-1)
{
cout<<"Lock Set."<<endl;
}
else
{
perror("fcntl");
return 1;
}
lseek(fd,-50,SEEK_END);
if(read(fd,arr,50)<0)
{
cout<<"Error Reading from file."<<endl;
}
else
{
arr[50] = '\0';
cout<<"File contents : "<<arr;
}
}
else
{
cout<<"File locked by a process with process ID : "<<var.l_pid<<endl;
}
var.l_type = F_UNLCK;
fcntl(fd,F_SETLK,&var);
return 0;
}
| [
"adityag2511@gmail.com"
] | adityag2511@gmail.com |
404198422927ad2ada9e539cbf6e7440f64a5e65 | baab07b796f78d722991ef8ab941b989d92936fc | /p4/peones.hpp | 655003557e2de2fb4f1ab6411faca1c8d65d567c | [] | no_license | cristinazuhe/InformaticaGrafica | ddf6d71dbe20fbb41a3ef8993d33c2e8de0f4c94 | 8b5d4b25dfdff8972356ac6bc6427629cc0b77cd | refs/heads/master | 2021-01-10T12:41:41.817369 | 2016-01-24T12:21:56 | 2016-01-24T12:21:56 | 44,780,229 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,375 | hpp | #ifndef PEONES_HPP
#define PEONES_HPP
#include "fuenteluz.hpp"
#include "operacionesmalla.hpp"
#include "grafoescena.hpp"
// Clase peon1
class Peon1: public Material {
protected:
MallaTVT mallapeon1;
NodoGE minodopeon1;
Matriz4f m_t_peon1; //para la traslacion del peon
ParMatriz4f m_escalado_peones; //para el escalado de los peones
Material materialpeon1;
public:
Peon1();
void P4_NGE_VisualizarPlano (NodoGE *nodo);
void P4_NGE_VisualizarSuave (NodoGE *nodo);
void VerPeon1EnPlano();
void VerPeon1EnSuave();
void CargarTexturaPeon1();
} ;
//clase peon2
class Peon2 {
protected:
MallaTVT mallapeon2;
NodoGE minodopeon2;
Matriz4f m_t_peon2;
ParMatriz4f m_escalado_peones; //para el escalado de los peones
Material materialpeon2;
public:
Peon2();
void Peon2_NGE_VisualizarSuave(NodoGE *nodo);
void Peon2_NGE_VisualizarPlano(NodoGE *nodo);
void VerPeon2EnPlano();
void VerPeon2EnSuave();
} ;
//clase peon3
class Peon3 {
protected:
MallaTVT mallapeon3;
NodoGE minodopeon3;
Matriz4f m_t_peon3;
ParMatriz4f m_escalado_peones; //para el escalado de los peones
Material materialpeon3;
public:
Peon3();
void Peon3_NGE_VisualizarSuave(NodoGE *nodo);
void Peon3_NGE_VisualizarPlano(NodoGE *nodo);
void VerPeon3EnPlano();
void VerPeon3EnSuave();
} ;
#endif
| [
"zuhe18@gmail.com"
] | zuhe18@gmail.com |
db51b54574064aa40df5c1d6916d328b8134fcb0 | 4af2f2138481ef0d113594b03a0945b7dde0f7ea | /lib/sensor/lidar/LIDARInterface.hpp | 65b7a6544917db5160aac8cb7fb303480afbcf0e | [] | no_license | flaredirector/ASM | 2baae4036efedd04c28e9e8c7595f4a41e79a281 | 3f0ed5da6cde13681cf8747af22e3bbdce0777b5 | refs/heads/master | 2020-04-19T19:14:11.305935 | 2019-04-19T16:20:34 | 2019-04-19T16:20:34 | 168,383,406 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 477 | hpp | /**
* Flare Director
* ASM
* LIDARInterface.hpp
*
* This header file contains the class definition
* for the LIDARInterface class.
*/
#ifndef LIDAR_LITE_H
#define LIDAR_LITE_H
#endif
class LIDARInterface {
int i2c_bus;
int adapter_num;
char filename[20];
int res;
public:
int err;
LIDARInterface(void);
~LIDARInterface(void);
int connect(void);
int writeAndWait(int, int);
int readAndWait(int);
int getDistance();
}; | [
"grantsavage1@me.com"
] | grantsavage1@me.com |
b32e2aa8b053c24abd2f5bd698cc27d50797737b | dd6fee79066e2dfa74371bd82c87a563dc0c47fd | /contest/2012summer/2012 Multi-University Training Contest 7/Dragon ball/standard_0.cpp | 0f613bda4e36ad44370b0fc377e14987a74b5af5 | [] | no_license | mzry1992/workspace | 404c31df66a3b15a60dc0f07fff397bf50bcc1dc | 9a181419f0d7224e37baa729feaf3bb656544420 | refs/heads/master | 2021-01-19T12:39:17.854501 | 2012-12-24T11:13:22 | 2012-12-24T11:13:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,307 | cpp | #include<cstdio>
#include<iostream>
#include<algorithm>
#include<time.h>
using namespace std;
const int N = 1005;
const int M = 52;
const int INF = 2000000011;
struct P
{
int p,e;
}data[M][N];
bool cmp(P a,P b)
{
return a.p<b.p;
}
int dp[M][N],q[N],top,tail;
int abs(int x){return x>0?x:-x;}
int cost(int i,int k,int j)
{
return dp[i-1][k]+abs(data[i-1][k].p-data[i][j].p);
}
int main()
{
int tt = clock();
//freopen("data.in", "r", stdin);
//freopen("data.out", "w", stdout);
int T,m,n,l,i,j,k,t;
scanf("%d",&T);
while(T--)
{
scanf("%d%d%d",&m,&n,&l);
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&data[i][j].p);
}
}
for(i=1;i<=m;i++)
{
for(j=1;j<=n;j++)
{
scanf("%d",&data[i][j].e);
}
sort(data[i]+1,data[i]+1+n,cmp);
}
for(i=1;i<=n;i++)dp[1][i]=abs(l-data[1][i].p)+data[1][i].e;
for(i=2;i<=m;i++)
{
top=0;
tail=-1;
for(k=j=1;j<=n;j++)
{
dp[i][j]=INF;
while(k<=n&&data[i-1][k].p<=data[i][j].p)
{
t=cost(i,k,j);
while(tail>=top&&cost(i,q[tail],j)>=t)tail--;
q[++tail]=k;
k++;
}
if(tail>=top)dp[i][j]=cost(i,q[top],j);
}
top=0;
tail=-1;
for(k=j=n;j>0;j--)
{
while(k>0&&data[i-1][k].p>data[i][j].p)
{
t=cost(i,k,j);
while(tail>=top&&cost(i,q[tail],j)>=t)tail--;
q[++tail]=k;
k--;
}
if(tail>=top)
{
t=cost(i,q[top],j);
if(dp[i][j]>t)dp[i][j]=t;
}
}
for(j=1;j<=n;j++)dp[i][j]+=data[i][j].e;
}
t=INF;
for(i=1;i<=n;i++)if(t>dp[m][i])t=dp[m][i];
printf("%d\n",t);
}
//cerr<<"time:"<<clock()-tt<<endl;
return 0;
}
| [
"muziriyun@gmail.com"
] | muziriyun@gmail.com |
ef153327daaa8b3d7bd469c88c5918c4f222d11b | aaa59489b21897d93d7f1c6fe38aa06dc7538a2d | /mathematics/prime_number/prime_number_sample.cpp | b25b7d89a7919802f2fb7d342466d4305debafaf | [] | no_license | k22o/algorithm_samples | 456d9eb019c26234f79150785d2db03e52ae4f9f | 7aea84192a390d5a20466d37756723a1a2f5fd39 | refs/heads/master | 2023-04-24T07:23:13.907203 | 2021-05-09T12:00:14 | 2021-05-09T12:00:14 | 259,832,557 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 556 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using namespace std;
#define rep(i,a,b) for(int (i)=a;(i)<(int)(b);(i)++)
using ipair = std::pair<ll,ll>;
//https://atcoder.jp/contests/abc084/tasks/abc084_d
//素数判定
bool prime_number(int a){
int flag = true;
for(int i=2;i<sqrt(a)+1;i++){
if(a%i==0){flag=false;break;}
}
return flag;
}
int main(){
int N;
cin >> N;
bool prime = prime_number(N);
if(prime) cout << "YES" << endl;
else cout << "NO" << endl;
} | [
"kana.t3.105@gmail.com"
] | kana.t3.105@gmail.com |
040131bbf30113e7bf85cce5d0f4d02ffeacd309 | fb8af12db950d47b9d2a2371f109b065722c8be1 | /CCF中学生计算机程序设计_1_入门篇/exam/2.1.3-3_定义变量的同时赋值.cpp | 67c1bb320306c9edc88e00a9d0e3076f258159de | [] | no_license | MHT-Quark/C-Plus-Plus | 29aa53917d3c8ca3d8f7e5c68d88c1414bc020dc | c521333d51bf241fb5f467c529921d94c9396170 | refs/heads/main | 2023-01-07T15:50:27.151153 | 2020-11-05T13:01:57 | 2020-11-05T13:01:57 | 281,591,783 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 148 | cpp | //exam2.6
#include <iostream>
using namespace std;
int main()
{
float x=7.5;
float y=10.6;
cout<<"Area of a rectangle:"<<x*y<<endl;
return 0;
}
| [
"mahaotian12315@163.com"
] | mahaotian12315@163.com |
91f649c938437d4c3f351506493edc3f6b22277c | 67f61e55d4d74a76deef5b826e9cb6c1d9e53c58 | /externals/skia/src/gpu/gl/GrGLAssembleInterface.cpp | 7c51f4e806cc7e0d1e97e99f1f5b38610ed217c2 | [
"BSD-3-Clause",
"MIT"
] | permissive | mono/linux-packaging-skiasharp | e7d0478b0c34c80f341e0224041e3dc076e13d41 | 47dbb2ff9ae01305b190f409ccea00b3b4f0bc79 | refs/heads/master | 2023-08-23T10:22:57.751473 | 2017-04-25T14:28:46 | 2017-04-25T14:28:46 | 89,267,865 | 1 | 5 | MIT | 2020-04-08T02:40:44 | 2017-04-24T17:23:42 | C++ | UTF-8 | C++ | false | false | 35,493 | cpp | /*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gl/GrGLAssembleInterface.h"
#include "GrGLUtil.h"
#define GET_PROC(F) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
#define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S)
#define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
#define GET_EGL_PROC_SUFFIX(F, S) functions->fEGL ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S)
const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) {
GET_PROC_LOCAL(GetString);
if (nullptr == GetString) {
return nullptr;
}
const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
if (nullptr == verStr) {
return nullptr;
}
GrGLStandard standard = GrGLGetStandardInUseFromString(verStr);
if (kGLES_GrGLStandard == standard) {
return GrGLAssembleGLESInterface(ctx, get);
} else if (kGL_GrGLStandard == standard) {
return GrGLAssembleGLInterface(ctx, get);
}
return nullptr;
}
static void get_egl_query_and_display(GrEGLQueryStringProc* queryString, GrEGLDisplay* display,
void* ctx, GrGLGetProc get) {
*queryString = (GrEGLQueryStringProc) get(ctx, "eglQueryString");
*display = GR_EGL_NO_DISPLAY;
if (*queryString) {
GrEGLGetCurrentDisplayProc getCurrentDisplay =
(GrEGLGetCurrentDisplayProc) get(ctx, "eglGetCurrentDisplay");
if (getCurrentDisplay) {
*display = getCurrentDisplay();
} else {
*queryString = nullptr;
}
}
}
const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
GET_PROC_LOCAL(GetString);
GET_PROC_LOCAL(GetStringi);
GET_PROC_LOCAL(GetIntegerv);
// GetStringi may be nullptr depending on the GL version.
if (nullptr == GetString || nullptr == GetIntegerv) {
return nullptr;
}
const char* versionString = (const char*) GetString(GR_GL_VERSION);
GrGLVersion glVer = GrGLGetVersionFromString(versionString);
if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {
// We must have array and element_array buffer objects.
return nullptr;
}
GrEGLQueryStringProc queryString;
GrEGLDisplay display;
get_egl_query_and_display(&queryString, &display, ctx, get);
GrGLExtensions extensions;
if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
display)) {
return nullptr;
}
GrGLInterface* interface = new GrGLInterface();
GrGLInterface::Functions* functions = &interface->fFunctions;
GET_PROC(ActiveTexture);
GET_PROC(AttachShader);
GET_PROC(BindAttribLocation);
GET_PROC(BindBuffer);
if (glVer >= GR_GL_VER(3,0)) {
GET_PROC(BindFragDataLocation);
}
GET_PROC(BeginQuery);
GET_PROC(BindTexture);
if (extensions.has("GL_KHR_blend_equation_advanced")) {
GET_PROC_SUFFIX(BlendBarrier, KHR);
} else if (extensions.has("GL_NV_blend_equation_advanced")) {
GET_PROC_SUFFIX(BlendBarrier, NV);
}
if (glVer >= GR_GL_VER(1,4) ||
extensions.has("GL_ARB_imaging")) {
GET_PROC(BlendColor);
} else if (extensions.has("GL_EXT_blend_color")) {
GET_PROC_SUFFIX(BlendColor, EXT);
}
if (glVer >= GR_GL_VER(1,4) ||
extensions.has("GL_ARB_imaging")) {
GET_PROC(BlendEquation);
} else if (extensions.has("GL_EXT_blend_subtract")) {
GET_PROC_SUFFIX(BlendEquation, EXT);
}
GET_PROC(BlendFunc);
GET_PROC(BufferData);
GET_PROC(BufferSubData);
GET_PROC(Clear);
GET_PROC(ClearColor);
GET_PROC(ClearStencil);
GET_PROC(ColorMask);
GET_PROC(CompileShader);
GET_PROC(CompressedTexImage2D);
GET_PROC(CompressedTexSubImage2D);
GET_PROC(CopyTexSubImage2D);
GET_PROC(CreateProgram);
GET_PROC(CreateShader);
GET_PROC(CullFace);
GET_PROC(DeleteBuffers);
GET_PROC(DeleteProgram);
GET_PROC(DeleteQueries);
GET_PROC(DeleteShader);
GET_PROC(DeleteTextures);
GET_PROC(DepthMask);
GET_PROC(Disable);
GET_PROC(DisableVertexAttribArray);
GET_PROC(DrawArrays);
GET_PROC(DrawBuffer);
GET_PROC(DrawBuffers);
GET_PROC(DrawElements);
if (glVer >= GR_GL_VER(3,1) || extensions.has("GL_ARB_draw_instanced") ||
extensions.has("GL_EXT_draw_instanced")) {
GET_PROC(DrawArraysInstanced);
GET_PROC(DrawElementsInstanced);
}
if (glVer >= GR_GL_VER(4,0) || extensions.has("GL_ARB_draw_indirect")) {
GET_PROC(DrawArraysIndirect);
GET_PROC(DrawElementsIndirect);
}
if (glVer >= GR_GL_VER(2,0)) {
GET_PROC(DrawRangeElements);
}
GET_PROC(Enable);
GET_PROC(EnableVertexAttribArray);
GET_PROC(EndQuery);
GET_PROC(Finish);
GET_PROC(Flush);
GET_PROC(FrontFace);
GET_PROC(GenBuffers);
GET_PROC(GenerateMipmap);
GET_PROC(GetBufferParameteriv);
GET_PROC(GetError);
GET_PROC(GetIntegerv);
if (glVer >= GR_GL_VER(3,2) || extensions.has("GL_ARB_texture_multisample")) {
GET_PROC(GetMultisamplefv);
}
GET_PROC(GetQueryObjectiv);
GET_PROC(GetQueryObjectuiv);
if (glVer >= GR_GL_VER(3,3) || extensions.has("GL_ARB_timer_query")) {
GET_PROC(GetQueryObjecti64v);
GET_PROC(GetQueryObjectui64v);
GET_PROC(QueryCounter);
} else if (extensions.has("GL_EXT_timer_query")) {
GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
}
GET_PROC(GetQueryiv);
GET_PROC(GetProgramInfoLog);
GET_PROC(GetProgramiv);
GET_PROC(GetShaderInfoLog);
GET_PROC(GetShaderiv);
GET_PROC(GetString);
GET_PROC(GetStringi);
GET_PROC(GetShaderPrecisionFormat);
GET_PROC(GetTexLevelParameteriv);
GET_PROC(GenQueries);
GET_PROC(GenTextures);
GET_PROC(GetUniformLocation);
GET_PROC(IsTexture);
GET_PROC(LineWidth);
GET_PROC(LinkProgram);
GET_PROC(MapBuffer);
if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_multi_draw_indirect")) {
GET_PROC(MultiDrawArraysIndirect);
GET_PROC(MultiDrawElementsIndirect);
}
GET_PROC(PixelStorei);
if (extensions.has("GL_EXT_raster_multisample")) {
GET_PROC_SUFFIX(RasterSamples, EXT);
}
GET_PROC(ReadBuffer);
GET_PROC(ReadPixels);
GET_PROC(Scissor);
GET_PROC(ShaderSource);
GET_PROC(StencilFunc);
GET_PROC(StencilFuncSeparate);
GET_PROC(StencilMask);
GET_PROC(StencilMaskSeparate);
GET_PROC(StencilOp);
GET_PROC(StencilOpSeparate);
if (glVer >= GR_GL_VER(3,1)) {
GET_PROC(TexBuffer);
}
if (glVer >= GR_GL_VER(4,3)) {
GET_PROC(TexBufferRange);
}
GET_PROC(TexImage2D);
GET_PROC(TexParameteri);
GET_PROC(TexParameteriv);
if (glVer >= GR_GL_VER(4,2) || extensions.has("GL_ARB_texture_storage")) {
GET_PROC(TexStorage2D);
} else if (extensions.has("GL_EXT_texture_storage")) {
GET_PROC_SUFFIX(TexStorage2D, EXT);
}
GET_PROC(TexSubImage2D);
if (glVer >= GR_GL_VER(4,5) || extensions.has("GL_ARB_texture_barrier")) {
GET_PROC(TextureBarrier);
} else if (extensions.has("GL_NV_texture_barrier")) {
GET_PROC_SUFFIX(TextureBarrier, NV);
}
GET_PROC(Uniform1f);
GET_PROC(Uniform1i);
GET_PROC(Uniform1fv);
GET_PROC(Uniform1iv);
GET_PROC(Uniform2f);
GET_PROC(Uniform2i);
GET_PROC(Uniform2fv);
GET_PROC(Uniform2iv);
GET_PROC(Uniform3f);
GET_PROC(Uniform3i);
GET_PROC(Uniform3fv);
GET_PROC(Uniform3iv);
GET_PROC(Uniform4f);
GET_PROC(Uniform4i);
GET_PROC(Uniform4fv);
GET_PROC(Uniform4iv);
GET_PROC(UniformMatrix2fv);
GET_PROC(UniformMatrix3fv);
GET_PROC(UniformMatrix4fv);
GET_PROC(UnmapBuffer);
GET_PROC(UseProgram);
GET_PROC(VertexAttrib1f);
GET_PROC(VertexAttrib2fv);
GET_PROC(VertexAttrib3fv);
GET_PROC(VertexAttrib4fv);
if (glVer >= GR_GL_VER(3,2) || extensions.has("GL_ARB_instanced_arrays")) {
GET_PROC(VertexAttribDivisor);
}
if (glVer >= GR_GL_VER(3,0)) {
GET_PROC(VertexAttribIPointer);
}
GET_PROC(VertexAttribPointer);
GET_PROC(Viewport);
GET_PROC(BindFragDataLocationIndexed);
if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_vertex_array_object")) {
// no ARB suffix for GL_ARB_vertex_array_object
GET_PROC(BindVertexArray);
GET_PROC(GenVertexArrays);
GET_PROC(DeleteVertexArrays);
} else if (extensions.has("GL_APPLE_vertex_array_object")) {
GET_PROC_SUFFIX(BindVertexArray, APPLE);
GET_PROC_SUFFIX(GenVertexArrays, APPLE);
GET_PROC_SUFFIX(DeleteVertexArrays, APPLE);
}
if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_map_buffer_range")) {
GET_PROC(MapBufferRange);
GET_PROC(FlushMappedBufferRange);
}
// First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
// GL_ARB_framebuffer_object doesn't use ARB suffix.)
if (glVer >= GR_GL_VER(3,0) || extensions.has("GL_ARB_framebuffer_object")) {
GET_PROC(GenFramebuffers);
GET_PROC(GetFramebufferAttachmentParameteriv);
GET_PROC(GetRenderbufferParameteriv);
GET_PROC(BindFramebuffer);
GET_PROC(FramebufferTexture2D);
GET_PROC(CheckFramebufferStatus);
GET_PROC(DeleteFramebuffers);
GET_PROC(RenderbufferStorage);
GET_PROC(GenRenderbuffers);
GET_PROC(DeleteRenderbuffers);
GET_PROC(FramebufferRenderbuffer);
GET_PROC(BindRenderbuffer);
GET_PROC(RenderbufferStorageMultisample);
GET_PROC(BlitFramebuffer);
} else if (extensions.has("GL_EXT_framebuffer_object")) {
GET_PROC_SUFFIX(GenFramebuffers, EXT);
GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
GET_PROC_SUFFIX(BindFramebuffer, EXT);
GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
GET_PROC_SUFFIX(RenderbufferStorage, EXT);
GET_PROC_SUFFIX(GenRenderbuffers, EXT);
GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
GET_PROC_SUFFIX(BindRenderbuffer, EXT);
if (extensions.has("GL_EXT_framebuffer_multisample")) {
GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
}
if (extensions.has("GL_EXT_framebuffer_blit")) {
GET_PROC_SUFFIX(BlitFramebuffer, EXT);
}
} else {
// we must have FBOs
delete interface;
return nullptr;
}
if (extensions.has("GL_NV_path_rendering")) {
GET_PROC_SUFFIX(MatrixLoadf, EXT);
GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
GET_PROC_SUFFIX(PathCommands, NV);
GET_PROC_SUFFIX(PathParameteri, NV);
GET_PROC_SUFFIX(PathParameterf, NV);
GET_PROC_SUFFIX(GenPaths, NV);
GET_PROC_SUFFIX(DeletePaths, NV);
GET_PROC_SUFFIX(IsPath, NV);
GET_PROC_SUFFIX(PathStencilFunc, NV);
GET_PROC_SUFFIX(StencilFillPath, NV);
GET_PROC_SUFFIX(StencilStrokePath, NV);
GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
GET_PROC_SUFFIX(CoverFillPath, NV);
GET_PROC_SUFFIX(CoverStrokePath, NV);
GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
}
if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
GET_PROC_SUFFIX(CoverageModulation, NV);
}
if (extensions.has("GL_EXT_debug_marker")) {
GET_PROC_SUFFIX(InsertEventMarker, EXT);
GET_PROC_SUFFIX(PushGroupMarker, EXT);
GET_PROC_SUFFIX(PopGroupMarker, EXT);
}
if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_invalidate_subdata")) {
GET_PROC(InvalidateBufferData);
GET_PROC(InvalidateBufferSubData);
GET_PROC(InvalidateFramebuffer);
GET_PROC(InvalidateSubFramebuffer);
GET_PROC(InvalidateTexImage);
GET_PROC(InvalidateTexSubImage);
}
if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_ARB_program_interface_query")) {
GET_PROC(GetProgramResourceLocation);
}
if (extensions.has("GL_NV_bindless_texture")) {
GET_PROC_SUFFIX(GetTextureHandle, NV);
GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
GET_PROC_SUFFIX(GetImageHandle, NV);
GET_PROC_SUFFIX(MakeImageHandleResident, NV);
GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
GET_PROC_SUFFIX(IsTextureHandleResident, NV);
GET_PROC_SUFFIX(IsImageHandleResident, NV);
GET_PROC_SUFFIX(UniformHandleui64, NV);
GET_PROC_SUFFIX(UniformHandleui64v, NV);
GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
}
if (extensions.has("GL_EXT_direct_state_access")) {
GET_PROC_SUFFIX(TextureParameteri, EXT);
GET_PROC_SUFFIX(TextureParameteriv, EXT);
GET_PROC_SUFFIX(TextureParameterf, EXT);
GET_PROC_SUFFIX(TextureParameterfv, EXT);
GET_PROC_SUFFIX(TextureImage1D, EXT);
GET_PROC_SUFFIX(TextureImage2D, EXT);
GET_PROC_SUFFIX(TextureSubImage1D, EXT);
GET_PROC_SUFFIX(TextureSubImage2D, EXT);
GET_PROC_SUFFIX(CopyTextureImage1D, EXT);
GET_PROC_SUFFIX(CopyTextureImage2D, EXT);
GET_PROC_SUFFIX(CopyTextureSubImage1D, EXT);
GET_PROC_SUFFIX(CopyTextureSubImage2D, EXT);
GET_PROC_SUFFIX(GetTextureImage, EXT);
GET_PROC_SUFFIX(GetTextureParameterfv, EXT);
GET_PROC_SUFFIX(GetTextureParameteriv, EXT);
GET_PROC_SUFFIX(GetTextureLevelParameterfv, EXT);
GET_PROC_SUFFIX(GetTextureLevelParameteriv, EXT);
if (glVer >= GR_GL_VER(1,2)) {
GET_PROC_SUFFIX(TextureImage3D, EXT);
GET_PROC_SUFFIX(TextureSubImage3D, EXT);
GET_PROC_SUFFIX(CopyTextureSubImage3D, EXT);
GET_PROC_SUFFIX(CompressedTextureImage3D, EXT);
GET_PROC_SUFFIX(CompressedTextureImage2D, EXT);
GET_PROC_SUFFIX(CompressedTextureImage1D, EXT);
GET_PROC_SUFFIX(CompressedTextureSubImage3D, EXT);
GET_PROC_SUFFIX(CompressedTextureSubImage2D, EXT);
GET_PROC_SUFFIX(CompressedTextureSubImage1D, EXT);
GET_PROC_SUFFIX(GetCompressedTextureImage, EXT);
}
if (glVer >= GR_GL_VER(1,5)) {
GET_PROC_SUFFIX(NamedBufferData, EXT);
GET_PROC_SUFFIX(NamedBufferSubData, EXT);
GET_PROC_SUFFIX(MapNamedBuffer, EXT);
GET_PROC_SUFFIX(UnmapNamedBuffer, EXT);
GET_PROC_SUFFIX(GetNamedBufferParameteriv, EXT);
GET_PROC_SUFFIX(GetNamedBufferPointerv, EXT);
GET_PROC_SUFFIX(GetNamedBufferSubData, EXT);
}
if (glVer >= GR_GL_VER(2,0)) {
GET_PROC_SUFFIX(ProgramUniform1f, EXT);
GET_PROC_SUFFIX(ProgramUniform2f, EXT);
GET_PROC_SUFFIX(ProgramUniform3f, EXT);
GET_PROC_SUFFIX(ProgramUniform4f, EXT);
GET_PROC_SUFFIX(ProgramUniform1i, EXT);
GET_PROC_SUFFIX(ProgramUniform2i, EXT);
GET_PROC_SUFFIX(ProgramUniform3i, EXT);
GET_PROC_SUFFIX(ProgramUniform4i, EXT);
GET_PROC_SUFFIX(ProgramUniform1fv, EXT);
GET_PROC_SUFFIX(ProgramUniform2fv, EXT);
GET_PROC_SUFFIX(ProgramUniform3fv, EXT);
GET_PROC_SUFFIX(ProgramUniform4fv, EXT);
GET_PROC_SUFFIX(ProgramUniform1iv, EXT);
GET_PROC_SUFFIX(ProgramUniform2iv, EXT);
GET_PROC_SUFFIX(ProgramUniform3iv, EXT);
GET_PROC_SUFFIX(ProgramUniform4iv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix2fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix3fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix4fv, EXT);
}
if (glVer >= GR_GL_VER(2,1)) {
GET_PROC_SUFFIX(ProgramUniformMatrix2x3fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix3x2fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix2x4fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix4x2fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix3x4fv, EXT);
GET_PROC_SUFFIX(ProgramUniformMatrix4x3fv, EXT);
}
if (glVer >= GR_GL_VER(3,0)) {
GET_PROC_SUFFIX(NamedRenderbufferStorage, EXT);
GET_PROC_SUFFIX(GetNamedRenderbufferParameteriv, EXT);
GET_PROC_SUFFIX(NamedRenderbufferStorageMultisample, EXT);
GET_PROC_SUFFIX(CheckNamedFramebufferStatus, EXT);
GET_PROC_SUFFIX(NamedFramebufferTexture1D, EXT);
GET_PROC_SUFFIX(NamedFramebufferTexture2D, EXT);
GET_PROC_SUFFIX(NamedFramebufferTexture3D, EXT);
GET_PROC_SUFFIX(NamedFramebufferRenderbuffer, EXT);
GET_PROC_SUFFIX(GetNamedFramebufferAttachmentParameteriv, EXT);
GET_PROC_SUFFIX(GenerateTextureMipmap, EXT);
GET_PROC_SUFFIX(FramebufferDrawBuffer, EXT);
GET_PROC_SUFFIX(FramebufferDrawBuffers, EXT);
GET_PROC_SUFFIX(FramebufferReadBuffer, EXT);
GET_PROC_SUFFIX(GetFramebufferParameteriv, EXT);
GET_PROC_SUFFIX(NamedCopyBufferSubData, EXT);
GET_PROC_SUFFIX(VertexArrayVertexOffset, EXT);
GET_PROC_SUFFIX(VertexArrayColorOffset, EXT);
GET_PROC_SUFFIX(VertexArrayEdgeFlagOffset, EXT);
GET_PROC_SUFFIX(VertexArrayIndexOffset, EXT);
GET_PROC_SUFFIX(VertexArrayNormalOffset, EXT);
GET_PROC_SUFFIX(VertexArrayTexCoordOffset, EXT);
GET_PROC_SUFFIX(VertexArrayMultiTexCoordOffset, EXT);
GET_PROC_SUFFIX(VertexArrayFogCoordOffset, EXT);
GET_PROC_SUFFIX(VertexArraySecondaryColorOffset, EXT);
GET_PROC_SUFFIX(VertexArrayVertexAttribOffset, EXT);
GET_PROC_SUFFIX(VertexArrayVertexAttribIOffset, EXT);
GET_PROC_SUFFIX(EnableVertexArray, EXT);
GET_PROC_SUFFIX(DisableVertexArray, EXT);
GET_PROC_SUFFIX(EnableVertexArrayAttrib, EXT);
GET_PROC_SUFFIX(DisableVertexArrayAttrib, EXT);
GET_PROC_SUFFIX(GetVertexArrayIntegerv, EXT);
GET_PROC_SUFFIX(GetVertexArrayPointerv, EXT);
GET_PROC_SUFFIX(GetVertexArrayIntegeri_v, EXT);
GET_PROC_SUFFIX(GetVertexArrayPointeri_v, EXT);
GET_PROC_SUFFIX(MapNamedBufferRange, EXT);
GET_PROC_SUFFIX(FlushMappedNamedBufferRange, EXT);
}
if (glVer >= GR_GL_VER(3,1)) {
GET_PROC_SUFFIX(TextureBuffer, EXT);
}
}
if (glVer >= GR_GL_VER(4,3) || extensions.has("GL_KHR_debug")) {
// KHR_debug defines these methods to have no suffix in an OpenGL (not ES) context.
GET_PROC(DebugMessageControl);
GET_PROC(DebugMessageInsert);
GET_PROC(DebugMessageCallback);
GET_PROC(GetDebugMessageLog);
GET_PROC(PushDebugGroup);
GET_PROC(PopDebugGroup);
GET_PROC(ObjectLabel);
}
if (extensions.has("GL_EXT_window_rectangles")) {
GET_PROC_SUFFIX(WindowRectangles, EXT);
}
if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
GET_EGL_PROC_SUFFIX(CreateImage, KHR);
GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
}
if (glVer >= GR_GL_VER(4, 0) || extensions.has("GL_ARB_sample_shading")) {
GET_PROC(MinSampleShading);
}
if (glVer >= GR_GL_VER(3, 2) || extensions.has("GL_ARB_sync")) {
GET_PROC(FenceSync);
GET_PROC(ClientWaitSync);
GET_PROC(DeleteSync);
}
if (glVer >= GR_GL_VER(4, 2) || extensions.has("GL_ARB_shader_image_load_store")) {
GET_PROC(BindImageTexture);
GET_PROC(MemoryBarrier);
}
if (glVer >= GR_GL_VER(4, 5) || extensions.has("GL_ARB_ES3_1_compatibility")) {
GET_PROC(MemoryBarrierByRegion);
}
interface->fStandard = kGL_GrGLStandard;
interface->fExtensions.swap(&extensions);
return interface;
}
const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
GET_PROC_LOCAL(GetString);
if (nullptr == GetString) {
return nullptr;
}
const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
GrGLVersion version = GrGLGetVersionFromString(verStr);
if (version < GR_GL_VER(2,0)) {
return nullptr;
}
GET_PROC_LOCAL(GetIntegerv);
GET_PROC_LOCAL(GetStringi);
GrEGLQueryStringProc queryString;
GrEGLDisplay display;
get_egl_query_and_display(&queryString, &display, ctx, get);
GrGLExtensions extensions;
if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
display)) {
return nullptr;
}
GrGLInterface* interface = new GrGLInterface;
GrGLInterface::Functions* functions = &interface->fFunctions;
GET_PROC(ActiveTexture);
GET_PROC(AttachShader);
GET_PROC(BindAttribLocation);
GET_PROC(BindBuffer);
GET_PROC(BindTexture);
GET_PROC_SUFFIX(BindVertexArray, OES);
if (version >= GR_GL_VER(3,0) && extensions.has("GL_EXT_blend_func_extended")) {
GET_PROC_SUFFIX(BindFragDataLocation, EXT);
GET_PROC_SUFFIX(BindFragDataLocationIndexed, EXT);
}
if (extensions.has("GL_KHR_blend_equation_advanced")) {
GET_PROC_SUFFIX(BlendBarrier, KHR);
} else if (extensions.has("GL_NV_blend_equation_advanced")) {
GET_PROC_SUFFIX(BlendBarrier, NV);
}
GET_PROC(BlendColor);
GET_PROC(BlendEquation);
GET_PROC(BlendFunc);
GET_PROC(BufferData);
GET_PROC(BufferSubData);
GET_PROC(Clear);
GET_PROC(ClearColor);
GET_PROC(ClearStencil);
GET_PROC(ColorMask);
GET_PROC(CompileShader);
GET_PROC(CompressedTexImage2D);
GET_PROC(CompressedTexSubImage2D);
GET_PROC(CopyTexSubImage2D);
GET_PROC(CreateProgram);
GET_PROC(CreateShader);
GET_PROC(CullFace);
GET_PROC(DeleteBuffers);
GET_PROC(DeleteProgram);
GET_PROC(DeleteShader);
GET_PROC(DeleteTextures);
GET_PROC_SUFFIX(DeleteVertexArrays, OES);
GET_PROC(DepthMask);
GET_PROC(Disable);
GET_PROC(DisableVertexAttribArray);
GET_PROC(DrawArrays);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(DrawArraysInstanced);
GET_PROC(DrawElementsInstanced);
} else if (extensions.has("GL_EXT_draw_instanced")) {
GET_PROC_SUFFIX(DrawArraysInstanced, EXT);
GET_PROC_SUFFIX(DrawElementsInstanced, EXT);
}
if (version >= GR_GL_VER(3,1)) {
GET_PROC(DrawArraysIndirect);
GET_PROC(DrawElementsIndirect);
}
GET_PROC(DrawElements);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(DrawRangeElements);
}
GET_PROC(Enable);
GET_PROC(EnableVertexAttribArray);
GET_PROC(Finish);
GET_PROC(Flush);
GET_PROC(FrontFace);
GET_PROC(GenBuffers);
GET_PROC(GenerateMipmap);
GET_PROC(GenTextures);
GET_PROC_SUFFIX(GenVertexArrays, OES);
GET_PROC(GetBufferParameteriv);
GET_PROC(GetError);
GET_PROC(GetIntegerv);
if (version >= GR_GL_VER(3,1)) {
GET_PROC(GetMultisamplefv);
}
GET_PROC(GetProgramInfoLog);
GET_PROC(GetProgramiv);
GET_PROC(GetShaderInfoLog);
GET_PROC(GetShaderPrecisionFormat);
GET_PROC(GetShaderiv);
GET_PROC(GetString);
GET_PROC(GetStringi);
GET_PROC(GetUniformLocation);
GET_PROC(IsTexture);
GET_PROC(LineWidth);
GET_PROC(LinkProgram);
if (extensions.has("GL_EXT_multi_draw_indirect")) {
GET_PROC_SUFFIX(MultiDrawArraysIndirect, EXT);
GET_PROC_SUFFIX(MultiDrawElementsIndirect, EXT);
}
GET_PROC(PixelStorei);
if (extensions.has("GL_EXT_raster_multisample")) {
GET_PROC_SUFFIX(RasterSamples, EXT);
}
GET_PROC(ReadPixels);
GET_PROC(Scissor);
GET_PROC(ShaderSource);
GET_PROC(StencilFunc);
GET_PROC(StencilFuncSeparate);
GET_PROC(StencilMask);
GET_PROC(StencilMaskSeparate);
GET_PROC(StencilOp);
GET_PROC(StencilOpSeparate);
if (version >= GR_GL_VER(3,2)) {
GET_PROC(TexBuffer);
GET_PROC(TexBufferRange);
} else if (extensions.has("GL_OES_texture_buffer")) {
GET_PROC_SUFFIX(TexBuffer, OES);
GET_PROC_SUFFIX(TexBufferRange, OES);
} else if (extensions.has("GL_EXT_texture_buffer")) {
GET_PROC_SUFFIX(TexBuffer, EXT);
GET_PROC_SUFFIX(TexBufferRange, EXT);
}
GET_PROC(TexImage2D);
GET_PROC(TexParameteri);
GET_PROC(TexParameteriv);
GET_PROC(TexSubImage2D);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(TexStorage2D);
} else {
GET_PROC_SUFFIX(TexStorage2D, EXT);
}
if (extensions.has("GL_NV_texture_barrier")) {
GET_PROC_SUFFIX(TextureBarrier, NV);
}
GET_PROC_SUFFIX(DiscardFramebuffer, EXT);
GET_PROC(Uniform1f);
GET_PROC(Uniform1i);
GET_PROC(Uniform1fv);
GET_PROC(Uniform1iv);
GET_PROC(Uniform2f);
GET_PROC(Uniform2i);
GET_PROC(Uniform2fv);
GET_PROC(Uniform2iv);
GET_PROC(Uniform3f);
GET_PROC(Uniform3i);
GET_PROC(Uniform3fv);
GET_PROC(Uniform3iv);
GET_PROC(Uniform4f);
GET_PROC(Uniform4i);
GET_PROC(Uniform4fv);
GET_PROC(Uniform4iv);
GET_PROC(UniformMatrix2fv);
GET_PROC(UniformMatrix3fv);
GET_PROC(UniformMatrix4fv);
GET_PROC(UseProgram);
GET_PROC(VertexAttrib1f);
GET_PROC(VertexAttrib2fv);
GET_PROC(VertexAttrib3fv);
GET_PROC(VertexAttrib4fv);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(VertexAttribDivisor);
} else if (extensions.has("GL_EXT_instanced_arrays")) {
GET_PROC_SUFFIX(VertexAttribDivisor, EXT);
}
if (version >= GR_GL_VER(3,0)) {
GET_PROC(VertexAttribIPointer);
}
GET_PROC(VertexAttribPointer);
GET_PROC(Viewport);
GET_PROC(BindFramebuffer);
GET_PROC(BindRenderbuffer);
GET_PROC(CheckFramebufferStatus);
GET_PROC(DeleteFramebuffers);
GET_PROC(DeleteRenderbuffers);
GET_PROC(FramebufferRenderbuffer);
GET_PROC(FramebufferTexture2D);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(RenderbufferStorageMultisample);
GET_PROC(BlitFramebuffer);
} else if (extensions.has("GL_CHROMIUM_framebuffer_multisample")) {
GET_PROC_SUFFIX(RenderbufferStorageMultisample, CHROMIUM);
GET_PROC_SUFFIX(BlitFramebuffer, CHROMIUM);
} else {
if (extensions.has("GL_ANGLE_framebuffer_multisample")) {
GET_PROC_SUFFIX(RenderbufferStorageMultisample, ANGLE);
}
if (extensions.has("GL_ANGLE_framebuffer_blit")) {
GET_PROC_SUFFIX(BlitFramebuffer, ANGLE);
}
}
if (extensions.has("GL_CHROMIUM_map_sub")) {
GET_PROC_SUFFIX(MapBufferSubData, CHROMIUM);
GET_PROC_SUFFIX(MapTexSubImage2D, CHROMIUM);
GET_PROC_SUFFIX(UnmapBufferSubData, CHROMIUM);
GET_PROC_SUFFIX(UnmapTexSubImage2D, CHROMIUM);
}
if (extensions.has("GL_EXT_multisampled_render_to_texture")) {
GET_PROC_SUFFIX(FramebufferTexture2DMultisample, EXT);
functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleEXT");
} else if (extensions.has("GL_IMG_multisampled_render_to_texture")) {
GET_PROC_SUFFIX(FramebufferTexture2DMultisample, IMG);
functions->fRenderbufferStorageMultisampleES2EXT = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleIMG");
} else if (extensions.has("GL_APPLE_framebuffer_multisample")) {
functions->fRenderbufferStorageMultisampleES2APPLE = (GrGLRenderbufferStorageMultisampleProc) get(ctx, "glRenderbufferStorageMultisampleAPPLE");
GET_PROC_SUFFIX(ResolveMultisampleFramebuffer, APPLE);
}
GET_PROC(GenFramebuffers);
GET_PROC(GenRenderbuffers);
GET_PROC(GetFramebufferAttachmentParameteriv);
GET_PROC(GetRenderbufferParameteriv);
GET_PROC(RenderbufferStorage);
GET_PROC_SUFFIX(MapBuffer, OES);
GET_PROC_SUFFIX(UnmapBuffer, OES);
if (version >= GR_GL_VER(3,0)) {
GET_PROC(MapBufferRange);
GET_PROC(FlushMappedBufferRange);
} else if (extensions.has("GL_EXT_map_buffer_range")) {
GET_PROC_SUFFIX(MapBufferRange, EXT);
GET_PROC_SUFFIX(FlushMappedBufferRange, EXT);
}
if (extensions.has("GL_EXT_debug_marker")) {
GET_PROC(InsertEventMarker);
GET_PROC(PushGroupMarker);
GET_PROC(PopGroupMarker);
// The below check is here because a device has been found that has the extension string but
// returns nullptr from the eglGetProcAddress for the functions
if (nullptr == functions->fInsertEventMarker ||
nullptr == functions->fPushGroupMarker ||
nullptr == functions->fPopGroupMarker) {
extensions.remove("GL_EXT_debug_marker");
}
}
GET_PROC(InvalidateFramebuffer);
GET_PROC(InvalidateSubFramebuffer);
GET_PROC(InvalidateBufferData);
GET_PROC(InvalidateBufferSubData);
GET_PROC(InvalidateTexImage);
GET_PROC(InvalidateTexSubImage);
if (version >= GR_GL_VER(3,1)) {
GET_PROC(GetProgramResourceLocation);
}
if (extensions.has("GL_NV_path_rendering")) {
GET_PROC_SUFFIX(MatrixLoadf, EXT);
GET_PROC_SUFFIX(MatrixLoadIdentity, EXT);
GET_PROC_SUFFIX(PathCommands, NV);
GET_PROC_SUFFIX(PathParameteri, NV);
GET_PROC_SUFFIX(PathParameterf, NV);
GET_PROC_SUFFIX(GenPaths, NV);
GET_PROC_SUFFIX(DeletePaths, NV);
GET_PROC_SUFFIX(IsPath, NV);
GET_PROC_SUFFIX(PathStencilFunc, NV);
GET_PROC_SUFFIX(StencilFillPath, NV);
GET_PROC_SUFFIX(StencilStrokePath, NV);
GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
GET_PROC_SUFFIX(CoverFillPath, NV);
GET_PROC_SUFFIX(CoverStrokePath, NV);
GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
GET_PROC_SUFFIX(StencilThenCoverFillPath, NV);
GET_PROC_SUFFIX(StencilThenCoverStrokePath, NV);
GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, NV);
GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, NV);
GET_PROC_SUFFIX(ProgramPathFragmentInputGen, NV);
}
if (extensions.has("GL_CHROMIUM_path_rendering")) {
GET_PROC_SUFFIX(MatrixLoadf, CHROMIUM);
GET_PROC_SUFFIX(MatrixLoadIdentity, CHROMIUM);
GET_PROC_SUFFIX(PathCommands, CHROMIUM);
GET_PROC_SUFFIX(PathParameteri, CHROMIUM);
GET_PROC_SUFFIX(PathParameterf, CHROMIUM);
GET_PROC_SUFFIX(GenPaths, CHROMIUM);
GET_PROC_SUFFIX(DeletePaths, CHROMIUM);
GET_PROC_SUFFIX(IsPath, CHROMIUM);
GET_PROC_SUFFIX(PathStencilFunc, CHROMIUM);
GET_PROC_SUFFIX(StencilFillPath, CHROMIUM);
GET_PROC_SUFFIX(StencilStrokePath, CHROMIUM);
GET_PROC_SUFFIX(StencilFillPathInstanced, CHROMIUM);
GET_PROC_SUFFIX(StencilStrokePathInstanced, CHROMIUM);
GET_PROC_SUFFIX(CoverFillPath, CHROMIUM);
GET_PROC_SUFFIX(CoverStrokePath, CHROMIUM);
GET_PROC_SUFFIX(CoverFillPathInstanced, CHROMIUM);
GET_PROC_SUFFIX(CoverStrokePathInstanced, CHROMIUM);
GET_PROC_SUFFIX(StencilThenCoverFillPath, CHROMIUM);
GET_PROC_SUFFIX(StencilThenCoverStrokePath, CHROMIUM);
GET_PROC_SUFFIX(StencilThenCoverFillPathInstanced, CHROMIUM);
GET_PROC_SUFFIX(StencilThenCoverStrokePathInstanced, CHROMIUM);
GET_PROC_SUFFIX(ProgramPathFragmentInputGen, CHROMIUM);
// GL_CHROMIUM_path_rendering additions:
GET_PROC_SUFFIX(BindFragmentInputLocation, CHROMIUM);
}
if (extensions.has("GL_NV_framebuffer_mixed_samples")) {
GET_PROC_SUFFIX(CoverageModulation, NV);
}
if (extensions.has("GL_CHROMIUM_framebuffer_mixed_samples")) {
GET_PROC_SUFFIX(CoverageModulation, CHROMIUM);
}
if (extensions.has("GL_NV_bindless_texture")) {
GET_PROC_SUFFIX(GetTextureHandle, NV);
GET_PROC_SUFFIX(GetTextureSamplerHandle, NV);
GET_PROC_SUFFIX(MakeTextureHandleResident, NV);
GET_PROC_SUFFIX(MakeTextureHandleNonResident, NV);
GET_PROC_SUFFIX(GetImageHandle, NV);
GET_PROC_SUFFIX(MakeImageHandleResident, NV);
GET_PROC_SUFFIX(MakeImageHandleNonResident, NV);
GET_PROC_SUFFIX(IsTextureHandleResident, NV);
GET_PROC_SUFFIX(IsImageHandleResident, NV);
GET_PROC_SUFFIX(UniformHandleui64, NV);
GET_PROC_SUFFIX(UniformHandleui64v, NV);
GET_PROC_SUFFIX(ProgramUniformHandleui64, NV);
GET_PROC_SUFFIX(ProgramUniformHandleui64v, NV);
}
if (extensions.has("GL_KHR_debug")) {
GET_PROC_SUFFIX(DebugMessageControl, KHR);
GET_PROC_SUFFIX(DebugMessageInsert, KHR);
GET_PROC_SUFFIX(DebugMessageCallback, KHR);
GET_PROC_SUFFIX(GetDebugMessageLog, KHR);
GET_PROC_SUFFIX(PushDebugGroup, KHR);
GET_PROC_SUFFIX(PopDebugGroup, KHR);
GET_PROC_SUFFIX(ObjectLabel, KHR);
// In general we have a policy against removing extension strings when the driver does
// not provide function pointers for an advertised extension. However, because there is a
// known device that advertises GL_KHR_debug but fails to provide the functions and this is
// a debugging- only extension we've made an exception. This also can happen when using
// APITRACE.
if (!interface->fFunctions.fDebugMessageControl) {
extensions.remove("GL_KHR_debug");
}
}
if (extensions.has("GL_CHROMIUM_bind_uniform_location")) {
GET_PROC_SUFFIX(BindUniformLocation, CHROMIUM);
}
if (extensions.has("GL_EXT_window_rectangles")) {
GET_PROC_SUFFIX(WindowRectangles, EXT);
}
if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
GET_EGL_PROC_SUFFIX(CreateImage, KHR);
GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
}
if (extensions.has("GL_OES_sample_shading")) {
GET_PROC_SUFFIX(MinSampleShading, OES);
}
if (version >= GR_GL_VER(3, 0)) {
GET_PROC(FenceSync);
GET_PROC(ClientWaitSync);
GET_PROC(DeleteSync);
}
if (version >= GR_GL_VER(3, 1)) {
GET_PROC(BindImageTexture);
GET_PROC(MemoryBarrier);
GET_PROC(MemoryBarrierByRegion);
}
interface->fStandard = kGLES_GrGLStandard;
interface->fExtensions.swap(&extensions);
return interface;
}
| [
"joshield@microsoft.com"
] | joshield@microsoft.com |
0989b39d8f11354bce21682d173aa7aae936510c | 03f6e7caf6634fc913b1dc5c16a507c51cb8aec2 | /src/qt/overviewpage.cpp | d3f4f6a3b2c630094877a702cc9ce920a88a4e16 | [
"MIT"
] | permissive | Simple-Software-Solutions/SSS-Core | 5b247220640f493a03a849a37126034a02813563 | a0a728e9f6e376aade43d89945b7a56047e7e86a | refs/heads/master | 2021-07-05T06:34:22.710496 | 2021-04-20T17:05:33 | 2021-04-20T17:05:33 | 233,949,845 | 9 | 6 | MIT | 2020-11-16T21:34:37 | 2020-01-14T22:38:52 | C++ | UTF-8 | C++ | false | false | 19,467 | cpp | // Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Copyright (c) 2018-2019 The SSSolutions developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "overviewpage.h"
#include "ui_overviewpage.h"
#include "bitcoinunits.h"
#include "clientmodel.h"
#include "guiconstants.h"
#include "guiutil.h"
#include "init.h"
#include "obfuscation.h"
#include "obfuscationconfig.h"
#include "optionsmodel.h"
#include "transactionfilterproxy.h"
#include "transactionrecord.h"
#include "transactiontablemodel.h"
#include "walletmodel.h"
#include <QAbstractItemDelegate>
#include <QPainter>
#include <QSettings>
#include <QTimer>
#define DECORATION_SIZE 48
#define ICON_OFFSET 16
#define NUM_ITEMS 9
extern CWallet* pwalletMain;
class TxViewDelegate : public QAbstractItemDelegate
{
Q_OBJECT
public:
TxViewDelegate() : QAbstractItemDelegate(), unit(BitcoinUnits::SSS)
{
}
inline void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
painter->save();
QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole));
QRect mainRect = option.rect;
mainRect.moveLeft(ICON_OFFSET);
QRect decorationRect(mainRect.topLeft(), QSize(DECORATION_SIZE, DECORATION_SIZE));
int xspace = DECORATION_SIZE + 8;
int ypad = 6;
int halfheight = (mainRect.height() - 2 * ypad) / 2;
QRect amountRect(mainRect.left() + xspace, mainRect.top() + ypad, mainRect.width() - xspace - ICON_OFFSET, halfheight);
QRect addressRect(mainRect.left() + xspace, mainRect.top() + ypad + halfheight, mainRect.width() - xspace, halfheight);
icon.paint(painter, decorationRect);
QDateTime date = index.data(TransactionTableModel::DateRole).toDateTime();
QString address = index.data(Qt::DisplayRole).toString();
qint64 amount = index.data(TransactionTableModel::AmountRole).toLongLong();
bool confirmed = index.data(TransactionTableModel::ConfirmedRole).toBool();
QVariant value = index.data(Qt::ForegroundRole);
QColor foreground = COLOR_BLACK;
if (value.canConvert<QBrush>()) {
QBrush brush = qvariant_cast<QBrush>(value);
foreground = brush.color();
}
painter->setPen(foreground);
QRect boundingRect;
painter->drawText(addressRect, Qt::AlignLeft | Qt::AlignVCenter, address, &boundingRect);
if (index.data(TransactionTableModel::WatchonlyRole).toBool()) {
QIcon iconWatchonly = qvariant_cast<QIcon>(index.data(TransactionTableModel::WatchonlyDecorationRole));
QRect watchonlyRect(boundingRect.right() + 5, mainRect.top() + ypad + halfheight, 16, halfheight);
iconWatchonly.paint(painter, watchonlyRect);
}
if (amount < 0)
foreground = COLOR_NEGATIVE;
painter->setPen(foreground);
QString amountText = BitcoinUnits::formatWithUnit(unit, amount, true, BitcoinUnits::separatorAlways);
if (!confirmed) {
amountText = QString("[") + amountText + QString("]");
}
painter->drawText(amountRect, Qt::AlignRight | Qt::AlignVCenter, amountText);
painter->setPen(COLOR_BLACK);
painter->drawText(amountRect, Qt::AlignLeft | Qt::AlignVCenter, GUIUtil::dateTimeStr(date));
painter->restore();
}
inline QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const
{
return QSize(DECORATION_SIZE, DECORATION_SIZE);
}
int unit;
};
#include "overviewpage.moc"
OverviewPage::OverviewPage(QWidget* parent) : QWidget(parent),
ui(new Ui::OverviewPage),
clientModel(0),
walletModel(0),
currentBalance(-1),
currentUnconfirmedBalance(-1),
currentImmatureBalance(-1),
currentZerocoinBalance(-1),
currentUnconfirmedZerocoinBalance(-1),
currentimmatureZerocoinBalance(-1),
currentWatchOnlyBalance(-1),
currentWatchUnconfBalance(-1),
currentWatchImmatureBalance(-1),
txdelegate(new TxViewDelegate()),
filter(0)
{
nDisplayUnit = 0; // just make sure it's not unitialized
ui->setupUi(this);
// Recent transactions
ui->listTransactions->setItemDelegate(txdelegate);
ui->listTransactions->setIconSize(QSize(DECORATION_SIZE, DECORATION_SIZE));
ui->listTransactions->setMinimumHeight(NUM_ITEMS * (DECORATION_SIZE + 2));
ui->listTransactions->setAttribute(Qt::WA_MacShowFocusRect, false);
connect(ui->listTransactions, SIGNAL(clicked(QModelIndex)), this, SLOT(handleTransactionClicked(QModelIndex)));
// init "out of sync" warning labels
ui->labelWalletStatus->setText("(" + tr("out of sync") + ")");
ui->labelTransactionsStatus->setText("(" + tr("out of sync") + ")");
// start with displaying the "out of sync" warnings
showOutOfSyncWarning(true);
}
void OverviewPage::handleTransactionClicked(const QModelIndex& index)
{
if (filter)
emit transactionClicked(filter->mapToSource(index));
}
OverviewPage::~OverviewPage()
{
delete ui;
}
void OverviewPage::getPercentage(CAmount nUnlockedBalance, CAmount nZerocoinBalance, QString& sSSSPercentage, QString& szsssPercentage)
{
int nPrecision = 2;
double dzPercentage = 0.0;
if (nZerocoinBalance <= 0){
dzPercentage = 0.0;
}
else{
if (nUnlockedBalance <= 0){
dzPercentage = 100.0;
}
else{
dzPercentage = 100.0 * (double)(nZerocoinBalance / (double)(nZerocoinBalance + nUnlockedBalance));
}
}
double dPercentage = 100.0 - dzPercentage;
szsssPercentage = "(" + QLocale(QLocale::system()).toString(dzPercentage, 'f', nPrecision) + " %)";
sSSSPercentage = "(" + QLocale(QLocale::system()).toString(dPercentage, 'f', nPrecision) + " %)";
}
void OverviewPage::setBalance(const CAmount& balance, const CAmount& unconfirmedBalance, const CAmount& immatureBalance,
const CAmount& zerocoinBalance, const CAmount& unconfirmedZerocoinBalance, const CAmount& immatureZerocoinBalance,
const CAmount& watchOnlyBalance, const CAmount& watchUnconfBalance, const CAmount& watchImmatureBalance)
{
currentBalance = balance;
currentUnconfirmedBalance = unconfirmedBalance;
currentImmatureBalance = immatureBalance;
currentZerocoinBalance = zerocoinBalance;
currentUnconfirmedZerocoinBalance = unconfirmedZerocoinBalance;
currentimmatureZerocoinBalance = immatureZerocoinBalance;
currentWatchOnlyBalance = watchOnlyBalance;
currentWatchUnconfBalance = watchUnconfBalance;
currentWatchImmatureBalance = watchImmatureBalance;
CAmount nLockedBalance = 0;
CAmount nWatchOnlyLockedBalance = 0;
if (pwalletMain) {
nLockedBalance = pwalletMain->GetLockedCoins();
nWatchOnlyLockedBalance = pwalletMain->GetLockedWatchOnlyBalance();
}
// SSS Balance
CAmount nTotalBalance = balance + unconfirmedBalance;
CAmount SSSAvailableBalance = balance - immatureBalance - nLockedBalance;
CAmount nUnlockedBalance = nTotalBalance - nLockedBalance;
// SSS Watch-Only Balance
CAmount nTotalWatchBalance = watchOnlyBalance + watchUnconfBalance;
CAmount nAvailableWatchBalance = watchOnlyBalance - watchImmatureBalance - nWatchOnlyLockedBalance;
// zsss Balance
CAmount matureZerocoinBalance = zerocoinBalance - unconfirmedZerocoinBalance - immatureZerocoinBalance;
// Percentages
QString szPercentage = "";
QString sPercentage = "";
getPercentage(nUnlockedBalance, zerocoinBalance, sPercentage, szPercentage);
// Combined balances
CAmount availableTotalBalance = SSSAvailableBalance + matureZerocoinBalance;
CAmount sumTotalBalance = nTotalBalance + zerocoinBalance;
// SSS labels
ui->labelBalance->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, SSSAvailableBalance, false, BitcoinUnits::separatorAlways));
ui->labelUnconfirmed->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, unconfirmedBalance, false, BitcoinUnits::separatorAlways));
ui->labelImmature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, immatureBalance, false, BitcoinUnits::separatorAlways));
ui->labelLockedBalance->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, nLockedBalance, false, BitcoinUnits::separatorAlways));
ui->labelTotal->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, nTotalBalance, false, BitcoinUnits::separatorAlways));
// Watchonly labels
ui->labelWatchAvailable->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, nAvailableWatchBalance, false, BitcoinUnits::separatorAlways));
ui->labelWatchPending->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchUnconfBalance, false, BitcoinUnits::separatorAlways));
ui->labelWatchImmature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchImmatureBalance, false, BitcoinUnits::separatorAlways));
ui->labelWatchLocked->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, nWatchOnlyLockedBalance, false, BitcoinUnits::separatorAlways));
ui->labelWatchTotal->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, nTotalWatchBalance, false, BitcoinUnits::separatorAlways));
// zsss labels
ui->labelzBalance->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, zerocoinBalance, false, BitcoinUnits::separatorAlways));
ui->labelzBalanceUnconfirmed->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, unconfirmedZerocoinBalance, false, BitcoinUnits::separatorAlways));
ui->labelzBalanceMature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, matureZerocoinBalance, false, BitcoinUnits::separatorAlways));
ui->labelzBalanceImmature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, immatureZerocoinBalance, false, BitcoinUnits::separatorAlways));
// Combined labels
ui->labelBalancez->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, availableTotalBalance, false, BitcoinUnits::separatorAlways));
ui->labelTotalz->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, sumTotalBalance, false, BitcoinUnits::separatorAlways));
// Percentage labels
ui->labelSSSPercent->setText(sPercentage);
ui->labelzsssPercent->setText(szPercentage);
// Adjust bubble-help according to AutoMint settings
QString automintHelp = tr("Current percentage of zsss.\nIf AutoMint is enabled this percentage will settle around the configured AutoMint percentage (default = 10%).\n");
bool fEnableZeromint = GetBoolArg("-enablezeromint", false);
int nZeromintPercentage = GetArg("-zeromintpercentage", 0);
if (fEnableZeromint) {
automintHelp += tr("AutoMint is currently enabled and set to ") + QString::number(nZeromintPercentage) + "%.\n";
automintHelp += tr("To disable AutoMint add 'enablezeromint=0' in sssolutions.conf.");
}
else {
automintHelp += tr("AutoMint is currently disabled.\nTo enable AutoMint change 'enablezeromint=0' to 'enablezeromint=1' in sssolutions.conf");
}
// Only show most balances if they are non-zero for the sake of simplicity
QSettings settings;
bool settingShowAllBalances = !settings.value("fHideZeroBalances").toBool();
bool showSumAvailable = settingShowAllBalances || sumTotalBalance != availableTotalBalance;
ui->labelBalanceTextz->setVisible(showSumAvailable);
ui->labelBalancez->setVisible(showSumAvailable);
bool showWatchOnly = nTotalWatchBalance != 0;
// SSS Available
bool showSSSAvailable = settingShowAllBalances || SSSAvailableBalance != nTotalBalance;
bool showWatchOnlySSSAvailable = showSSSAvailable || nAvailableWatchBalance != nTotalWatchBalance;
ui->labelBalanceText->setVisible(showSSSAvailable || showWatchOnlySSSAvailable);
ui->labelBalance->setVisible(showSSSAvailable || showWatchOnlySSSAvailable);
ui->labelWatchAvailable->setVisible(showWatchOnlySSSAvailable && showWatchOnly);
// SSS Pending
bool showSSSPending = settingShowAllBalances || unconfirmedBalance != 0;
bool showWatchOnlySSSPending = showSSSPending || watchUnconfBalance != 0;
ui->labelPendingText->setVisible(showSSSPending || showWatchOnlySSSPending);
ui->labelUnconfirmed->setVisible(showSSSPending || showWatchOnlySSSPending);
ui->labelWatchPending->setVisible(showWatchOnlySSSPending && showWatchOnly);
// SSS Immature
bool showSSSImmature = settingShowAllBalances || immatureBalance != 0;
bool showWatchOnlyImmature = showSSSImmature || watchImmatureBalance != 0;
ui->labelImmatureText->setVisible(showSSSImmature || showWatchOnlyImmature);
ui->labelImmature->setVisible(showSSSImmature || showWatchOnlyImmature); // for symmetry reasons also show immature label when the watch-only one is shown
ui->labelWatchImmature->setVisible(showWatchOnlyImmature && showWatchOnly); // show watch-only immature balance
// SSS Locked
bool showSSSLocked = settingShowAllBalances || nLockedBalance != 0;
bool showWatchOnlySSSLocked = showSSSLocked || nWatchOnlyLockedBalance != 0;
ui->labelLockedBalanceText->setVisible(showSSSLocked || showWatchOnlySSSLocked);
ui->labelLockedBalance->setVisible(showSSSLocked || showWatchOnlySSSLocked);
ui->labelWatchLocked->setVisible(showWatchOnlySSSLocked && showWatchOnly);
// zsss
bool showzsssAvailable = settingShowAllBalances || zerocoinBalance != matureZerocoinBalance;
bool showzsssUnconfirmed = settingShowAllBalances || unconfirmedZerocoinBalance != 0;
bool showzsssImmature = settingShowAllBalances || immatureZerocoinBalance != 0;
ui->labelzBalanceMature->setVisible(showzsssAvailable);
ui->labelzBalanceMatureText->setVisible(showzsssAvailable);
ui->labelzBalanceUnconfirmed->setVisible(showzsssUnconfirmed);
ui->labelzBalanceUnconfirmedText->setVisible(showzsssUnconfirmed);
ui->labelzBalanceImmature->setVisible(showzsssImmature);
ui->labelzBalanceImmatureText->setVisible(showzsssImmature);
// Percent split
bool showPercentages = ! (zerocoinBalance == 0 && nTotalBalance == 0);
ui->labelSSSPercent->setVisible(showPercentages);
ui->labelzsssPercent->setVisible(showPercentages);
static int cachedTxLocks = 0;
if (cachedTxLocks != nCompleteTXLocks) {
cachedTxLocks = nCompleteTXLocks;
ui->listTransactions->update();
}
}
// show/hide watch-only labels
void OverviewPage::updateWatchOnlyLabels(bool showWatchOnly)
{
ui->labelSpendable->setVisible(showWatchOnly); // show spendable label (only when watch-only is active)
ui->labelWatchonly->setVisible(showWatchOnly); // show watch-only label
ui->labelWatchAvailable->setVisible(showWatchOnly); // show watch-only available balance
ui->labelWatchPending->setVisible(showWatchOnly); // show watch-only pending balance
ui->labelWatchLocked->setVisible(showWatchOnly); // show watch-only total balance
ui->labelWatchTotal->setVisible(showWatchOnly); // show watch-only total balance
if (!showWatchOnly) {
ui->labelWatchImmature->hide();
} else {
ui->labelBalance->setIndent(20);
ui->labelUnconfirmed->setIndent(20);
ui->labelLockedBalance->setIndent(20);
ui->labelImmature->setIndent(20);
ui->labelTotal->setIndent(20);
}
}
void OverviewPage::setClientModel(ClientModel* model)
{
this->clientModel = model;
if (model) {
// Show warning if this is a prerelease version
connect(model, SIGNAL(alertsChanged(QString)), this, SLOT(updateAlerts(QString)));
updateAlerts(model->getStatusBarWarnings());
}
}
void OverviewPage::setWalletModel(WalletModel* model)
{
this->walletModel = model;
if (model && model->getOptionsModel()) {
// Set up transaction list
filter = new TransactionFilterProxy();
filter->setSourceModel(model->getTransactionTableModel());
filter->setLimit(NUM_ITEMS);
filter->setDynamicSortFilter(true);
filter->setSortRole(Qt::EditRole);
filter->setShowInactive(false);
filter->sort(TransactionTableModel::Date, Qt::DescendingOrder);
ui->listTransactions->setModel(filter);
ui->listTransactions->setModelColumn(TransactionTableModel::ToAddress);
// Keep up to date with wallet
setBalance(model->getBalance(), model->getUnconfirmedBalance(), model->getImmatureBalance(),
model->getZerocoinBalance(), model->getUnconfirmedZerocoinBalance(), model->getImmatureZerocoinBalance(),
model->getWatchBalance(), model->getWatchUnconfirmedBalance(), model->getWatchImmatureBalance());
connect(model, SIGNAL(balanceChanged(CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount)), this,
SLOT(setBalance(CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount, CAmount)));
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
connect(model->getOptionsModel(), SIGNAL(hideZeroBalancesChanged(bool)), this, SLOT(updateDisplayUnit()));
connect(model->getOptionsModel(), SIGNAL(hideOrphansChanged(bool)), this, SLOT(hideOrphans(bool)));
updateWatchOnlyLabels(model->haveWatchOnly());
connect(model, SIGNAL(notifyWatchonlyChanged(bool)), this, SLOT(updateWatchOnlyLabels(bool)));
}
// update the display unit, to not use the default ("SSS")
updateDisplayUnit();
// Hide orphans
QSettings settings;
hideOrphans(settings.value("fHideOrphans", false).toBool());
}
void OverviewPage::updateDisplayUnit()
{
if (walletModel && walletModel->getOptionsModel()) {
nDisplayUnit = walletModel->getOptionsModel()->getDisplayUnit();
if (currentBalance != -1)
setBalance(currentBalance, currentUnconfirmedBalance, currentImmatureBalance, currentZerocoinBalance, currentUnconfirmedZerocoinBalance, currentimmatureZerocoinBalance,
currentWatchOnlyBalance, currentWatchUnconfBalance, currentWatchImmatureBalance);
// Update txdelegate->unit with the current unit
txdelegate->unit = nDisplayUnit;
ui->listTransactions->update();
}
}
void OverviewPage::updateAlerts(const QString& warnings)
{
this->ui->labelAlerts->setVisible(!warnings.isEmpty());
this->ui->labelAlerts->setText(warnings);
}
void OverviewPage::showOutOfSyncWarning(bool fShow)
{
ui->labelWalletStatus->setVisible(fShow);
ui->labelTransactionsStatus->setVisible(fShow);
}
void OverviewPage::hideOrphans(bool fHide)
{
if (filter)
filter->setHideOrphans(fHide);
}
| [
"ultrapoolcom@gmail.com"
] | ultrapoolcom@gmail.com |
7f006d3c4e8ad930828987b99951262b4ebac2ef | b75d5abcba3bcaf5302e92f32f235beb9cbba845 | /City/TileVisitor.h | fd9852b0be117e35f7669f1669efa26430dee40b | [] | no_license | proosjen/city-patterns | 402052dbbca5a1a239cc32ea11fb88baf730e086 | c46609667af7232c79c91f307616f11cf954f7c5 | refs/heads/master | 2021-01-12T08:42:18.213846 | 2016-12-16T18:41:25 | 2016-12-16T18:41:25 | 76,673,190 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,016 | h | /**
* \file TileVisitor.h
*
* \author Jenn Proos
*
* Tile visitor base class.
*/
#pragma once
// Forward references to all tile types
class CTileBuilding;
class CTileCoalmine;
class CTileLandscape;
class CTileRoad;
class CTileRocket;
/** Tile visitor base class */
class CTileVisitor
{
public:
CTileVisitor();
virtual ~CTileVisitor();
/** Visit a CTileBuilding object
* \param building Building we are visiting */
virtual void VisitBuilding(CTileBuilding *building) {}
/** Visit a CTileCoalmine object
* \param coalmine Coal mine we are visiting */
virtual void VisitCoalmine(CTileCoalmine *coalmine) {}
/** Visit a CTileLandscape object
* \param landscape Landscape tile we are visiting */
virtual void VisitLandscape(CTileLandscape *landscape) {}
/** Visit a CTileRoad object
* \param road Road we are visiting */
virtual void VisitRoad(CTileRoad *road) {}
/** Visit a CTileRocket object
* \param rocket Rocket we are visitng */
virtual void VisitRocket(CTileRocket *rocket) {}
};
| [
"proosjen@msu.edu"
] | proosjen@msu.edu |
535b386ee0388db156d76f5b9d25c1aa9b5fdb17 | ca6e5b909c86fc0f6b970779564696d7cc5d11f8 | /Session1/01-Data-Pointers-Classes/02 - NewDelete/newDelete/main.cpp | f76cef76876baa3718815bbc34aadb26b1b25732 | [] | no_license | Craigson/FundamentalsOfComputing | d808edea43c9030a2ff99b1a85241a3bc870d155 | 6ac3fdd71e78121461a9e99e3da9bafcb96ac10e | refs/heads/master | 2022-09-08T18:56:35.658693 | 2022-08-16T12:40:04 | 2022-08-16T12:40:04 | 71,504,031 | 19 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,026 | cpp |
#include <iostream>
// See Basic Pointers for explanation of these.
int main(int argc, const char * argv[])
{
// create a null int pointer (nullptr is a value used to initialize pointers
// to 0x0, meaning it doesn't point to anything) this variable (myIntPtr) lives
// on the stack of main, it will get destoryed when the variable goes out of scope
// basically when main returns at the bottom
int * myIntPtr = nullptr;
// Check to see the address stored in myIntPtr, it should be something like 0x0
std::cout << myIntPtr << std::endl;
// To create dynamic memory (on the Heap), you use the 'new' operator. 'new' asks the
// operating system if it has memory it can afford to give, in this case 4 bytes for the
// int that we'd like to initialize to 200. 'new' will then return an address to the
// initialized memory that the operating system found which we'll store in myIntPtr.
myIntPtr = new int(200);
// Print out the 'new' address stored inside myIntPtr, as you'll see the value stored in
// this pointer will no longer be 0x0, it'll be the address that 'new' returned
std::cout << myIntPtr << std::endl;
// Print out the value stored at that address by dereferencing myIntPtr with the '*'
std::cout << *myIntPtr << std::endl;
// This is the most important aspect of using Heap memory, after the operating system
// gives you the address it forgets that it even had a conversation with your program.
// It is your responsibility to give back the memory associated with myIntPtr. The way
// to do this is by calling 'delete'. 'delete' is an operator like 'new' that tells the
// operating system that you're done with the memory, otherwise the operating system
// believes that you are still using that memory. That is called a memory leak. If
// myIntPtr, a variable created on the stack, goes out of scope and therefore is destroyed
// you will not be able to find that memory address and thus it gets leaked.
delete myIntPtr;
return 0;
}
| [
"craigpick@gmail.com"
] | craigpick@gmail.com |
ecb85ef96b19832cebc0c39048e824614334ef71 | 15cfc1d5cdc6396e62da3c0cd2e0929687892939 | /src/runtracker.cpp | e5f792ebcb4b91ce8bab5beb0e0dbea67178fbd8 | [] | no_license | mengeryang/kcf_faster-rcnn | 0bbd462fcdf5808556520b1102f6383450afb3e2 | e85f4529f2b08c9ad96afb6411e9b52365c37e5d | refs/heads/master | 2020-03-17T17:44:06.907213 | 2018-05-17T11:07:59 | 2018-05-17T11:07:59 | 133,799,817 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,295 | cpp | #include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <ctime>
#include <chrono>
#include <vector>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "kcftracker.hpp"
#include "cuda_profiler_api.h"
#include <dirent.h>
using namespace std;
using namespace cv;
double time_interval(clock_t start, clock_t end)
{
return 1000.0 * (end - start) / CLOCKS_PER_SEC;
}
void init_FR()
{
PyObject *pName, *pModule, *pDict, *pInitFR;
const char* module_name = "demo";
const char* init_frcnn = "init_faster_rcnn";
Py_Initialize();
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.argv=['pdm']");
PyRun_SimpleString("sys.path.append('./')");
PyRun_SimpleString("sys.path.append('./tools')");
pName = PyString_FromString(module_name);
}
int main(int argc, char* argv[]){
if (argc > 6) return -1;
bool HOG = true;
bool FIXEDWINDOW = false;
bool MULTISCALE = true;
bool SILENT = true;
bool LAB = false;
int no_wait = 1;
for(int i = 0; i < argc; i++){
if ( strcmp (argv[i], "hog") == 0 )
HOG = true;
if ( strcmp (argv[i], "fixed_window") == 0 )
FIXEDWINDOW = true;
if ( strcmp (argv[i], "singlescale") == 0 )
MULTISCALE = false;
if ( strcmp (argv[i], "show") == 0 )
SILENT = false;
if ( strcmp (argv[i], "lab") == 0 ){
LAB = true;
HOG = true;
}
if ( strcmp (argv[i], "gray") == 0 )
HOG = false;
if ( strcmp (argv[i], "wait") == 0 )
no_wait = 0;
}
// Create KCFTracker object
KCFTracker tracker(HOG, FIXEDWINDOW, MULTISCALE, LAB);
// Frame readed
Mat frame;
vector<Mat> images;
// Tracker results
Rect result;
// Path to list.txt
ifstream listFile;
string fileName = "images.txt";
listFile.open(fileName);
// Read groundtruth for the 1st frame
ifstream groundtruthFile;
string groundtruth = "region.txt";
groundtruthFile.open(groundtruth);
string firstLine;
getline(groundtruthFile, firstLine);
groundtruthFile.close();
istringstream ss(firstLine);
// Read groundtruth like a dumb
float x1, y1, x2, y2, x3, y3, x4, y4;
char ch;
ss >> x1;
ss >> ch;
ss >> y1;
ss >> ch;
ss >> x2;
ss >> ch;
ss >> y2;
ss >> ch;
ss >> x3;
ss >> ch;
ss >> y3;
ss >> ch;
ss >> x4;
ss >> ch;
ss >> y4;
// Using min and max of X and Y for groundtruth rectangle
float xMin = min(x1, min(x2, min(x3, x4)));
float yMin = min(y1, min(y2, min(y3, y4)));
float width = max(x1, max(x2, max(x3, x4))) - xMin;
float height = max(y1, max(y2, max(y3, y4))) - yMin;
// Read Images
ifstream listFramesFile;
string listFrames = "images.txt";
listFramesFile.open(listFrames);
string frameName;
// Write Results
ofstream resultsFile;
string resultsPath = "output.txt";
resultsFile.open(resultsPath);
// read all images into memory
while(getline(listFramesFile, frameName))
images.push_back(imread(frameName, CV_LOAD_IMAGE_COLOR));
// Init and warm up gpu
//frame = imread(frameName, CV_LOAD_IMAGE_COLOR);
tracker.init( Rect(xMin, yMin, width, height), images[0] );
rectangle( images[0], Point( xMin, yMin ), Point( xMin+width, yMin+height), Scalar( 0, 255, 255 ), 1, 8 );
resultsFile << xMin << "," << yMin << "," << width << "," << height << endl;
// Frame counter
int nFrames = 0;
cudaProfilerStart();
auto tic = chrono::high_resolution_clock::now();
for(int i = 1; i < images.size(); i++){
// frameName = frameName;
// Read each frame from the list
frame = images[i];
// Update
result = tracker.update(frame);
rectangle( frame, Point( result.x, result.y ), Point( result.x+result.width, result.y+result.height), Scalar( 0, 255, 255 ), 1, 8 );
resultsFile << result.x << "," << result.y << "," << result.width << "," << result.height << endl;
nFrames++;
if (!SILENT){
imshow("Image", frame);
waitKey(no_wait);
}
}
auto toc = chrono::high_resolution_clock::now();
double total_time_ms = chrono::duration<double, std::milli>(toc-tic).count();
cudaProfilerStop();
cufhog_finalize();
cout << "total time: " << total_time_ms / 1000.0 << "s" << endl;
cout << "time per frame: " << total_time_ms / nFrames << "ms" << endl;
resultsFile.close();
listFile.close();
}
| [
"mengeryang163@gmail.com"
] | mengeryang163@gmail.com |
838657d651dc23cffc2e72735aeda2fb493be6a0 | b2227d02d4d9e33c01e02ce2bcdb29bdc24df3a7 | /src/extern-libs/DXInterceptorLibs/xgraph/CurveDlg.h | a6e1ed2f337d656b64646ea6495e4d96a6f51bdd | [
"MIT",
"BSD-2-Clause-Views",
"BSD-3-Clause"
] | permissive | Lycheus/GLSL-ATTILA | dfc709690a79462c80eda1e7dfe5c55b383b9f9d | ff401192b9fce46ca08d6de8990dd57763a1c711 | refs/heads/master | 2021-03-27T15:46:05.925536 | 2015-12-11T03:02:13 | 2015-12-11T03:02:13 | 30,689,357 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 2,285 | h | #if !defined(AFX_CURVEDLG_H__98B20941_D604_4120_8561_3902741205F0__INCLUDED_)
#define AFX_CURVEDLG_H__98B20941_D604_4120_8561_3902741205F0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// CurveDlg.h : Header-Datei
//
/////////////////////////////////////////////////////////////////////////////
// Dialogfeld CCurveDlg
#include "XGraphDataSerie.h"
#include "ColorButton.h"
class CCurveDlg : public CDialog
{
// Konstruktion
public:
CCurveDlg(CWnd* pParent = NULL); // Standardkonstruktor
void PresetValues();
// Dialogfelddaten
//{{AFX_DATA(CCurveDlg)
CComboBox m_cbFillCurve;
CSpinButtonCtrl m_SpinLineSize;
CSpinButtonCtrl m_SpinMarkerSize;
CComboBox m_cbMarker;
CColorButton m_Color;
int m_nType;
UINT m_nLineSize;
int m_nStyle;
BOOL m_bShowMarker;
BOOL m_bVisible;
BOOL m_bFillBeneath;
int m_nFillStyle;
BOOL m_bFillTransparent;
CString m_cLabel;
int m_nMarkerType;
int m_nMarker;
UINT m_nMarkerSize;
int m_nFillCurve;
//}}AFX_DATA
CXGraphDataSerie* m_pSerie;
// Überschreibungen
// Vom Klassen-Assistenten generierte virtuelle Funktionsüberschreibungen
//{{AFX_VIRTUAL(CCurveDlg)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV-Unterstützung
//}}AFX_VIRTUAL
// Implementierung
protected:
// Generierte Nachrichtenzuordnungsfunktionen
//{{AFX_MSG(CCurveDlg)
virtual BOOL OnInitDialog();
afx_msg void OnApply();
afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
afx_msg void OnChanged();
afx_msg LRESULT OnColorChanged(WPARAM, LPARAM);
virtual void OnOK();
afx_msg void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct);
afx_msg void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct);
afx_msg void OnMavg();
afx_msg void OnLintrend();
afx_msg void OnCubtrend();
afx_msg void OnPolytrend();
virtual void OnCancel();
afx_msg void OnSelchangeCbfillcurve();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ fügt unmittelbar vor der vorhergehenden Zeile zusätzliche Deklarationen ein.
#endif // AFX_CURVEDLG_H__98B20941_D604_4120_8561_3902741205F0__INCLUDED_
| [
"lycheus@ubuntu.(none)"
] | lycheus@ubuntu.(none) |
739e41b44051dba53b1931c31eef5bf16f2c1c2f | c51febc209233a9160f41913d895415704d2391f | /library/ATF/_animus_download_result_zoclInfo.hpp | 58a83153311849a9017af170338b89639e7f16ba | [
"MIT"
] | permissive | roussukke/Yorozuya | 81f81e5e759ecae02c793e65d6c3acc504091bc3 | d9a44592b0714da1aebf492b64fdcb3fa072afe5 | refs/heads/master | 2023-07-08T03:23:00.584855 | 2023-06-29T08:20:25 | 2023-06-29T08:20:25 | 463,330,454 | 0 | 0 | MIT | 2022-02-24T23:15:01 | 2022-02-24T23:15:00 | null | UTF-8 | C++ | false | false | 898 | hpp | // This file auto generated by plugin for ida pro. Generated code only for x64. Please, dont change manually
#pragma once
#include <common/common.h>
#include <_animus_download_result_zocl.hpp>
START_ATF_NAMESPACE
namespace Info
{
using _animus_download_result_zoclctor__animus_download_result_zocl2_ptr = void (WINAPIV*)(struct _animus_download_result_zocl*);
using _animus_download_result_zoclctor__animus_download_result_zocl2_clbk = void (WINAPIV*)(struct _animus_download_result_zocl*, _animus_download_result_zoclctor__animus_download_result_zocl2_ptr);
using _animus_download_result_zoclsize4_ptr = int (WINAPIV*)(struct _animus_download_result_zocl*);
using _animus_download_result_zoclsize4_clbk = int (WINAPIV*)(struct _animus_download_result_zocl*, _animus_download_result_zoclsize4_ptr);
}; // end namespace Info
END_ATF_NAMESPACE
| [
"b1ll.cipher@yandex.ru"
] | b1ll.cipher@yandex.ru |
f88989b4f900b84f87d5338da2677cc944892798 | 23b72c62167a6eee40b684fd1869d2eed05fe55a | /exercises/prob310.cpp | d99727d23d9a814302f1ee9b0b01d9c6190db88d | [] | no_license | rg3915/cpp | 846f0b34a660234dcd7daaa6752bfa8f81ee9833 | 2b6100e9a28dcd0fa72be08ab73fb2d0b45aff58 | refs/heads/master | 2021-01-21T01:44:42.743599 | 2018-02-14T02:26:47 | 2018-02-14T02:26:47 | 61,590,081 | 0 | 1 | null | 2018-02-14T02:26:48 | 2016-06-21T00:36:09 | TeX | UTF-8 | C++ | false | false | 1,142 | cpp | #include <iostream>
#define MAX 100
using namespace std;
float media(float A[MAX][MAX], itn n, int m, int i, int j)
{
float soma = 0;
int qtde = 0;
if(i - 1 >= 0)
{
soma += A[i-1][j];
qtde ++;
}
if(j - 1 >= 0)
{
soma += A[i][j-1];
qtde ++;
}
if(i + 1 < n)
{
soma += A[i+1][j];
qtde ++;
}
if(j + 1 < m)
{
soma += A[i][j+1];
qtde ++;
}
return soma/qtde;
}
void matriz_media(float A[MAX][MAX], int n, int m, float B[MAX][MAX])
{
int i, j;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
B[i][j] = media(A,n,m,i,j);
}
void imprime(float A[MAX][MAX], int n, int m)
{
int i,j;
for(i = 0; i < n; i++)
{
for(j = 0; j < m; j++)
cout << A[i][j] << " ";
cout << endl;
}
}
int main()
{
int n, m, i, j, k, r;
float A[MAX][MAX], B[MAX][MAX];
cin >> n >> m;
for(i = 0; i < n; i++)
for(j = 0; j < m; j++)
cin >> A[i][j];
imprime(A,n,m);
for(r = 0; r < k; r++)
{
if(r % 2 == 0)
{
matriz_media(A,n,m,B);
imprime(B,n,m);
}
else
{
matriz_media(B,n,m,A);
imprime(A,n,m);
}
}
return 0;
}
| [
"rg3915@yahoo.com.br"
] | rg3915@yahoo.com.br |
1acc521269852c3376615e55f3fc89c900b24412 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Plugins/Editor/USDImporter/Source/ThirdParty/USD/include/boost/context/detail/invoke.hpp | 5ec54800e3e94a4c223110604f8a7301e74164e0 | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 1,341 | hpp |
// Copyright Oliver Kowalke 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_CONTEXT_DETAIL_INVOKE_H
#define BOOST_CONTEXT_DETAIL_INVOKE_H
#include <functional>
#include <type_traits>
#include <utility>
#include <boost/config.hpp>
#include <boost/context/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace context {
namespace detail {
#if _MSC_VER > 1800
using std::invoke;
#else
template< typename Fn, typename ... Args >
typename std::enable_if<
std::is_member_pointer< typename std::decay< Fn >::type >::value,
typename std::result_of< Fn &&( Args && ... ) >::type
>::type
invoke( Fn && fn, Args && ... args) {
return std::mem_fn( fn)( std::forward< Args >( args) ... );
}
template< typename Fn, typename ... Args >
typename std::enable_if<
! std::is_member_pointer< typename std::decay< Fn >::type >::value,
typename std::result_of< Fn &&( Args && ... ) >::type
>::type
invoke( Fn && fn, Args && ... args) {
return std::forward< Fn >( fn)( std::forward< Args >( args) ... );
}
#endif
}}}
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_CONTEXT_DETAIL_INVOKE_H
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
6ba1de83056153265af2cc117bc81b39bb708bcb | c4546cbdbcce1ac2ac7ab3532be622ed2567378c | /Trabalho_1/testes.cpp | 38dbb6c0ba0197cecc0ac510b1e3463c688e4664 | [
"MIT"
] | permissive | barcelona86/TP1 | c22064b27bb558722feeec4ad91e6ed68b0dd995 | 7973987f050d15c01134db79f0676a8ba191c825 | refs/heads/main | 2023-03-16T15:27:37.988952 | 2021-03-06T12:13:06 | 2021-03-06T12:13:06 | 345,222,198 | 0 | 0 | MIT | 2021-03-07T00:06:17 | 2021-03-07T00:06:16 | null | ISO-8859-1 | C++ | false | false | 11,918 | cpp | #include "testes.h"
//Código Imóvel
void TUCodigoImovel::setUp(){
codigoImovel = new CodigoImovel();
estado = SUCESSO;
}
void TUCodigoImovel::tearDown(){
delete codigoImovel;
}
void TUCodigoImovel::testarCenarioSucesso(){
try{
codigoImovel->setCodigoImovel(VALOR_VALIDO);
if (codigoImovel->getCodigoImovel() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUCodigoImovel::testarCenarioFalha(){
try{
codigoImovel->setCodigoImovel(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (codigoImovel->getCodigoImovel() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUCodigoImovel::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Classe
void TUClasse::setUp(){
classe = new Classe();
estado = SUCESSO;
}
void TUClasse::tearDown(){
delete classe;
}
void TUClasse::testarCenarioSucesso(){
try{
classe->setClasse(VALOR_VALIDO);
if (classe->getClasse() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUClasse::testarCenarioFalha(){
try{
classe->setClasse(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (classe->getClasse() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUClasse::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Descricao
void TUDescricao::setUp(){
descricao = new Descricao();
estado = SUCESSO;
}
void TUDescricao::tearDown(){
delete descricao;
}
void TUDescricao::testarCenarioSucesso(){
try{
descricao->setDescricao(VALOR_VALIDO);
if (descricao->getDescricao() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUDescricao::testarCenarioFalha(){
try{
descricao->setDescricao(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (descricao->getDescricao() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUDescricao::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Endereco
void TUEndereco::setUp(){
endereco = new Endereco();
estado = SUCESSO;
}
void TUEndereco::tearDown(){
delete endereco;
}
void TUEndereco::testarCenarioSucesso(){
try{
endereco->setEndereco(VALOR_VALIDO);
if (endereco->getEndereco() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUEndereco::testarCenarioFalha(){
try{
endereco->setEndereco(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (endereco->getEndereco() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUEndereco::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Data Inicial Imóvel
void TUDataInicialImovel::setUp(){
dataInicialImovel = new DataInicialImovel();
estado = SUCESSO;
}
void TUDataInicialImovel::tearDown(){
delete dataInicialImovel;
}
void TUDataInicialImovel::testarCenarioSucesso(){
try{
dataInicialImovel->setDataInicialImovel(VALOR_VALIDO);
if (dataInicialImovel->getDataInicialImovel() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUDataInicialImovel::testarCenarioFalha(){
try{
dataInicialImovel->setDataInicialImovel(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (dataInicialImovel->getDataInicialImovel() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUDataInicialImovel::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Data Final Imóvel
void TUDataFinalImovel::setUp(){
dataFinalImovel = new DataFinalImovel();
estado = SUCESSO;
}
void TUDataFinalImovel::tearDown(){
delete dataFinalImovel;
}
void TUDataFinalImovel::testarCenarioSucesso(){
try{
dataFinalImovel->setDataFinalImovel(VALOR_VALIDO);
if (dataFinalImovel->getDataFinalImovel() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUDataFinalImovel::testarCenarioFalha(){
try{
dataFinalImovel->setDataFinalImovel(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (dataFinalImovel->getDataFinalImovel() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUDataFinalImovel::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Número Imóvel
void TUNumeroImovel::setUp(){
numeroImovel = new NumeroImovel();
estado = SUCESSO;
}
void TUNumeroImovel::tearDown(){
delete numeroImovel;
}
void TUNumeroImovel::testarCenarioSucesso(){
try{
numeroImovel->setNumeroImovel(VALOR_VALIDO);
if (numeroImovel->getNumeroImovel() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUNumeroImovel::testarCenarioFalha(){
try{
numeroImovel->setNumeroImovel(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (numeroImovel->getNumeroImovel() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUNumeroImovel::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Moeda Imóvel
void TUMoedaImovel::setUp(){
moedaImovel = new MoedaImovel();
estado = SUCESSO;
}
void TUMoedaImovel::tearDown(){
delete moedaImovel;
}
void TUMoedaImovel::testarCenarioSucesso(){
try{
moedaImovel->setMoedaImovel(VALOR_VALIDO);
if (moedaImovel->getMoedaImovel() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUMoedaImovel::testarCenarioFalha(){
try{
moedaImovel->setMoedaImovel(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (moedaImovel->getMoedaImovel() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUMoedaImovel::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Código Proposta
void TUCodigoProposta::setUp(){
codigoProposta = new CodigoProposta();
estado = SUCESSO;
}
void TUCodigoProposta::tearDown(){
delete codigoProposta;
}
void TUCodigoProposta::testarCenarioSucesso(){
try{
codigoProposta->setCodigoProposta(VALOR_VALIDO);
if (codigoProposta->getCodigoProposta() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUCodigoProposta::testarCenarioFalha(){
try{
codigoProposta->setCodigoProposta(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (codigoProposta->getCodigoProposta() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUCodigoProposta::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Data Inicial Proposta
void TUDataInicialProposta::setUp(){
dataInicialProposta = new DataInicialProposta();
estado = SUCESSO;
}
void TUDataInicialProposta::tearDown(){
delete dataInicialProposta;
}
void TUDataInicialProposta::testarCenarioSucesso(){
try{
dataInicialProposta->setDataInicialProposta(VALOR_VALIDO);
if (dataInicialProposta->getDataInicialProposta() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUDataInicialProposta::testarCenarioFalha(){
try{
dataInicialProposta->setDataInicialProposta(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (dataInicialProposta->getDataInicialProposta() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUDataInicialProposta::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Data Final Proposta
void TUDataFinalProposta::setUp(){
dataFinalProposta = new DataFinalProposta();
estado = SUCESSO;
}
void TUDataFinalProposta::tearDown(){
delete dataFinalProposta;
}
void TUDataFinalProposta::testarCenarioSucesso(){
try{
dataFinalProposta->setDataFinalProposta(VALOR_VALIDO);
if (dataFinalProposta->getDataFinalProposta() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUDataFinalProposta::testarCenarioFalha(){
try{
dataFinalProposta->setDataFinalProposta(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (dataFinalProposta->getDataFinalProposta() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUDataFinalProposta::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Número Proposta
void TUNumeroProposta::setUp(){
numeroProposta = new numeroProposta();
estado = SUCESSO;
}
void TUNumeroProposta::tearDown(){
delete numeroProposta;
}
void TUNumeroProposta::testarCenarioSucesso(){
try{
numeroProposta->setNumeroProposta(VALOR_VALIDO);
if (numeroProposta->getNumeroProposta() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUNumeroProposta::testarCenarioFalha(){
try{
numeroProposta->setNumeroProposta(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (numeroProposta->getNumeroProposta() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUNumeroProposta::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
//Moeda Proposta
void TUMoedaProposta::setUp(){
moedaProposta = new MoedaProposta();
estado = SUCESSO;
}
void TUMoedaProposta::tearDown(){
delete moedaProposta;
}
void TUMoedaProposta::testarCenarioSucesso(){
try{
moedaProposta->setMoedaProposta(VALOR_VALIDO);
if (moedaProposta->getMoedaProposta() != VALOR_VALIDO)
estado = FALHA;
}
catch(invalid_argument &excecao){
estado = FALHA;
}
}
void TUMoedaProposta::testarCenarioFalha(){
try{
moedaProposta->setMoedaProposta(VALOR_INVALIDO);
estado = FALHA;
}
catch(invalid_argument &excecao){
if (moedaProposta->getMoedaProposta() == VALOR_INVALIDO)
estado = FALHA;
return;
}
}
int TUMoedaProposta::run(){
setUp();
testarCenarioSucesso();
testarCenarioFalha();
tearDown();
return estado;
}
| [
"noreply@github.com"
] | noreply@github.com |
bfdee59df94dc2c4a44b0e3e43dc0e2e86eaf0a2 | 14602fe91e63007aa83666f3929d31308bedc333 | /349.两个数组的交集.cpp | 9eebd3afd1f4dbe6d9828a28b5590b28da51d31b | [] | no_license | GusteSL/SingleDog | 1769dbe780707f7b34ac28d01a39003a7451c413 | b12b62084cb4f8843e261cd50c9bd5bca790f3e8 | refs/heads/master | 2021-06-23T19:09:24.834801 | 2021-02-20T02:33:54 | 2021-02-20T02:33:54 | 197,308,679 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 943 | cpp | /*
* @lc app=leetcode.cn id=349 lang=cpp
*
* [349] 两个数组的交集
*/
// @lc code=start
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
SortAndDrop(nums1);
SortAndDrop(nums2);
vector<int> tmp(nums1);
for(int i = 0; i < nums2.size(); ++i) {
tmp.push_back(nums2[i]);
}
return SortAndDrop(tmp);
}
vector<int> SortAndDrop(vector<int>& nums) {
sort(nums.begin(), nums.end(), [](int n1, int n2){return n1<n2;});
vector<int> tmp;
for(int i = 1; i < nums.size(); ++i) {
if(nums[i] == nums[i-1]) {
if(tmp.empty() || nums[i] != tmp.back()) {
tmp.push_back(nums[i]);
}
nums.erase(nums.begin()+i);
--i;
}
}
return tmp;
}
};
// @lc code=end
| [
"ling.shi@horizon.ai"
] | ling.shi@horizon.ai |
8bd1269464ac6c648ec0f0c49fe6da43a9cd5030 | eb0b9e28df8c8e522392d31628760c2361266693 | /tags/TeXstudio/2.5.1/latexdocument.cpp | 4e275ee9e87f665ced32d24fffb085d64a62a098 | [] | no_license | svn2github/texstudio | 9b0c7ccf22ed2aef453b43edf0fb0c416c742c93 | de425fe2f8d2c48637d91632f3aa5554d6e68899 | refs/heads/master | 2021-01-25T07:29:04.777238 | 2013-08-27T16:18:15 | 2013-08-27T16:18:15 | 11,453,207 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 83,846 | cpp | #include "latexdocument.h"
#include "qdocument.h"
#include "qformatscheme.h"
#include "qdocumentline.h"
#include "qdocumentline_p.h"
#include "qdocumentcursor.h"
#include "qeditor.h"
#include "latexcompleter.h"
#include "latexcompleter_config.h"
#include "smallUsefulFunctions.h"
//FileNamePair::FileNamePair(const QString& rel):relative(rel){};
FileNamePair::FileNamePair(const QString& rel, const QString& abs):relative(rel),absolute(abs){};
LatexDocument::LatexDocument(QObject *parent):QDocument(parent),edView(0),mAppendixLine(0)
{
baseStructure = new StructureEntry(this,StructureEntry::SE_DOCUMENT_ROOT);
magicCommentList = new StructureEntry(this, StructureEntry::SE_OVERVIEW);
labelList = new StructureEntry(this, StructureEntry::SE_OVERVIEW);
todoList = new StructureEntry(this, StructureEntry::SE_OVERVIEW);
bibTeXList = new StructureEntry(this, StructureEntry::SE_OVERVIEW);
blockList = new StructureEntry(this, StructureEntry::SE_OVERVIEW);
magicCommentList->title=tr("MAGIC_COMMENTS");
labelList->title=tr("LABELS");
todoList->title=tr("TODO");
bibTeXList->title=tr("BIBLIOGRAPHY");
blockList->title=tr("BLOCKS");
mLabelItem.clear();
mBibItem.clear();
mUserCommandList.clear();
mMentionedBibTeXFiles.clear();
masterDocument=0;
this->parent=0;
mSpellingLanguage=QLocale::c();
}
LatexDocument::~LatexDocument(){
if (!magicCommentList->parent) delete magicCommentList;
if (!labelList->parent) delete labelList;
if (!todoList->parent) delete todoList;
if (!bibTeXList->parent) delete bibTeXList;
if (!blockList->parent) delete blockList;
delete baseStructure;
}
void LatexDocument::setFileName(const QString& fileName){
//clear all references to old editor
if (this->edView){
StructureEntryIterator iter(baseStructure);
while (iter.hasNext()) iter.next()->setLine(0);
}
this->fileName=fileName;
this->fileInfo=QFileInfo(fileName);
this->edView=0;
}
void LatexDocument::setEditorView(LatexEditorView* edView){
this->fileName=edView->editor->fileName();
this->fileInfo=edView->editor->fileInfo();
this->edView=edView;
if(baseStructure){
baseStructure->title=fileName;
emit updateElement(baseStructure);
}
}
LatexEditorView *LatexDocument::getEditorView() const{
return this->edView;
}
QString LatexDocument::getFileName() const{
return fileName;
}
bool LatexDocument::isHidden(){
return parent->hiddenDocuments.contains(this);
}
QFileInfo LatexDocument::getFileInfo() const{
return fileInfo;
}
QMultiHash<QDocumentLineHandle*,FileNamePair>& LatexDocument::mentionedBibTeXFiles(){
return mMentionedBibTeXFiles;
}
const QMultiHash<QDocumentLineHandle*,FileNamePair>& LatexDocument::mentionedBibTeXFiles() const{
return mMentionedBibTeXFiles;
}
QDocumentSelection LatexDocument::sectionSelection(StructureEntry* section){
QDocumentSelection result;
result.endLine=-1;result.startLine=-1;
if (section->type!=StructureEntry::SE_SECTION) return result;
int startLine=section->getRealLineNumber();
// find next section or higher
StructureEntry* parent;
int index;
do {
parent=section->parent;
if (parent) {
index=section->getRealParentRow();
section=parent;
} else index=-1;
} while ((index>=0)&&(index>=parent->children.count()-1)&&(parent->type==StructureEntry::SE_SECTION));
int endingLine=-1;
if (index>=0 && index<parent->children.count()-1) {
endingLine=parent->children.at(index+1)->getRealLineNumber();
} else {
// no ending section but end of document
endingLine=findLineContaining("\\end{document}",startLine,Qt::CaseInsensitive);
if (endingLine<0) endingLine=lines();
}
result.startLine=startLine;
result.endLine=endingLine;
result.end=0;
result.start=0;
return result;
}
void LatexDocument::clearStructure() {
mUserCommandList.clear();
mLabelItem.clear();
mBibItem.clear();
mRefItem.clear();
mMentionedBibTeXFiles.clear();
mAppendixLine=0;
if(baseStructure){
emit structureUpdated(this,0);
if (!magicCommentList->parent) delete magicCommentList;
if (!labelList->parent) delete labelList;
if (!todoList->parent) delete todoList;
if (!bibTeXList->parent) delete bibTeXList;
if (!blockList->parent) delete blockList;
int row=parent->documents.indexOf(this);
if(parent->model->getSingleDocMode()){
if(parent->currentDocument==this){
removeElement(baseStructure,0);
delete baseStructure;
removeElementFinished();
}else{
LatexDocument *doc=parent->currentDocument;
parent->currentDocument=this;
parent->updateStructure();
removeElement(baseStructure,0);
delete baseStructure;
removeElementFinished();
parent->currentDocument=doc;
parent->updateStructure();
}
}else{
removeElement(baseStructure,row);
delete baseStructure;
removeElementFinished();
}
}
#ifndef QT_NO_DEBUG
//Q_ASSERT(StructureContent.isEmpty());
#endif
baseStructure=0;
}
void LatexDocument::initStructure(){
clearStructure();
baseStructure = new StructureEntry(this,StructureEntry::SE_DOCUMENT_ROOT);
baseStructure->title=fileName;
magicCommentList = new StructureEntry(this,StructureEntry::SE_OVERVIEW);
magicCommentList->title=tr("MAGIC_COMMENTS");
labelList = new StructureEntry(this,StructureEntry::SE_OVERVIEW);
labelList->title=tr("LABELS");
todoList = new StructureEntry(this,StructureEntry::SE_OVERVIEW);
todoList->title=tr("TODO");
bibTeXList = new StructureEntry(this,StructureEntry::SE_OVERVIEW);
bibTeXList->title=tr("BIBLIOGRAPHY");
blockList = new StructureEntry(this,StructureEntry::SE_OVERVIEW);
blockList->title=tr("BLOCKS");
}
void LatexDocument::updateStructure() {
initStructure();
patchStructure(0, lineCount());
emit structureLost(this);
}
/* Removes a deleted line from the structure view */
void LatexDocument::patchStructureRemoval(QDocumentLineHandle* dlh) {
if(!baseStructure) return;
bool completerNeedsUpdate=false;
bool bibTeXFilesNeedsUpdate=false;
bool updateSyntaxCheck=false;
if (mLabelItem.contains(dlh)) {
QList<ReferencePair> labels=mLabelItem.values(dlh);
completerNeedsUpdate = true;
mLabelItem.remove(dlh);
foreach(const ReferencePair& rp,labels)
updateRefsLabels(rp.name);
}
mRefItem.remove(dlh);
if(mMentionedBibTeXFiles.remove(dlh))
bibTeXFilesNeedsUpdate=true;
if (mBibItem.contains(dlh)) {
mBibItem.remove(dlh);
bibTeXFilesNeedsUpdate=true;
}
QStringList commands=mUserCommandList.values(dlh);
foreach(QString elem,commands){
int i=elem.indexOf("{");
if(i>=0) elem=elem.left(i);
ltxCommands.possibleCommands["user"].remove(elem);
updateSyntaxCheck=true;
}
mUserCommandList.remove(dlh);
QStringList removeIncludes=mIncludedFilesList.values(dlh);
if(mIncludedFilesList.remove(dlh)>0){
parent->removeDocs(removeIncludes);
parent->updateMasterSlaveRelations(this);
}
QStringList removedUsepackages;
removedUsepackages << mUsepackageList.values(dlh);
mUsepackageList.remove(dlh);
if(dlh==mAppendixLine){
updateAppendix(mAppendixLine,0);
mAppendixLine=0;
}
int linenr = indexOf(dlh);
if (linenr==-1) linenr=lines();
// check if line contains bookmark
if(edView){
for(int i=-1;i<10;i++){
if(edView->hasBookmark(dlh,i)){
emit bookmarkRemoved(dlh);
edView->removeBookmark(dlh,i);
break;
}
}
}
QList<StructureEntry*> categories=QList<StructureEntry*>() << magicCommentList << labelList << todoList << blockList << bibTeXList;
foreach (StructureEntry* sec, categories) {
int l=0;
QMutableListIterator<StructureEntry*> iter(sec->children);
while (iter.hasNext()){
StructureEntry* se=iter.next();
if(dlh==se->getLineHandle()) {
emit removeElement(se,l);
iter.remove();
emit removeElementFinished();
delete se;
} else l++;
}
}
LatexParser& latexParser = LatexParser::getInstance();
QVector<StructureEntry*> parent_level(latexParser.structureCommands.count());
QList<StructureEntry*> ls;
mergeStructure(baseStructure, parent_level, ls, linenr, 1);
// rehighlight current cursor position
StructureEntry *newSection=0;
if(edView){
int i=edView->editor->cursor().lineNumber();
if(i>=0) {
newSection=findSectionForLine(i);
}
}
emit structureUpdated(this,newSection);
if (bibTeXFilesNeedsUpdate)
emit updateBibTeXFiles();
if (completerNeedsUpdate || bibTeXFilesNeedsUpdate)
emit updateCompleter();
if(!removedUsepackages.isEmpty() || updateSyntaxCheck){
QStringList files=mUsepackageList.values();
updateCompletionFiles(files,updateSyntaxCheck);
}
}
void LatexDocument::patchStructure(int linenr, int count) {
if (!baseStructure) return;
emit toBeChanged();
bool completerNeedsUpdate=false;
bool bibTeXFilesNeedsUpdate=false;
bool bibItemsChanged=false;
QDocumentLineHandle *oldLine=mAppendixLine; // to detect a change in appendix position
QMultiHash<QDocumentLineHandle*,StructureEntry*> MapOfMagicComments;
QMutableListIterator<StructureEntry*> iter_magicComment(magicCommentList->children);
findStructureEntryBefore(iter_magicComment,MapOfMagicComments,linenr,count);
QMultiHash<QDocumentLineHandle*,StructureEntry*> MapOfLabels;
QMutableListIterator<StructureEntry*> iter_label(labelList->children);
findStructureEntryBefore(iter_label,MapOfLabels,linenr,count);
QMultiHash<QDocumentLineHandle*,StructureEntry*> MapOfTodo;
QMutableListIterator<StructureEntry*> iter_todo(todoList->children);
findStructureEntryBefore(iter_todo,MapOfTodo,linenr,count);
QMultiHash<QDocumentLineHandle*,StructureEntry*> MapOfBlock;
QMutableListIterator<StructureEntry*> iter_block(blockList->children);
findStructureEntryBefore(iter_block,MapOfBlock,linenr,count);
QMultiHash<QDocumentLineHandle*,StructureEntry*> MapOfBibtex;
QMutableListIterator<StructureEntry*> iter_bibTeX(bibTeXList->children);
findStructureEntryBefore(iter_bibTeX,MapOfBibtex,linenr,count);
LatexParser& latexParser = LatexParser::getInstance();
int verbatimFormat=QDocument::formatFactory()->id("verbatim");
bool updateSyntaxCheck=false;
QList<StructureEntry*> flatStructure;
// usepackage list
QStringList removedUsepackages;
QStringList addedUsepackages;
QStringList removedUserCommands,addedUserCommands;
QStringList lstFilesToLoad;
//TODO: This assumes one command per line, which is not necessary true
for (int i=linenr; i<linenr+count; i++) {
//update bookmarks
if(edView && edView->hasBookmark(i,-1)){
emit bookmarkLineUpdated(i);
}
QString curLine = line(i).text(); //TODO: use this instead of s
QVector<int> fmts=line(i).getFormats();
for(int j=0;j<curLine.length() && j < fmts.size();j++){
if(fmts[j]==verbatimFormat){
curLine[j]=QChar(' ');
}
}
// remove command,bibtex,labels at from this line
QDocumentLineHandle* dlh=line(i).handle();
QStringList commands=mUserCommandList.values(dlh);
foreach(QString elem,commands){
int i=elem.indexOf("{");
if(i>=0) elem=elem.left(i);
ltxCommands.possibleCommands["user"].remove(elem);
removedUserCommands << elem;
updateSyntaxCheck=true;
}
if (mLabelItem.contains(dlh)) {
QList<ReferencePair> labels=mLabelItem.values(dlh);
completerNeedsUpdate = true;
mLabelItem.remove(dlh);
foreach(const ReferencePair& rp,labels)
updateRefsLabels(rp.name);
}
mRefItem.remove(dlh);
QStringList removedIncludes=mIncludedFilesList.values(dlh);
mIncludedFilesList.remove(dlh);
if (mUserCommandList.remove(dlh)>0) completerNeedsUpdate = true;
if(mBibItem.remove(dlh))
bibTeXFilesNeedsUpdate=true;
removedUsepackages << mUsepackageList.values(dlh);
if (mUsepackageList.remove(dlh)>0) completerNeedsUpdate = true;
//remove old bibs files from hash, but keeps a temporary copy
QStringList oldBibs;
while (mMentionedBibTeXFiles.contains(dlh)) {
QMultiHash<QDocumentLineHandle*, FileNamePair>::iterator it = mMentionedBibTeXFiles.find(dlh);
Q_ASSERT(it.key() == dlh);
Q_ASSERT(it != mMentionedBibTeXFiles.end());
if (it == mMentionedBibTeXFiles.end()) break;
oldBibs.append(it.value().relative);
mMentionedBibTeXFiles.erase(it);
}
//find entries prior to changed lines
QString name;
QString arg;
QString cmd;
QString remainder;
int optionStart;
//// TODO marker
QString s=curLine;
int l=s.indexOf("%TODO");
if (l>=0) {
s=s.mid(l+6,s.length());
bool reuse=false;
StructureEntry *newTodo;
if(MapOfTodo.contains(dlh)){
newTodo=MapOfTodo.value(dlh);
//parent->add(newTodo);
newTodo->type=StructureEntry::SE_TODO;
MapOfTodo.remove(dlh,newTodo);
reuse=true;
}else{
newTodo=new StructureEntry(this, StructureEntry::SE_TODO);
}
newTodo->title=s;
newTodo->setLine(line(i).handle(), i);
newTodo->parent=todoList;
if(!reuse) emit addElement(todoList,todoList->children.size()); //todo: why here but not in label?
iter_todo.insert(newTodo);
}
//// magic comment
s=curLine;
l=s.indexOf("% !TeX",0,Qt::CaseInsensitive);
if (l>=0) {
s=s.mid(l+6,s.length());
bool reuse=false;
StructureEntry *newMagicComment;
if(MapOfMagicComments.contains(dlh)){
newMagicComment=MapOfMagicComments.value(dlh);
newMagicComment->type=StructureEntry::SE_MAGICCOMMENT;
MapOfMagicComments.remove(dlh,newMagicComment);
reuse=true;
}else{
newMagicComment=new StructureEntry(this, StructureEntry::SE_MAGICCOMMENT);
}
QString name;
QString val;
splitMagicComment(s, name, val);
parseMagicComment(name, val, newMagicComment);
newMagicComment->title=s;
newMagicComment->setLine(line(i).handle(), i);
newMagicComment->parent=magicCommentList;
if(!reuse) emit addElement(magicCommentList,magicCommentList->children.size()); //todo: why here but not in label?
iter_magicComment.insert(newMagicComment);
}
////Ref
//for reference counting (can be placed in command options as well ...
foreach(QString cmd,latexParser.possibleCommands["%ref"]){
QString name;
cmd.append('{');
int start=0;
do{
name=findToken(curLine,cmd,start);
if(!name.isEmpty()){
ReferencePair elem;
elem.name=name;
elem.start=start;
mRefItem.insert(line(i).handle(),elem);
}
}while(start>=0);
}
//// label ////
//TODO: Use label from dynamical reference checker
foreach(QString cmd,latexParser.possibleCommands["%label"]){
QString name;
cmd.append('{');
int start=0;
do{
name=findToken(curLine,cmd,start);
if(!name.isEmpty()){
ReferencePair elem;
elem.name=name;
elem.start=start;
mLabelItem.insert(line(i).handle(),elem);
completerNeedsUpdate=true;
StructureEntry *newLabel;
if(MapOfLabels.contains(dlh)){
newLabel=MapOfLabels.value(dlh);
newLabel->type=StructureEntry::SE_LABEL;
MapOfLabels.remove(dlh,newLabel);
}else{
newLabel=new StructureEntry(this, StructureEntry::SE_LABEL);
}
newLabel->title=name;
newLabel->setLine(line(i).handle(), i);
newLabel->parent=labelList;
iter_label.insert(newLabel);
}
}while(start>=0);
}
// check also in command argument, als references might be put there as well...
//// Appendix keyword
if (curLine=="\\appendix") {
oldLine=mAppendixLine;
mAppendixLine=line(i).handle();
}
if(line(i).handle()==mAppendixLine && curLine!="\\appendix"){
oldLine=mAppendixLine;
mAppendixLine=0;
}
//let %\include be processed
if(curLine.startsWith("%\\include")||curLine.startsWith("%\\input")){
curLine.replace(0,1,' ');
}
int totalLength=curLine.length();
while(findCommandWithArg(curLine,cmd,name,arg,remainder,optionStart)){
//update offset
//store optional arguments []
//copy remainder to curLine for next round
curLine=remainder;
int offset=totalLength-curLine.length(); //TODO?? (line was commented out, with todo before)
//// newcommand ////
//TODO: handle optional arguments
if (latexParser.possibleCommands["%definition"].contains(cmd)||ltxCommands.possibleCommands["%definition"].contains(cmd)) {
completerNeedsUpdate=true;
QRegExp rx("^\\s*\\[(\\d+)\\](\\[.+\\])?");
int options=0;
int def=0;
if(rx.indexIn(remainder)>-1){
options=rx.cap(1).toInt(); //returns 0 if conversion fails
if(!rx.cap(2).isEmpty())
def=1;
}
ltxCommands.possibleCommands["user"].insert(name);
addedUserCommands << name;
if(def==1){
QString helper=name;
for (int j=0; j<options; j++) {
if (j==1)
helper.append("{%<arg1%|%>}");
if(j>1)
helper.append(QString("{%<arg%1%>}").arg(j));
}
mUserCommandList.insert(line(i).handle(),helper);
}
for (int j=0; j<options; j++) {
if (j==0) {
if(def==0)
name.append("{%<arg1%|%>}");
else
name.append("[%<opt. arg1%|%>]");
} else
name.append(QString("{%<arg%1%>}").arg(j+1));
}
mUserCommandList.insert(line(i).handle(),name);
// remove obsolete Overlays (maybe this can be refined
updateSyntaxCheck=true;
continue;
}
// special treatment \def
if (cmd=="\\def") {
completerNeedsUpdate=true;
QRegExp rx("(\\\\\\w+)\\s*(#\\d+)?");
if(rx.indexIn(remainder)>-1){
QString name=rx.cap(1);
QString optionStr=rx.cap(2);
//qDebug()<< name << ":"<< optionStr;
int options=optionStr.mid(1).toInt(); //returns 0 if conversion fails
ltxCommands.possibleCommands["user"].insert(name);
addedUserCommands << name;
for (int j=0; j<options; j++) {
if (j==0) name.append("{%<arg1%|%>}");
else name.append(QString("{%<arg%1%>}").arg(j+1));
}
mUserCommandList.insert(line(i).handle(),name);
// remove obsolete Overlays (maybe this can be refined
updateSyntaxCheck=true;
}
continue;
}
//// newenvironment ////
static const QStringList envTokens = QStringList() << "\\newenvironment" << "\\renewenvironment";
if (envTokens.contains(cmd)) {
completerNeedsUpdate=true;
int options=arg.toInt(); //returns 0 if conversion fails
name.append("}");
mUserCommandList.insert(line(i).handle(),"\\end{"+name);
QStringList lst;
lst << "\\begin{"+name << "\\end{"+name;
foreach(const QString& elem,lst){
ltxCommands.possibleCommands["user"].insert(elem);
if(!removedUserCommands.removeAll(elem)){
addedUserCommands << elem;
}
}
for (int j=0; j<options; j++) {
if (j==0) name.append("{%<1%|%>}");
else name.append(QString("{%<%1%>}").arg(j+1));
}
//mUserCommandList.insert(line(i).handle(),name);//???
mUserCommandList.insert(line(i).handle(),"\\begin{"+name);
continue;
}
//// newtheorem ////
if (cmd=="\\newtheorem" || cmd=="\\newtheorem*" || cmd=="\\declaretheorem") {
completerNeedsUpdate=true;
QStringList lst;
lst << "\\begin{"+name+"}" << "\\end{"+name+"}";
foreach(const QString& elem,lst){
mUserCommandList.insert(line(i).handle(),elem);
ltxCommands.possibleCommands["user"].insert(elem);
if(!removedUserCommands.removeAll(elem)){
addedUserCommands << elem;
}
}
continue;
}
//// newcounter ////
if (cmd=="\\newcounter") {
completerNeedsUpdate=true;
QStringList lst;
lst << "\\the"+name ;
foreach(const QString& elem,lst){
mUserCommandList.insert(line(i).handle(),elem);
ltxCommands.possibleCommands["user"].insert(elem);
if(!removedUserCommands.removeAll(elem)){
addedUserCommands << elem;
}
}
continue;
}
/// bibitem ///
if(latexParser.possibleCommands["%bibitem"].contains(cmd)){
if(!name.isEmpty()){
ReferencePair elem;
elem.name=name;
elem.start=optionStart;
mBibItem.insert(line(i).handle(),elem);
bibItemsChanged=true;
continue;
}
}
///usepackage
if (latexParser.possibleCommands["%usepackage"].contains(cmd)) {
completerNeedsUpdate=true;
QStringList packagesHelper=name.split(",");
if(cmd.endsWith("theme")){ // special treatment for \usetheme
QString preambel=cmd;
preambel.remove(0,4);
preambel.prepend("beamer");
packagesHelper.replaceInStrings(QRegExp("^"),preambel);
}
QStringList packages;
foreach(const QString& elem,packagesHelper)
if(latexParser.packageAliases.contains(elem))
packages << latexParser.packageAliases.values(elem);
else
packages << elem;
foreach(const QString& elem,packages){
if(!removedUsepackages.removeAll(elem))
addedUsepackages << elem;
mUsepackageList.insertMulti(dlh,elem);
}
continue;
}
//// bibliography ////
if (latexParser.possibleCommands["%bibliography"].contains(cmd)) {
QStringList bibs=name.split(',',QString::SkipEmptyParts);
//add new bibs and set bibTeXFilesNeedsUpdate if there was any change
foreach(const QString& elem,bibs){ //latex doesn't seem to allow any spaces in file names
mMentionedBibTeXFiles.insert(line(i).handle(),FileNamePair(elem,getAbsoluteFilePath(elem,"bib")));
if (oldBibs.removeAll(elem) == 0)
bibTeXFilesNeedsUpdate = true;
}
//write bib tex in tree
foreach (const QString& bibFile, bibs) {
StructureEntry *newFile;
if(MapOfBibtex.contains(dlh)){
newFile=MapOfBibtex.value(dlh);
newFile->type=StructureEntry::SE_BIBTEX;
MapOfBibtex.remove(dlh,newFile);
}else{
newFile=new StructureEntry(this, StructureEntry::SE_BIBTEX);
}
newFile->title=bibFile;
newFile->setLine(line(i).handle(), i);
newFile->parent=bibTeXList;
iter_bibTeX.insert(newFile);
}
continue;
}
//// beamer blocks ////
if (cmd=="\\begin" && name=="block") {
QString s=extractSectionName(remainder,true);
StructureEntry *newBlock;
if(MapOfBlock.contains(dlh)){
newBlock=MapOfBlock.value(dlh);
newBlock->type=StructureEntry::SE_BLOCK;
MapOfBlock.remove(dlh,newBlock);
}else{
newBlock=new StructureEntry(this, StructureEntry::SE_BLOCK);
}
newBlock->title=s;
newBlock->setLine(line(i).handle(), i);
newBlock->parent=blockList;
iter_block.insert(newBlock);
continue;
}
//// include,input ////
//static const QStringList inputTokens = QStringList() << "\\input" << "\\include";
if (latexParser.possibleCommands["%include"].contains(cmd)) {
StructureEntry *newInclude=new StructureEntry(this, StructureEntry::SE_INCLUDE);
newInclude->title=name;
removedIncludes.removeAll(name);
QString fname=findFileName(name);
mIncludedFilesList.insert(line(i).handle(),fname);
LatexDocument* dc=parent->findDocumentFromName(fname);
if(dc) dc->setMasterDocument(this);
else {
lstFilesToLoad << fname;
//parent->addDocToLoad(fname);
}
newInclude->valid = dc;
newInclude->setLine(line(i).handle(), i);
newInclude->columnNumber = offset;
flatStructure << newInclude;
continue;
}
//// all sections ////
if(cmd.endsWith("*"))
cmd=cmd.left(cmd.length()-1);
int header=latexParser.structureCommands.indexOf(cmd);
if (header>-1) {
StructureEntry *newSection = new StructureEntry(this,StructureEntry::SE_SECTION);
if(mAppendixLine &&indexOf(mAppendixLine)<i) newSection->appendix=true;
else newSection->appendix=false;
newSection->title=parseTexOrPDFString(name);
newSection->level=header;
newSection->setLine(line(i).handle(), i);
newSection->columnNumber = offset;
flatStructure << newSection;
}
}// for each command
if (!oldBibs.isEmpty())
bibTeXFilesNeedsUpdate = true; //file name removed
if(!removedIncludes.isEmpty()){
parent->removeDocs(removedIncludes);
parent->updateMasterSlaveRelations(this);
}
}//for each line handle
QVector<StructureEntry*> parent_level(latexParser.structureCommands.count());
if(!isHidden()){
mergeStructure(baseStructure, parent_level, flatStructure, linenr, count);
const QList<StructureEntry*> categories=
QList<StructureEntry*>() << magicCommentList << blockList << labelList << todoList << bibTeXList;
for (int i=categories.size()-1;i>=0;i--) {
StructureEntry *cat = categories[i];
if (cat->children.isEmpty() == (cat->parent == 0)) continue;
if (cat->children.isEmpty()) removeElementWithSignal(cat);
else insertElementWithSignal(baseStructure, 0, cat);
}
//update appendix change
if(oldLine!=mAppendixLine){
updateAppendix(oldLine,mAppendixLine);
}
// rehighlight current cursor position
StructureEntry *newSection=0;
if(edView){
int i=edView->editor->cursor().lineNumber();
if(i>=0) {
newSection=findSectionForLine(i);
}
}
emit structureUpdated(this,newSection);
}
StructureEntry* se;
foreach(se,MapOfTodo.values())
delete se;
foreach(se,MapOfBibtex.values())
delete se;
foreach(se,MapOfBlock.values())
delete se;
foreach(se,MapOfLabels.values())
delete se;
foreach(se,MapOfMagicComments.values())
delete se;
if(!addedUsepackages.isEmpty() || !removedUsepackages.isEmpty() || !addedUserCommands.isEmpty() || !removedUserCommands.isEmpty()){
bool forceUpdate=!addedUserCommands.isEmpty() || !removedUserCommands.isEmpty();
QStringList files=mUsepackageList.values();
updateCompletionFiles(files,forceUpdate);
}
if (bibTeXFilesNeedsUpdate)
emit updateBibTeXFiles();
if(bibItemsChanged)
parent->updateBibFiles(false);
if (completerNeedsUpdate || bibTeXFilesNeedsUpdate)
emit updateCompleter();
if(updateSyntaxCheck) {
foreach(LatexDocument* elem,getListOfDocs()){
//getEditorView()->reCheckSyntax();//todo: signal
if(elem->edView)
elem->edView->reCheckSyntax();
}
}
//update view
if(edView)
edView->documentContentChanged(linenr, count);
#ifndef QT_NO_DEBUG
if(!isHidden())
checkForLeak();
#endif
foreach(QString fname,lstFilesToLoad){
parent->addDocToLoad(fname);
}
}
#ifndef QT_NO_DEBUG
void LatexDocument::checkForLeak(){
StructureEntryIterator iter(baseStructure);
QSet<StructureEntry*>zw=StructureContent;
while (iter.hasNext()){
zw.remove(iter.next());
}
// filter top level elements
QMutableSetIterator<StructureEntry *> i(zw);
while (i.hasNext())
if(i.next()->type==StructureEntry::SE_OVERVIEW) i.remove();
if(zw.count()>0){
qDebug("Memory leak in structure");
}
}
#endif
StructureEntry * LatexDocument::findSectionForLine(int currentLine){
StructureEntryIterator iter(baseStructure);
StructureEntry *newSection=0;
while (/*iter.hasNext()*/true){
StructureEntry *curSection=0;
while (iter.hasNext()){
curSection=iter.next();
if (curSection->type==StructureEntry::SE_SECTION)
break;
}
if (curSection==0 || curSection->type!=StructureEntry::SE_SECTION)
break;
if (curSection->getRealLineNumber() > currentLine) break; //curSection is after newSection where the cursor is
else newSection=curSection;
}
if(newSection && newSection->getRealLineNumber()>currentLine) newSection=0;
return newSection;
}
void LatexDocument::setTemporaryFileName(const QString& fileName){
temporaryFileName=fileName;
}
QString LatexDocument::getTemporaryFileName() const{
return temporaryFileName;
}
int LatexDocument::countLabels(const QString& name){
int result=0;
foreach(const LatexDocument *elem,getListOfDocs()){
QStringList items=elem->labelItems();
result+=items.count(name);
}
return result;
}
int LatexDocument::countRefs(const QString& name){
int result=0;
foreach(const LatexDocument *elem,getListOfDocs()){
QStringList items=elem->refItems();
result+=items.count(name);
}
return result;
}
QMultiHash<QDocumentLineHandle*,int> LatexDocument::getBibItems(const QString& name){
QHash<QDocumentLineHandle*,int> result;
foreach(const LatexDocument *elem,getListOfDocs()){
QMultiHash<QDocumentLineHandle*,ReferencePair>::const_iterator it;
for (it = elem->mBibItem.constBegin(); it != elem->mBibItem.constEnd(); ++it){
ReferencePair rp=it.value();
if(rp.name==name){
result.insert(it.key(),rp.start);
}
}
}
return result;
}
QMultiHash<QDocumentLineHandle*,int> LatexDocument::getLabels(const QString& name){
QHash<QDocumentLineHandle*,int> result;
foreach(const LatexDocument *elem,getListOfDocs()){
QMultiHash<QDocumentLineHandle*,ReferencePair>::const_iterator it;
for (it = elem->mLabelItem.constBegin(); it != elem->mLabelItem.constEnd(); ++it){
ReferencePair rp=it.value();
if(rp.name==name){
result.insert(it.key(),rp.start);
}
}
}
return result;
}
QMultiHash<QDocumentLineHandle*,int> LatexDocument::getRefs(const QString& name){
QHash<QDocumentLineHandle*,int> result;
foreach(const LatexDocument *elem,getListOfDocs()){
QMultiHash<QDocumentLineHandle*,ReferencePair>::const_iterator it;
for (it = elem->mRefItem.constBegin(); it != elem->mRefItem.constEnd(); ++it){
ReferencePair rp=it.value();
if(rp.name==name){
result.insert(it.key(),rp.start);
}
}
}
return result;
}
void LatexDocument::setMasterDocument(LatexDocument* doc){
masterDocument=doc;
QList<LatexDocument *>listOfDocs=getListOfDocs();
foreach(LatexDocument *elem,listOfDocs){
elem->recheckRefsLabels();
}
}
QList<LatexDocument *>LatexDocument::getListOfDocs(QSet<LatexDocument*> *visitedDocs){
QList<LatexDocument *>listOfDocs;
bool deleteVisitedDocs=false;
if(parent->masterDocument){
listOfDocs=parent->getDocuments();
}else{
LatexDocument *master=this;
if(!visitedDocs){
visitedDocs=new QSet<LatexDocument*>();
deleteVisitedDocs=true;
}
foreach(LatexDocument *elem,parent->getDocuments()){ // check children
if(elem!=master && elem->masterDocument!=master) continue;
if(visitedDocs && !visitedDocs->contains(elem)){
listOfDocs << elem;
visitedDocs->insert(elem);
listOfDocs << elem->getListOfDocs(visitedDocs);
}
}
if(masterDocument){ //check masters
master=masterDocument;
if(!visitedDocs->contains(master))
listOfDocs << master->getListOfDocs(visitedDocs);
}
}
if(deleteVisitedDocs)
delete visitedDocs;
return listOfDocs;
}
void LatexDocument::recheckRefsLabels(){
// get occurences (refs)
int referenceMultipleFormat=QDocument::formatFactory()->id("referenceMultiple");
int referencePresentFormat=QDocument::formatFactory()->id("referencePresent");
int referenceMissingFormat=QDocument::formatFactory()->id("referenceMissing");
QMultiHash<QDocumentLineHandle*,ReferencePair>::const_iterator it;
for(it=mLabelItem.constBegin();it!=mLabelItem.constEnd();++it){
QDocumentLineHandle* dlh=it.key();
foreach(const ReferencePair& rp,mLabelItem.values(dlh)){
int cnt=countLabels(rp.name);
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referenceMultipleFormat));
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referencePresentFormat));
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referenceMissingFormat));
if (cnt>1) {
dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referenceMultipleFormat));
} else if (cnt==1) dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referencePresentFormat));
else dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referenceMissingFormat));
}
}
for(it=mRefItem.constBegin();it!=mRefItem.constEnd();++it){
QDocumentLineHandle* dlh=it.key();
foreach(const ReferencePair& rp,mRefItem.values(dlh)){
int cnt=countLabels(rp.name);
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referenceMultipleFormat));
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referencePresentFormat));
dlh->removeOverlay(QFormatRange(rp.start,rp.name.length(),referenceMissingFormat));
if (cnt>1) {
dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referenceMultipleFormat));
} else if (cnt==1) dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referencePresentFormat));
else dlh->addOverlay(QFormatRange(rp.start,rp.name.length(),referenceMissingFormat));
}
}
}
QStringList LatexDocument::someItems(const QMultiHash<QDocumentLineHandle*,ReferencePair>& list){
QList<ReferencePair> lst=list.values();
QStringList result;
foreach(const ReferencePair& elem,lst){
result << elem.name;
}
return result;
}
QStringList LatexDocument::labelItems() const{
return someItems(mLabelItem);
}
QStringList LatexDocument::refItems() const{
return someItems(mRefItem);
}
QStringList LatexDocument::bibItems() const{
return someItems(mBibItem);
}
void LatexDocument::updateRefsLabels(const QString& ref){
// get occurences (refs)
int referenceMultipleFormat=QDocument::formatFactory()->id("referenceMultiple");
int referencePresentFormat=QDocument::formatFactory()->id("referencePresent");
int referenceMissingFormat=QDocument::formatFactory()->id("referenceMissing");
int cnt=countLabels(ref);
QMultiHash<QDocumentLineHandle*,int> occurences=getLabels(ref);
occurences+=getRefs(ref);
QMultiHash<QDocumentLineHandle*,int>::const_iterator it;
for(it=occurences.constBegin();it!=occurences.constEnd();++it){
QDocumentLineHandle* dlh=it.key();
foreach(const int pos,occurences.values(dlh)){
dlh->removeOverlay(QFormatRange(pos,ref.length(),referenceMultipleFormat));
dlh->removeOverlay(QFormatRange(pos,ref.length(),referencePresentFormat));
dlh->removeOverlay(QFormatRange(pos,ref.length(),referenceMissingFormat));
if (cnt>1) {
dlh->addOverlay(QFormatRange(pos,ref.length(),referenceMultipleFormat));
} else if (cnt==1) dlh->addOverlay(QFormatRange(pos,ref.length(),referencePresentFormat));
else dlh->addOverlay(QFormatRange(pos,ref.length(),referenceMissingFormat));
}
}
}
/*
void LatexDocument::includeDocument(LatexDocument* includedDocument){
includedDocument->deleteLater();
if (texFiles.contains(includedDocument->fileName))
return; //this should never happen
texFiles.unite(includedDocument->texFiles);
containedLabels.unite(includedDocument->containedLabels);
containedReferences.unite(includedDocument->containedReferences);
mentionedBibTeXFiles.unite(includedDocument->mentionedBibTeXFiles);
allBibTeXIds.unite(includedDocument->allBibTeXIds);
}
*/
StructureEntry::StructureEntry(LatexDocument* doc, Type newType):type(newType),level(0), parent(0), document(doc),appendix(false), parentRow(-1), lineHandle(0), lineNumber(-1){
#ifndef QT_NO_DEBUG
Q_ASSERT(document);
document->StructureContent.insert(this);
#endif
}
StructureEntry::~StructureEntry(){
level=-1; //invalidate entry
foreach (StructureEntry* se, children)
delete se;
#ifndef QT_NO_DEBUG
Q_ASSERT(document);
bool removed = document->StructureContent.remove(this);
Q_ASSERT(removed); //prevent double deletion
#endif
}
void StructureEntry::add(StructureEntry* child){
Q_ASSERT(child!=0);
children.append(child);
child->parent=this;
}
void StructureEntry::insert(int pos, StructureEntry* child){
Q_ASSERT(child!=0);
children.insert(pos,child);
child->parent=this;
}
void StructureEntry::setLine(QDocumentLineHandle* handle, int lineNr){
lineHandle = handle;
lineNumber = lineNr;
}
QDocumentLineHandle* StructureEntry::getLineHandle() const{
return lineHandle;
}
int StructureEntry::getCachedLineNumber() const{
return lineNumber;
}
int StructureEntry::getRealLineNumber() const{
lineNumber = document->indexOf(lineHandle, lineNumber);
Q_ASSERT(lineNumber == -1 || document->line(lineNumber).handle() == lineHandle);
return lineNumber;
}
template <typename T> inline int hintedIndexOf (const QList<T*>& list, const T* elem, int hint) {
if (hint < 2) return list.indexOf(const_cast<T*>(elem));
int backward = hint, forward = hint + 1;
for (;backward >= 0 && forward < list.size();
backward--, forward++) {
if (list[backward] == elem) return backward;
if (list[forward] == elem) return forward;
}
if (backward >= list.size()) backward = list.size() - 1;
for (;backward >= 0; backward--)
if (list[backward] == elem) return backward;
if (forward < 0) forward = 0;
for (;forward < list.size(); forward++)
if (list[forward] == elem) return forward;
return -1;
}
int StructureEntry::getRealParentRow() const{
REQUIRE_RET(parent, -1);
parentRow = hintedIndexOf<StructureEntry>(parent->children, this, parentRow);
return parentRow;
}
void StructureEntry::debugPrint(const char* message) const{
qDebug("%s %p",message, this);
if (!this) return;
qDebug(" level: %i",level);
qDebug(" type: %i",(int)type);
qDebug(" line nr: %i", lineNumber);
qDebug(" title: %s", qPrintable(title));
}
StructureEntryIterator::StructureEntryIterator(StructureEntry* entry){
if (!entry) return;
while (entry->parent){
entryHierarchy.prepend(entry);
indexHierarchy.prepend(entry->getRealParentRow());
entry=entry->parent;
}
entryHierarchy.prepend(entry);
indexHierarchy.prepend(0);
}
bool StructureEntryIterator::hasNext(){
return !entryHierarchy.isEmpty();
}
StructureEntry* StructureEntryIterator::next(){
if (!hasNext()) return 0;
StructureEntry* result=entryHierarchy.last();
if (!result->children.isEmpty()) { //first child is next element, go a level deeper
entryHierarchy.append(result->children.at(0));
indexHierarchy.append(0);
} else { //no child, go to next on same level
entryHierarchy.removeLast();
indexHierarchy.last()++;
while (!entryHierarchy.isEmpty() && indexHierarchy.last()>=entryHierarchy.last()->children.size()) {
//doesn't exists, proceed to travel upwards
entryHierarchy.removeLast();
indexHierarchy.removeLast();
indexHierarchy.last()++;
}
if (!entryHierarchy.isEmpty())
entryHierarchy.append(entryHierarchy.last()->children.at(indexHierarchy.last()));
}
return result;
}
LatexDocumentsModel::LatexDocumentsModel(LatexDocuments& docs):documents(docs),
iconDocument(":/images/doc.png"), iconMasterDocument(":/images/masterdoc.png"), iconBibTeX(":/images/bibtex.png"), iconInclude(":/images/include.png"),
iconWarning(getRealIcon("warning")), m_singleMode(false){
mHighlightIndex=QModelIndex();
iconSection.resize(LatexParser::getInstance().structureCommands.count());
for (int i=0;i<LatexParser::getInstance().structureCommands.count();i++)
iconSection[i]=QIcon(":/images/"+LatexParser::getInstance().structureCommands[i].mid(1)+".png");
}
Qt::ItemFlags LatexDocumentsModel::flags ( const QModelIndex & index ) const{
if (index.isValid()) return Qt::ItemIsEnabled|Qt::ItemIsSelectable;
else return 0;
}
QVariant LatexDocumentsModel::data ( const QModelIndex & index, int role) const{
if (!index.isValid()) return QVariant();
StructureEntry* entry = (StructureEntry*) index.internalPointer();
if (!entry) return QVariant();
QString result;
switch (role) {
case Qt::DisplayRole:
if (entry->type==StructureEntry::SE_DOCUMENT_ROOT){ //show only base file name
QString title=entry->title.mid(1+qMax(entry->title.lastIndexOf("/"), entry->title.lastIndexOf(QDir::separator())));
if(title.isEmpty()) title=tr("untitled");
return QVariant(title);
}
//show full title in other cases
if(documents.showLineNumbersInStructure && entry->getCachedLineNumber()>-1){
result=entry->title+QString(tr(" (Line %1)").arg(entry->getRealLineNumber()+1));
}else{
result=entry->title;
}
return QVariant(result);
case Qt::ToolTipRole:
//qDebug("data %x",entry);
if (!entry->tooltip.isNull()) {
return QVariant(entry->tooltip);
}
if (entry->type==StructureEntry::SE_DOCUMENT_ROOT) {
return QVariant(entry->document->getFileName());
}
if (entry->type==StructureEntry::SE_SECTION) {
QString tooltip(entry->title);
if (entry->getCachedLineNumber()>-1)
tooltip.append("\n"+tr("Line")+QString(": %1").arg(entry->getRealLineNumber()+1));
StructureEntry *se = LatexDocumentsModel::labelForStructureEntry(entry);
if (se)
tooltip.append("\n"+tr("Label")+": "+se->title);
return QVariant(tooltip);
}
if (entry->getCachedLineNumber()>-1)
return QVariant(entry->title+QString(tr(" (Line %1)").arg(entry->getRealLineNumber()+1)));
else
return QVariant();
case Qt::DecorationRole:
switch (entry->type){
case StructureEntry::SE_BIBTEX: return iconBibTeX;
case StructureEntry::SE_INCLUDE: return iconInclude;
case StructureEntry::SE_MAGICCOMMENT:
if (entry->valid)
return QVariant();
else
return iconWarning;
case StructureEntry::SE_SECTION:
if (entry->level>=0 && entry->level<iconSection.count())
return iconSection[entry->level];
else
return QVariant();
case StructureEntry::SE_DOCUMENT_ROOT:
if (documents.masterDocument==entry->document)
return iconMasterDocument;
else
return iconDocument;
default: return QVariant();
}
case Qt::BackgroundRole:
if (index==mHighlightIndex) return QVariant(Qt::lightGray);
if (entry->appendix) return QVariant(QColor(200,230,200));
else return QVariant();
case Qt::ForegroundRole:
if((entry->type==StructureEntry::SE_INCLUDE) && (entry->valid)) {
return QVariant(Qt::red);
}else return QVariant();
case Qt::FontRole:
if(entry->type==StructureEntry::SE_DOCUMENT_ROOT) {
QFont f=QApplication::font();
if(entry->document==documents.currentDocument) f.setBold(true);
if(entry->title.isEmpty()) f.setItalic(true);
return QVariant(f);
}
return QVariant();
default:
return QVariant();
}
}
QVariant LatexDocumentsModel::headerData ( int section, Qt::Orientation orientation, int role ) const{
Q_UNUSED(orientation);
if (section!=0) return QVariant();
if (role!=Qt::DisplayRole) return QVariant();
return QVariant("Structure");
}
int LatexDocumentsModel::rowCount ( const QModelIndex & parent ) const{
if (!parent.isValid()) return documents.documents.count();
else {
StructureEntry* entry = (StructureEntry*) parent.internalPointer();
if (!entry) return 0;
return entry->children.size();
}
}
int LatexDocumentsModel::columnCount ( const QModelIndex & parent ) const{
Q_UNUSED(parent);
return 1;
}
QModelIndex LatexDocumentsModel::index ( int row, int column, const QModelIndex & parent ) const{
if (column!=0) return QModelIndex(); //one column
if (row<0) return QModelIndex(); //shouldn't happen
if (parent.isValid()) {
const StructureEntry* entry = (StructureEntry*) parent.internalPointer();
if (!entry) return QModelIndex(); //should never happen
if (row>=entry->children.size()) return QModelIndex(); //shouldn't happen in a correct view
return createIndex(row,column, entry->children.at(row));
} else {
if (row>=documents.documents.size()) return QModelIndex();
if(m_singleMode){
if(row!=0 || !documents.currentDocument )
return QModelIndex();
else
return createIndex(row, column, documents.currentDocument->baseStructure);
}else{
return createIndex(row, column, documents.documents.at(row)->baseStructure);
}
}
}
QModelIndex LatexDocumentsModel::index ( StructureEntry* entry ) const{
if (!entry) return QModelIndex();
if (entry->parent==0 && entry->type==StructureEntry::SE_DOCUMENT_ROOT) {
int row=documents.documents.indexOf(entry->document);
if(m_singleMode){
row=0;
}
if (row<0) return QModelIndex();
return createIndex(row, 0, entry);
} else if (entry->parent!=0 && entry->type!=StructureEntry::SE_DOCUMENT_ROOT) {
int row=entry->getRealParentRow();
if (row<0) return QModelIndex(); //shouldn't happen
return createIndex(row, 0, entry);
} else return QModelIndex(); //shouldn't happen
}
QModelIndex LatexDocumentsModel::parent ( const QModelIndex & index ) const{
if (!index.isValid()) return QModelIndex();
const StructureEntry* entry = (StructureEntry*) index.internalPointer();
#ifndef QT_NO_DEBUG
const LatexDocument* found = 0;
foreach (const LatexDocument* ld, documents.documents)
if (ld->StructureContent.contains(const_cast<StructureEntry*>(entry))) {
found = ld;
break;
}
if (!found) entry->debugPrint("No document for entry:");
Q_ASSERT(found);
Q_ASSERT(entry->document == found);
#endif
if (!entry) return QModelIndex();
if (!entry->parent) return QModelIndex();
if(entry->level>LatexParser::getInstance().structureCommands.count() || entry->level<0){
entry->debugPrint("Structure broken!");
//qDebug("Title %s",qPrintable(entry->title));
return QModelIndex();
}
if(entry->parent->level>LatexParser::getInstance().structureCommands.count() || entry->parent->level<0){
entry->debugPrint("Structure broken (b)!");
//qDebug("Title %s",qPrintable(entry->title));
return QModelIndex();
}
if (entry->parent->parent)
return createIndex(entry->parent->getRealParentRow(), 0, entry->parent);
else {
if(m_singleMode)
return createIndex(0, 0, entry->parent);
for (int i=0; i < documents.documents.count(); i++)
if (documents.documents.at(i)->baseStructure==entry->parent)
return createIndex(i, 0, entry->parent);
return QModelIndex();
}
}
StructureEntry* LatexDocumentsModel::indexToStructureEntry(const QModelIndex & index ){
if (!index.isValid()) return 0;
StructureEntry* result=(StructureEntry*)index.internalPointer();
if (!result || !result->document) return 0;
return result;
}
/*!
Returns an associated SE_LABEL entry for a structure element if one exists, otherwise 0.
TODO: currently association is checked, by checking, if the label is on the same line or on the next.
This is not necessarily correct. It fails if:
- there are multiple labels on one line (always the first label is chosen)
- the label is more than one line after the entry (label not detected)
*/
StructureEntry *LatexDocumentsModel::labelForStructureEntry(const StructureEntry *entry)
{
StructureEntryIterator iter(entry->document->baseStructure);
QDocumentLineHandle *dlh = entry->getLineHandle();
QDocumentLineHandle *nextDlh = dlh->next();
while (iter.hasNext()){
StructureEntry *se = iter.next();
if (se->type==StructureEntry::SE_LABEL) {
QDocumentLineHandle *labelDlh = se->getLineHandle();
if (labelDlh == dlh || labelDlh == nextDlh) {
return se;
}
}
}
return 0;
}
QModelIndex LatexDocumentsModel::highlightedEntry(){
return mHighlightIndex;
}
void LatexDocumentsModel::setHighlightedEntry(StructureEntry* entry){
QModelIndex i1=mHighlightIndex;
QModelIndex i2=index(entry);
if (i1==i2) return;
emit dataChanged(i1,i1);
mHighlightIndex=i2;
emit dataChanged(i2,i2);
}
void LatexDocumentsModel::resetAll(){
mHighlightIndex=QModelIndex();
reset();
}
void LatexDocumentsModel::resetHighlight(){
mHighlightIndex=QModelIndex();
}
void LatexDocumentsModel::structureUpdated(LatexDocument* document,StructureEntry *highlight){
Q_UNUSED(document);
//resetAll();
if(highlight){
mHighlightIndex=index(highlight);
}else{
mHighlightIndex=QModelIndex();
}
emit layoutChanged();
//emit resetAll();
}
void LatexDocumentsModel::structureLost(LatexDocument* document){
Q_UNUSED(document);
resetAll();
}
void LatexDocumentsModel::removeElement(StructureEntry *se,int row){
REQUIRE(se);
if (!se->parent)
beginRemoveRows(QModelIndex(),row,row); // remove from root (documents)
else {
if(row<0) row=se->getRealParentRow();
else Q_ASSERT(row < se->parent->children.size()), Q_ASSERT(se->parent->children[row] == se);
beginRemoveRows(index(se->parent),row,row);
}
}
void LatexDocumentsModel::removeElementFinished(){
endRemoveRows();
}
void LatexDocumentsModel::addElement(StructureEntry *se, int row){
beginInsertRows(index(se),row,row);
}
void LatexDocumentsModel::addElementFinished(){
endInsertRows();
}
void LatexDocumentsModel::updateElement(StructureEntry *se){
emit dataChanged(index(se),index(se));
}
void LatexDocumentsModel::setSingleDocMode(bool singleMode){
if(m_singleMode!=singleMode){
//resetAll();
if(singleMode){
foreach(LatexDocument *doc,documents.documents){
changePersistentIndex(index(doc->baseStructure),createIndex(0,0,doc->baseStructure));
}
}else{
for(int i=0;i<documents.documents.count();i++){
StructureEntry *se=documents.documents.at(i)->baseStructure;
changePersistentIndex(index(se),createIndex(i,0,se));
}
}
m_singleMode=singleMode;
}
structureUpdated(documents.currentDocument,0);
}
void LatexDocumentsModel::moveDocs(int from,int to){ //work only for adjacent elements !!!
Q_ASSERT(abs(from-to)==1);
StructureEntry *se=documents.documents.at(from)->baseStructure;
changePersistentIndex(index(se),createIndex(to,0,se));
se=documents.documents.at(to)->baseStructure;
changePersistentIndex(index(se),createIndex(from,0,se));
}
bool LatexDocumentsModel::getSingleDocMode(){
return m_singleMode;
}
LatexDocuments::LatexDocuments(): model(new LatexDocumentsModel(*this)), masterDocument(0), currentDocument(0), bibTeXFilesModified(false){
showLineNumbersInStructure=false;
indentationInStructure=-1;
}
LatexDocuments::~LatexDocuments(){
delete model;
}
void LatexDocuments::addDocument(LatexDocument* document,bool hidden){
if(hidden){
hiddenDocuments.append(document);
}else{
documents.append(document);
}
connect(document, SIGNAL(updateBibTeXFiles()), SLOT(bibTeXFilesNeedUpdate()));
connect(document,SIGNAL(structureLost(LatexDocument*)),model,SLOT(structureLost(LatexDocument*)));
connect(document,SIGNAL(structureUpdated(LatexDocument*,StructureEntry*)),model,SLOT(structureUpdated(LatexDocument*,StructureEntry*)));
connect(document,SIGNAL(toBeChanged()),model,SIGNAL(layoutAboutToBeChanged()));
connect(document,SIGNAL(removeElement(StructureEntry*,int)),model,SLOT(removeElement(StructureEntry*,int)));
connect(document,SIGNAL(removeElementFinished()),model,SLOT(removeElementFinished()));
connect(document,SIGNAL(addElement(StructureEntry*,int)),model,SLOT(addElement(StructureEntry*,int)));
connect(document,SIGNAL(addElementFinished()),model,SLOT(addElementFinished()));
connect(document,SIGNAL(updateElement(StructureEntry*)),model,SLOT(updateElement(StructureEntry*)));
document->parent=this;
if(masterDocument){
// repaint all docs
foreach(const LatexDocument *doc,documents){
LatexEditorView *edView=doc->getEditorView();
if (edView) edView->documentContentChanged(0,edView->editor->document()->lines());
}
}
if(!hidden)
model->structureUpdated(document,0);
}
void LatexDocuments::deleteDocument(LatexDocument* document,bool hidden){
if(!hidden)
emit aboutToDeleteDocument(document);
LatexEditorView *view=document->getEditorView();
if(view)
view->closeCompleter();
if (document!=masterDocument) {
// get list of all affected documents
QList<LatexDocument*> lstOfDocs=document->getListOfDocs();
// count open related (child/parent) documents
int n=0;
foreach(LatexDocument* elem,lstOfDocs){
if(!elem->isHidden())
n++;
}
if(hidden){
hiddenDocuments.removeAll(document);
return;
}
if(n>1){ // at least one related document will be open after removal
hiddenDocuments.append(document);
}else{
/*
// set document.masterdocument = 0
foreach(LatexDocument* elem,lstOfDocs){
if(elem->getMasterDocument()==document){
elem->setMasterDocument(0);
}
}
//document->setMasterDocument(0);
//recheck labels in all open documents connected to this document
foreach(LatexDocument* elem,lstOfDocs){
elem->recheckRefsLabels();
}*/
// no open document remains, remove all others as well
foreach(LatexDocument* elem,lstOfDocs){
if(elem->isHidden()){
hiddenDocuments.removeAll(elem);
delete elem->getEditorView();
delete elem;
}
}
}
int row=documents.indexOf(document);
//qDebug()<<document->getFileName()<<row;
if (!document->baseStructure) row = -1; //may happen directly after reload (but won't)
if(model->getSingleDocMode()){
row=0;
}
if(row>=0 ){//&& !model->getSingleDocMode()){
model->resetHighlight();
model->removeElement(document->baseStructure,row); //remove from root
}
documents.removeAll(document);
if (document==currentDocument){
currentDocument=0;
}
if(row>=0 ){//&& !model->getSingleDocMode()){
model->removeElementFinished();
}
//model->resetAll();
if(n>1) {// don't remove document, stays hidden instead
hideDocInEditor(document->getEditorView());
return;
}
if (view) delete view;
delete document;
} else {
if(hidden){
hiddenDocuments.removeAll(document);
return;
}
document->setFileName(document->getFileName());
model->resetAll();
document->clearAppendix();
if (view) delete view;
if (document==currentDocument)
currentDocument=0;
}
}
void LatexDocuments::setMasterDocument(LatexDocument* document){
if (document==masterDocument) return;
if (masterDocument!=0 && masterDocument->getEditorView()==0){
QString fn=masterDocument->getFileName();
addDocToLoad(fn);
LatexDocument *doc=masterDocument;
masterDocument=0;
deleteDocument(doc);
//documents.removeAll(masterDocument);
//delete masterDocument;
}
masterDocument=document;
if (masterDocument!=0) {
documents.removeAll(masterDocument);
documents.prepend(masterDocument);
// repaint doc
foreach(LatexDocument *doc,documents){
LatexEditorView *edView=doc->getEditorView();
if (edView) edView->documentContentChanged(0,edView->editor->document()->lines());
}
}
model->resetAll();
emit masterDocumentChanged(masterDocument);
}
LatexDocument* LatexDocuments::getCurrentDocument() const{
return currentDocument;
}
LatexDocument* LatexDocuments::getMasterDocument() const{
return masterDocument;
}
QList<LatexDocument*> LatexDocuments::getDocuments() const{
QList<LatexDocument*> docs=documents+hiddenDocuments;
return docs;
}
void LatexDocuments::move(int from, int to){
model->layoutAboutToBeChanged();
model->moveDocs(from,to);
documents.move(from,to);
model->layoutChanged();
}
QString LatexDocuments::getCurrentFileName() {
if (!currentDocument) return "";
return currentDocument->getFileName();
}
QString LatexDocuments::getCompileFileName(){
if (masterDocument)
return masterDocument->getFileName();
if (!currentDocument)
return "";
const LatexDocument* masterDoc=currentDocument->getTopMasterDocument();
QString curDocFile = currentDocument->getFileName();
if(masterDoc)
curDocFile=masterDoc->getFileName();
return curDocFile;
}
QString LatexDocuments::getTemporaryCompileFileName(){
QString temp = getCompileFileName();
if (!temp.isEmpty()) return temp;
if (masterDocument) return masterDocument->getTemporaryFileName();
else if (currentDocument) return currentDocument->getTemporaryFileName();
return "";
}
QString LatexDocuments::getAbsoluteFilePath(const QString & relName, const QString &extension){
QString s=relName;
QString ext = extension;
if (!ext.isEmpty() && !ext.startsWith(".")) ext = "." + ext;
if (!s.endsWith(ext,Qt::CaseInsensitive)) s+=ext;
QFileInfo fi(s);
if (!fi.isRelative()) return s;
QString compileFileName=getTemporaryCompileFileName();
if (compileFileName.isEmpty()) return s; //what else can we do?
QString compilePath=QFileInfo(compileFileName).absolutePath();
if (!compilePath.endsWith("\\") && !compilePath.endsWith("/"))
compilePath+=QDir::separator();
return compilePath+s;
}
LatexDocument* LatexDocuments::findDocumentFromName(const QString& fileName){
QList<LatexDocument*> docs=getDocuments();
foreach(LatexDocument *doc,docs){
if(doc->getFileName()==fileName) return doc;
}
return 0;
}
LatexDocument* LatexDocuments::findDocument(const QDocument *qDoc){
QList<LatexDocument*> docs=getDocuments();
foreach(LatexDocument *doc,docs){
LatexEditorView *edView=doc->getEditorView();
if(edView && edView->editor->document()==qDoc) return doc;
}
return 0;
}
LatexDocument* LatexDocuments::findDocument(const QString& fileName, bool checkTemporaryNames){
if (fileName=="") return 0;
if (checkTemporaryNames) {
LatexDocument* temp = findDocument(fileName, false);
if (temp) return temp;
}
QString fnorm = fileName;
fnorm.replace("/",QDir::separator()).replace("\\",QDir::separator());
//fast check for absolute file names
#ifdef Q_WS_WIN
Qt::CaseSensitivity cs = Qt::CaseInsensitive;
#else
Qt::CaseSensitivity cs = Qt::CaseSensitive;
#endif
QList<LatexDocument*> docs=getDocuments();
foreach (LatexDocument* document, docs)
if (document->getFileName().compare(fnorm,cs)==0)
return document;
if (checkTemporaryNames)
foreach (LatexDocument* document, documents)
if (document->getFileName().isEmpty() &&
document->getTemporaryFileName().compare(fnorm,cs)==0)
return document;
//check for relative file names
QFileInfo fi(getAbsoluteFilePath(fileName));
if (!fi.exists()) {
if (QFileInfo(getAbsoluteFilePath(fileName),".tex").exists())
fi=QFileInfo(getAbsoluteFilePath(fileName),".tex");
else if (QFileInfo(getAbsoluteFilePath(fileName),".bib").exists())
fi=QFileInfo(getAbsoluteFilePath(fileName),".bib");
else return 0;
}
//check for same file infos (is not reliable in qt < 4.5, because they just compare absoluteFilePath)
foreach (LatexDocument* document, docs)
if (document->getFileInfo().exists() && document->getFileInfo()==fi)
return document;
//check for canonical file path (unnecessary in qt 4.5)
fnorm = fi.canonicalFilePath();
foreach (LatexDocument* document, docs)
if (document->getFileInfo().canonicalFilePath().compare(fnorm,cs)==0)
return document;
return 0;
}
void LatexDocuments::settingsRead(){
model->iconSection.resize(LatexParser::getInstance().structureCommands.count());
for (int i=0;i<LatexParser::getInstance().structureCommands.count();i++)
model->iconSection[i]=QIcon(":/images/"+LatexParser::getInstance().structureCommands[i].mid(1)+".png");
}
bool LatexDocuments::singleMode(){
return !masterDocument;
}
void LatexDocuments::updateBibFiles(bool updateFiles){
mentionedBibTeXFiles.clear();
QSet<QString> newBibItems;
foreach (LatexDocument* doc, documents) {
if(updateFiles){
QMultiHash<QDocumentLineHandle*,FileNamePair>::iterator it = doc->mentionedBibTeXFiles().begin();
QMultiHash<QDocumentLineHandle*,FileNamePair>::iterator itend = doc->mentionedBibTeXFiles().end();
for (; it != itend; ++it){
if (it.value().absolute.isEmpty()) it.value().absolute = getAbsoluteFilePath(it.value().relative,".bib").replace(QDir::separator(), "/"); //store absolute
mentionedBibTeXFiles << it.value().absolute;
}
}
newBibItems.unite(QSet<QString>::fromList(doc->bibItems()));
}
bool changed=false;
if(updateFiles){
for (int i=0; i<mentionedBibTeXFiles.count();i++){
QString &fileName=mentionedBibTeXFiles[i];
QFileInfo fi(fileName);
if (!fi.isReadable()) continue; //ups...
if (!bibTeXFiles.contains(fileName))
bibTeXFiles.insert(fileName,BibTeXFileInfo());
BibTeXFileInfo& bibTex=bibTeXFiles[mentionedBibTeXFiles[i]];
if (bibTex.loadIfModified(fileName))
changed = true;
if (bibTex.ids.empty() && !bibTex.linksTo.isEmpty())
//handle obscure bib tex feature, a just line containing "link fileName"
mentionedBibTeXFiles.append(bibTex.linksTo);
}
}
if (changed || (newBibItems!=bibItems)) {
allBibTeXIds.clear();
bibItems=newBibItems;
for (QMap<QString, BibTeXFileInfo>::const_iterator it=bibTeXFiles.constBegin(); it!=bibTeXFiles.constEnd();++it)
foreach (const QString& s, it.value().ids)
allBibTeXIds << s;
allBibTeXIds.unite(bibItems);
for (int i=0;i<documents.size();i++)
if (documents[i]->getEditorView())
documents[i]->getEditorView()->setBibTeXIds(&allBibTeXIds);
bibTeXFilesModified=true;
}
}
QString LatexDocuments::findFileFromBibId(const QString& bibId)
{
QStringList keys=bibTeXFiles.keys();
foreach(const QString key,keys){
if(bibTeXFiles.value(key).ids.contains(bibId)){
return key;
}
}
return QString();
}
void LatexDocuments::removeDocs(QStringList removeIncludes){
foreach(QString fname,removeIncludes){
LatexDocument* dc=findDocumentFromName(fname);
if(dc && dc->isHidden()){
QStringList toremove=dc->includedFiles();
dc->setMasterDocument(0);
hiddenDocuments.removeAll(dc);
qDebug()<<fname;
delete dc->getEditorView();
delete dc;
if(!toremove.isEmpty())
removeDocs(toremove);
}
}
}
void LatexDocuments::addDocToLoad(QString filename){
emit docToLoad(filename);
}
void LatexDocuments::hideDocInEditor(LatexEditorView *edView){
emit docToHide(edView);
}
void LatexDocument::findStructureEntryBefore(QMutableListIterator<StructureEntry*> &iter,QMultiHash<QDocumentLineHandle*,StructureEntry*> &MapOfElements,int linenr,int count){
bool goBack=false;
int l=0;
while(iter.hasNext()){
StructureEntry* se=iter.next();
int realline = se->getRealLineNumber();
Q_ASSERT(realline >= 0);
if(realline>=linenr && (realline<linenr+count) ){
emit removeElement(se,l);
iter.remove();
emit removeElementFinished();
MapOfElements.insert(se->getLineHandle(),se);
l--;
}
if(realline>=linenr+count) {
goBack=true;
break;
}
l++;
}
if(goBack && iter.hasPrevious()) iter.previous();
}
void LatexDocument::mergeStructure(StructureEntry* se, QVector<StructureEntry*> &parent_level, QList<StructureEntry*>& flatStructure, const int linenr, const int count){
if (!se) return;
if (se->type != StructureEntry::SE_DOCUMENT_ROOT && se->type != StructureEntry::SE_SECTION && se->type != StructureEntry::SE_INCLUDE) return;
if (se == baseStructure) parent_level.fill(se);
int se_line = se->getRealLineNumber();
if (se_line < linenr || se == baseStructure) {
//se is before updated region, but children might still be in it
updateParentVector(parent_level, se);
//if (!se->children.isEmpty() && se->children.last()->getRealLineNumber() >= linenr) {
int start = -1;
for (int i=0;i<se->children.size();i++){
StructureEntry* c = se->children[i];
if (c->type != StructureEntry::SE_SECTION && c->type != StructureEntry::SE_INCLUDE) continue;
if (c->getRealLineNumber() < linenr)
updateParentVector(parent_level, c);
start = i;
break;
}
if (start >=0) {
if (start > 0) start--;
QList<StructureEntry*> oldChildren = se->children;
for (int i=start;i<oldChildren.size();i++)
mergeStructure(oldChildren[i], parent_level, flatStructure, linenr, count);
}
} else {
//se is within or after the region
// => insert flatStructure.first() before se or replace se with it (don't insert after since there might be another "se" to replace)
while (!flatStructure.isEmpty() && se->getRealLineNumber() >= flatStructure.first()->getRealLineNumber() ) {
if (se->getRealLineNumber() == flatStructure.first()->getRealLineNumber()) {
flatStructure.first()->parent = se->parent;
flatStructure.first()->children = se->children;
*se = *flatStructure.first();
flatStructure.first()->children.clear();
delete flatStructure.takeFirst();
emit updateElement(se);
moveToAppropiatePositionWithSignal(parent_level, se);
// qDebug()<<"a"<<se->children.size() << ":"<<se->title<<" von "<<linenr<<count;
QList<StructureEntry*> oldChildren = se->children;
foreach (StructureEntry* next, oldChildren)
mergeStructure(next, parent_level, flatStructure, linenr, count);
return;
}
moveToAppropiatePositionWithSignal(parent_level, flatStructure.takeFirst());
}
if (se_line < linenr + count) {
//se is within the region (delete if necessary and then merge children)
if (flatStructure.isEmpty() || se->getRealLineNumber() < flatStructure.first()->getRealLineNumber()) {
QList<StructureEntry*> oldChildren = se->children;
int oldrow = se->getRealParentRow();
for (int i=se->children.size()-1;i>=0;i--)
moveElementWithSignal(se->children[i], se->parent, oldrow);
removeElementWithSignal(se);
delete se;
for (int i=1;i<parent_level.size();i++)
if (parent_level[i] == se)
parent_level[i] = parent_level[i-1];
foreach (StructureEntry* next, oldChildren)
mergeStructure(next, parent_level, flatStructure, linenr, count);
return;
}
}
//se not replaced or deleted => se is after everything the region => keep children
moveToAppropiatePositionWithSignal(parent_level, se);
QList<StructureEntry*> oldChildren = se->children;
foreach (StructureEntry* c, oldChildren)
moveToAppropiatePositionWithSignal(parent_level, c);
}
//insert unprocessed elements of flatStructure at the end of the structure
if (se == baseStructure && !flatStructure.isEmpty()) {
foreach (StructureEntry* s, flatStructure){
addElementWithSignal(parent_level[s->level], s);
updateParentVector(parent_level, s);
}
flatStructure.clear();
}
return;
}
void LatexDocument::removeElementWithSignal(StructureEntry* se){
int parentRow = se->getRealParentRow();
REQUIRE(parentRow >= 0);
emit removeElement(se, parentRow);
se->parent->children.removeAt(parentRow);
se->parent = 0;
emit removeElementFinished();
}
void LatexDocument::addElementWithSignal(StructureEntry* parent, StructureEntry* se){
emit addElement(parent, parent->children.size());
parent->children.append(se);
se->parent = parent;
emit addElementFinished();
}
void LatexDocument::insertElementWithSignal(StructureEntry* parent, int pos, StructureEntry* se){
emit addElement(parent, pos);
parent->children.insert(pos, se);
se->parent = parent;
emit addElementFinished();
}
void LatexDocument::moveElementWithSignal(StructureEntry* se, StructureEntry* parent, int pos){
removeElementWithSignal(se);
insertElementWithSignal(parent, pos, se);
}
void LatexDocument::updateParentVector(QVector<StructureEntry*> &parent_level, StructureEntry* se){
REQUIRE(se);
if (se->type == StructureEntry::SE_DOCUMENT_ROOT || se->type == StructureEntry::SE_INCLUDE)
parent_level.fill(baseStructure);
else if (se->type == StructureEntry::SE_SECTION)
for (int j=se->level+1;j<parent_level.size();j++)
parent_level[j] = se;
}
class LessThanRealLineNumber
{
public:
inline bool operator()(const StructureEntry * const se1, const StructureEntry * const se2) const
{
int l1 = se1->getRealLineNumber();
int l2 = se2->getRealLineNumber();
if (l1 < l2) return true;
if (l1 == l2 && (se1->columnNumber < se2->columnNumber)) return true;
return false;
}
};
StructureEntry* LatexDocument::moveToAppropiatePositionWithSignal(QVector<StructureEntry*> &parent_level, StructureEntry* se){
REQUIRE_RET(se, 0);
StructureEntry* newParent = parent_level[se->level];
if (se->parent == newParent) {
updateParentVector(parent_level, se);
return 0;
}
int newPos = newParent->children.size();
if (newParent->children.size() > 0 &&
newParent->children.last()->getRealLineNumber() >= se->getRealLineNumber())
newPos = qUpperBound(newParent->children.begin(), newParent->children.end(), se, LessThanRealLineNumber()) - newParent->children.begin();
//qDebug() << "auto insert at " << newPos;
if (se->parent) moveElementWithSignal(se, newParent, newPos);
else insertElementWithSignal(newParent, newPos, se);
updateParentVector(parent_level, se);
return newParent;
}
/*!
Splits a [name] = [val] string into \a name and \a val removing extra spaces.
\return true if splitting successful, false otherwise (in that case name and val are empty)
*/
bool LatexDocument::splitMagicComment(const QString &comment, QString &name, QString &val) {
int sep = comment.indexOf("=");
if (sep < 0) return false;
name = comment.left(sep).trimmed();
val = comment.mid(sep+1).trimmed();
return true;
}
/*!
Formats the StructureEntry and modifies the document according to the MagicComment contents
*/
void LatexDocument::parseMagicComment(const QString &name, const QString &val, StructureEntry* se) {
if (name.isEmpty()) {
se->tooltip = QString();
se->valid = false;
}
if (name.toLower() == "spellcheck") {
QString lang=val;
lang.replace("-", "_"); // QLocale expects "_". This is to stay compatible with texworks which uses "-"
mSpellingLanguage = QLocale(lang);
if (mSpellingLanguage.language() == QLocale::C) {
se->tooltip = tr("Invalid language format");
return;
}
emit spellingLanguageChanged(mSpellingLanguage);
se->valid = true;
// TODO: set master document
} else if ((name.toLower() == "texroot")||(name.toLower() == "root")){
QString fname=findFileName(val);
LatexDocument* dc=parent->findDocumentFromName(fname);
if(dc) setMasterDocument(dc);
else {
parent->addDocToLoad(fname);
}
se->valid = true;
} else if (name.toLower() == "encoding") {
QTextCodec *codec = QTextCodec::codecForName(val.toAscii());
if (!codec) {
se->tooltip = tr("Invalid codec");
return;
}
setCodec(codec);
se->valid = true;
} else {
se->tooltip = tr("Unknown magic comment");
return;
}
se->valid = true;
}
void LatexDocument::updateAppendix(QDocumentLineHandle *oldLine,QDocumentLineHandle *newLine){
int endLine=newLine?indexOf(newLine):-1 ;
int startLine=-1;
if(oldLine){
startLine=indexOf(oldLine);
if(endLine<0 || endLine>startLine){
// remove appendic marker
StructureEntry *se=baseStructure;
setAppendix(se,startLine,endLine,false);
}
}
if(endLine>-1 && (endLine<startLine || startLine<0)){
StructureEntry *se=baseStructure;
setAppendix(se,endLine,startLine,true);
}
}
void LatexDocument::setAppendix(StructureEntry *se,int startLine,int endLine,bool state){
bool first=false;
for(int i=0;i<se->children.size();i++){
StructureEntry *elem=se->children[i];
if(endLine>=0 && elem->getLineHandle() && elem->getRealLineNumber()>endLine) break;
if(elem->type==StructureEntry::SE_SECTION && elem->getRealLineNumber()>startLine){
if(!first && i>0) setAppendix(se->children[i-1],startLine,endLine,state);
elem->appendix=state;
emit updateElement(elem);
setAppendix(se->children[i],startLine,endLine,state);
first=true;
}
}
if(!first && !se->children.isEmpty()) {
StructureEntry *elem=se->children.last();
if(elem->type==StructureEntry::SE_SECTION) setAppendix(elem,startLine,endLine,state);
}
}
bool LatexDocument::fileExits(QString fname){
QString curPath=ensureTrailingDirSeparator(getFileInfo().absolutePath());
bool exist=QFile(getAbsoluteFilePath(fname,".tex")).exists();
if (!exist) exist=QFile(getAbsoluteFilePath(curPath+fname,".tex")).exists();
if (!exist) exist=QFile(getAbsoluteFilePath(curPath+fname,"")).exists();
return exist;
}
QString LatexDocument::findFileName(QString fname){
QString curPath=ensureTrailingDirSeparator(getFileInfo().absolutePath());
QString result;
if(QFile(getAbsoluteFilePath(fname,".tex")).exists())
result=QFileInfo(getAbsoluteFilePath(fname,".tex")).absoluteFilePath();
if (result.isEmpty() && QFile(getAbsoluteFilePath(curPath+fname,".tex")).exists())
result=QFileInfo(getAbsoluteFilePath(curPath+fname,".tex")).absoluteFilePath();
if (result.isEmpty() && QFile(getAbsoluteFilePath(curPath+fname,"")).exists())
result=QFileInfo(getAbsoluteFilePath(curPath+fname,"")).absoluteFilePath();
return result;
}
void LatexDocuments::updateStructure(){
foreach(const LatexDocument* doc,documents){
model->updateElement(doc->baseStructure);
}
if(model->getSingleDocMode()){
model->structureUpdated(currentDocument,0);
}
}
void LatexDocuments::bibTeXFilesNeedUpdate(){
bibTeXFilesModified=true;
}
void LatexDocuments::updateMasterSlaveRelations(LatexDocument *doc){
//update Master/Child relations
//remove old settings ...
doc->setMasterDocument(0);
QList<LatexDocument*> docs=getDocuments();
foreach(LatexDocument* elem,docs){
if(elem->getMasterDocument()==doc){
elem->setMasterDocument(0);
elem->recheckRefsLabels();
}
}
//check whether document is child of other docs
QString fname=doc->getFileName();
foreach(LatexDocument* elem,docs){
if(elem==doc)
continue;
QStringList includedFiles=elem->includedFiles();
if(includedFiles.contains(fname)){
doc->setMasterDocument(elem);
break;
}
}
// check for already open child documents (included in this file)
QStringList includedFiles=doc->includedFiles();
foreach(const QString& fname,includedFiles){
LatexDocument* child=this->findDocumentFromName(fname);
if(child){
child->setMasterDocument(doc);
LatexEditorView *edView=child->getEditorView();
if(edView)
edView->reCheckSyntax(); // redo syntax checking (in case of defined commands)
}
}
//recheck references
doc->recheckRefsLabels();
}
const LatexDocument* LatexDocument::getTopMasterDocument(QSet<const LatexDocument*> *visitedDocs) const {
const LatexDocument *result=this;
bool deleteVisitedDocs=false;
if(!visitedDocs){
visitedDocs=new QSet<const LatexDocument*>();
deleteVisitedDocs=true;
}
visitedDocs->insert(this);
if(masterDocument && !visitedDocs->contains(masterDocument))
result=masterDocument->getTopMasterDocument(visitedDocs);
if (result->getFileName().endsWith("bib"))
foreach (const LatexDocument* d, parent->documents) {
QMultiHash<QDocumentLineHandle*,FileNamePair>::const_iterator it = d->mentionedBibTeXFiles().constBegin();
QMultiHash<QDocumentLineHandle*,FileNamePair>::const_iterator itend = d->mentionedBibTeXFiles().constEnd();
for (; it != itend; ++it) {
//qDebug() << it.value().absolute << " <> "<<result->getFileName();
if (it.value().absolute == result->getFileName()){
result = d->getTopMasterDocument(visitedDocs);
break;
}
}
if (result == d) break;
}
if(deleteVisitedDocs)
delete visitedDocs;
return result;
}
LatexDocument* LatexDocument::getTopMasterDocument(){
return const_cast<LatexDocument*>(getTopMasterDocument(0));
}
QStringList LatexDocument::includedFiles(){
QStringList result;
foreach(const StructureEntry* se,baseStructure->children){
if(se->type==StructureEntry::SE_INCLUDE){
QString fname=findFileName(se->title);
if(!fname.isEmpty())
result << fname;
}
}
return result;
}
void LatexDocument::updateCompletionFiles(QStringList &added,QStringList &removed,bool forceUpdate){
// remove
QStringList filtered;
LatexEditorView *edView=getEditorView();
LatexCompleterConfig *config=edView->getCompleter()->getConfig();
bool update=forceUpdate;
foreach(QString elem,removed){
if(!mUsepackageList.keys(elem).isEmpty())
continue;
elem.append(".cwl");
if(!filtered.contains(elem)){
if(!elem.isEmpty())
filtered << elem;
}
}
if(!filtered.isEmpty()){
LatexParser cmds;
//QStringList removedWords=loadCwlFiles(filtered,&cmds,config);
foreach(QString elem,filtered){
LatexPackage pck=parent->cachedPackages.value(elem);
cmds.possibleCommands=pck.possibleCommands;
ltxCommands.substract(cmds);
foreach(const QString& elem,pck.completionWords)
mCompleterWords.remove(elem);
}
//recheck syntax of ALL documents ...
update=true;
}
// add
filtered.clear();
foreach(QString elem,added){
elem.append(".cwl");
if(!filtered.contains(elem)){
if(parent->cachedPackages.contains(elem)){
filtered << elem;
continue;
}
QString fn=findResourceFile("completion/"+elem,false,QStringList(config->importedCwlBaseDir));
if(!fn.isEmpty())
filtered << elem;
else {
emit importPackage(elem);
}
}
}
if(!filtered.isEmpty()){
LatexParser cmds;
foreach(QString elem,filtered){
LatexPackage pck;
if(parent->cachedPackages.contains(elem)){
pck=parent->cachedPackages.value(elem);
}else{
pck=loadCwlFile(elem,config);
if(pck.packageName!="<notFound>"){
parent->cachedPackages.insert(elem,pck); // cache package
}else{
LatexPackage zw;
zw.packageName=elem;
parent->cachedPackages.insert(elem,zw); // cache package as empty/not found package
}
}
cmds.possibleCommands=pck.possibleCommands;
ltxCommands.append(cmds);
mCompleterWords.unite(pck.completionWords.toSet());
}
//recheck syntax of ALL documents ...
update=true;
}
if(update){
foreach(LatexDocument* elem,getListOfDocs()){
LatexEditorView *edView=elem->getEditorView();
if(edView){
edView->updateLtxCommands();
edView->reCheckSyntax();
}
}
}
}
void LatexDocument::updateCompletionFiles(QStringList &files,bool forceUpdate,bool forceLabelUpdate){
// remove
LatexEditorView *edView=getEditorView();
LatexCompleterConfig *completerConfig=edView->getCompleter()->getConfig();
bool update=forceUpdate;
//recheck syntax of ALL documents ...
LatexPackage pck;
QStringList loadedFiles;
for(int i=0;i<files.count();i++){
if(!files.at(i).endsWith(".cwl"))
files[i]=files[i]+".cwl";
}
files.append(completerConfig->getLoadedFiles());
gatherCompletionFiles(files,loadedFiles,pck);
update=true;
completerConfig->words=pck.completionWords;
ltxCommands.optionCommands=pck.optionCommands;
ltxCommands.possibleCommands=pck.possibleCommands;
ltxCommands.environmentAliases=pck.environmentAliases;
// user commands
QStringList commands=mUserCommandList.values();
foreach(QString elem,commands){
if(!elem.startsWith("\\begin{")&&!elem.startsWith("\\end{")){
int i=elem.indexOf("{");
if(i>=0) elem=elem.left(i);
}
ltxCommands.possibleCommands["user"].insert(elem);
}
//patch lines for new commands (ref,def, etc)
LatexParser& latexParser = LatexParser::getInstance();
QStringList categories;
categories<< "%ref" << "%label" << "%definition" << "%cite" << "%usepackage" << "%graphics" << "%file" << "%bibliography" << "%include";
QStringList newCmds;
foreach(const QString elem,categories){
QStringList cmds=ltxCommands.possibleCommands[elem].values();
foreach(const QString cmd,cmds){
if(!latexParser.possibleCommands[elem].contains(cmd) || forceLabelUpdate){
newCmds << cmd;
latexParser.possibleCommands[elem]<< cmd;
}
}
}
if(!newCmds.isEmpty()){
patchLinesContaining(newCmds);
}
if(update){
foreach(LatexDocument* elem,getListOfDocs()){
LatexEditorView *edView=elem->getEditorView();
if(edView){
edView->updateLtxCommands();
edView->reCheckSyntax();
}
}
}
}
void LatexDocument::gatherCompletionFiles(QStringList &files,QStringList &loadedFiles,LatexPackage &pck){
LatexPackage zw;
LatexCompleterConfig *completerConfig=edView->getCompleter()->getConfig();
foreach(const QString& elem,files){
if(loadedFiles.contains(elem))
continue;
if(parent->cachedPackages.contains(elem)){
zw=parent->cachedPackages.value(elem);
}else{
zw=loadCwlFile(elem,completerConfig);
if(zw.packageName!="<notFound>"){
parent->cachedPackages.insert(elem,zw); // cache package
}else{
LatexPackage zw;
zw.packageName=elem;
parent->cachedPackages.insert(elem,zw); // cache package as empty/not found package
}
}
if(zw.packageName=="<notFound>"){
emit importPackage(elem);
} else {
pck.unite(zw);
loadedFiles.append(elem);
if(!zw.requiredPackages.isEmpty())
gatherCompletionFiles(zw.requiredPackages,loadedFiles,pck);
}
}
}
QString LatexDocument::getMagicComment(const QString& name) {
QString seName;
QString val;
StructureEntryIterator iter(magicCommentList);
while (iter.hasNext()) {
StructureEntry *se = iter.next();
splitMagicComment(se->title, seName, val);
if (seName.toLower()==name.toLower())
return val;
}
return QString();
}
QDocumentLineHandle* LatexDocument::getMagicCommentLineHandle(const QString& name) {
QString seName;
QString val;
if(!magicCommentList) return NULL;
StructureEntryIterator iter(magicCommentList);
while (iter.hasNext()) {
StructureEntry *se = iter.next();
splitMagicComment(se->title, seName, val);
if (seName==name)
return se->getLineHandle();
}
return NULL;
}
/*!
replaces the value of the magic comment
*/
void LatexDocument::updateMagicComment(const QString &name, const QString &val, bool createIfNonExisting) {
QString line(QString("\% !TeX %1 = %2").arg(name).arg(val));
QDocumentLineHandle* dlh = getMagicCommentLineHandle(name);
if(dlh) {
QDocumentCursor cur(this, dlh->line());
cur.select(QDocumentCursor::LineUnderCursor);
cur.replaceSelectedText(line);
} else {
if (createIfNonExisting) {
QDocumentCursor cur(this);
cur.beginEditBlock();
cur.insertText(line);
cur.insertLine();
cur.endEditBlock();
}
}
}
void LatexDocument::updateMagicCommentScripts(){
if (!magicCommentList) return;
localMacros.clear();
QRegExp trigger(" *// *(Trigger) *[:=](.*)");
StructureEntryIterator iter(magicCommentList);
while (iter.hasNext()) {
StructureEntry *se = iter.next();
QString seName, val;
splitMagicComment(se->title, seName, val);
if (seName=="TXS-SCRIPT") {
Macro newMacro;
newMacro.name = val;
newMacro.trigger = "";
newMacro.abbrev = "";
newMacro.tag = "%SCRIPT\n";
int l = se->getRealLineNumber() + 1;
for (; l < lineCount(); l++) {
QString lt = line(l).text().trimmed();
if (lt.endsWith("TXS-SCRIPT-END") || !(lt.isEmpty() || lt.startsWith("%")) ) break;
lt.remove(0,1);
newMacro.tag += lt + "\n";
if (trigger.exactMatch(lt))
newMacro.trigger = trigger.cap(2).trimmed();
}
newMacro.init(newMacro.name,newMacro.tag,newMacro.abbrev,newMacro.trigger);
newMacro.document = this;
localMacros.append(newMacro);
}
}
}
bool LatexDocument::containsPackage(const QString& name){
return mUsepackageList.keys(name).count()>0;
}
LatexDocument *LatexDocuments::getMasterDocumentForDoc(LatexDocument *doc) const { // doc==0 means current document
if(masterDocument)
return masterDocument;
LatexDocument *current=currentDocument;
if(doc)
current=doc;
if(!current)
return current;
return current->getTopMasterDocument();
}
QString LatexDocument::getAbsoluteFilePath(const QString & relName, const QString &extension) const {
QString s=relName;
QString ext = extension;
if (!ext.isEmpty() && !ext.startsWith(".")) ext = "." + ext;
if (!s.endsWith(ext,Qt::CaseInsensitive)) s+=ext;
QFileInfo fi(s);
if (!fi.isRelative()) return s;
const LatexDocument *masterDoc=getTopMasterDocument();
QString compileFileName=masterDoc->getFileName();
if (compileFileName.isEmpty()) return s; //what else can we do?
QString compilePath=QFileInfo(compileFileName).absolutePath();
if (!compilePath.endsWith("\\") && !compilePath.endsWith("/"))
compilePath+=QDir::separator();
return compilePath+s;
}
void LatexDocuments::lineGrammarChecked(const void* doc,const void* line,int lineNr, const QList<GrammarError>& errors){
int d = documents.indexOf(static_cast<LatexDocument*>(const_cast<void*>(doc)));
if (d == -1) return;
if (!documents[d]->getEditorView()) return;
documents[d]->getEditorView()->lineGrammarChecked(doc,line,lineNr,errors);
}
void LatexDocument::patchLinesContaining(const QStringList cmds){
foreach(LatexDocument *elem,getListOfDocs()){
// search all cmds in all lines, patch line if cmd is found
for (int i=0;i<elem->lines();i++){
QString text=elem->line(i).text();
foreach(const QString cmd,cmds){
if(text.contains(cmd)){
//elem->patchStructure(i,1);
patchStructure(i,1);
break;
}
}
}
}
}
| [
"benibela@92cce386-e96d-4106-809f-596c673a3fd8"
] | benibela@92cce386-e96d-4106-809f-596c673a3fd8 |
fc01c02c94f80723cfd505185f5c188c8be138ba | 0bb9667a565d9c75c80a6afffbd6596a7531b82d | /Parcial 3 de Programacion 1/Parcial3.cpp | 4efb0baf909ff5c36cbd25b18df84a4f8f03a18f | [] | no_license | Mendez101/Programacion | 4da825d97562fda84367068c136c758ed4576618 | 052070070ce1866ff8e729750648cff503f0c411 | refs/heads/master | 2020-04-05T22:27:03.229917 | 2018-11-29T04:26:28 | 2018-11-29T04:26:28 | 157,256,729 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,144 | cpp | //Programa creado por: Enrique Antonio Mendez Caceres
//Ultima fecha de modificacion: 28/11/2018
/*El presente programa realiza la serie de Fibonacci y serie de taylor,
Este Almacena los resultados y los muestra resultados en consola.*/
//Librerias
#include <iostream>//Libreria de entradas y salidas
#include <cstdlib>//Contiene Funicones y macros
#include <math.h>// Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones matemáticas
#include <fstream>//Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el programar, tanto leer como escribir en ellos.
#include <string>//contenedores tipo string;
#include <sstream>//Proporciona algunas plantillas
#include <conio.h>//Libreria para comandos
using namespace std; //Simplificar el codigo
//Declaracion de Funciones
void menu();//Declaracion de funcion para el menu
void titulo (); //Declaracion de funcion para el titulo
void fibo(); //Declaracion de funcion fibonachi
void taylor();//Declaracion de funcion para Taylor
double tay(int n, int x);//Ingreso de datos taylor
double factorial(int n);//Ingreso de datos factoriAL
void final();//Declaracion de funcion, mensaje final
int escribir(int o, string n, string d, string r);//Decalracion de datos
void leer();//Declaracion de funcion 6, no retorna, no recibe parametros
//Desarrollo del codigo
int main(){
system("color 4A");// esto sirve para cambiar el color en pantalla
menu();//Uso de funcion para el menu
}
void menu(){//uso de funcion para el menu, no retorna, no recibe parametros
titulo();//Uso de la funcion titulo
int n;//Variable n
//Presentacion del Menu
cout<<"-- Menu Principal --"<<endl;//Imprime en pantalla
cout<<endl;
cout<<"1. Resolver Fibonacci"<<endl;//Imprime en pantalla
cout<<"2. Serie de Taylor"<<endl;//Imprime en pantalla
cout<<"3. Ver resultados"<<endl;//Imprime en pantalla
cout<<"4. Salir"<<endl;//Imprime en pantalla
cout<<endl;
cout<<"Elija una opcion: "; cin>>n;//Imprime en pantalla
system("cls");//Limpiar Pantalla
switch(n){//Variable switch
case 1://Para el caso 1
fibo();
break;
case 2://Para el caso 2
taylor();
break;
case 3://Para el caso 3
leer();
break;
case 4://Para el caso 4
final();
break;
}
}
void fibo(){//Acciones a ejecutar por la funcion fibo
string nom = "Fibonacci";
int i, n, cont = 0;
long long int a[100];
stringstream ss;
a[0] = 0;
a[1] = 1;
cout << "Digite el Numero de terminos de la serie = ";//Imprime en pantalla
cin >> n;
cout << "\n";
for(i=1; i < n; i++){
a[i+1] = a[i-1] + a[i];
}
for(i=0; i < n; i++){
if (cont == 10){
cout << "\n";
cont = 0;
}
cout << a[i] << " ";
cont += 1;
ss<< a[i] << " ";
}
cout << "\n";
stringstream sq;
sq<<"Terminos de la serie: "<<n;
string datos= sq.str();
string res= ss.str();
escribir(1, nom, datos, res);
getch();
menu();
}
void taylor(){//Acciones a ejecutar por la funcion taylor
int n;
int x;
double res;
string nom = "Serie de Taylor";//Imprime en pantalla
cout<<"Ingrese valor de n: "; cin>> n;//Imprime en pantalla
cout<<"Ingrese valor de x: "; cin>> x;//Imprime en pantalla
cout<<endl;
res = tay(n,x);
cout<<"El valor de Taylor para n= "<<n<<" y x= "<<x<<" es igual a: "<<res<<endl;//Imprime en pantalla
stringstream ss;
ss<<"n= "<<n <<" y x= "<<x;
string datos= ss.str();
stringstream sr;
sr<<"El resultado es: "<<res;
string re= sr.str();
escribir(2, nom, datos, re);
getch();
menu();
}
double tay(int n, int x){//Uso de las declaraciones
double t;
double s;
for (int i = 0; i < n; i++){
t = pow(x, i) / factorial(i);
s += t;
}
return s;
}
double factorial(int n){//Uso de las declaraciones
double fact =1;
for(int i= 2; i<=n; i++){
fact*=i;
}
return fact;
}
int escribir(int o, string n, string d, string r){
fstream file("registro.txt", ios::in | ios::out | ios::app);//Se almacenaran datos
if (!file.is_open()){
cout<<"Error al abrir archivo";//En caso que falle el archivo
}else{
cout<<"Proceso realisado correctamente"<<endl;//En caso que abra correectaente
cout<<"Presione enter para regresar al menu"<<endl;//Opcion para regresar al menu
stringstream sa;
sa<<o;
string opcion= sa.str();
string nombre = n;
string datos = d;
string resultado=r;
file<<opcion<<" - "<<nombre<<" - "<<datos<<" - "<<resultado<<endl;
}
return 0;
}
void leer(){//Acciones a ejecutar por la funcion leer
system("color F0");// esto sirve para cambiar el color en pantalla
fstream file("registro.txt", ios::in | ios::out | ios::app);
if (!file.is_open()){
cout<<"Error al abrir archivo";
}else{
file.seekg(0);
string line;
cout<<"-Registro-"<<endl;
while(file.good()){
getline(file, line);
cout << line << endl;
}
}
getch();
menu();
}
void final(){//Uso de funcion final
cout<<endl;//Espacio de linea
system("pause");
system("cls");
cout<<"----------------------"<<endl;//Imprime en pantalla
cout<<"* Proceso Finalizado "<<endl;//Imprime en pantalla
cout<<"----------------------"<<endl;//Imprime en pantalla
}
//Acciones a ejecutar por la funcion titulo
void titulo() {
system ("cls"); //Limpia el contenido en pantalla
cout << "========================================================" << endl; //Imprime en pantalla
cout << "-------La sucesiOn de Fibonacci y Serie Taylor----------" << endl; //Imprime en pantalla
cout << "========================================================" << endl; //Imprime en pantalla
cout << endl; //Espacio de linea
}
| [
"noreply@github.com"
] | noreply@github.com |
d53c408232f00bfa00a148d11fd47976223db45e | 9b48da12e8d70fb3d633b988b9c7d63a954434bf | /ECC8.1/Server/kennel/monitor/SvExcelPlugin/xlw/Win32StreamBuf.inl | 583b6591843dbbeb58f7d71359b476732e583a09 | [] | no_license | SiteView/ECC8.1.3 | 446e222e33f37f0bb6b67a9799e1353db6308095 | 7d7d8c7e7d7e7e03fa14f9f0e3ce5e04aacdb033 | refs/heads/master | 2021-01-01T18:07:05.104362 | 2012-08-30T08:58:28 | 2012-08-30T08:58:28 | 4,735,167 | 1 | 3 | null | null | null | null | ISO-8859-1 | C++ | false | false | 1,525 | inl | /*
Copyright (C) 1998, 1999, 2001, 2002, 2003 Jérôme Lecomte
This file is part of xlw, a free-software/open-source C++ wrapper of the
Excel C API - http://xlw.sourceforge.net/
xlw is free software: you can redistribute it and/or modify it under the
terms of the xlw license. You should have received a copy of the
license along with this program; if not, please email xlw-users@lists.sf.net
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 license for more details.
*/
/*!
* \file Win32StreamBuf.inl
* \brief Inline implementation of the class Win32StreamBuf
* \group utils
*/
// $Id: Win32StreamBuf.inl,v 1.1 2006/07/24 07:55:36 nando Exp $
#ifdef NDEBUG
#define INLINE inline
#else
#define INLINE
#endif
/*!
This method is called to dump stuff in the put area out to the file.
We intercept it to send to debug window.
*/
INLINE int Win32StreamBuf::sync()
{
SendToDebugWindow();
buf_.erase();
return 0;
}
/*!
This method is called to dump stuff in the put area out to the file.
We intercept it to send to debug window.
*/
INLINE int Win32StreamBuf::overflow(int ch)
{
if (!traits_type::eq_int_type(traits_type::eof(), ch))
{
buf_.append(1, traits_type::to_char_type(ch)); // 1
}
else
{
return sync();
}
return traits_type::not_eof(ch);
}
| [
"136122085@163.com"
] | 136122085@163.com |
5be9773cfd4efe9b4f322c31eb9854a3296bf41c | 0dda8cef707f38f5058c3503666cbe3bf6ce8c57 | /PKU_JudgeOnline/1125_Stockbroker_Grapevine.cpp | 40c5e7b1787873a171dc497ca3284b717f82b545 | [] | no_license | Yuessiah/Destiny_Record | 4b1ea05be13fa8e78b55bc95f8ee9a1b682108f2 | 69beb5486d2048e43fb5943c96c093f77e7133af | refs/heads/master | 2022-10-09T07:05:04.820318 | 2022-10-07T01:50:58 | 2022-10-07T01:50:58 | 44,083,491 | 0 | 1 | null | 2017-05-04T12:50:35 | 2015-10-12T04:08:17 | C++ | UTF-8 | C++ | false | false | 853 | cpp | #include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100 + 10;
const int INF = maxn*10;
int n, R[maxn][maxn];
int main()
{
while(scanf("%d", &n) && n) {
for(int u = 1; u <= n; u++) fill(R[u]+1, R[u]+n+1, INF);
for(int u = 1; u <= n; u++) {
R[u][u] = 0;
int m, v, t;
scanf("%d", &m);
while(m--) {
scanf("%d%d", &v, &t);
R[u][v] = t;
}
}
//floyd
for(int k = 1; k <= n; k++)
for(int u = 1; u <= n; u++)
for(int v = 1; v <= n; v++)
R[u][v] = min(R[u][v], R[u][k] + R[k][v]);
//find VIP
int dur = INF, vip;
for(int u = 1; u <= n; u++) {
int maxi = 0;
for(int v = 1; v <= n; v++) maxi = max(maxi, R[u][v]);
if(dur > maxi) {
vip = u;
dur = maxi;
}
}
if(dur == INF) puts("disjoint");
else printf("%d %d\n", vip, dur);
}
return 0;
}
| [
"yuessiah@gmail.com"
] | yuessiah@gmail.com |
c714dc51b0b2fc4dbac1e85b7e90ca6ae3250daa | 22872c21393622db35ae3a5da1b9b7895cf05a7c | /src/PDFPageInputDriver.cpp | 09dfc08723586a823db1c0c99bdb671510ed0cc3 | [
"Apache-2.0"
] | permissive | mattleff/HummusJS | 9fd13dec91bf1abadccd5bea811411b58468d0f5 | 2c59158b2dd261c840f4d67886dbdc1e6efde624 | refs/heads/master | 2020-05-13T01:38:31.972870 | 2019-04-15T20:36:27 | 2019-04-15T20:36:27 | 181,580,253 | 0 | 0 | NOASSERTION | 2019-04-15T23:34:59 | 2019-04-15T23:34:59 | null | UTF-8 | C++ | false | false | 6,175 | cpp | /*
Source File : PDFPageInputDriver
Copyright 2013 Gal Kahana HummusJS
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 "PDFPageInputDriver.h"
#include "PDFPageInput.h"
#include "PDFDictionaryDriver.h"
#include "ConstructorsHolder.h"
using namespace v8;
PDFPageInputDriver::PDFPageInputDriver()
{
PageInput = NULL;
}
PDFPageInputDriver::~PDFPageInputDriver()
{
delete PageInput;
}
DEF_SUBORDINATE_INIT(PDFPageInputDriver::Init)
{
CREATE_ISOLATE_CONTEXT;
Local<FunctionTemplate> t = NEW_FUNCTION_TEMPLATE_EXTERNAL(New);
t->SetClassName(NEW_STRING("PDFPageInput"));
t->InstanceTemplate()->SetInternalFieldCount(1);
SET_PROTOTYPE_METHOD(t, "getDictionary", GetDictionary);
SET_PROTOTYPE_METHOD(t, "getMediaBox", GetMediaBox);
SET_PROTOTYPE_METHOD(t, "getCropBox", GetCropBox);
SET_PROTOTYPE_METHOD(t, "getTrimBox", GetTrimBox);
SET_PROTOTYPE_METHOD(t, "getBleedBox", GetBleedBox);
SET_PROTOTYPE_METHOD(t, "getArtBox", GetArtBox);
SET_PROTOTYPE_METHOD(t, "getRotate", GetRotate);
// save in factory
EXPOSE_EXTERNAL_FOR_INIT(ConstructorsHolder, holder)
SET_CONSTRUCTOR(holder->PDFPageInput_constructor, t);
}
METHOD_RETURN_TYPE PDFPageInputDriver::New(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
EXPOSE_EXTERNAL_ARGS(ConstructorsHolder, externalHolder)
PDFPageInputDriver* element = new PDFPageInputDriver();
element->holder = externalHolder;
element->Wrap(args.This());
SET_FUNCTION_RETURN_VALUE(args.This())
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetDictionary(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if(!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
Handle<Value> newInstance;
newInstance = element->holder->GetNewPDFDictionary();
ObjectWrap::Unwrap<PDFDictionaryDriver>(newInstance->TO_OBJECT())->TheObject = element->PageInputDictionary;
SET_FUNCTION_RETURN_VALUE(newInstance)
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetMediaBox(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if(!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(GetArrayForPDFRectangle(element->PageInput->GetMediaBox()))
}
Handle<Value> PDFPageInputDriver::GetArrayForPDFRectangle(const PDFRectangle& inRectangle)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
Local<Array> result = NEW_ARRAY(4);
result->Set(NEW_NUMBER(0),NEW_NUMBER(inRectangle.LowerLeftX));
result->Set(NEW_NUMBER(1),NEW_NUMBER(inRectangle.LowerLeftY));
result->Set(NEW_NUMBER(2),NEW_NUMBER(inRectangle.UpperRightX));
result->Set(NEW_NUMBER(3),NEW_NUMBER(inRectangle.UpperRightY));
return CLOSE_SCOPE(result);
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetCropBox(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if (!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(GetArrayForPDFRectangle(element->PageInput->GetCropBox()))
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetTrimBox(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if (!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(GetArrayForPDFRectangle(element->PageInput->GetTrimBox()))
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetBleedBox(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if (!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(GetArrayForPDFRectangle(element->PageInput->GetBleedBox()))
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetArtBox(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if (!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(GetArrayForPDFRectangle(element->PageInput->GetArtBox()))
}
METHOD_RETURN_TYPE PDFPageInputDriver::GetRotate(const ARGS_TYPE& args)
{
CREATE_ISOLATE_CONTEXT;
CREATE_ESCAPABLE_SCOPE;
PDFPageInputDriver* element = ObjectWrap::Unwrap<PDFPageInputDriver>(args.This());
if (!element->PageInput)
{
THROW_EXCEPTION("page input not initialized. create one using the PDFReader.parsePage");
SET_FUNCTION_RETURN_VALUE(UNDEFINED)
}
else
SET_FUNCTION_RETURN_VALUE(NEW_NUMBER(element->PageInput->GetRotate()))
} | [
"gal.kahana@hotmail.com"
] | gal.kahana@hotmail.com |
86d0a4bd420c7194e2ceaa899f4cce1ca76f9737 | 5a2349399fa9d57c6e8cc6e0f7226d683391a362 | /src/qt/qtwebkit/Source/WebKit2/Shared/mac/CookieStorageShimLibrary.cpp | 5bc877af01e7f025b1d469ab4e78c61b8fdb52a3 | [
"BSD-3-Clause"
] | permissive | aharthcock/phantomjs | e70f3c379dcada720ec8abde3f7c09a24808154c | 7d7f2c862347fbc7215c849e790290b2e07bab7c | refs/heads/master | 2023-03-18T04:58:32.428562 | 2023-03-14T05:52:52 | 2023-03-14T05:52:52 | 24,828,890 | 0 | 0 | BSD-3-Clause | 2023-03-14T05:52:53 | 2014-10-05T23:38:56 | C++ | UTF-8 | C++ | false | false | 3,565 | cpp | /*
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "CookieStorageShimLibrary.h"
#if ENABLE(NETWORK_PROCESS)
#include <WebCore/DynamicLinkerInterposing.h>
extern "C" CFDictionaryRef _CFHTTPCookieStorageCopyRequestHeaderFieldsForURL(CFAllocatorRef inAllocator, CFHTTPCookieStorageRef inCookieStorage, CFURLRef inRequestURL);
namespace WebKit {
extern "C" void WebKitCookieStorageShimInitialize(const CookieStorageShimCallbacks&);
static CookieStorageShimCallbacks cookieStorageShimCallbacks;
class ShimProtector {
public:
ShimProtector() { ++m_count; }
~ShimProtector() { --m_count; }
static unsigned count() { return m_count; }
private:
__thread static unsigned m_count;
};
__thread unsigned ShimProtector::m_count = 0;
static CFDictionaryRef shimCFHTTPCookieStorageCopyRequestHeaderFieldsForURL(CFAllocatorRef inAllocator, CFHTTPCookieStorageRef inCookieStorage, CFURLRef inRequestURL)
{
ShimProtector protector;
do {
// Protect against uninitialized callbacks:
if (!cookieStorageShimCallbacks.cookieStorageCopyRequestHeaderFieldsForURL)
break;
// Protect against accidental recursion:
if (ShimProtector::count() > 1)
break;
CFDictionaryRef results = cookieStorageShimCallbacks.cookieStorageCopyRequestHeaderFieldsForURL(inCookieStorage, inRequestURL);
if (!results)
break;
return results;
} while (0);
// If we've failed to retrieve the cookies manually, fall back to the original imposed function:
return _CFHTTPCookieStorageCopyRequestHeaderFieldsForURL(inAllocator, inCookieStorage, inRequestURL);
}
DYLD_INTERPOSE(shimCFHTTPCookieStorageCopyRequestHeaderFieldsForURL, _CFHTTPCookieStorageCopyRequestHeaderFieldsForURL);
__attribute__((visibility("default")))
void WebKitCookieStorageShimInitialize(const CookieStorageShimCallbacks& callbacks)
{
// Because the value of cookieStorageShimCallbacks will be read from mulitple threads,
// only allow it to be initialized once.
static int initialized = 0;
if (!OSAtomicCompareAndSwapInt(0, 1, &initialized)) {
return;
}
cookieStorageShimCallbacks = callbacks;
}
}
#endif // ENABLE(NETWORK_PROCESS)
| [
"ariya.hidayat@gmail.com"
] | ariya.hidayat@gmail.com |
b1272964d6d61fee306e75f757c18683c1d86482 | c7baf650c0d64fc2bef6484366ddc9b04d883c91 | /weight_propagation-inl.h | 167ebbe24e9928aee1105d6540310efb8dae3393 | [] | no_license | gaopeng-eugene/Mxnet-Operator | d83cd1d9ab1bea291e7020d770707b43ca269891 | 44096dc9efbd62d915ab15128e3d52fc54e2f45e | refs/heads/master | 2020-04-13T11:03:53.858145 | 2018-12-13T13:55:03 | 2018-12-13T13:55:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,876 | h | /*!
* Copyright (c) 2017 by Contributors
* Copyright (c) 2017 Microsoft
* Licensed under The Apache-2.0 License [see LICENSE for details]
* \file psroi_pooling-inl.h
* \brief psroi pooling operator and symbol
* \author Jiang ZhengKai
*/
#ifndef MXNET_OPERATOR_CONTRIB_WEIGHT_PROPAGATION_INL_H_
#define MXNET_OPERATOR_CONTRIB_WEIGHT_PROPAGATION_INL_H_
#include <dmlc/logging.h>
#include <dmlc/parameter.h>
#include <mxnet/operator.h>
#include <map>
#include <vector>
#include <string>
#include <utility>
#include "../operator_common.h"
#include "../mshadow_op.h"
namespace mxnet {
namespace op {
// Declare enumeration of input order to make code more intuitive
namespace weightpropagation {
enum WeightPropagationOpInputs {kData, kWeights};
enum WeightPropagationOpOutputs {kOut};
} // WeightPropogation
struct WeightPropagationParam : public dmlc::Parameter<WeightPropagationParam> {
// Tshape
int weight_width;
int weight_height;
int hole;
DMLC_DECLARE_PARAMETER(WeightPropagationParam) {
DMLC_DECLARE_FIELD(weight_height)
.describe("weight propagation height");
DMLC_DECLARE_FIELD(weight_width)
.describe("weight propagation width");
DMLC_DECLARE_FIELD(hole).set_default(1)
.describe("hole params for larger recieve field");
}
};
template<typename xpu, typename DType>
class WeightPropagationOp : public Operator {
public:
explicit WeightPropagationOp(WeightPropagationParam p) {
this->param_ = p;
}
// forward
virtual void Forward(const OpContext &ctx,
const std::vector<TBlob> &in_data,
const std::vector<OpReqType> &req,
const std::vector<TBlob> &out_data,
const std::vector<TBlob> &aux_args) {
using namespace mshadow;
size_t expected_in = 2;
size_t expected_out = 1;
CHECK_EQ(in_data.size(), expected_in);
CHECK_EQ(out_data.size(), expected_out);
CHECK_EQ(in_data[weightpropagation::kData].shape_[2], out_data[weightpropagation::kWeights].shape_[2]);
CHECK_EQ(in_data[weightpropagation::kData].shape_[3], out_data[weightpropagation::kWeights].shape_[3]);
CHECK_EQ(in_data[weightpropagation::kData].shape_, out_data[weightpropagation::kOut].shape_);
Stream<xpu> *s = ctx.get_stream<xpu>();
Tensor<xpu, 4, DType> data = in_data[weightpropagation::kData].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> weights = in_data[weightpropagation::kWeights].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> out = out_data[weightpropagation::kOut].get<xpu, 4, DType>(s);
CHECK_EQ(data.CheckContiguous(), true);
CHECK_EQ(weights.CheckContiguous(), true);
CHECK_EQ(out.CheckContiguous(), true);
out = 0.0;
WeightPropagationForward(out, data, weights, param_.weight_height, param_.weight_width, param_.hole);
}
// backward
virtual void Backward(const OpContext &ctx,
const std::vector<TBlob> &out_grad,
const std::vector<TBlob> &in_data,
const std::vector<TBlob> &out_data,
const std::vector<OpReqType> &req,
const std::vector<TBlob> &in_grad,
const std::vector<TBlob> &aux_args) {
using namespace mshadow;
size_t expected_in = 2;
size_t expected_out = 1;
CHECK_EQ(in_data.size(), expected_in);
CHECK_EQ(out_data.size(), expected_out);
CHECK_EQ(out_grad[weightpropagation::kOut].shape_, in_data[weightpropagation::kData].shape_);
CHECK_NE(req[weightpropagation::kData], kWriteInplace) <<
"WeightPropagation: Backward doesn't support kWriteInplace.";
CHECK_NE(req[weightpropagation::kWeights], kWriteInplace) <<
"WeightPropagation: Backward doesn't support kWriteInplace.";
Stream<xpu> *s = ctx.get_stream<xpu>();
Tensor<xpu, 4, DType> grad_out = out_grad[weightpropagation::kOut].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> data = in_data[weightpropagation::kData].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> weights = in_data[weightpropagation::kWeights].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> grad_data = in_grad[weightpropagation::kData].get<xpu, 4, DType>(s);
Tensor<xpu, 4, DType> grad_weights = in_grad[weightpropagation::kWeights].get<xpu, 4, DType>(s);
CHECK_EQ(grad_out.CheckContiguous(), true);
CHECK_EQ(data.CheckContiguous(), true);
CHECK_EQ(grad_data.CheckContiguous(), true);
CHECK_EQ(grad_weights.CheckContiguous(), true);
grad_data = 0.0;
grad_weights = 0.0;
WeightPropagationBackwardAcc(grad_data, grad_weights, grad_out, data, weights, param_.weight_width, param_.weight_height, param_.hole);
}
private:
WeightPropagationParam param_;
}; // class weightpropagationop
// Decalre Factory function, used for dispatch specialization
template<typename xpu>
Operator* CreateOp(WeightPropagationParam param, int dtype);
#if DMLC_USE_CXX11
class WeightPropagationProp : public OperatorProperty {
public:
std::vector<std::string> ListArguments() const override {
return {"data", "weights"};
}
std::vector<std::string> ListOutputs() const override {
return {"output"};
}
int NumOutputs() const override {
return 1;
}
int NumVisibleOutputs() const override {
return 1;
}
void Init(const std::vector<std::pair<std::string, std::string> >& kwargs) override {
param_.Init(kwargs);
}
std::map<std::string, std::string> GetParams() const override {
return param_.__DICT__();
}
bool InferShape(std::vector<TShape> *in_shape,
std::vector<TShape> *out_shape,
std::vector<TShape> *aux_shape) const override {
using namespace mshadow;
CHECK_EQ(in_shape->size(), 2) << "Input:[data, weights]";
// data: [batch_size, c, h, w]
TShape dshape = in_shape->at(weightpropagation::kData);
CHECK_EQ(dshape.ndim(), 4) << "data should be a 4D tensor";
// weights [batch_size, k*k, h, w]
TShape wshape = in_shape->at(weightpropagation::kWeights);
CHECK_EQ(wshape.ndim(), 4) << "bbox should be a 4D tensor of shape [batch, k*k, h, w]";
// out: [batch_size, c, h , w]
out_shape->clear();
out_shape->push_back(dshape);
return true;
}
bool InferType(std::vector<int> *in_type,
std::vector<int> *out_type,
std::vector<int> *aux_type) const override {
CHECK_EQ(in_type->size(), 2);
int dtype = (*in_type)[0];
CHECK_EQ(dtype, (*in_type)[1]);
CHECK_NE(dtype, -1) << "Input must have specified type";
out_type->clear();
out_type->push_back(dtype);
return true;
}
OperatorProperty* Copy() const override {
auto ptr = new WeightPropagationProp();
ptr->param_ = param_;
return ptr;
}
std::string TypeString() const override {
return "_contrib_WeightPropagation";
}
// decalre dependency and inplace optimization options
std::vector<int> DeclareBackwardDependency(
const std::vector<int> &out_grad,
const std::vector<int> &in_data,
const std::vector<int> &out_data) const override {
return {out_grad[weightpropagation::kOut], in_data[weightpropagation::kData], in_data[weightpropagation::kWeights]};
}
Operator* CreateOperator(Context ctx) const override {
LOG(FATAL) << "Not Implemented.";
return NULL;
}
Operator* CreateOperatorEx(Context ctx, std::vector<TShape> *in_shape,
std::vector<int> *in_type) const override;
private:
WeightPropagationParam param_;
}; // class WeightPropogation
#endif
} // namespace op
} // namespace mxnet
#endif // MXNET_OPERATOR_WEIGHTPROPAGATION_INL_H_
| [
"noreply@github.com"
] | noreply@github.com |
b39b45e66272be62b6a779235e99943bac52b4dc | 10f5774411120870b7188fe0dcc0480ab8aad3a3 | /streegp/crossover.hpp | 3641494896a2d52a100d14c97cb883d3380c1d55 | [] | no_license | mngr777/stree-gp | 4aaa222ec9ce9d094023c68ca31db46aded2971f | 252f96931268678b9bba71d0f368b94a09fd77a5 | refs/heads/master | 2022-05-16T14:10:36.208763 | 2022-03-10T09:30:43 | 2022-03-10T09:30:43 | 212,445,096 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,113 | hpp | #ifndef STREEGP_CROSSOVER_HPP_
#define STREEGP_CROSSOVER_HPP_
#include <random>
#include <stree/stree.hpp>
#include <streegp/config.hpp>
#include <streegp/context.hpp>
#include <streegp/random.hpp>
namespace stree { namespace gp {
using TreeList = std::vector<Tree>;
template<typename R>
Tree crossover_one_point(
Tree tree1, const Tree& tree2,
float p_term,
R& prng);
template<typename C>
Tree crossover_one_point(
C& context,
const Tree& tree1, const Tree& tree2,
float p_term)
{
return crossover_one_point<typename C::PrngType>(tree1, tree2, p_term, context.prng);
}
template<typename C>
Tree crossover_one_point(C& context, const Tree& tree1, const Tree& tree2) {
const Config& config = context.config;
return crossover_one_point<C>(
context,
tree1, tree2,
config.get<float>(conf::CrossoverOnePointPTerm));
}
template<typename C>
typename C::IndividualType crossover_one_point(
C& context,
const typename C::IndividualType& parent1,
const typename C::IndividualType& parent2)
{
return typename C::IndividualType(
crossover_one_point<C>(context, parent1.tree(), parent2.tree()));
}
template<typename R>
Tree crossover_random(
Tree tree1, const Tree& tree2,
float p_term,
R& prng);
template<typename C>
Tree crossover_random(
C& context,
const Tree& tree1, const Tree& tree2,
float p_term)
{
return crossover_random<typename C::PrngType>(tree1, tree2, p_term, context.prng);
}
template<typename C>
Tree crossover_random(
C& context,
const Tree& tree1, const Tree& tree2)
{
const Config& config = context.config;
return crossover_random<C>(
context,
tree1, tree2,
config.get<float>(conf::CrossoverRandomPTerm));
}
template<typename C>
typename C::IndividualType crossover_random(
C& context,
const typename C::IndividualType& parent1,
const typename C::IndividualType& parent2)
{
return typename C::IndividualType(
crossover_random<C>(context, parent1.tree(), parent2.tree()));
}
}}
#include "impl/crossover.ipp"
#endif
| [
"managerzf168@gmail.com"
] | managerzf168@gmail.com |
d750a5fccc49957565b83660a34eb2e23662a2af | ec11093dcf38cf4461d1198be00824d7d91f1d2c | /Menu.cpp | a6ee7a0ae76fa5c2926295d66b996964ace3f09b | [] | no_license | ViktarKrau/Biplanes | ebddccbf44946ccf07e3afd75d62316d09ccc0a9 | 82c2ab022f4daf7541229eea733bb9e1161280c9 | refs/heads/master | 2021-05-29T16:26:25.973250 | 2015-06-04T23:26:28 | 2015-06-04T23:26:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,003 | cpp | #include "Menu.h"
#include "MenuBackground.h"
#include "ButtonPanel.h"
#include "StaticObject.h"
#include "Game.h"
Menu::Menu(sf::RenderWindow& win)
: Scene(win)
, buttons(new ButtonPanel({
std::shared_ptr<Button>(new Button("New game", Scene::ExitAction::RunPlayModeSelect, { 0.f, 300.f }, { 1.f, 0.f }, { 1066.f / 2.f, 300.f }))
, std::shared_ptr<Button>(new Button("Options", Scene::ExitAction::RunOptions, { -300.f, 400.f }, { 1.f, 0.f }, { 1066.f / 2.f, 400.f }))
, std::shared_ptr<Button>(new Button("About", Scene::ExitAction::RunAbout, { -600.f, 500.f }, { 1.f, 0.f }, { 1066.f / 2.f, 500.f }))
, std::shared_ptr<Button>(new Button("Exit", Scene::ExitAction::Exit, { -900.f, 600.f }, { 1.f, 0.f }, {1066.f / 2, 600.f }))
})){
sf::Text* text = new sf::Text("BIPLANES", Game::getFont(), static_cast<unsigned>(72.f * SVector2f::getConversation().y));
text->setPosition(SVector2f(520.f, 100.f));
manager.add(new MenuBackground());
manager.add(buttons);
manager.add(new StaticObject(text));
}
const Menu::ExitAction Menu::run(){
manager.restart();
while (window.isOpen()){
Scene::ExitAction act = processEvents();
if (act != Scene::ExitAction::NoAction){
return act;
}
render();
}
return Scene::ExitAction::Exit;
}
void Menu::render(){
window.clear();
manager.move();
window.display();
}
const Scene::ExitAction Menu::processEvents(){
sf::Event event;
while (window.pollEvent(event)){
if (event.type == sf::Event::Closed){
return Scene::ExitAction::Exit;
}
else if (event.type == sf::Event::KeyReleased){
switch (event.key.code){
case sf::Keyboard::Up:
case sf::Keyboard::W:
buttons->selectPrevious();
break;
case sf::Keyboard::Down:
case sf::Keyboard::S:
buttons->selectNext();
break;
case sf::Keyboard::Return:
case sf::Keyboard::D:
case sf::Keyboard::Right:
return buttons->choose();
case sf::Keyboard::Escape:
return Scene::ExitAction::Exit;
}
}
}
return Scene::ExitAction::NoAction;
} | [
"kwr@nxt.ru"
] | kwr@nxt.ru |
600b051645b92e0301cef4aab28e4eb80033191f | 57574cc7192ea8564bd630dbc2a1f1c4806e4e69 | /Poker/Servidor/EstadoEsperandoJugadores.cpp | 518901044b5b336025316ec1f11cbf205bf09297 | [] | no_license | natlehmann/taller-2010-2c-poker | 3c6821faacccd5afa526b36026b2b153a2e471f9 | d07384873b3705d1cd37448a65b04b4105060f19 | refs/heads/master | 2016-09-05T23:43:54.272182 | 2010-11-17T11:48:00 | 2010-11-17T11:48:00 | 32,321,142 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,515 | cpp | #include "EstadoEsperandoJugadores.h"
#include "ContextoJuego.h"
#include "RecursosServidor.h"
#include "UtilTiposDatos.h"
EstadoEsperandoJugadores::EstadoEsperandoJugadores(void)
{
}
EstadoEsperandoJugadores::~EstadoEsperandoJugadores(void)
{
}
void EstadoEsperandoJugadores::setEstadoRondaCiega(EstadoRondaCiega* rondaCiega){
this->estadoRondaCiega = rondaCiega;
}
EstadoJuego* EstadoEsperandoJugadores::getSiguienteEstado(){
int tiempoMinimo = UtilTiposDatos::getEntero(
RecursosServidor::getConfig()->get("servidor.logica.timeout.esperandoJugadores") );
if (ContextoJuego::getInstancia()->getCantidadJugadoresActivos() > 1
&& ContextoJuego::getInstancia()->getTiempoEsperandoJugadores() >= tiempoMinimo ) {
ContextoJuego::getInstancia()->iniciarJuego();
return this->estadoRondaCiega;
} else {
return this;
}
}
string EstadoEsperandoJugadores::getEscenarioJuego(int idJugador){
DomTree* arbol = EstadoJuego::crearArbolEscenario();
this->agregarMesa(arbol);
this->agregarBote(arbol);
// TODO: Ver si se manda el mensaje al archivo de configuracion
this->agregarMensaje(arbol, "Esperando que se sumen jugadores ...");
this->agregarJugadores(arbol, idJugador);
this->agregarPanelBotones(arbol, false);
string resultado = this->arbolToString(arbol);
delete(arbol);
return resultado;
}
string EstadoEsperandoJugadores::getEscenarioJuego(int idJugador, string mensaje){
// MEtodo vacio: nunca puede llamarse
return "";
}
| [
"natlehmann@gmail.com@a9434d28-8610-e991-b0d0-89a272e3a296"
] | natlehmann@gmail.com@a9434d28-8610-e991-b0d0-89a272e3a296 |
f11881cd40174912829595ace166d31a779e92fc | 0f3122ce2aa1a5c4c5e0d38c3d8c590ce485ca03 | /winui/sideshow/tasks/TasksPropPage.h | 28f216278ec7fa5ca421b4a7ac0f8edccdae0dfb | [] | no_license | WindowsKernel/sdk71examples | 15cfee86bcb6621d13b91ca59bba425391b1b7a8 | 677997402e3bd3e51558464e50e4c33ebe1dd491 | refs/heads/master | 2022-04-27T21:10:51.846940 | 2015-01-19T18:35:09 | 2015-01-19T18:35:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,118 | h | // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
#pragma once
#include "stdafx.h"
#include "Tasks_h.h"
#include "resource.h"
class ATL_NO_VTABLE CTasksPropertyPage :
public CComObjectRootEx<CComSingleThreadModel>,
public CComCoClass<CTasksPropertyPage, &CLSID_TasksPropertyPage>,
public IPropertyPageImpl<CTasksPropertyPage>,
public CDialogImpl<CTasksPropertyPage>
{
public:
CTasksPropertyPage();
enum {IDD = IDD_TASKSPROPPAGE};
DECLARE_REGISTRY_RESOURCEID(IDR_TASKSAPPPROPPAGE)
BEGIN_COM_MAP(CTasksPropertyPage)
COM_INTERFACE_ENTRY(IPropertyPage)
END_COM_MAP()
BEGIN_MSG_MAP(CTasksPropertyPage)
CHAIN_MSG_MAP(IPropertyPageImpl<CTasksPropertyPage>)
END_MSG_MAP()
STDMETHOD(Show)(UINT nCmdShow);
STDMETHOD(Apply)();
};
OBJECT_ENTRY_AUTO(__uuidof(TasksPropertyPage), CTasksPropertyPage)
| [
"ganboing@gmail.com"
] | ganboing@gmail.com |
17c7855cd63ca7fee7e9ec4b282fa1d11af48749 | a029903af967d1d6331d265bbabe60e200f21b09 | /cpp_11/ring_classes/src/ring.h | 3cd536847a5335f1cbf6923ed6e4857878f50820 | [
"MIT"
] | permissive | pvavercak/cpp_course_sources | b693ec61ff668c2c522eb2a8d9b4ce20cf97beaa | 6e17b8b05173c8ee41d329492c3e02200bad054f | refs/heads/master | 2023-02-05T12:23:30.914463 | 2020-12-26T13:32:22 | 2020-12-26T13:32:22 | 320,414,112 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,305 | h | #ifndef RING_H
#define RING_H
template<typename T>
class ring
{
private:
int m_pos;
int m_size;
T *m_values;
public:
class iterator;
public:
ring(int size) :
m_pos(0), m_size(size), m_values(nullptr)
{
m_values = new T[m_size];
}
~ring()
{
delete [] m_values;
}
int size()
{
return m_size;
}
void add(T item)
{
m_values[m_pos++] = item;
if(m_pos == m_size)
{
m_pos = 0;
}
}
T &get(int pos)
{
return m_values[pos];
}
iterator begin()
{
return iterator(0, *this);
}
iterator end()
{
return iterator(m_size, *this);
}
};
template<typename T>
class ring<T>::iterator
{
private:
int m_pos;
ring &m_ring;
public:
iterator(int pos, ring &a_ring):
m_pos(pos), m_ring(a_ring)
{
}
bool operator!=(const iterator &other) const
{
return m_pos != other.m_pos;
}
// prefix operator
iterator &operator++()
{
++m_pos;
return *this;
}
// postfix operator
iterator &operator++(int)
{
++m_pos;
return *this;
}
T &operator*()
{
return m_ring.get(m_pos);
}
};
#endif // RING_H | [
"patrik.vavercak@innovatrics.com"
] | patrik.vavercak@innovatrics.com |
f67d302427993bb5384acf5b9d643adecc369f44 | 575731c1155e321e7b22d8373ad5876b292b0b2f | /examples/native/ios/Pods/boost-for-react-native/boost/units/base_units/astronomical/light_hour.hpp | 20cdb630d2f811dce656eabffac38708a0daca08 | [
"BSL-1.0",
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Nozbe/zacs | 802a84ffd47413a1687a573edda519156ca317c7 | c3d455426bc7dfb83e09fdf20781c2632a205c04 | refs/heads/master | 2023-06-12T20:53:31.482746 | 2023-06-07T07:06:49 | 2023-06-07T07:06:49 | 201,777,469 | 432 | 10 | MIT | 2023-01-24T13:29:34 | 2019-08-11T14:47:50 | JavaScript | UTF-8 | C++ | false | false | 1,255 | hpp | // Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2007-2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_HOUR_HPP_INCLUDED
#define BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_HOUR_HPP_INCLUDED
#include <boost/units/scaled_base_unit.hpp>
#include <boost/units/static_rational.hpp>
#include <boost/units/scale.hpp>
#include <boost/units/base_units/astronomical/light_second.hpp>
namespace boost {
namespace units {
namespace astronomical {
typedef scaled_base_unit<boost::units::astronomical::light_second_base_unit, scale<3600, static_rational<1> > > light_hour_base_unit;
} // namespace astronomical
template<>
struct base_unit_info<astronomical::light_hour_base_unit> {
static const char* name() { return("light hour"); }
static const char* symbol() { return("lhr"); }
};
} // namespace units
} // namespace boost
#endif // BOOST_UNIT_SYSTEMS_ASTRONOMICAL_LIGHT_HOUR_HPP_INCLUDED
| [
"radexpl@gmail.com"
] | radexpl@gmail.com |
fb1eeabfb798ee332482410a9da40b090d03e502 | cdfde37ecd614fdb41e9306f9b90e14a664cea99 | /src/txdb.h | 066d0a701ebbc0959cb1435e5de3ba757a997aa1 | [
"MIT"
] | permissive | digital50/PIVX-master-test-mod | 12b0fd08c5ded9ff0978b20bf64395142d18ea69 | 57b70194b5c1277b87b537c2b92af4b597cf0224 | refs/heads/master | 2021-04-29T23:32:44.394988 | 2018-02-14T23:56:04 | 2018-02-14T23:56:04 | 121,557,911 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,151 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2016-2017 The GoCoinMe developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_TXDB_H
#define BITCOIN_TXDB_H
#include "leveldbwrapper.h"
#include "main.h"
#include "primitives/zerocoin.h"
#include <map>
#include <string>
#include <utility>
#include <vector>
class CCoins;
class uint256;
//! -dbcache default (MiB)
static const int64_t nDefaultDbCache = 100;
//! max. -dbcache in (MiB)
static const int64_t nMaxDbCache = sizeof(void*) > 4 ? 4096 : 1024;
//! min. -dbcache in (MiB)
static const int64_t nMinDbCache = 4;
/** CCoinsView backed by the LevelDB coin database (chainstate/) */
class CCoinsViewDB : public CCoinsView
{
protected:
CLevelDBWrapper db;
public:
CCoinsViewDB(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
bool GetCoins(const uint256& txid, CCoins& coins) const;
bool HaveCoins(const uint256& txid) const;
uint256 GetBestBlock() const;
bool BatchWrite(CCoinsMap& mapCoins, const uint256& hashBlock);
bool GetStats(CCoinsStats& stats) const;
};
/** Access to the block database (blocks/index/) */
class CBlockTreeDB : public CLevelDBWrapper
{
public:
CBlockTreeDB(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
private:
CBlockTreeDB(const CBlockTreeDB&);
void operator=(const CBlockTreeDB&);
public:
bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
bool ReadBlockFileInfo(int nFile, CBlockFileInfo& fileinfo);
bool WriteBlockFileInfo(int nFile, const CBlockFileInfo& fileinfo);
bool ReadLastBlockFile(int& nFile);
bool WriteLastBlockFile(int nFile);
bool WriteReindexing(bool fReindex);
bool ReadReindexing(bool& fReindex);
bool ReadTxIndex(const uint256& txid, CDiskTxPos& pos);
bool WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >& list);
bool WriteFlag(const std::string& name, bool fValue);
bool ReadFlag(const std::string& name, bool& fValue);
bool WriteInt(const std::string& name, int nValue);
bool ReadInt(const std::string& name, int& nValue);
bool LoadBlockIndexGuts();
};
class CZerocoinDB : public CLevelDBWrapper
{
public:
CZerocoinDB(size_t nCacheSize, bool fMemory = false, bool fWipe = false);
private:
CZerocoinDB(const CZerocoinDB&);
void operator=(const CZerocoinDB&);
public:
bool WriteCoinMint(const libzerocoin::PublicCoin& pubCoin, const uint256& txHash);
bool ReadCoinMint(const CBigNum& bnPubcoin, uint256& txHash);
bool WriteCoinSpend(const CBigNum& bnSerial, const uint256& txHash);
bool ReadCoinSpend(const CBigNum& bnSerial, uint256& txHash);
bool EraseCoinMint(const CBigNum& bnPubcoin);
bool EraseCoinSpend(const CBigNum& bnSerial);
bool WriteAccumulatorValue(const uint32_t& nChecksum, const CBigNum& bnValue);
bool ReadAccumulatorValue(const uint32_t& nChecksum, CBigNum& bnValue);
bool EraseAccumulatorValue(const uint32_t& nChecksum);
};
#endif // BITCOIN_TXDB_H
| [
"35665802+digital50@users.noreply.github.com"
] | 35665802+digital50@users.noreply.github.com |
1938e73a3f94da5ee44381ca064da36bf4d3379f | 111aab0f5414de9e5afe55b33de08fb8dc09f9ec | /Lab04/Rect.h | 8daaf8e5da0f9a087c800b8437cb855703744e33 | [] | no_license | zencipher/Object-Oriented-Programming | d246950cbc6ad0008228b3121d5111a9ccdc9edd | b4bb05aff161a4dfbdef20f8586b71d5f89a7de0 | refs/heads/master | 2020-03-15T03:42:52.230756 | 2018-05-06T22:56:50 | 2018-05-06T22:56:50 | 131,948,836 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,600 | h | #define Rect_h
#include <string>
using namespace std;
class Vec {
public:
float x,y;
Vec(float x,float y){
this->x = x;
this->y = y;
}
Vec(){
this->x = 0;
this->y = 0;
}
void setX(float x) {
this->x = x;
}
float getX() const{
return this->x;
}
void setY(float y){
this->y = y;
}
float getY() const{
return y;
}
void add(Vec v){
this->x +=v.getX();
this->y+= v.getY();
}
void print(){
cout << "(" << x << " ," << y << ")";
}
};
class Rect {
public:
float x, y, width, height;
Rect(float x, float y, float width, float height){
this->x = x;
this->y = y;
this->width = width;
this->height = height;
}
Rect(){
this->x = 0;
this->y = 0;
this->width = 0;
this->height = 0;
}
void setX(float x) {
this->x = x;
}
float getX() const{
return this->x;
}
void setY(float y){
this->y = y;
}
float getY() const{
return y;
}
void setWidth(float width){
this->width = width;
}
float getWidth() const{
return width;
}
void setHeight(float height){
this->height = height;
}
float getHeight() const{
return height;
}
bool contains(Vec poop){
if(poop.getY() < y && poop.getY() > (y - height) && poop.getX() < (x + width) && poop.getX() > x){
return true;
}
return false;
}
};
| [
"noreply@github.com"
] | noreply@github.com |
9cabeb829f1e05c1dea91a1bec256cfd8b748b74 | 6bd5b1e6d3ba96ffbd5e02aebddedf9ba7883ad5 | /CDTestFramework/txFourPeakSurfacePlaneQuery.h | b584c359bd6f6a0cb612a88d4aeaa80040ce153c | [] | no_license | tianxiao/opcode-CDTestFramework | 75f2d6c2297a9edaa770bfb60dd467f9fe2e319f | 17ea4ee74870cc317610e122a06f1f3ed186aef0 | refs/heads/master | 2021-03-12T19:35:55.741973 | 2013-05-14T05:42:23 | 2013-05-14T05:42:23 | 8,042,802 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,153 | h | #pragma once
#include "CollisionTest.h"
class SurfaceImporter;
class TXSurfaceDrawer;
class TXOpcodeModelBuilder;
class txMesh;
class txTriSurfaceData;
class txFourPeakSurfacePlaneQuery:
public CollisionTest
{
public:
txFourPeakSurfacePlaneQuery(void);
~txFourPeakSurfacePlaneQuery(void);
virtual void Init();
virtual void Release();
virtual void PerformTest();
virtual void Select();
virtual void Deselect();
virtual void KeyboardCallback(unsigned char key, int x, int y);
virtual void MouseCallback(int button, int state, int x, int y);
virtual void MotionCallback(int x, int y);
TwBar *mBar;
int pfappset;
float mZ;
OpcodeSettings mSettings;
float mGamma;
float mAlpha;
float mBeta;
Model mPlane;
MeshInterface mMeshI;
//float mVB[4*3];
//size_t mFB[2*3];
float *mVB;
size_t *mFB;
// Mesh from the surface
SurfaceImporter *surface;
txMesh *mesh;
TXSurfaceDrawer *drawer;
TXOpcodeModelBuilder *modelbuilder;
// Initial from surf
txTriSurfaceData *surf;
SurfaceImporter *surface2;
txTriSurfaceData *surf2;
txMesh *mesh2;
TXSurfaceDrawer *drawer2;
TXOpcodeModelBuilder *modelbuilder2;
};
| [
"tianxiao987@gmail.com"
] | tianxiao987@gmail.com |
f28498640f2d91291fbdeba827e47b7ec697c7b8 | 860d313f73a0a27b6b977de2da5409737cd04a6c | /VulkanTest/VulkanTest/MathUtils.h | 9aa37d41cdf8d575c59e220149ec40cd85886e71 | [] | no_license | GTSKA/Moebius | ec60bab25bffc574e4f8ff7337c3f24d97ab8b97 | cfb67fbf59cab5399b98153d613fb495aaceab4f | refs/heads/master | 2020-03-17T10:59:19.686735 | 2018-08-24T04:06:11 | 2018-08-24T04:06:11 | 133,532,826 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,535 | h | #pragma once
#ifndef GLfloat
typedef float GLfloat;
#endif
#define M_PI 3.141593
//Vector2
class Vector2
{
public:
//Constructors
Vector2() : x(0.0f), y(0.0f) {}
Vector2(GLfloat _x, GLfloat _y) : x(_x), y(_y) {}
Vector2(GLfloat * pArg) : x(pArg[0]), y(pArg[1]) {}
Vector2(Vector2 & vector) : x(vector.x), y(vector.y) {}
Vector2(const Vector2& vector) : x(vector.x), y(vector.y) {};
//Vector's operations
GLfloat Length();
Vector2 & Normalize();
Vector2 operator + (Vector2 & vector);
Vector2 & operator += (Vector2 & vector);
Vector2 operator - ();
Vector2 operator - (Vector2 & vector);
Vector2 & operator -= (Vector2 & vector);
Vector2 operator * (GLfloat k);
Vector2 & operator *= (GLfloat k);
Vector2 operator / (GLfloat k);
Vector2 & operator /= (GLfloat k);
Vector2 & operator = (Vector2 & vector);
Vector2 & operator = (const Vector2 & vector);
Vector2 Modulate(Vector2 & vector);
GLfloat Dot(Vector2 & vector);
//access to elements
GLfloat operator [] (unsigned int idx);
//data members
GLfloat x;
GLfloat y;
};
//Vector3
class Vector3
{
public:
//Constructors
Vector3() : x(0.0f), y(0.0f), z(0.0f) {}
Vector3(GLfloat _x, GLfloat _y, GLfloat _z) : x(_x), y(_y), z(_z) {}
Vector3(GLfloat * pArg) : x(pArg[0]), y(pArg[1]), z(pArg[2]) {}
Vector3(Vector3 & vector) : x(vector.x), y(vector.y), z(vector.z) {}
Vector3(const Vector3 & vector) : x(vector.x), y(vector.y), z(vector.z) {}
//Vector's operations
GLfloat Length();
Vector3 & Normalize();
Vector3 operator + (Vector3 & vector);
Vector3 & operator += (Vector3 & vector);
Vector3 operator - ();
Vector3 operator - (Vector3 & vector);
Vector3 & operator -= (Vector3 & vector);
Vector3 operator * (GLfloat k);
Vector3 & operator *= (GLfloat k);
Vector3 operator / (GLfloat k);
Vector3 & operator /= (GLfloat k);
Vector3 & operator = (Vector3 & vector);
Vector3 & operator = (const Vector3 & vector);
Vector3 Modulate(Vector3 & vector);
GLfloat Dot(Vector3 & vector);
Vector3 Cross(Vector3 & vector);
static Vector3 Cross(Vector3&, Vector3&);
static GLfloat Dot(Vector3&, Vector3&);
static GLfloat Dist(Vector3&, Vector3&);
//access to elements
GLfloat operator [] (unsigned int idx);
// data members
GLfloat x;
GLfloat y;
GLfloat z;
};
class Matrix;
//Vector4
class Vector4
{
public:
//Constructors
Vector4() : x(0.0f), y(0.0f), z(0.0f), w(0.0f) {}
Vector4(GLfloat _x, GLfloat _y, GLfloat _z) : x(_x), y(_y), z(_z), w(1.0f) {}
Vector4(GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) : x(_x), y(_y), z(_z), w(_w) {}
Vector4(GLfloat * pArg) : x(pArg[0]), y(pArg[1]), z(pArg[2]), w(pArg[3]) {}
Vector4(Vector3 & vector) : x(vector.x), y(vector.y), z(vector.z), w(1.0f) {}
Vector4(Vector3 & vector, GLfloat _w) : x(vector.x), y(vector.y), z(vector.z), w(_w) {}
Vector4(Vector4 & vector) : x(vector.x), y(vector.y), z(vector.z), w(vector.w) {}
Vector4(const Vector4 & vector) : x(vector.x), y(vector.y), z(vector.z), w(vector.w) {}
//Vector's operations
GLfloat Length();
Vector4 & Normalize();
Vector4 operator + (Vector4 & vector);
Vector4 & operator += (Vector4 & vector);
Vector4 operator - ();
Vector4 operator - (Vector4 & vector);
Vector4 & operator -= (Vector4 & vector);
Vector4 operator * (GLfloat k);
Vector4 & operator *= (GLfloat k);
Vector4 operator / (GLfloat k);
Vector4 & operator /= (GLfloat k);
Vector4 & operator = (Vector4 & vector);
Vector4 & operator = (const Vector4 & vector);
Vector4 Modulate(Vector4 & vector);
GLfloat Dot(Vector4 & vector);
Vector3 xyz();
//matrix multiplication
Vector4 operator * (Matrix & m);
//access to elements
GLfloat operator [] (unsigned int idx);
//data members
GLfloat x;
GLfloat y;
GLfloat z;
GLfloat w;
};
//Matrix 4 X 4
class Matrix
{
public:
//constructors
Matrix() {}
Matrix(GLfloat val);
Matrix(Matrix & mat);
// Matrix operations
Matrix & SetZero();
Matrix & SetIdentity();
Matrix & SetRotationX(GLfloat angle);
Matrix & SetRotationY(GLfloat angle);
Matrix & SetRotationZ(GLfloat angle);
Matrix & SetRotationAngleAxis(float angle, float x, float y, float z);
Matrix & SetScale(GLfloat scale);
Matrix & SetScale(GLfloat scaleX, GLfloat scaleY, GLfloat scaleZ);
Matrix & SetScale(GLfloat * pScale);
Matrix & SetScale(Vector3 &scaleVec);
Matrix & SetTranslation(GLfloat x, GLfloat y, GLfloat z);
Matrix & SetTranslation(GLfloat *pTrans);
Matrix & SetTranslation(Vector3 &vec);
Matrix & SetPerspective(GLfloat fovY, GLfloat aspect, GLfloat nearPlane, GLfloat farPlane);
Matrix & LookAt(Vector3 pos, Vector3 target, Vector3 Up);
Matrix Transpose();
Matrix operator + (Matrix & mat);
Matrix & operator += (Matrix & mat);
Matrix operator - (Matrix & mat);
Matrix &operator -= (Matrix & mat);
Matrix operator * (Matrix & mat);
Matrix operator * (GLfloat k);
Matrix & operator *= (GLfloat k);
Vector4 operator * (Vector4 & vec);
Matrix & operator = (Matrix & mat);
//data members
GLfloat m[4][4];
};
//Line
class Line
{
public:
Line() {}
Line(Vector3& _p0, Vector3& _d)
{
p0 = _p0;
d = _d;
}
float DistanceToPoint(Vector3&);
static bool ClosestPoint(Line&, Line&, Vector3&, Vector3&);
static GLfloat Distance(Line&, Line&);
static GLfloat DistanceSq(Line&, Line&);
Vector3 p0;
Vector3 d;
};
//Plane
class Plane
{
public:
Plane();
Plane(const GLfloat*);
Plane(Vector4);
Plane(GLfloat, GLfloat, GLfloat, GLfloat);
Plane(Vector3&, GLfloat);
//loads the plane from a point on the surface and a normal vector
static Plane ConstructFromPointNormal(Vector3&, Vector3&);
//loads the plane from a point on the surface and two vectors in the plane
static Plane ConstructFromPointVectors(Vector3&, Vector3&, Vector3&);
//loads the plane from 3 points on the surface
static Plane ConstructFromPoints(Vector3&, Vector3&, Vector3&);
// Normalization
Plane Normalize();
GLfloat UnsignedDistance(Vector3&);
GLfloat SignedDistance(Vector3&);
Vector3 ClosestPoint(Vector3&);
//determines the intersect of the line defined by the points V1 and V2 with the plane.
//If there is no intersection, Hit will be false.
Vector3 IntersectLine(Vector3&, Vector3&, bool&);
//determines the intersect of the line defined by the points V1 and V2 with the plane.
//Returns the point of intersection. Origin is returned if no intersection exists.
Vector3 IntersectLine(Vector3&, Vector3&);
//Paramaterize the line with the variable t such that t = 0 is V1 and t = 1 is V2.
//returns the t for this line that lies on this plane.
GLfloat IntersectLineRatio(Vector3&, Vector3&);
Vector3 IntersectLine(Line&);
//dot product of a plane and a 4D vector
static GLfloat Dot(Plane&, Vector4&);
//dot product of a plane and a 3D coordinate
static GLfloat DotCoord(Plane&, Vector3&);
//dot product of a plane and a 3D normal
static GLfloat DotNormal(Plane&, Vector3&);
static bool PlanePlaneIntersection(Plane&, Plane&, Line&);
__forceinline Vector3 Plane::Normal() const
{
return Vector3(a, b, c);
}
__forceinline Plane Flip()
{
Plane result;
result.a = -a;
result.b = -b;
result.c = -c;
result.d = -d;
return result;
}
bool operator == (const Plane& p) const;
bool operator != (const Plane& p) const;
friend Plane operator *(GLfloat k, const Plane& p);
Plane operator * (GLfloat) const;
Plane operator / (GLfloat) const;
Plane& operator *= (GLfloat);
Plane& operator /= (GLfloat);
operator const GLfloat*() const;
operator GLfloat*();
//the (a, b, c, d) in a*x + b*y + c*z + d = 0.
GLfloat a, b, c, d;
}; | [
"gene.trigo@gameloft.com"
] | gene.trigo@gameloft.com |
a7023371df2afbfceadd8079d007ac11ed8f6818 | b780425ed05bf7956c20941202091803aa081184 | /src/governance-votedb.h | cdb39598d60123b2a9a6fc19c40be671276d296d | [
"MIT"
] | permissive | mycoinworld/SuperMasterNode | 8c86ed4b89643444cc7d53cee6beed144f07f7d3 | a3f4c83455ee1c437f0fd4bf06e8147333d63dd4 | refs/heads/master | 2020-07-20T18:50:04.857690 | 2019-09-06T02:37:43 | 2019-09-06T02:37:43 | 206,694,267 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,284 | h | // Copyright (c) 2014-2017 The SuperMasterNode developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef GOVERNANCE_VOTEDB_H
#define GOVERNANCE_VOTEDB_H
#include <list>
#include <map>
#include "governance-vote.h"
#include "serialize.h"
#include "uint256.h"
/**
* Represents the collection of votes associated with a given CGovernanceObject
* Recently received votes are held in memory until a maximum size is reached after
* which older votes a flushed to a disk file.
*
* Note: This is a stub implementation that doesn't limit the number of votes held
* in memory and doesn't flush to disk.
*/
class CGovernanceObjectVoteFile
{
public: // Types
typedef std::list<CGovernanceVote> vote_l_t;
typedef vote_l_t::iterator vote_l_it;
typedef vote_l_t::const_iterator vote_l_cit;
typedef std::map<uint256,vote_l_it> vote_m_t;
typedef vote_m_t::iterator vote_m_it;
typedef vote_m_t::const_iterator vote_m_cit;
private:
static const int MAX_MEMORY_VOTES = -1;
int nMemoryVotes;
vote_l_t listVotes;
vote_m_t mapVoteIndex;
public:
CGovernanceObjectVoteFile();
CGovernanceObjectVoteFile(const CGovernanceObjectVoteFile& other);
/**
* Add a vote to the file
*/
void AddVote(const CGovernanceVote& vote);
/**
* Return true if the vote with this hash is currently cached in memory
*/
bool HasVote(const uint256& nHash) const;
/**
* Retrieve a vote cached in memory
*/
bool GetVote(const uint256& nHash, CGovernanceVote& vote) const;
int GetVoteCount() {
return nMemoryVotes;
}
std::vector<CGovernanceVote> GetVotes() const;
CGovernanceObjectVoteFile& operator=(const CGovernanceObjectVoteFile& other);
void RemoveVotesFromMasternode(const COutPoint& outpointMasternode);
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
{
READWRITE(nMemoryVotes);
READWRITE(listVotes);
if(ser_action.ForRead()) {
RebuildIndex();
}
}
private:
void RebuildIndex();
};
#endif
| [
"537072749@qq.com"
] | 537072749@qq.com |
1acf6a1a2b09386629d1cf04d85eb8c5cfc9c1ea | 08b8cf38e1936e8cec27f84af0d3727321cec9c4 | /data/crawl/squid/new_hunk_7457.cpp | 7fa816d31ad57e04b8cb9ef6208ba1c017ee8675 | [] | no_license | ccdxc/logSurvey | eaf28e9c2d6307140b17986d5c05106d1fd8e943 | 6b80226e1667c1e0760ab39160893ee19b0e9fb1 | refs/heads/master | 2022-01-07T21:31:55.446839 | 2018-04-21T14:12:43 | 2018-04-21T14:12:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 441 | cpp | storeAppendPrintf(sentry, "{PINGS ACKED: %8d %3d%%}\n",
e->stats.pings_acked,
percent(e->stats.pings_acked, e->stats.pings_sent));
storeAppendPrintf(sentry, "{IGNORED : %8d %3d%%}\n",
e->stats.ignored_replies,
percent(e->stats.ignored_replies, e->stats.pings_acked));
storeAppendPrintf(sentry, "{Histogram of PINGS ACKED:}\n");
for (op = ICP_OP_INVALID; op < ICP_OP_END; op++) {
if (e->stats.counts[op] == 0)
| [
"993273596@qq.com"
] | 993273596@qq.com |
c1dcc11b6a3547178c25628ca7a832414205da56 | f98439a5ea465239a988f0d0193410f245ccaf5b | /Atomic/AtHttpServerThread.h | 395e2f98566174c8991d61f716276b60665262e0 | [
"MIT"
] | permissive | denisbider/Atomic | 6f0b6040dfdd71f80aa6bb30c1577a26d4136202 | 8e8e979a6ef24d217a77f17fa81a4129f3506952 | refs/heads/master | 2021-07-01T00:27:29.102487 | 2021-03-05T19:21:49 | 2021-03-05T19:21:49 | 220,709,742 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 591 | h | #pragma once
#include "AtHttpServer.h"
#include "AtWebServerThread.h"
namespace At
{
class HttpServerThread : public WebServerThread<HttpServer>
{
public:
HttpServerThread() : m_httpEvent(Event::CreateAuto) {}
private:
Event m_httpEvent;
OVERLAPPED m_ovl;
Str m_ioBuf;
bool m_responseSent;
void WorkPoolThread_ProcessWorkItem(void* pvWorkItem) override;
// If response version is not yet set (is 0.0), sets version to 1.0 or 1.1, depending on request version.
void SendPreparedResponse(HttpRequest& req, HTTP_RESPONSE* resp) override;
};
}
| [
"denisbider@users.noreply.github.com"
] | denisbider@users.noreply.github.com |
51a4096e53a7060bf168a6245e6e71d5869ac5ad | 4fb6ac5060727f05abd056cf9f3ee830a0734aee | /google/codejam/2016/round_1c/sol.cpp | 4aacad26718c7ea48146ff909978d287d625281e | [] | no_license | booneng/competitive_programming | 6141c1ab60e49ffd1ae1cf4ede018622b122ed6b | b6a39e1574c4b8b513945d6fa6e9075a4f458370 | refs/heads/master | 2021-04-15T12:50:59.351207 | 2019-07-23T08:01:06 | 2019-07-23T08:01:06 | 126,816,788 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 693 | cpp | #include <iostream>
using namespace std;
int main() {
int tt;
scanf("%d", &tt);
for (int qq = 1; qq <= tt; qq++) {
printf("Case #%d: ", qq);
int b;
long long m;
cin >> b >> m;
if (m > (1LL << (b - 2))) {
puts("IMPOSSIBLE");
continue;
}
puts("POSSIBLE");
for (int i = 0; i < b; i++) {
for (int j = 0; j < b; j++) {
if (i < j && j < b - 1) {
putchar('1');
continue;
}
if (j == b - 1 && (i == 0 || ((m - 1) & (1LL << (i - 1))))) {
putchar('1');
continue;
}
putchar('0');
}
putchar('\n');
}
}
return 0;
}
| [
"ohbooneng@gmail.com"
] | ohbooneng@gmail.com |
b6daf44989a79fb118f0b788df0fa3f54418ba8d | f1576b9e53223ad954cae709ed8930364817e859 | /Staticlist.h | dec8615aba535c5544a91eecf17bf7f06bb406de | [] | no_license | glbnba/DTLib | 89ad778153f2d9368ab7740d64fce6c2dd3608d3 | 7861ec2cbaf7ce7ed210c7b0b38f9c97ab41fd5f | refs/heads/master | 2020-10-01T21:05:24.157820 | 2020-01-03T14:48:53 | 2020-01-03T14:48:53 | 227,625,050 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 503 | h | #ifndef STATICLIST_H
#define STATICLIST_H
#include "seqlist.h"
namespace DTLib
{
template <typename T, int N>
class StaticList: public SeqList<T>
{
protected:
T m_space[N]; //顺序存储空间，N为模板参数
public:
StaticList() //指定父类成员的具体值
{
this->m_array = m_space; //将父类的m_array这个指针指向子类的m_space这个数组
this->m_length = 0;
}
int capacity() const
{
return N;
}
};
}
#endif // STATICLIST_H
| [
"glbnba@163.com"
] | glbnba@163.com |
206adae0d6d1948fcfcea384b50e28588a36113a | ca31410f6fe550b89e38bce5f3e0e66ff8af05ae | /AprioriAlgorithm/1.cpp | 94e5e7f2918bfc89cd3ff333f7499c2f3cd6105a | [] | no_license | lakshg13/Data_Mining | a5d1db212cbbc111c4443fa220d6ee889c659921 | 414d4d6ea16528b73ceaeb080644b9da0c580aac | refs/heads/master | 2021-01-21T17:01:53.169106 | 2016-03-27T13:25:38 | 2016-03-27T13:25:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 684 | cpp | #include <iostream>
#include <set>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
int main(){
set<int> set1;
set<int> set2;
set1.insert(1);
set1.insert(2);
set1.insert(3);
set1.insert(4);
set1.insert(5);
set1.insert(6);
set1.insert(7);
set2.insert(2);
set2.insert(3);
set2.insert(4);
set<int> result;
set_difference(set1.begin(), set1.end(), set2.begin(), set2.end(),inserter(result, result.end()));
for (set<int>::iterator it = result.begin(); it != result.end(); it++) {
cout << *it << " ";
}
cout << endl;
return 0;
} | [
"kumarsasikanth@gmail.com"
] | kumarsasikanth@gmail.com |
3caad179787617c77830865c86a3a3608e8962a5 | 693779e95b172303fdfb68acd919ae2daae22e2c | /sdk/fido/fido_packets.h | 578f90ac6bfd9ddf8ff417e78c8f72ed0a8906c7 | [] | no_license | ericwhitestone/wwiv | 09660136c709714e249326df11e38a65442b8d51 | 2ea29d970ab2082d12b48ecc161fa28d4ae4282e | refs/heads/master | 2021-01-20T10:00:31.337399 | 2017-03-04T14:43:29 | 2017-03-04T14:43:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,149 | h | /**************************************************************************/
/* */
/* WWIV Version 5.x */
/* Copyright (C)2016-2017, WWIV Software Services */
/* */
/* 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 __INCLUDED_SDK_FIDO_FIDO_PACKETS_H__
#define __INCLUDED_SDK_FIDO_FIDO_PACKETS_H__
#include <cstdint>
#include <set>
#include <string>
#include <vector>
#include "core/file.h"
#include "sdk/config.h"
#include "sdk/networks.h"
#include "sdk/net.h"
namespace wwiv {
namespace sdk {
namespace fido {
#ifndef __MSDOS__
#pragma pack(push, 1)
#endif // __MSDOS__
/*
Type-2 Packet Format (proposed, but currently in use)
-----------------------------------------------------
Field Ofs Siz Type Description Expected value(s)
------- --- --- ---- -------------------------- -----------------
OrgNode 0x0 2 Word Origination node address 0-65535
DstNode 2 2 Word Destination node address 1-65535
Year 4 2 Int Year packet generated 19??-2???
Month 6 2 Int Month " " 0-11 (0=Jan)
Day 8 2 Int Day " " 1-31
Hour A 2 Int Hour " " 0-23
Min C 2 Int Minute " " 0-59
Sec E 2 Int Second " " 0-59
Baud 10 2 Int Baud Rate (not in use) ????
PktVer 12 2 Int Packet Version Always 2
OrgNet 14 2 Word Origination net address 1-65535
DstNet 16 2 Word Destination net address 1-65535
PrdCodL 18 1 Byte FTSC Product Code (lo) 1-255
* PVMajor 19 1 Byte FTSC Product Rev (major) 1-255
Password 1A 8 Char Packet password A-Z,0-9
* QOrgZone 22 2 Int Orig Zone (ZMailQ,QMail) 1-65535
* QDstZone 24 2 Int Dest Zone (ZMailQ,QMail) 1-65535
Filler 26 2 Byte Spare Change ?
* CapValid 28 2 Word CW Byte-Swapped Valid Copy BitField
* PrdCodH 2A 1 Byte FTSC Product Code (hi) 1-255
* PVMinor 2B 1 Byte FTSC Product Rev (minor) 1-255
* CapWord 2C 2 Word Capability Word BitField
* OrigZone 2E 2 Int Origination Zone 1-65535
* DestZone 30 2 Int Destination Zone 1-65535
* OrigPoint 32 2 Int Origination Point 1-65535
* DestPoint 34 2 Int Destination Point 1-65535
* ProdData 36 4 Long Product-specific data Whatever
PktTerm 3A 2 Word Packet terminator 0000
*/
struct packet_header_2p_t { /* FSC-0039 Type 2.+ */
uint16_t orig_node,
dest_node,
year,
month,
day,
hour,
minute,
second,
baud,
packet_ver,
orig_net,
dest_net;
uint8_t product_code_low;
uint8_t product_rev_major;
char password[8];
uint16_t qm_orig_zone,
qm_dest_zone;
uint8_t filler[2];
uint16_t capabilities_valid;
uint8_t product_code_high,
product_rev_minor;
uint16_t capabilities,
orig_zone,
dest_zone,
orig_point,
dest_point;
uint32_t product_data;
};
/*
Stored Message (*.MSG format)
From http://ftsc.org/docs/fts-0001.016
-----------------------------------------------------
Message =
fromUserName(36) (* Null terminated *)
toUserName(36) (* Null terminated *)
subject(72) (* see FileList below *)
DateTime (* message body was last edited *)
timesRead (* number of times msg has been read *)
destNode (* of message *)
origNode (* of message *)
cost (* in lowest unit of originator's
currency *)
origNet (* of message *)
destNet (* of message *)
destZone (* of message *)
origZone (* of message *)
destPoint (* of message *)
origPoint (* of message *)
replyTo (* msg to which this replies *)
AttributeWord
nextReply (* msg which replies to this *)
text(unbounded) (* Null terminated *)
*/
struct fido_stored_message_t {
char from[36];
char to[36];
char subject[72];
char date_time[20];
int16_t times_read,
dest_node,
orig_node,
cost,
orig_net,
dest_net,
dest_zone,
orig_zone,
dest_point,
orig_point,
reply_to,
attribute,
next_reply;
};
static_assert(sizeof(packet_header_2p_t) == 58, "packet_header_2p_t != 58 bytes");
static_assert(sizeof(fido_stored_message_t) == 190, "fido_stored_message_t != 190 bytes");
/*
,-------------------------------------------------------------------.
| Name | Offset | Bytes | Type | Description |
+-----------+--------+-------+-------+------------------------------+
| msgType | 0 | 2 | Int16 | MUST have a value of 2 |
| origNode | 2 | 2 | Int16 | Node number packet is from |
| destNode | 4 | 2 | Int16 | Node number packet is to |
| origNet | 6 | 2 | Int16 | Network number packet is from|
| destNet | 8 | 2 | Int16 | Network number packet is to |
| attribute | 10 | 2 | Int16 | See Notes |
| cost | 12 | 2 | Int16 | See Notes |
`-----------+--------+-------+-------+------------------------------'
*/
struct fido_packed_message_t {
uint16_t message_type,
orig_node,
dest_node,
orig_net,
dest_net,
attribute,
cost;
};
#ifndef __MSDOS__
#pragma pack(pop)
#endif // __MSDOS__
/////////////////////////////////////////////////////////////////////////////
//
// Non DOS packed structs and classes.
//
//
// Private message
static constexpr uint16_t MSGPRIVATE = 0x0001;
// High priority
static constexpr uint16_t MSGCRASH = 0x0002;
// Read by addressee
static constexpr uint16_t MSGREAD = 0x0004;
// Has been sent
static constexpr uint16_t MSGSENT = 0x0008;
// File attached to msg
static constexpr uint16_t MSGFILE = 0x0010;
// In transit
static constexpr uint16_t MSGTRANSIT = 0x0020;
// Unknown node
static constexpr uint16_t MSGORPHAN = 0x0040;
// Kill after mailing
static constexpr uint16_t MSGKILL = 0x0080;
// Message was entered here
static constexpr uint16_t MSGLOCAL = 0x0100;
// Hold for pickup
static constexpr uint16_t MSGHOLD = 0x0200;
// Unused
static constexpr uint16_t MSGUNUSED = 0x0400;
// File req uest
static constexpr uint16_t MSGFREQ = 0x0800;
// Return receipt request
static constexpr uint16_t MSGRRREQ = 0x1000;
// Is return receipt
static constexpr uint16_t MSGISRR = 0x2000;
// Audit request
static constexpr uint16_t MSGAREQ = 0x4000;
// File update request
static constexpr uint16_t MSGFUPDREQ = 0x8000;
struct fido_variable_length_header_t {
std::string date_time;
std::string to_user_name;
std::string from_user_name;
std::string subject;
std::string text;
};
/**
* Representes a message in a .PKT file in FidoNET.
*/
class FidoPackedMessage {
public:
FidoPackedMessage(const fido_packed_message_t& h, const fido_variable_length_header_t& v)
: nh(h), vh(v) {}
FidoPackedMessage() {}
virtual ~FidoPackedMessage() {}
fido_packed_message_t nh{};
fido_variable_length_header_t vh;
};
/**
* Representes a .MSG file in FidoNET.
*/
class FidoStoredMessage {
public:
FidoStoredMessage(const fido_stored_message_t& h, const std::string& t): nh(h), text(t) {}
FidoStoredMessage() {}
virtual ~FidoStoredMessage() {}
fido_stored_message_t nh = {};
std::string text;
};
bool write_fido_packet_header(File& f, packet_header_2p_t& header);
bool write_packed_message(File& f, FidoPackedMessage& packet);
bool write_stored_message(File& f, FidoStoredMessage& packet);
enum class ReadPacketResponse { OK, ERROR, END_OF_FILE };
ReadPacketResponse read_packed_message(File& file, FidoPackedMessage& packet);
ReadPacketResponse read_stored_message(File& file, FidoStoredMessage& packet);
} // namespace fido
} // namespace sdk
} // namespace wwiv
#endif // __INCLUDED_SDK_FIDO_FIDO_PACKETS_H__
| [
"rushfan@wwivbbs.org"
] | rushfan@wwivbbs.org |
d881a5f4a1a31e01725dd3065bbd6e1dae4899a4 | 28dcfe5ca774332193a0e9bd759228429bf1d8f2 | /Code/c++/assignments/assignment18/assignment18/tree.cpp | 4aadff853bc65ee5ac0fa4f001876914c8dd51df | [] | no_license | LeviSquires/School-Work | 41b442a5fde1003b37f59bee3d9f91cf6e915c8a | 647975e9f0fc44dbd2a2f28818cba353a71fae33 | refs/heads/master | 2020-05-22T13:11:55.624496 | 2014-10-08T15:58:25 | 2014-10-08T15:58:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26 | cpp | #include "tree.h"
| [
"squires_levi@hotmail.com"
] | squires_levi@hotmail.com |
38e9ba278d4152c25006a6648c3078bb9d22354e | c9c5c2e97f4a18fc34c198640478ee533ee3d2cf | /src/qt/cashcash/settings/settingsnetworkwidget.h | 5e27270b6629d9e20daa9843f06c9fdf22ad20f8 | [
"MIT"
] | permissive | cashcash-project/cashcash-2.0 | d0c64f909f645f605412f5a2f8a14dbabdf36748 | 18ce7648c6f973a18bf8918d3cf68ff220cf8a3d | refs/heads/master | 2023-05-30T23:50:25.245029 | 2021-07-08T22:45:06 | 2021-07-08T22:45:06 | 383,936,393 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 735 | h | // Copyright (c) 2019 The cashcash developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef SETTINGSNETWORKWIDGET_H
#define SETTINGSNETWORKWIDGET_H
#include <QWidget>
#include <QDataWidgetMapper>
#include "qt/cashcash/pwidget.h"
namespace Ui {
class SettingsNetworkWidget;
}
class SettingsNetworkWidget : public PWidget
{
Q_OBJECT
public:
explicit SettingsNetworkWidget(cashcashGUI* _window, QWidget *parent = nullptr);
~SettingsNetworkWidget();
void setMapper(QDataWidgetMapper *mapper);
private:
Ui::SettingsNetworkWidget *ui;
Q_SIGNALS:
void saveSettings() {};
};
#endif // SETTINGSNETWORKWIDGET_H
| [
"w.menezes@loro.com.co"
] | w.menezes@loro.com.co |
4b4cd6ea22517fb22ac62603d780e2e38aa144d6 | 9497932579bc42d3a8dbf57d2551412cbea1fc64 | /platform_game/story_script.h | d7d828b6f04a80e509884b293874532f10d34397 | [
"MIT"
] | permissive | resultant-gamedev/my_godot_modules | 73c03f574ed5837ef6ef1657bb8c2933f555b28a | 8b273b42ed1f40f98d91ef474eba7a2a3c4fc227 | refs/heads/master | 2021-01-19T02:15:11.258759 | 2016-02-05T03:26:34 | 2016-02-05T03:26:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,580 | h | //
// Created by gen on 15-6-13.
//
#ifndef GODOT_MASTER_SCRIPT_H
#define GODOT_MASTER_SCRIPT_H
#include "../../core/resource.h"
#include "../../core/ustring.h"
#include "../../scene/main/node.h"
class StoryScript;
class StoryScriptNode : public Node {
OBJ_TYPE(StoryScriptNode, Node);
private:
NodePath _camera_path;
Node *_camera;
Dictionary _params;
Ref<StoryScript> script_resource;
void update_camera();
protected:
void _notification(int p_notification);
static void _bind_methods();
public:
_FORCE_INLINE_ Node *camera() {return _camera;}
_FORCE_INLINE_ Dictionary params() {return _params;}
_FORCE_INLINE_ void set_camera_path(NodePath p_path) {_camera_path=p_path;update_camera();}
_FORCE_INLINE_ NodePath get_camera_path() {return _camera_path;}
_FORCE_INLINE_ void set_script_resource(Ref<StoryScript> p_resource) {script_resource=p_resource;}
_FORCE_INLINE_ Ref<StoryScript> get_script_resource() {return script_resource;}
bool run();
void over();
StoryScriptNode() {_params = Dictionary(true);}
};
class StoryScript : public Resource {
OBJ_TYPE(StoryScript, Resource);
private:
Node *_camera;
Dictionary _params;
StoryScriptNode *_node;
friend class StoryScriptNode;
protected:
static void _bind_methods();
public:
_FORCE_INLINE_ Node* camera() {return _camera;}
_FORCE_INLINE_ Dictionary params() {return _params;}
void run();
_FORCE_INLINE_ void over(){_node->over();}
_FORCE_INLINE_ StoryScript() {}
};
#endif //GODOT_MASTER_SCRIPT_H
| [
"z.rz2323721@gmail.com"
] | z.rz2323721@gmail.com |
bf353ca9bf92df03bec1d0a162d51e3d508f54b9 | 4016599a99ef8369e2cc665c451c4444e7af51c5 | /include/DateTime/Date.h | 3b438e6ac1d42adbf236b7e52a13b0b7b8b4e171 | [
"MIT"
] | permissive | TobiasHuber/datetime | 8b9ec12836af72108add4b6dee77c2fcb241d406 | 01002e0dd254e35481805342d461e4e42e866b54 | refs/heads/master | 2022-12-02T06:05:07.863308 | 2020-08-03T10:37:38 | 2020-08-03T10:37:38 | 284,647,387 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,434 | h | /*Copyright (c) 2020 TobiasHuber
This file is part of the DateTime library by TobiasHuber
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 DT_DATE_H
#define DT_DATE_H
#include "Time.h"
namespace dt
{
class Date
{
public:
uint64_t year;
uint64_t month;
uint64_t day;
uint64_t hour;
uint64_t minute;
uint64_t second;
uint64_t year_day;
uint64_t week_day;
static Date fromTime(const Time time);
Time toTime();
};
}
#endif | [
"tobias.huber2000@gmail.com"
] | tobias.huber2000@gmail.com |
ac9b81cbca8f2705ac4c11f7aabc9d2831e9d9a5 | 9a3b9d80afd88e1fa9a24303877d6e130ce22702 | /src/Providers/UNIXProviders/LogicalNetworkService/UNIX_LogicalNetworkService_DARWIN.hxx | b9422927876ff4c4ef49587a1abaa59a61c5c926 | [
"MIT"
] | permissive | brunolauze/openpegasus-providers | 3244b76d075bc66a77e4ed135893437a66dd769f | f24c56acab2c4c210a8d165bb499cd1b3a12f222 | refs/heads/master | 2020-04-17T04:27:14.970917 | 2015-01-04T22:08:09 | 2015-01-04T22:08:09 | 19,707,296 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,828 | hxx | //%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_OS_DARWIN
#ifndef __UNIX_LOGICALNETWORKSERVICE_PRIVATE_H
#define __UNIX_LOGICALNETWORKSERVICE_PRIVATE_H
#endif
#endif
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
1b736be2e8cb013923058329d42c9f75ae914a4b | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /chromeos/components/proximity_auth/proximity_auth_profile_pref_manager.h | 9e5bfb82babdcd743b68dbc11dc646215e85040f | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 3,406 | h | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_PROFILE_PREF_MANAGER_H_
#define CHROMEOS_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_PROFILE_PREF_MANAGER_H_
#include <memory>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "chromeos/components/proximity_auth/proximity_auth_pref_manager.h"
#include "components/account_id/account_id.h"
#include "components/prefs/pref_change_registrar.h"
class PrefService;
namespace base {
class DictionaryValue;
} // namespace base
namespace user_prefs {
class PrefRegistrySyncable;
} // namespace user_prefs
namespace proximity_auth {
// Implementation of ProximityAuthPrefManager for a logged in session with a
// user profile.
class ProximityAuthProfilePrefManager : public ProximityAuthPrefManager {
public:
// Creates a pref manager backed by preferences registered in
// |pref_service| (persistent across browser restarts). |pref_service| should
// have been registered using RegisterPrefs(). Not owned, must out live this
// instance.
explicit ProximityAuthProfilePrefManager(PrefService* pref_service);
~ProximityAuthProfilePrefManager() override;
// Initializes the manager to listen to pref changes and sync prefs to the
// user's local state.
void StartSyncingToLocalState(PrefService* local_state,
const AccountId& account_id);
// Registers the prefs used by this class to the given |pref_service|.
static void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry);
// ProximityAuthPrefManager:
bool IsEasyUnlockAllowed() const override;
void SetIsEasyUnlockEnabled(bool is_easy_unlock_enabled) const override;
bool IsEasyUnlockEnabled() const override;
void SetEasyUnlockEnabledStateSet() const override;
bool IsEasyUnlockEnabledStateSet() const override;
void SetLastPasswordEntryTimestampMs(int64_t timestamp_ms) override;
int64_t GetLastPasswordEntryTimestampMs() const override;
void SetLastPromotionCheckTimestampMs(int64_t timestamp_ms) override;
int64_t GetLastPromotionCheckTimestampMs() const override;
void SetPromotionShownCount(int count) override;
int GetPromotionShownCount() const override;
void SetProximityThreshold(ProximityThreshold value) override;
ProximityThreshold GetProximityThreshold() const override;
void SetIsChromeOSLoginEnabled(bool is_enabled) override;
bool IsChromeOSLoginEnabled() override;
private:
const base::DictionaryValue* GetRemoteBleDevices() const;
void SyncPrefsToLocalState();
// Contains perferences that outlive the lifetime of this object and across
// process restarts. Not owned and must outlive this instance.
PrefService* pref_service_;
// Listens to pref changes so they can be synced to the local state.
PrefChangeRegistrar registrar_;
// The local state to which to sync the profile prefs.
PrefService* local_state_;
// The account id of the current profile.
AccountId account_id_;
base::WeakPtrFactory<ProximityAuthProfilePrefManager> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ProximityAuthProfilePrefManager);
};
} // namespace proximity_auth
#endif // CHROMEOS_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_PROFILE_PREF_MANAGER_H_
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
6851a909c91d2a1993162becc16f09d61dde4270 | 43a2fbc77f5cea2487c05c7679a30e15db9a3a50 | /Cpp/External/SDK/sailslivery_orderofsouls_01_CustomizationDesc_functions.cpp | b0a100159de6bb21587e32dd684a47979de7cb50 | [] | no_license | zH4x/SoT-Insider-SDK | 57e2e05ede34ca1fd90fc5904cf7a79f0259085c | 6bff738a1b701c34656546e333b7e59c98c63ad7 | refs/heads/main | 2023-06-09T23:10:32.929216 | 2021-07-07T01:34:27 | 2021-07-07T01:34:27 | 383,638,719 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 633 | cpp | // Name: SoT-Insider, Version: 1.102.2382.0
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
void Usailslivery_orderofsouls_01_CustomizationDesc_C::AfterRead()
{
UShipCustomizationDesc::AfterRead();
}
void Usailslivery_orderofsouls_01_CustomizationDesc_C::BeforeDelete()
{
UShipCustomizationDesc::BeforeDelete();
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"Massimo.linker@gmail.com"
] | Massimo.linker@gmail.com |
e95d8d4e491102298935e16b15f245203cea94aa | c87b228b21cfef7cb24b405c9820f09bf26fb4e6 | /src/Updater.cpp | 7c86a6a0eb1d3408a8940e56a0a5acde1aa7bae0 | [] | no_license | greboid/javalauncher | 4a71b17a3f9adc2d28f68a1b7fcdcae371499459 | ab100346f9c7c48915b7bf3e1c69377e99974a77 | refs/heads/master | 2020-04-16T15:43:13.265653 | 2018-01-02T20:58:53 | 2018-01-02T20:58:53 | 17,285,787 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 4,707 | cpp | #include "Updater.h"
using namespace std;
Updater::Updater(boost::program_options::variables_map& config) {
this->config = config;
this->newVersion = "";
}
void Updater::relaunch(std::string args) {
BOOST_LOG_TRIVIAL(debug) << "Creating new process.";
Platform::launchApplication(Utils::getExePathAndName(), args);
BOOST_LOG_TRIVIAL(debug) << "Releasing mutex";
updateMutex.unlock();
BOOST_LOG_TRIVIAL(debug) << "Exiting app.";
exit(0);
}
void Updater::getAndLockMutex() {
BOOST_LOG_TRIVIAL(debug) << "Creating mutex.";
updateMutex = Mutex();
updateMutex.init("DMDirc-Updater");
BOOST_LOG_TRIVIAL(debug) << "Waiting for mutex.";
updateMutex.lock();
}
void Updater::deleteOldLauncher() {
BOOST_LOG_TRIVIAL(debug) << "Checking for old launcher.";
Platform::deleteFileIfExists(Utils::getExePathAndName() + ".old");
}
bool Updater::doUpdate(std::string directory) {
getAndLockMutex();
deleteOldLauncher();
bool relaunchNeeded = false;
BOOST_LOG_TRIVIAL(debug) << "Checking launcher auto update";
if (config["launcher.autoupdate"].as<bool>()) {
BOOST_LOG_TRIVIAL(debug) << "Attempting to update launcher.";
int success = updateLauncher(directory, Utils::getExePath());
BOOST_LOG_TRIVIAL(debug) << "Update result: " << success;
if (success == 1) {
BOOST_LOG_TRIVIAL(debug) << "Success, restart needed.";
relaunchNeeded = true;
}
}
BOOST_LOG_TRIVIAL(debug) << "Checking application update";
if (config["application.autoupdate"].as<bool>()) {
BOOST_LOG_TRIVIAL(debug) << "Attempting to update application.";
int success = updateApplication(directory, Utils::getExePath());
if (success == 1) {
relaunchNeeded = true;
}
}
BOOST_LOG_TRIVIAL(debug) << "Releasing mutex.";
updateMutex.unlock();
BOOST_LOG_TRIVIAL(debug) << "Returning value: " << relaunchNeeded;
return relaunchNeeded;
}
int Updater::updateLauncher(std::string from, std::string to) {
std::ifstream file((char*)(from + "/" + Utils::getExeName()).c_str());
if (file.good()) {
BOOST_LOG_TRIVIAL(debug) << "Update file exists";
file.close();
BOOST_LOG_TRIVIAL(debug) << "Attempting to backup existing launcher.";
if (Platform::moveFile(Utils::getExePathAndName(), Utils::getExePathAndName() + ".old")) {
BOOST_LOG_TRIVIAL(debug) << "Unable to backup existing launcher.";
return -1;
}
if (!Platform::moveFile(from + "/" + Utils::getExeName(), to + Utils::getExePath())) {
BOOST_LOG_TRIVIAL(debug) << "Moving new launcher failed.";
return -1;
}
BOOST_LOG_TRIVIAL(debug) << "Updating launcher suceeded.";
return 1;
} else {
file.close();
BOOST_LOG_TRIVIAL(debug) << "Updating launcher not required.";
return 0;
}
}
void Updater::moveApplicationUpdates(std::string from) {
BOOST_LOG_TRIVIAL(debug) << "Getting app path.";
std::string to = Utils::getExePath();
BOOST_LOG_TRIVIAL(debug) << "Getting matching files to update.";
vector<string> files = Utils::addMatchingFilesToVector(from, std::regex(".*\\.tmp"));
BOOST_LOG_TRIVIAL(debug) << "Looping files to update.";
for (unsigned int i = 0; i < files.size(); i++) {
std::string updateSource = files[i];
std::string updateTarget = files[i].substr(0, files[i].length() - 4);
if (Platform::moveFile(from + updateSource, to + updateTarget)) {
BOOST_LOG_TRIVIAL(debug) << "Updating suceeded.";
}
else {
BOOST_LOG_TRIVIAL(debug) << "Updating failed.";
}
}
BOOST_LOG_TRIVIAL(debug) << "Finished moving application updates.";
}
int Updater::updateApplication(std::string from, std::string to) {
vector<string> files = Utils::addMatchingFilesToVector(to, std::regex(".*"));
if (files.size() == 0) {
BOOST_LOG_TRIVIAL(debug) << "Updating application not required.";
return 0;
}
else {
BOOST_LOG_TRIVIAL(debug) << "Updating application: " << files.size();
}
int restartNeeded = 0;
for (unsigned int i = 0; i < files.size(); i++) {
BOOST_LOG_TRIVIAL(debug) << "Attempting to update: " << files[i];
std::string updateSource = "." + files[i];
std::string updateTarget = files[i];
std::ifstream file((char*)(from + "/" + updateSource).c_str());
if (file.good()) {
file.close();
BOOST_LOG_TRIVIAL(debug) << "Update file exists, trying to copy.";
BOOST_LOG_TRIVIAL(debug) << "Updating: " << from + updateSource << " => " << to + updateTarget;
if (Platform::moveFile(from + updateSource, to + updateTarget + ".tmp")) {
BOOST_LOG_TRIVIAL(debug) << "Updating suceeded.";
restartNeeded = 1;
}
else {
BOOST_LOG_TRIVIAL(debug) << "Updating failed.";
restartNeeded = 0;
}
}
else {
BOOST_LOG_TRIVIAL(debug) << "Update file does not exist.";
}
}
BOOST_LOG_TRIVIAL(debug) << "Finished updating application.";
return restartNeeded;
} | [
"git@greg.holmes.name"
] | git@greg.holmes.name |
d937a23c412b7c6a42fc547e5e5e9cf7f5e82aa7 | 0f964d634ff96fdbfee0110014cebbad302cc072 | /SpaceSim/Core/Resource/GameResource.h | 026b985726c9589e98ad6611d0c1f1df0d528ea9 | [] | no_license | OGDecode/SpaceSim | b295f3330a86ec9d024899207cc802d08412cc14 | dc1c01f8223456f44d4956db8ade82003f4ac27b | refs/heads/master | 2021-06-08T09:48:59.513031 | 2016-09-29T20:05:42 | 2016-09-29T20:05:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,636 | h | #pragma once
#include "resourceable.h"
class CameraManager;
class DeviceManager;
class SettingsManager;
class TextureManager;
class GameObjectManager;
class ModelManager;
class ParticleSystemManager;
class LightManager;
class LaserManager;
class ShaderCache;
class EffectCache;
class Paths;
class EntityManager;
class UIManger;
class HTTPServer;
class Logger;
class PhysicsManager;
class GameResource : public Resource
{
public:
GameResource(ResourceableParam(EntityManager, entityManager),
ResourceableParam(CameraManager, cameraManager), ResourceableParam(DeviceManager, deviceManager)
,ResourceableParam(SettingsManager, settingsManager), ResourceableParam(TextureManager, textureManager)
,ResourceableParam(GameObjectManager, gameObjectManager), ResourceableParam(ModelManager, modelManager)
,ResourceableParam(ParticleSystemManager, pfxManager), ResourceableParam(LightManager, lightManager)
,ResourceableParam(LaserManager, laserManager), ResourceableParam(ShaderCache, shaderCache)
,ResourceableParam(EffectCache, effectCache), ResourceableParam(Paths, paths)
,ResourceableParam(UIManger, uiManager), ResourceableParam(HTTPServer, server), ResourceableParam(Logger, logger)
,ResourceableParam(PhysicsManager, physicsManager) ):
ResourceInitialiser(EntityManager, entityManager),
ResourceInitialiser(CameraManager, cameraManager),
ResourceInitialiser(DeviceManager, deviceManager),
ResourceInitialiser(SettingsManager, settingsManager),
ResourceInitialiser(TextureManager, textureManager),
ResourceInitialiser(GameObjectManager, gameObjectManager),
ResourceInitialiser(ModelManager, modelManager),
ResourceInitialiser(ParticleSystemManager, pfxManager),
ResourceInitialiser(LightManager, lightManager),
ResourceInitialiser(LaserManager, laserManager),
ResourceInitialiser(ShaderCache, shaderCache),
ResourceInitialiser(EffectCache, effectCache),
ResourceInitialiser(Paths, paths),
ResourceInitialiser(UIManger, uiManager),
ResourceInitialiser(HTTPServer, server),
ResourceInitialiser(Logger, logger),
ResourceInitialiser(PhysicsManager, physicsManager)
{}
~GameResource() {}
ResourceDefinition(EntityManager);
ResourceDefinition(CameraManager)
ResourceDefinition(DeviceManager)
ResourceDefinition(SettingsManager)
ResourceDefinition(TextureManager)
ResourceDefinition(GameObjectManager)
ResourceDefinition(ModelManager)
ResourceDefinition(ParticleSystemManager)
ResourceDefinition(LightManager)
ResourceDefinition(LaserManager)
ResourceDefinition(ShaderCache)
ResourceDefinition(EffectCache)
ResourceDefinition(Paths);
ResourceDefinition(UIManger);
ResourceDefinition(HTTPServer);
ResourceDefinition(Logger);
ResourceDefinition(PhysicsManager);
};
//This class should contain all the accessors for the game resource, means a resource can have everthing in a list and this class is the one objects use to interfact with the systems
class GameResourceHelper
{
public:
GameResourceHelper(Resource* resource) : m_resource(resource) {}
GameResourceHelper(const Resource* resource) : m_resource((Resource*)resource) {}
~GameResourceHelper() {}
const GameResource& getGameResource() const { return *(GameResource*)m_resource; }
GameResource& getWritableGameResource() const { return *(GameResource*)m_resource; }
private:
Resource* m_resource;
};
| [
"paulkruitz@gmail.com"
] | paulkruitz@gmail.com |
67400614afe2180bf0df02e5fb8f99cd643a960d | 4b86dafab3b94532e4308988352a53659fa7b854 | /hls/resnet50_1/solution1/syn/systemc/compute_3.cpp | 39227941dbe838bcc97e588db53948d663ac8b27 | [] | no_license | sterngerlach/ResNet-50_INT8 | 22842ee435f8d7574f05b1c40aa82cb714df8edf | e813beb03158b7df5eee46e9382011a140f6ead2 | refs/heads/main | 2023-08-25T01:41:56.795030 | 2021-11-04T04:49:11 | 2021-11-04T04:49:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 226,138 | cpp | #include "compute.h"
#include "AESL_pkg.h"
using namespace std;
namespace ap_rtl {
void compute::thread_K_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
K_blk_n = K_empty_n.read();
} else {
K_blk_n = ap_const_logic_1;
}
}
void compute::thread_K_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
K_read = ap_const_logic_1;
} else {
K_read = ap_const_logic_0;
}
}
void compute::thread_OSIZE_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
OSIZE_blk_n = OSIZE_empty_n.read();
} else {
OSIZE_blk_n = ap_const_logic_1;
}
}
void compute::thread_OSIZE_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
OSIZE_read = ap_const_logic_1;
} else {
OSIZE_read = ap_const_logic_0;
}
}
void compute::thread_P_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
P_blk_n = P_empty_n.read();
} else {
P_blk_n = ap_const_logic_1;
}
}
void compute::thread_P_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
P_read = ap_const_logic_1;
} else {
P_read = ap_const_logic_0;
}
}
void compute::thread_S_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
S_blk_n = S_empty_n.read();
} else {
S_blk_n = ap_const_logic_1;
}
}
void compute::thread_S_cast2_i_i_cast2686_fu_8806_p1() {
S_cast2_i_i_cast2686_fu_8806_p1 = esl_zext<17,2>(S_read_reg_30698.read());
}
void compute::thread_S_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
S_read = ap_const_logic_1;
} else {
S_read = ap_const_logic_0;
}
}
void compute::thread_TI_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
TI_blk_n = TI_empty_n.read();
} else {
TI_blk_n = ap_const_logic_1;
}
}
void compute::thread_TI_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
TI_read = ap_const_logic_1;
} else {
TI_read = ap_const_logic_0;
}
}
void compute::thread_TO_r_blk_n() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1)))) {
TO_r_blk_n = TO_r_empty_n.read();
} else {
TO_r_blk_n = ap_const_logic_1;
}
}
void compute::thread_TO_r_read() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()) &&
!(esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read())))) {
TO_r_read = ap_const_logic_1;
} else {
TO_r_read = ap_const_logic_0;
}
}
void compute::thread_add_ln135_1_fu_13022_p2() {
add_ln135_1_fu_13022_p2 = (!ap_phi_mux_row_0_i_i_phi_fu_8691_p4.read().is_01() || !ap_const_lv6_1.is_01())? sc_lv<6>(): (sc_biguint<6>(ap_phi_mux_row_0_i_i_phi_fu_8691_p4.read()) + sc_biguint<6>(ap_const_lv6_1));
}
void compute::thread_add_ln135_fu_13003_p2() {
add_ln135_fu_13003_p2 = (!indvar_flatten_reg_8676.read().is_01() || !ap_const_lv12_1.is_01())? sc_lv<12>(): (sc_biguint<12>(indvar_flatten_reg_8676.read()) + sc_biguint<12>(ap_const_lv12_1));
}
void compute::thread_add_ln156_fu_13136_p2() {
add_ln156_fu_13136_p2 = (!zext_ln137_fu_13095_p1.read().is_01() || !mul_ln140_5_fu_13059_p2.read().is_01())? sc_lv<12>(): (sc_biguint<12>(zext_ln137_fu_13095_p1.read()) + sc_biguint<12>(mul_ln140_5_fu_13059_p2.read()));
}
void compute::thread_add_ln700_1000_fu_22810_p2() {
add_ln700_1000_fu_22810_p2 = (!sext_ln700_1061_fu_22751_p1.read().is_01() || !tmp_769_i_i_fu_22758_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1061_fu_22751_p1.read()) + sc_biguint<48>(tmp_769_i_i_fu_22758_p4.read()));
}
void compute::thread_add_ln700_1001_fu_22816_p2() {
add_ln700_1001_fu_22816_p2 = (!sext_ln647_82_fu_22789_p1.read().is_01() || !sext_ln647_81_fu_22775_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_82_fu_22789_p1.read()) + sc_bigint<43>(sext_ln647_81_fu_22775_p1.read()));
}
void compute::thread_add_ln700_1002_fu_22826_p2() {
add_ln700_1002_fu_22826_p2 = (!add_ln700_1000_fu_22810_p2.read().is_01() || !sext_ln700_1088_fu_22822_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1000_fu_22810_p2.read()) + sc_bigint<48>(sext_ln700_1088_fu_22822_p1.read()));
}
void compute::thread_add_ln700_1003_fu_22832_p2() {
add_ln700_1003_fu_22832_p2 = (!sext_ln700_1062_fu_22755_p1.read().is_01() || !sext_ln647_83_fu_22803_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1062_fu_22755_p1.read()) + sc_bigint<43>(sext_ln647_83_fu_22803_p1.read()));
}
void compute::thread_add_ln700_1004_fu_22838_p2() {
add_ln700_1004_fu_22838_p2 = (!sext_ln700_1087_fu_22807_p1.read().is_01() || !sext_ln215_1079_fu_22793_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1087_fu_22807_p1.read()) + sc_bigint<19>(sext_ln215_1079_fu_22793_p1.read()));
}
void compute::thread_add_ln700_1005_fu_22848_p2() {
add_ln700_1005_fu_22848_p2 = (!sext_ln215_1078_fu_22779_p1.read().is_01() || !sext_ln700_1089_fu_22844_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1078_fu_22779_p1.read()) + sc_bigint<20>(sext_ln700_1089_fu_22844_p1.read()));
}
void compute::thread_add_ln700_1006_fu_22858_p2() {
add_ln700_1006_fu_22858_p2 = (!add_ln700_1003_fu_22832_p2.read().is_01() || !sext_ln700_1090_fu_22854_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_1003_fu_22832_p2.read()) + sc_bigint<43>(sext_ln700_1090_fu_22854_p1.read()));
}
void compute::thread_add_ln700_1007_fu_22868_p2() {
add_ln700_1007_fu_22868_p2 = (!add_ln700_1002_fu_22826_p2.read().is_01() || !sext_ln700_1091_fu_22864_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1002_fu_22826_p2.read()) + sc_bigint<48>(sext_ln700_1091_fu_22864_p1.read()));
}
void compute::thread_add_ln700_100_fu_19560_p2() {
add_ln700_100_fu_19560_p2 = (!sext_ln700_86_fu_19501_p1.read().is_01() || !tmp_619_i_i_fu_19508_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_86_fu_19501_p1.read()) + sc_biguint<48>(tmp_619_i_i_fu_19508_p4.read()));
}
void compute::thread_add_ln700_1010_fu_18612_p2() {
add_ln700_1010_fu_18612_p2 = (!grp_fu_29818_p3.read().is_01() || !grp_fu_29810_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29818_p3.read()) + sc_bigint<36>(grp_fu_29810_p3.read()));
}
void compute::thread_add_ln700_1013_fu_18616_p2() {
add_ln700_1013_fu_18616_p2 = (!grp_fu_29790_p3.read().is_01() || !grp_fu_29782_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29790_p3.read()) + sc_bigint<36>(grp_fu_29782_p3.read()));
}
void compute::thread_add_ln700_1014_fu_18620_p2() {
add_ln700_1014_fu_18620_p2 = (!add_ln700_1010_fu_18612_p2.read().is_01() || !add_ln700_1013_fu_18616_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1010_fu_18612_p2.read()) + sc_biguint<36>(add_ln700_1013_fu_18616_p2.read()));
}
void compute::thread_add_ln700_1017_fu_18652_p2() {
add_ln700_1017_fu_18652_p2 = (!grp_fu_29874_p3.read().is_01() || !grp_fu_29866_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29874_p3.read()) + sc_bigint<36>(grp_fu_29866_p3.read()));
}
void compute::thread_add_ln700_101_fu_19566_p2() {
add_ln700_101_fu_19566_p2 = (!sext_ln647_7_fu_19539_p1.read().is_01() || !sext_ln647_6_fu_19525_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_7_fu_19539_p1.read()) + sc_bigint<43>(sext_ln647_6_fu_19525_p1.read()));
}
void compute::thread_add_ln700_1020_fu_18656_p2() {
add_ln700_1020_fu_18656_p2 = (!grp_fu_29846_p3.read().is_01() || !grp_fu_29838_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29846_p3.read()) + sc_bigint<36>(grp_fu_29838_p3.read()));
}
void compute::thread_add_ln700_1021_fu_18660_p2() {
add_ln700_1021_fu_18660_p2 = (!add_ln700_1017_fu_18652_p2.read().is_01() || !add_ln700_1020_fu_18656_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1017_fu_18652_p2.read()) + sc_biguint<36>(add_ln700_1020_fu_18656_p2.read()));
}
void compute::thread_add_ln700_1024_fu_18692_p2() {
add_ln700_1024_fu_18692_p2 = (!grp_fu_29930_p3.read().is_01() || !grp_fu_29922_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29930_p3.read()) + sc_bigint<36>(grp_fu_29922_p3.read()));
}
void compute::thread_add_ln700_1027_fu_18696_p2() {
add_ln700_1027_fu_18696_p2 = (!grp_fu_29902_p3.read().is_01() || !grp_fu_29894_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29902_p3.read()) + sc_bigint<36>(grp_fu_29894_p3.read()));
}
void compute::thread_add_ln700_1028_fu_18700_p2() {
add_ln700_1028_fu_18700_p2 = (!add_ln700_1024_fu_18692_p2.read().is_01() || !add_ln700_1027_fu_18696_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1024_fu_18692_p2.read()) + sc_biguint<36>(add_ln700_1027_fu_18696_p2.read()));
}
void compute::thread_add_ln700_102_fu_19576_p2() {
add_ln700_102_fu_19576_p2 = (!add_ln700_100_fu_19560_p2.read().is_01() || !sext_ln700_113_fu_19572_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_100_fu_19560_p2.read()) + sc_bigint<48>(sext_ln700_113_fu_19572_p1.read()));
}
void compute::thread_add_ln700_1031_fu_18732_p2() {
add_ln700_1031_fu_18732_p2 = (!grp_fu_29986_p3.read().is_01() || !grp_fu_29978_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29986_p3.read()) + sc_bigint<36>(grp_fu_29978_p3.read()));
}
void compute::thread_add_ln700_1034_fu_18736_p2() {
add_ln700_1034_fu_18736_p2 = (!grp_fu_29958_p3.read().is_01() || !grp_fu_29950_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29958_p3.read()) + sc_bigint<36>(grp_fu_29950_p3.read()));
}
void compute::thread_add_ln700_1035_fu_18740_p2() {
add_ln700_1035_fu_18740_p2 = (!add_ln700_1031_fu_18732_p2.read().is_01() || !add_ln700_1034_fu_18736_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1031_fu_18732_p2.read()) + sc_biguint<36>(add_ln700_1034_fu_18736_p2.read()));
}
void compute::thread_add_ln700_1036_fu_22940_p2() {
add_ln700_1036_fu_22940_p2 = (!sext_ln700_1100_fu_22881_p1.read().is_01() || !tmp_775_i_i_fu_22888_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1100_fu_22881_p1.read()) + sc_biguint<48>(tmp_775_i_i_fu_22888_p4.read()));
}
void compute::thread_add_ln700_1037_fu_22946_p2() {
add_ln700_1037_fu_22946_p2 = (!sext_ln647_85_fu_22919_p1.read().is_01() || !sext_ln647_84_fu_22905_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_85_fu_22919_p1.read()) + sc_bigint<43>(sext_ln647_84_fu_22905_p1.read()));
}
void compute::thread_add_ln700_1038_fu_22956_p2() {
add_ln700_1038_fu_22956_p2 = (!add_ln700_1036_fu_22940_p2.read().is_01() || !sext_ln700_1127_fu_22952_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1036_fu_22940_p2.read()) + sc_bigint<48>(sext_ln700_1127_fu_22952_p1.read()));
}
void compute::thread_add_ln700_1039_fu_22962_p2() {
add_ln700_1039_fu_22962_p2 = (!sext_ln700_1101_fu_22885_p1.read().is_01() || !sext_ln647_86_fu_22933_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1101_fu_22885_p1.read()) + sc_bigint<43>(sext_ln647_86_fu_22933_p1.read()));
}
void compute::thread_add_ln700_103_fu_19582_p2() {
add_ln700_103_fu_19582_p2 = (!sext_ln700_87_fu_19505_p1.read().is_01() || !sext_ln647_8_fu_19553_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_87_fu_19505_p1.read()) + sc_bigint<43>(sext_ln647_8_fu_19553_p1.read()));
}
void compute::thread_add_ln700_1040_fu_22968_p2() {
add_ln700_1040_fu_22968_p2 = (!sext_ln700_1126_fu_22937_p1.read().is_01() || !sext_ln215_1081_fu_22923_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1126_fu_22937_p1.read()) + sc_bigint<19>(sext_ln215_1081_fu_22923_p1.read()));
}
void compute::thread_add_ln700_1041_fu_22978_p2() {
add_ln700_1041_fu_22978_p2 = (!sext_ln215_1080_fu_22909_p1.read().is_01() || !sext_ln700_1128_fu_22974_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1080_fu_22909_p1.read()) + sc_bigint<20>(sext_ln700_1128_fu_22974_p1.read()));
}
void compute::thread_add_ln700_1042_fu_22988_p2() {
add_ln700_1042_fu_22988_p2 = (!add_ln700_1039_fu_22962_p2.read().is_01() || !sext_ln700_1129_fu_22984_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_1039_fu_22962_p2.read()) + sc_bigint<43>(sext_ln700_1129_fu_22984_p1.read()));
}
void compute::thread_add_ln700_1043_fu_22998_p2() {
add_ln700_1043_fu_22998_p2 = (!add_ln700_1038_fu_22956_p2.read().is_01() || !sext_ln700_1130_fu_22994_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1038_fu_22956_p2.read()) + sc_bigint<48>(sext_ln700_1130_fu_22994_p1.read()));
}
void compute::thread_add_ln700_1046_fu_18772_p2() {
add_ln700_1046_fu_18772_p2 = (!grp_fu_30042_p3.read().is_01() || !grp_fu_30034_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30042_p3.read()) + sc_bigint<36>(grp_fu_30034_p3.read()));
}
void compute::thread_add_ln700_1049_fu_18776_p2() {
add_ln700_1049_fu_18776_p2 = (!grp_fu_30014_p3.read().is_01() || !grp_fu_30006_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30014_p3.read()) + sc_bigint<36>(grp_fu_30006_p3.read()));
}
void compute::thread_add_ln700_104_fu_19588_p2() {
add_ln700_104_fu_19588_p2 = (!sext_ln700_112_fu_19557_p1.read().is_01() || !sext_ln215_1029_fu_19543_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_112_fu_19557_p1.read()) + sc_bigint<19>(sext_ln215_1029_fu_19543_p1.read()));
}
void compute::thread_add_ln700_1050_fu_18780_p2() {
add_ln700_1050_fu_18780_p2 = (!add_ln700_1046_fu_18772_p2.read().is_01() || !add_ln700_1049_fu_18776_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1046_fu_18772_p2.read()) + sc_biguint<36>(add_ln700_1049_fu_18776_p2.read()));
}
void compute::thread_add_ln700_1053_fu_18812_p2() {
add_ln700_1053_fu_18812_p2 = (!grp_fu_30098_p3.read().is_01() || !grp_fu_30090_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30098_p3.read()) + sc_bigint<36>(grp_fu_30090_p3.read()));
}
void compute::thread_add_ln700_1056_fu_18816_p2() {
add_ln700_1056_fu_18816_p2 = (!grp_fu_30070_p3.read().is_01() || !grp_fu_30062_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30070_p3.read()) + sc_bigint<36>(grp_fu_30062_p3.read()));
}
void compute::thread_add_ln700_1057_fu_18820_p2() {
add_ln700_1057_fu_18820_p2 = (!add_ln700_1053_fu_18812_p2.read().is_01() || !add_ln700_1056_fu_18816_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1053_fu_18812_p2.read()) + sc_biguint<36>(add_ln700_1056_fu_18816_p2.read()));
}
void compute::thread_add_ln700_105_fu_19598_p2() {
add_ln700_105_fu_19598_p2 = (!sext_ln215_1028_fu_19529_p1.read().is_01() || !sext_ln700_114_fu_19594_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1028_fu_19529_p1.read()) + sc_bigint<20>(sext_ln700_114_fu_19594_p1.read()));
}
void compute::thread_add_ln700_1060_fu_18852_p2() {
add_ln700_1060_fu_18852_p2 = (!grp_fu_30154_p3.read().is_01() || !grp_fu_30146_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30154_p3.read()) + sc_bigint<36>(grp_fu_30146_p3.read()));
}
void compute::thread_add_ln700_1063_fu_18856_p2() {
add_ln700_1063_fu_18856_p2 = (!grp_fu_30126_p3.read().is_01() || !grp_fu_30118_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30126_p3.read()) + sc_bigint<36>(grp_fu_30118_p3.read()));
}
void compute::thread_add_ln700_1064_fu_18860_p2() {
add_ln700_1064_fu_18860_p2 = (!add_ln700_1060_fu_18852_p2.read().is_01() || !add_ln700_1063_fu_18856_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1060_fu_18852_p2.read()) + sc_biguint<36>(add_ln700_1063_fu_18856_p2.read()));
}
void compute::thread_add_ln700_1067_fu_18892_p2() {
add_ln700_1067_fu_18892_p2 = (!grp_fu_30210_p3.read().is_01() || !grp_fu_30202_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30210_p3.read()) + sc_bigint<36>(grp_fu_30202_p3.read()));
}
void compute::thread_add_ln700_106_fu_19608_p2() {
add_ln700_106_fu_19608_p2 = (!add_ln700_103_fu_19582_p2.read().is_01() || !sext_ln700_115_fu_19604_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_103_fu_19582_p2.read()) + sc_bigint<43>(sext_ln700_115_fu_19604_p1.read()));
}
void compute::thread_add_ln700_1070_fu_18896_p2() {
add_ln700_1070_fu_18896_p2 = (!grp_fu_30182_p3.read().is_01() || !grp_fu_30174_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30182_p3.read()) + sc_bigint<36>(grp_fu_30174_p3.read()));
}
void compute::thread_add_ln700_1071_fu_18900_p2() {
add_ln700_1071_fu_18900_p2 = (!add_ln700_1067_fu_18892_p2.read().is_01() || !add_ln700_1070_fu_18896_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1067_fu_18892_p2.read()) + sc_biguint<36>(add_ln700_1070_fu_18896_p2.read()));
}
void compute::thread_add_ln700_1072_fu_23070_p2() {
add_ln700_1072_fu_23070_p2 = (!sext_ln700_1139_fu_23011_p1.read().is_01() || !tmp_781_i_i_fu_23018_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1139_fu_23011_p1.read()) + sc_biguint<48>(tmp_781_i_i_fu_23018_p4.read()));
}
void compute::thread_add_ln700_1073_fu_23076_p2() {
add_ln700_1073_fu_23076_p2 = (!sext_ln647_88_fu_23049_p1.read().is_01() || !sext_ln647_87_fu_23035_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_88_fu_23049_p1.read()) + sc_bigint<43>(sext_ln647_87_fu_23035_p1.read()));
}
void compute::thread_add_ln700_1074_fu_23086_p2() {
add_ln700_1074_fu_23086_p2 = (!add_ln700_1072_fu_23070_p2.read().is_01() || !sext_ln700_1166_fu_23082_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1072_fu_23070_p2.read()) + sc_bigint<48>(sext_ln700_1166_fu_23082_p1.read()));
}
void compute::thread_add_ln700_1075_fu_23092_p2() {
add_ln700_1075_fu_23092_p2 = (!sext_ln700_1140_fu_23015_p1.read().is_01() || !sext_ln647_89_fu_23063_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1140_fu_23015_p1.read()) + sc_bigint<43>(sext_ln647_89_fu_23063_p1.read()));
}
void compute::thread_add_ln700_1076_fu_23098_p2() {
add_ln700_1076_fu_23098_p2 = (!sext_ln700_1165_fu_23067_p1.read().is_01() || !sext_ln215_1083_fu_23053_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1165_fu_23067_p1.read()) + sc_bigint<19>(sext_ln215_1083_fu_23053_p1.read()));
}
void compute::thread_add_ln700_1077_fu_23108_p2() {
add_ln700_1077_fu_23108_p2 = (!sext_ln215_1082_fu_23039_p1.read().is_01() || !sext_ln700_1167_fu_23104_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1082_fu_23039_p1.read()) + sc_bigint<20>(sext_ln700_1167_fu_23104_p1.read()));
}
void compute::thread_add_ln700_1078_fu_23118_p2() {
add_ln700_1078_fu_23118_p2 = (!add_ln700_1075_fu_23092_p2.read().is_01() || !sext_ln700_1168_fu_23114_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_1075_fu_23092_p2.read()) + sc_bigint<43>(sext_ln700_1168_fu_23114_p1.read()));
}
void compute::thread_add_ln700_1079_fu_23128_p2() {
add_ln700_1079_fu_23128_p2 = (!add_ln700_1074_fu_23086_p2.read().is_01() || !sext_ln700_1169_fu_23124_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1074_fu_23086_p2.read()) + sc_bigint<48>(sext_ln700_1169_fu_23124_p1.read()));
}
void compute::thread_add_ln700_107_fu_19618_p2() {
add_ln700_107_fu_19618_p2 = (!add_ln700_102_fu_19576_p2.read().is_01() || !sext_ln700_116_fu_19614_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_102_fu_19576_p2.read()) + sc_bigint<48>(sext_ln700_116_fu_19614_p1.read()));
}
void compute::thread_add_ln700_1082_fu_18932_p2() {
add_ln700_1082_fu_18932_p2 = (!grp_fu_30266_p3.read().is_01() || !grp_fu_30258_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30266_p3.read()) + sc_bigint<36>(grp_fu_30258_p3.read()));
}
void compute::thread_add_ln700_1085_fu_18936_p2() {
add_ln700_1085_fu_18936_p2 = (!grp_fu_30238_p3.read().is_01() || !grp_fu_30230_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30238_p3.read()) + sc_bigint<36>(grp_fu_30230_p3.read()));
}
void compute::thread_add_ln700_1086_fu_18940_p2() {
add_ln700_1086_fu_18940_p2 = (!add_ln700_1082_fu_18932_p2.read().is_01() || !add_ln700_1085_fu_18936_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1082_fu_18932_p2.read()) + sc_biguint<36>(add_ln700_1085_fu_18936_p2.read()));
}
void compute::thread_add_ln700_1089_fu_18972_p2() {
add_ln700_1089_fu_18972_p2 = (!grp_fu_30322_p3.read().is_01() || !grp_fu_30314_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30322_p3.read()) + sc_bigint<36>(grp_fu_30314_p3.read()));
}
void compute::thread_add_ln700_1092_fu_18976_p2() {
add_ln700_1092_fu_18976_p2 = (!grp_fu_30294_p3.read().is_01() || !grp_fu_30286_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30294_p3.read()) + sc_bigint<36>(grp_fu_30286_p3.read()));
}
void compute::thread_add_ln700_1093_fu_18980_p2() {
add_ln700_1093_fu_18980_p2 = (!add_ln700_1089_fu_18972_p2.read().is_01() || !add_ln700_1092_fu_18976_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1089_fu_18972_p2.read()) + sc_biguint<36>(add_ln700_1092_fu_18976_p2.read()));
}
void compute::thread_add_ln700_1096_fu_19012_p2() {
add_ln700_1096_fu_19012_p2 = (!grp_fu_30378_p3.read().is_01() || !grp_fu_30370_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30378_p3.read()) + sc_bigint<36>(grp_fu_30370_p3.read()));
}
void compute::thread_add_ln700_1099_fu_19016_p2() {
add_ln700_1099_fu_19016_p2 = (!grp_fu_30350_p3.read().is_01() || !grp_fu_30342_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30350_p3.read()) + sc_bigint<36>(grp_fu_30342_p3.read()));
}
void compute::thread_add_ln700_1100_fu_19020_p2() {
add_ln700_1100_fu_19020_p2 = (!add_ln700_1096_fu_19012_p2.read().is_01() || !add_ln700_1099_fu_19016_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1096_fu_19012_p2.read()) + sc_biguint<36>(add_ln700_1099_fu_19016_p2.read()));
}
void compute::thread_add_ln700_1103_fu_19052_p2() {
add_ln700_1103_fu_19052_p2 = (!grp_fu_30434_p3.read().is_01() || !grp_fu_30426_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30434_p3.read()) + sc_bigint<36>(grp_fu_30426_p3.read()));
}
void compute::thread_add_ln700_1106_fu_19056_p2() {
add_ln700_1106_fu_19056_p2 = (!grp_fu_30406_p3.read().is_01() || !grp_fu_30398_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30406_p3.read()) + sc_bigint<36>(grp_fu_30398_p3.read()));
}
void compute::thread_add_ln700_1107_fu_19060_p2() {
add_ln700_1107_fu_19060_p2 = (!add_ln700_1103_fu_19052_p2.read().is_01() || !add_ln700_1106_fu_19056_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1103_fu_19052_p2.read()) + sc_biguint<36>(add_ln700_1106_fu_19056_p2.read()));
}
void compute::thread_add_ln700_1108_fu_23200_p2() {
add_ln700_1108_fu_23200_p2 = (!sext_ln700_1178_fu_23141_p1.read().is_01() || !tmp_787_i_i_fu_23148_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1178_fu_23141_p1.read()) + sc_biguint<48>(tmp_787_i_i_fu_23148_p4.read()));
}
void compute::thread_add_ln700_1109_fu_23206_p2() {
add_ln700_1109_fu_23206_p2 = (!sext_ln647_91_fu_23179_p1.read().is_01() || !sext_ln647_90_fu_23165_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_91_fu_23179_p1.read()) + sc_bigint<43>(sext_ln647_90_fu_23165_p1.read()));
}
void compute::thread_add_ln700_110_fu_14612_p2() {
add_ln700_110_fu_14612_p2 = (!grp_fu_24218_p3.read().is_01() || !grp_fu_24210_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24218_p3.read()) + sc_bigint<36>(grp_fu_24210_p3.read()));
}
void compute::thread_add_ln700_1110_fu_23216_p2() {
add_ln700_1110_fu_23216_p2 = (!add_ln700_1108_fu_23200_p2.read().is_01() || !sext_ln700_1205_fu_23212_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1108_fu_23200_p2.read()) + sc_bigint<48>(sext_ln700_1205_fu_23212_p1.read()));
}
void compute::thread_add_ln700_1111_fu_23222_p2() {
add_ln700_1111_fu_23222_p2 = (!sext_ln700_1179_fu_23145_p1.read().is_01() || !sext_ln647_92_fu_23193_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1179_fu_23145_p1.read()) + sc_bigint<43>(sext_ln647_92_fu_23193_p1.read()));
}
void compute::thread_add_ln700_1112_fu_23228_p2() {
add_ln700_1112_fu_23228_p2 = (!sext_ln700_1204_fu_23197_p1.read().is_01() || !sext_ln215_1085_fu_23183_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1204_fu_23197_p1.read()) + sc_bigint<19>(sext_ln215_1085_fu_23183_p1.read()));
}
void compute::thread_add_ln700_1113_fu_23238_p2() {
add_ln700_1113_fu_23238_p2 = (!sext_ln215_1084_fu_23169_p1.read().is_01() || !sext_ln700_1206_fu_23234_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1084_fu_23169_p1.read()) + sc_bigint<20>(sext_ln700_1206_fu_23234_p1.read()));
}
void compute::thread_add_ln700_1114_fu_23248_p2() {
add_ln700_1114_fu_23248_p2 = (!add_ln700_1111_fu_23222_p2.read().is_01() || !sext_ln700_1207_fu_23244_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_1111_fu_23222_p2.read()) + sc_bigint<43>(sext_ln700_1207_fu_23244_p1.read()));
}
void compute::thread_add_ln700_1115_fu_23258_p2() {
add_ln700_1115_fu_23258_p2 = (!add_ln700_1110_fu_23216_p2.read().is_01() || !sext_ln700_1208_fu_23254_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1110_fu_23216_p2.read()) + sc_bigint<48>(sext_ln700_1208_fu_23254_p1.read()));
}
void compute::thread_add_ln700_1118_fu_19092_p2() {
add_ln700_1118_fu_19092_p2 = (!grp_fu_30490_p3.read().is_01() || !grp_fu_30482_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30490_p3.read()) + sc_bigint<36>(grp_fu_30482_p3.read()));
}
void compute::thread_add_ln700_1121_fu_19096_p2() {
add_ln700_1121_fu_19096_p2 = (!grp_fu_30462_p3.read().is_01() || !grp_fu_30454_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30462_p3.read()) + sc_bigint<36>(grp_fu_30454_p3.read()));
}
void compute::thread_add_ln700_1122_fu_19100_p2() {
add_ln700_1122_fu_19100_p2 = (!add_ln700_1118_fu_19092_p2.read().is_01() || !add_ln700_1121_fu_19096_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1118_fu_19092_p2.read()) + sc_biguint<36>(add_ln700_1121_fu_19096_p2.read()));
}
void compute::thread_add_ln700_1125_fu_19132_p2() {
add_ln700_1125_fu_19132_p2 = (!grp_fu_30546_p3.read().is_01() || !grp_fu_30538_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30546_p3.read()) + sc_bigint<36>(grp_fu_30538_p3.read()));
}
void compute::thread_add_ln700_1128_fu_19136_p2() {
add_ln700_1128_fu_19136_p2 = (!grp_fu_30518_p3.read().is_01() || !grp_fu_30510_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30518_p3.read()) + sc_bigint<36>(grp_fu_30510_p3.read()));
}
void compute::thread_add_ln700_1129_fu_19140_p2() {
add_ln700_1129_fu_19140_p2 = (!add_ln700_1125_fu_19132_p2.read().is_01() || !add_ln700_1128_fu_19136_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1125_fu_19132_p2.read()) + sc_biguint<36>(add_ln700_1128_fu_19136_p2.read()));
}
void compute::thread_add_ln700_1132_fu_19172_p2() {
add_ln700_1132_fu_19172_p2 = (!grp_fu_30602_p3.read().is_01() || !grp_fu_30594_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30602_p3.read()) + sc_bigint<36>(grp_fu_30594_p3.read()));
}
void compute::thread_add_ln700_1135_fu_19176_p2() {
add_ln700_1135_fu_19176_p2 = (!grp_fu_30574_p3.read().is_01() || !grp_fu_30566_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30574_p3.read()) + sc_bigint<36>(grp_fu_30566_p3.read()));
}
void compute::thread_add_ln700_1136_fu_19180_p2() {
add_ln700_1136_fu_19180_p2 = (!add_ln700_1132_fu_19172_p2.read().is_01() || !add_ln700_1135_fu_19176_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1132_fu_19172_p2.read()) + sc_biguint<36>(add_ln700_1135_fu_19176_p2.read()));
}
void compute::thread_add_ln700_1139_fu_19212_p2() {
add_ln700_1139_fu_19212_p2 = (!grp_fu_30658_p3.read().is_01() || !grp_fu_30650_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30658_p3.read()) + sc_bigint<36>(grp_fu_30650_p3.read()));
}
void compute::thread_add_ln700_113_fu_14616_p2() {
add_ln700_113_fu_14616_p2 = (!grp_fu_24190_p3.read().is_01() || !grp_fu_24182_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24190_p3.read()) + sc_bigint<36>(grp_fu_24182_p3.read()));
}
void compute::thread_add_ln700_1142_fu_19216_p2() {
add_ln700_1142_fu_19216_p2 = (!grp_fu_30630_p3.read().is_01() || !grp_fu_30622_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_30630_p3.read()) + sc_bigint<36>(grp_fu_30622_p3.read()));
}
void compute::thread_add_ln700_1143_fu_19220_p2() {
add_ln700_1143_fu_19220_p2 = (!add_ln700_1139_fu_19212_p2.read().is_01() || !add_ln700_1142_fu_19216_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_1139_fu_19212_p2.read()) + sc_biguint<36>(add_ln700_1142_fu_19216_p2.read()));
}
void compute::thread_add_ln700_1144_fu_23330_p2() {
add_ln700_1144_fu_23330_p2 = (!sext_ln700_1217_fu_23271_p1.read().is_01() || !tmp_793_i_i_fu_23278_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1217_fu_23271_p1.read()) + sc_biguint<48>(tmp_793_i_i_fu_23278_p4.read()));
}
void compute::thread_add_ln700_1145_fu_23336_p2() {
add_ln700_1145_fu_23336_p2 = (!sext_ln647_94_fu_23309_p1.read().is_01() || !sext_ln647_93_fu_23295_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_94_fu_23309_p1.read()) + sc_bigint<43>(sext_ln647_93_fu_23295_p1.read()));
}
void compute::thread_add_ln700_1146_fu_23346_p2() {
add_ln700_1146_fu_23346_p2 = (!add_ln700_1144_fu_23330_p2.read().is_01() || !sext_ln700_1244_fu_23342_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1144_fu_23330_p2.read()) + sc_bigint<48>(sext_ln700_1244_fu_23342_p1.read()));
}
void compute::thread_add_ln700_1147_fu_23352_p2() {
add_ln700_1147_fu_23352_p2 = (!sext_ln700_1218_fu_23275_p1.read().is_01() || !sext_ln647_95_fu_23323_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1218_fu_23275_p1.read()) + sc_bigint<43>(sext_ln647_95_fu_23323_p1.read()));
}
void compute::thread_add_ln700_1148_fu_23358_p2() {
add_ln700_1148_fu_23358_p2 = (!sext_ln700_1243_fu_23327_p1.read().is_01() || !sext_ln215_1087_fu_23313_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1243_fu_23327_p1.read()) + sc_bigint<19>(sext_ln215_1087_fu_23313_p1.read()));
}
void compute::thread_add_ln700_1149_fu_23368_p2() {
add_ln700_1149_fu_23368_p2 = (!sext_ln215_1086_fu_23299_p1.read().is_01() || !sext_ln700_1245_fu_23364_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1086_fu_23299_p1.read()) + sc_bigint<20>(sext_ln700_1245_fu_23364_p1.read()));
}
void compute::thread_add_ln700_114_fu_14620_p2() {
add_ln700_114_fu_14620_p2 = (!add_ln700_110_fu_14612_p2.read().is_01() || !add_ln700_113_fu_14616_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_110_fu_14612_p2.read()) + sc_biguint<36>(add_ln700_113_fu_14616_p2.read()));
}
void compute::thread_add_ln700_1150_fu_23378_p2() {
add_ln700_1150_fu_23378_p2 = (!add_ln700_1147_fu_23352_p2.read().is_01() || !sext_ln700_1246_fu_23374_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_1147_fu_23352_p2.read()) + sc_bigint<43>(sext_ln700_1246_fu_23374_p1.read()));
}
void compute::thread_add_ln700_1151_fu_23388_p2() {
add_ln700_1151_fu_23388_p2 = (!add_ln700_1146_fu_23346_p2.read().is_01() || !sext_ln700_1247_fu_23384_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_1146_fu_23346_p2.read()) + sc_bigint<48>(sext_ln700_1247_fu_23384_p1.read()));
}
void compute::thread_add_ln700_117_fu_14652_p2() {
add_ln700_117_fu_14652_p2 = (!grp_fu_24274_p3.read().is_01() || !grp_fu_24266_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24274_p3.read()) + sc_bigint<36>(grp_fu_24266_p3.read()));
}
void compute::thread_add_ln700_120_fu_14656_p2() {
add_ln700_120_fu_14656_p2 = (!grp_fu_24246_p3.read().is_01() || !grp_fu_24238_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24246_p3.read()) + sc_bigint<36>(grp_fu_24238_p3.read()));
}
void compute::thread_add_ln700_121_fu_14660_p2() {
add_ln700_121_fu_14660_p2 = (!add_ln700_117_fu_14652_p2.read().is_01() || !add_ln700_120_fu_14656_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_117_fu_14652_p2.read()) + sc_biguint<36>(add_ln700_120_fu_14656_p2.read()));
}
void compute::thread_add_ln700_124_fu_14692_p2() {
add_ln700_124_fu_14692_p2 = (!grp_fu_24330_p3.read().is_01() || !grp_fu_24322_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24330_p3.read()) + sc_bigint<36>(grp_fu_24322_p3.read()));
}
void compute::thread_add_ln700_127_fu_14696_p2() {
add_ln700_127_fu_14696_p2 = (!grp_fu_24302_p3.read().is_01() || !grp_fu_24294_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24302_p3.read()) + sc_bigint<36>(grp_fu_24294_p3.read()));
}
void compute::thread_add_ln700_128_fu_14700_p2() {
add_ln700_128_fu_14700_p2 = (!add_ln700_124_fu_14692_p2.read().is_01() || !add_ln700_127_fu_14696_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_124_fu_14692_p2.read()) + sc_biguint<36>(add_ln700_127_fu_14696_p2.read()));
}
void compute::thread_add_ln700_12_fu_14112_p2() {
add_ln700_12_fu_14112_p2 = (!grp_fu_23574_p3.read().is_01() || !grp_fu_23566_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23574_p3.read()) + sc_bigint<36>(grp_fu_23566_p3.read()));
}
void compute::thread_add_ln700_131_fu_14732_p2() {
add_ln700_131_fu_14732_p2 = (!grp_fu_24386_p3.read().is_01() || !grp_fu_24378_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24386_p3.read()) + sc_bigint<36>(grp_fu_24378_p3.read()));
}
void compute::thread_add_ln700_134_fu_14736_p2() {
add_ln700_134_fu_14736_p2 = (!grp_fu_24358_p3.read().is_01() || !grp_fu_24350_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24358_p3.read()) + sc_bigint<36>(grp_fu_24350_p3.read()));
}
void compute::thread_add_ln700_135_fu_14740_p2() {
add_ln700_135_fu_14740_p2 = (!add_ln700_131_fu_14732_p2.read().is_01() || !add_ln700_134_fu_14736_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_131_fu_14732_p2.read()) + sc_biguint<36>(add_ln700_134_fu_14736_p2.read()));
}
void compute::thread_add_ln700_136_fu_19690_p2() {
add_ln700_136_fu_19690_p2 = (!sext_ln700_125_fu_19631_p1.read().is_01() || !tmp_625_i_i_fu_19638_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_125_fu_19631_p1.read()) + sc_biguint<48>(tmp_625_i_i_fu_19638_p4.read()));
}
void compute::thread_add_ln700_137_fu_19696_p2() {
add_ln700_137_fu_19696_p2 = (!sext_ln647_10_fu_19669_p1.read().is_01() || !sext_ln647_9_fu_19655_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_10_fu_19669_p1.read()) + sc_bigint<43>(sext_ln647_9_fu_19655_p1.read()));
}
void compute::thread_add_ln700_138_fu_19706_p2() {
add_ln700_138_fu_19706_p2 = (!add_ln700_136_fu_19690_p2.read().is_01() || !sext_ln700_152_fu_19702_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_136_fu_19690_p2.read()) + sc_bigint<48>(sext_ln700_152_fu_19702_p1.read()));
}
void compute::thread_add_ln700_139_fu_19712_p2() {
add_ln700_139_fu_19712_p2 = (!sext_ln700_126_fu_19635_p1.read().is_01() || !sext_ln647_11_fu_19683_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_126_fu_19635_p1.read()) + sc_bigint<43>(sext_ln647_11_fu_19683_p1.read()));
}
void compute::thread_add_ln700_13_fu_14116_p2() {
add_ln700_13_fu_14116_p2 = (!add_ln700_9_fu_14108_p2.read().is_01() || !add_ln700_12_fu_14112_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_9_fu_14108_p2.read()) + sc_biguint<36>(add_ln700_12_fu_14112_p2.read()));
}
void compute::thread_add_ln700_140_fu_19718_p2() {
add_ln700_140_fu_19718_p2 = (!sext_ln700_151_fu_19687_p1.read().is_01() || !sext_ln215_1031_fu_19673_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_151_fu_19687_p1.read()) + sc_bigint<19>(sext_ln215_1031_fu_19673_p1.read()));
}
void compute::thread_add_ln700_141_fu_19728_p2() {
add_ln700_141_fu_19728_p2 = (!sext_ln215_1030_fu_19659_p1.read().is_01() || !sext_ln700_153_fu_19724_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1030_fu_19659_p1.read()) + sc_bigint<20>(sext_ln700_153_fu_19724_p1.read()));
}
void compute::thread_add_ln700_142_fu_19738_p2() {
add_ln700_142_fu_19738_p2 = (!add_ln700_139_fu_19712_p2.read().is_01() || !sext_ln700_154_fu_19734_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_139_fu_19712_p2.read()) + sc_bigint<43>(sext_ln700_154_fu_19734_p1.read()));
}
void compute::thread_add_ln700_143_fu_19748_p2() {
add_ln700_143_fu_19748_p2 = (!add_ln700_138_fu_19706_p2.read().is_01() || !sext_ln700_155_fu_19744_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_138_fu_19706_p2.read()) + sc_bigint<48>(sext_ln700_155_fu_19744_p1.read()));
}
void compute::thread_add_ln700_146_fu_14772_p2() {
add_ln700_146_fu_14772_p2 = (!grp_fu_24442_p3.read().is_01() || !grp_fu_24434_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24442_p3.read()) + sc_bigint<36>(grp_fu_24434_p3.read()));
}
void compute::thread_add_ln700_149_fu_14776_p2() {
add_ln700_149_fu_14776_p2 = (!grp_fu_24414_p3.read().is_01() || !grp_fu_24406_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24414_p3.read()) + sc_bigint<36>(grp_fu_24406_p3.read()));
}
void compute::thread_add_ln700_150_fu_14780_p2() {
add_ln700_150_fu_14780_p2 = (!add_ln700_146_fu_14772_p2.read().is_01() || !add_ln700_149_fu_14776_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_146_fu_14772_p2.read()) + sc_biguint<36>(add_ln700_149_fu_14776_p2.read()));
}
void compute::thread_add_ln700_153_fu_14812_p2() {
add_ln700_153_fu_14812_p2 = (!grp_fu_24498_p3.read().is_01() || !grp_fu_24490_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24498_p3.read()) + sc_bigint<36>(grp_fu_24490_p3.read()));
}
void compute::thread_add_ln700_156_fu_14816_p2() {
add_ln700_156_fu_14816_p2 = (!grp_fu_24470_p3.read().is_01() || !grp_fu_24462_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24470_p3.read()) + sc_bigint<36>(grp_fu_24462_p3.read()));
}
void compute::thread_add_ln700_157_fu_14820_p2() {
add_ln700_157_fu_14820_p2 = (!add_ln700_153_fu_14812_p2.read().is_01() || !add_ln700_156_fu_14816_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_153_fu_14812_p2.read()) + sc_biguint<36>(add_ln700_156_fu_14816_p2.read()));
}
void compute::thread_add_ln700_160_fu_14852_p2() {
add_ln700_160_fu_14852_p2 = (!grp_fu_24554_p3.read().is_01() || !grp_fu_24546_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24554_p3.read()) + sc_bigint<36>(grp_fu_24546_p3.read()));
}
void compute::thread_add_ln700_163_fu_14856_p2() {
add_ln700_163_fu_14856_p2 = (!grp_fu_24526_p3.read().is_01() || !grp_fu_24518_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24526_p3.read()) + sc_bigint<36>(grp_fu_24518_p3.read()));
}
void compute::thread_add_ln700_164_fu_14860_p2() {
add_ln700_164_fu_14860_p2 = (!add_ln700_160_fu_14852_p2.read().is_01() || !add_ln700_163_fu_14856_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_160_fu_14852_p2.read()) + sc_biguint<36>(add_ln700_163_fu_14856_p2.read()));
}
void compute::thread_add_ln700_167_fu_14892_p2() {
add_ln700_167_fu_14892_p2 = (!grp_fu_24610_p3.read().is_01() || !grp_fu_24602_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24610_p3.read()) + sc_bigint<36>(grp_fu_24602_p3.read()));
}
void compute::thread_add_ln700_16_fu_14180_p2() {
add_ln700_16_fu_14180_p2 = (!grp_fu_23658_p3.read().is_01() || !grp_fu_23650_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23658_p3.read()) + sc_bigint<36>(grp_fu_23650_p3.read()));
}
void compute::thread_add_ln700_170_fu_14896_p2() {
add_ln700_170_fu_14896_p2 = (!grp_fu_24582_p3.read().is_01() || !grp_fu_24574_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24582_p3.read()) + sc_bigint<36>(grp_fu_24574_p3.read()));
}
void compute::thread_add_ln700_171_fu_14900_p2() {
add_ln700_171_fu_14900_p2 = (!add_ln700_167_fu_14892_p2.read().is_01() || !add_ln700_170_fu_14896_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_167_fu_14892_p2.read()) + sc_biguint<36>(add_ln700_170_fu_14896_p2.read()));
}
void compute::thread_add_ln700_172_fu_19820_p2() {
add_ln700_172_fu_19820_p2 = (!sext_ln700_164_fu_19761_p1.read().is_01() || !tmp_631_i_i_fu_19768_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_164_fu_19761_p1.read()) + sc_biguint<48>(tmp_631_i_i_fu_19768_p4.read()));
}
void compute::thread_add_ln700_173_fu_19826_p2() {
add_ln700_173_fu_19826_p2 = (!sext_ln647_13_fu_19799_p1.read().is_01() || !sext_ln647_12_fu_19785_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_13_fu_19799_p1.read()) + sc_bigint<43>(sext_ln647_12_fu_19785_p1.read()));
}
void compute::thread_add_ln700_174_fu_19836_p2() {
add_ln700_174_fu_19836_p2 = (!add_ln700_172_fu_19820_p2.read().is_01() || !sext_ln700_191_fu_19832_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_172_fu_19820_p2.read()) + sc_bigint<48>(sext_ln700_191_fu_19832_p1.read()));
}
void compute::thread_add_ln700_175_fu_19842_p2() {
add_ln700_175_fu_19842_p2 = (!sext_ln700_165_fu_19765_p1.read().is_01() || !sext_ln647_14_fu_19813_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_165_fu_19765_p1.read()) + sc_bigint<43>(sext_ln647_14_fu_19813_p1.read()));
}
void compute::thread_add_ln700_176_fu_19848_p2() {
add_ln700_176_fu_19848_p2 = (!sext_ln700_190_fu_19817_p1.read().is_01() || !sext_ln215_1033_fu_19803_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_190_fu_19817_p1.read()) + sc_bigint<19>(sext_ln215_1033_fu_19803_p1.read()));
}
void compute::thread_add_ln700_177_fu_19858_p2() {
add_ln700_177_fu_19858_p2 = (!sext_ln215_1032_fu_19789_p1.read().is_01() || !sext_ln700_192_fu_19854_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1032_fu_19789_p1.read()) + sc_bigint<20>(sext_ln700_192_fu_19854_p1.read()));
}
void compute::thread_add_ln700_178_fu_19868_p2() {
add_ln700_178_fu_19868_p2 = (!add_ln700_175_fu_19842_p2.read().is_01() || !sext_ln700_193_fu_19864_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_175_fu_19842_p2.read()) + sc_bigint<43>(sext_ln700_193_fu_19864_p1.read()));
}
void compute::thread_add_ln700_179_fu_19878_p2() {
add_ln700_179_fu_19878_p2 = (!add_ln700_174_fu_19836_p2.read().is_01() || !sext_ln700_194_fu_19874_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_174_fu_19836_p2.read()) + sc_bigint<48>(sext_ln700_194_fu_19874_p1.read()));
}
void compute::thread_add_ln700_182_fu_14932_p2() {
add_ln700_182_fu_14932_p2 = (!grp_fu_24666_p3.read().is_01() || !grp_fu_24658_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24666_p3.read()) + sc_bigint<36>(grp_fu_24658_p3.read()));
}
void compute::thread_add_ln700_185_fu_14936_p2() {
add_ln700_185_fu_14936_p2 = (!grp_fu_24638_p3.read().is_01() || !grp_fu_24630_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24638_p3.read()) + sc_bigint<36>(grp_fu_24630_p3.read()));
}
void compute::thread_add_ln700_186_fu_14940_p2() {
add_ln700_186_fu_14940_p2 = (!add_ln700_182_fu_14932_p2.read().is_01() || !add_ln700_185_fu_14936_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_182_fu_14932_p2.read()) + sc_biguint<36>(add_ln700_185_fu_14936_p2.read()));
}
void compute::thread_add_ln700_189_fu_14972_p2() {
add_ln700_189_fu_14972_p2 = (!grp_fu_24722_p3.read().is_01() || !grp_fu_24714_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24722_p3.read()) + sc_bigint<36>(grp_fu_24714_p3.read()));
}
void compute::thread_add_ln700_192_fu_14976_p2() {
add_ln700_192_fu_14976_p2 = (!grp_fu_24694_p3.read().is_01() || !grp_fu_24686_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24694_p3.read()) + sc_bigint<36>(grp_fu_24686_p3.read()));
}
void compute::thread_add_ln700_193_fu_14980_p2() {
add_ln700_193_fu_14980_p2 = (!add_ln700_189_fu_14972_p2.read().is_01() || !add_ln700_192_fu_14976_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_189_fu_14972_p2.read()) + sc_biguint<36>(add_ln700_192_fu_14976_p2.read()));
}
void compute::thread_add_ln700_196_fu_15012_p2() {
add_ln700_196_fu_15012_p2 = (!grp_fu_24778_p3.read().is_01() || !grp_fu_24770_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24778_p3.read()) + sc_bigint<36>(grp_fu_24770_p3.read()));
}
void compute::thread_add_ln700_199_fu_15016_p2() {
add_ln700_199_fu_15016_p2 = (!grp_fu_24750_p3.read().is_01() || !grp_fu_24742_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24750_p3.read()) + sc_bigint<36>(grp_fu_24742_p3.read()));
}
void compute::thread_add_ln700_19_fu_14184_p2() {
add_ln700_19_fu_14184_p2 = (!grp_fu_23630_p3.read().is_01() || !grp_fu_23622_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23630_p3.read()) + sc_bigint<36>(grp_fu_23622_p3.read()));
}
void compute::thread_add_ln700_200_fu_15020_p2() {
add_ln700_200_fu_15020_p2 = (!add_ln700_196_fu_15012_p2.read().is_01() || !add_ln700_199_fu_15016_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_196_fu_15012_p2.read()) + sc_biguint<36>(add_ln700_199_fu_15016_p2.read()));
}
void compute::thread_add_ln700_203_fu_15052_p2() {
add_ln700_203_fu_15052_p2 = (!grp_fu_24834_p3.read().is_01() || !grp_fu_24826_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24834_p3.read()) + sc_bigint<36>(grp_fu_24826_p3.read()));
}
void compute::thread_add_ln700_206_fu_15056_p2() {
add_ln700_206_fu_15056_p2 = (!grp_fu_24806_p3.read().is_01() || !grp_fu_24798_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24806_p3.read()) + sc_bigint<36>(grp_fu_24798_p3.read()));
}
void compute::thread_add_ln700_207_fu_15060_p2() {
add_ln700_207_fu_15060_p2 = (!add_ln700_203_fu_15052_p2.read().is_01() || !add_ln700_206_fu_15056_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_203_fu_15052_p2.read()) + sc_biguint<36>(add_ln700_206_fu_15056_p2.read()));
}
void compute::thread_add_ln700_208_fu_19950_p2() {
add_ln700_208_fu_19950_p2 = (!sext_ln700_203_fu_19891_p1.read().is_01() || !tmp_637_i_i_fu_19898_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_203_fu_19891_p1.read()) + sc_biguint<48>(tmp_637_i_i_fu_19898_p4.read()));
}
void compute::thread_add_ln700_209_fu_19956_p2() {
add_ln700_209_fu_19956_p2 = (!sext_ln647_16_fu_19929_p1.read().is_01() || !sext_ln647_15_fu_19915_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_16_fu_19929_p1.read()) + sc_bigint<43>(sext_ln647_15_fu_19915_p1.read()));
}
void compute::thread_add_ln700_20_fu_14188_p2() {
add_ln700_20_fu_14188_p2 = (!add_ln700_16_fu_14180_p2.read().is_01() || !add_ln700_19_fu_14184_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_16_fu_14180_p2.read()) + sc_biguint<36>(add_ln700_19_fu_14184_p2.read()));
}
void compute::thread_add_ln700_210_fu_19966_p2() {
add_ln700_210_fu_19966_p2 = (!add_ln700_208_fu_19950_p2.read().is_01() || !sext_ln700_230_fu_19962_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_208_fu_19950_p2.read()) + sc_bigint<48>(sext_ln700_230_fu_19962_p1.read()));
}
void compute::thread_add_ln700_211_fu_19972_p2() {
add_ln700_211_fu_19972_p2 = (!sext_ln700_204_fu_19895_p1.read().is_01() || !sext_ln647_17_fu_19943_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_204_fu_19895_p1.read()) + sc_bigint<43>(sext_ln647_17_fu_19943_p1.read()));
}
void compute::thread_add_ln700_212_fu_19978_p2() {
add_ln700_212_fu_19978_p2 = (!sext_ln700_229_fu_19947_p1.read().is_01() || !sext_ln215_1035_fu_19933_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_229_fu_19947_p1.read()) + sc_bigint<19>(sext_ln215_1035_fu_19933_p1.read()));
}
void compute::thread_add_ln700_213_fu_19988_p2() {
add_ln700_213_fu_19988_p2 = (!sext_ln215_1034_fu_19919_p1.read().is_01() || !sext_ln700_231_fu_19984_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1034_fu_19919_p1.read()) + sc_bigint<20>(sext_ln700_231_fu_19984_p1.read()));
}
void compute::thread_add_ln700_214_fu_19998_p2() {
add_ln700_214_fu_19998_p2 = (!add_ln700_211_fu_19972_p2.read().is_01() || !sext_ln700_232_fu_19994_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_211_fu_19972_p2.read()) + sc_bigint<43>(sext_ln700_232_fu_19994_p1.read()));
}
void compute::thread_add_ln700_215_fu_20008_p2() {
add_ln700_215_fu_20008_p2 = (!add_ln700_210_fu_19966_p2.read().is_01() || !sext_ln700_233_fu_20004_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_210_fu_19966_p2.read()) + sc_bigint<48>(sext_ln700_233_fu_20004_p1.read()));
}
void compute::thread_add_ln700_218_fu_15092_p2() {
add_ln700_218_fu_15092_p2 = (!grp_fu_24890_p3.read().is_01() || !grp_fu_24882_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24890_p3.read()) + sc_bigint<36>(grp_fu_24882_p3.read()));
}
void compute::thread_add_ln700_221_fu_15096_p2() {
add_ln700_221_fu_15096_p2 = (!grp_fu_24862_p3.read().is_01() || !grp_fu_24854_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24862_p3.read()) + sc_bigint<36>(grp_fu_24854_p3.read()));
}
void compute::thread_add_ln700_222_fu_15100_p2() {
add_ln700_222_fu_15100_p2 = (!add_ln700_218_fu_15092_p2.read().is_01() || !add_ln700_221_fu_15096_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_218_fu_15092_p2.read()) + sc_biguint<36>(add_ln700_221_fu_15096_p2.read()));
}
void compute::thread_add_ln700_225_fu_15132_p2() {
add_ln700_225_fu_15132_p2 = (!grp_fu_24946_p3.read().is_01() || !grp_fu_24938_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24946_p3.read()) + sc_bigint<36>(grp_fu_24938_p3.read()));
}
void compute::thread_add_ln700_228_fu_15136_p2() {
add_ln700_228_fu_15136_p2 = (!grp_fu_24918_p3.read().is_01() || !grp_fu_24910_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24918_p3.read()) + sc_bigint<36>(grp_fu_24910_p3.read()));
}
void compute::thread_add_ln700_229_fu_15140_p2() {
add_ln700_229_fu_15140_p2 = (!add_ln700_225_fu_15132_p2.read().is_01() || !add_ln700_228_fu_15136_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_225_fu_15132_p2.read()) + sc_biguint<36>(add_ln700_228_fu_15136_p2.read()));
}
void compute::thread_add_ln700_232_fu_15172_p2() {
add_ln700_232_fu_15172_p2 = (!grp_fu_25002_p3.read().is_01() || !grp_fu_24994_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25002_p3.read()) + sc_bigint<36>(grp_fu_24994_p3.read()));
}
void compute::thread_add_ln700_235_fu_15176_p2() {
add_ln700_235_fu_15176_p2 = (!grp_fu_24974_p3.read().is_01() || !grp_fu_24966_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24974_p3.read()) + sc_bigint<36>(grp_fu_24966_p3.read()));
}
void compute::thread_add_ln700_236_fu_15180_p2() {
add_ln700_236_fu_15180_p2 = (!add_ln700_232_fu_15172_p2.read().is_01() || !add_ln700_235_fu_15176_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_232_fu_15172_p2.read()) + sc_biguint<36>(add_ln700_235_fu_15176_p2.read()));
}
void compute::thread_add_ln700_239_fu_15212_p2() {
add_ln700_239_fu_15212_p2 = (!grp_fu_25058_p3.read().is_01() || !grp_fu_25050_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25058_p3.read()) + sc_bigint<36>(grp_fu_25050_p3.read()));
}
void compute::thread_add_ln700_23_fu_14252_p2() {
add_ln700_23_fu_14252_p2 = (!grp_fu_23714_p3.read().is_01() || !grp_fu_23706_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23714_p3.read()) + sc_bigint<36>(grp_fu_23706_p3.read()));
}
void compute::thread_add_ln700_242_fu_15216_p2() {
add_ln700_242_fu_15216_p2 = (!grp_fu_25030_p3.read().is_01() || !grp_fu_25022_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25030_p3.read()) + sc_bigint<36>(grp_fu_25022_p3.read()));
}
void compute::thread_add_ln700_243_fu_15220_p2() {
add_ln700_243_fu_15220_p2 = (!add_ln700_239_fu_15212_p2.read().is_01() || !add_ln700_242_fu_15216_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_239_fu_15212_p2.read()) + sc_biguint<36>(add_ln700_242_fu_15216_p2.read()));
}
void compute::thread_add_ln700_244_fu_20080_p2() {
add_ln700_244_fu_20080_p2 = (!sext_ln700_242_fu_20021_p1.read().is_01() || !tmp_643_i_i_fu_20028_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_242_fu_20021_p1.read()) + sc_biguint<48>(tmp_643_i_i_fu_20028_p4.read()));
}
void compute::thread_add_ln700_245_fu_20086_p2() {
add_ln700_245_fu_20086_p2 = (!sext_ln647_19_fu_20059_p1.read().is_01() || !sext_ln647_18_fu_20045_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_19_fu_20059_p1.read()) + sc_bigint<43>(sext_ln647_18_fu_20045_p1.read()));
}
void compute::thread_add_ln700_246_fu_20096_p2() {
add_ln700_246_fu_20096_p2 = (!add_ln700_244_fu_20080_p2.read().is_01() || !sext_ln700_269_fu_20092_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_244_fu_20080_p2.read()) + sc_bigint<48>(sext_ln700_269_fu_20092_p1.read()));
}
void compute::thread_add_ln700_247_fu_20102_p2() {
add_ln700_247_fu_20102_p2 = (!sext_ln700_243_fu_20025_p1.read().is_01() || !sext_ln647_20_fu_20073_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_243_fu_20025_p1.read()) + sc_bigint<43>(sext_ln647_20_fu_20073_p1.read()));
}
void compute::thread_add_ln700_248_fu_20108_p2() {
add_ln700_248_fu_20108_p2 = (!sext_ln700_268_fu_20077_p1.read().is_01() || !sext_ln215_1037_fu_20063_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_268_fu_20077_p1.read()) + sc_bigint<19>(sext_ln215_1037_fu_20063_p1.read()));
}
void compute::thread_add_ln700_249_fu_20118_p2() {
add_ln700_249_fu_20118_p2 = (!sext_ln215_1036_fu_20049_p1.read().is_01() || !sext_ln700_270_fu_20114_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1036_fu_20049_p1.read()) + sc_bigint<20>(sext_ln700_270_fu_20114_p1.read()));
}
void compute::thread_add_ln700_250_fu_20128_p2() {
add_ln700_250_fu_20128_p2 = (!add_ln700_247_fu_20102_p2.read().is_01() || !sext_ln700_271_fu_20124_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_247_fu_20102_p2.read()) + sc_bigint<43>(sext_ln700_271_fu_20124_p1.read()));
}
void compute::thread_add_ln700_251_fu_20138_p2() {
add_ln700_251_fu_20138_p2 = (!add_ln700_246_fu_20096_p2.read().is_01() || !sext_ln700_272_fu_20134_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_246_fu_20096_p2.read()) + sc_bigint<48>(sext_ln700_272_fu_20134_p1.read()));
}
void compute::thread_add_ln700_254_fu_15252_p2() {
add_ln700_254_fu_15252_p2 = (!grp_fu_25114_p3.read().is_01() || !grp_fu_25106_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25114_p3.read()) + sc_bigint<36>(grp_fu_25106_p3.read()));
}
void compute::thread_add_ln700_257_fu_15256_p2() {
add_ln700_257_fu_15256_p2 = (!grp_fu_25086_p3.read().is_01() || !grp_fu_25078_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25086_p3.read()) + sc_bigint<36>(grp_fu_25078_p3.read()));
}
void compute::thread_add_ln700_258_fu_15260_p2() {
add_ln700_258_fu_15260_p2 = (!add_ln700_254_fu_15252_p2.read().is_01() || !add_ln700_257_fu_15256_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_254_fu_15252_p2.read()) + sc_biguint<36>(add_ln700_257_fu_15256_p2.read()));
}
void compute::thread_add_ln700_261_fu_15292_p2() {
add_ln700_261_fu_15292_p2 = (!grp_fu_25170_p3.read().is_01() || !grp_fu_25162_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25170_p3.read()) + sc_bigint<36>(grp_fu_25162_p3.read()));
}
void compute::thread_add_ln700_264_fu_15296_p2() {
add_ln700_264_fu_15296_p2 = (!grp_fu_25142_p3.read().is_01() || !grp_fu_25134_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25142_p3.read()) + sc_bigint<36>(grp_fu_25134_p3.read()));
}
void compute::thread_add_ln700_265_fu_15300_p2() {
add_ln700_265_fu_15300_p2 = (!add_ln700_261_fu_15292_p2.read().is_01() || !add_ln700_264_fu_15296_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_261_fu_15292_p2.read()) + sc_biguint<36>(add_ln700_264_fu_15296_p2.read()));
}
void compute::thread_add_ln700_268_fu_15332_p2() {
add_ln700_268_fu_15332_p2 = (!grp_fu_25226_p3.read().is_01() || !grp_fu_25218_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25226_p3.read()) + sc_bigint<36>(grp_fu_25218_p3.read()));
}
void compute::thread_add_ln700_26_fu_14256_p2() {
add_ln700_26_fu_14256_p2 = (!grp_fu_23686_p3.read().is_01() || !grp_fu_23678_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23686_p3.read()) + sc_bigint<36>(grp_fu_23678_p3.read()));
}
void compute::thread_add_ln700_271_fu_15336_p2() {
add_ln700_271_fu_15336_p2 = (!grp_fu_25198_p3.read().is_01() || !grp_fu_25190_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25198_p3.read()) + sc_bigint<36>(grp_fu_25190_p3.read()));
}
void compute::thread_add_ln700_272_fu_15340_p2() {
add_ln700_272_fu_15340_p2 = (!add_ln700_268_fu_15332_p2.read().is_01() || !add_ln700_271_fu_15336_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_268_fu_15332_p2.read()) + sc_biguint<36>(add_ln700_271_fu_15336_p2.read()));
}
void compute::thread_add_ln700_275_fu_15372_p2() {
add_ln700_275_fu_15372_p2 = (!grp_fu_25282_p3.read().is_01() || !grp_fu_25274_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25282_p3.read()) + sc_bigint<36>(grp_fu_25274_p3.read()));
}
void compute::thread_add_ln700_278_fu_15376_p2() {
add_ln700_278_fu_15376_p2 = (!grp_fu_25254_p3.read().is_01() || !grp_fu_25246_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25254_p3.read()) + sc_bigint<36>(grp_fu_25246_p3.read()));
}
void compute::thread_add_ln700_279_fu_15380_p2() {
add_ln700_279_fu_15380_p2 = (!add_ln700_275_fu_15372_p2.read().is_01() || !add_ln700_278_fu_15376_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_275_fu_15372_p2.read()) + sc_biguint<36>(add_ln700_278_fu_15376_p2.read()));
}
void compute::thread_add_ln700_27_fu_14260_p2() {
add_ln700_27_fu_14260_p2 = (!add_ln700_23_fu_14252_p2.read().is_01() || !add_ln700_26_fu_14256_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_23_fu_14252_p2.read()) + sc_biguint<36>(add_ln700_26_fu_14256_p2.read()));
}
void compute::thread_add_ln700_280_fu_20210_p2() {
add_ln700_280_fu_20210_p2 = (!sext_ln700_281_fu_20151_p1.read().is_01() || !tmp_649_i_i_fu_20158_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_281_fu_20151_p1.read()) + sc_biguint<48>(tmp_649_i_i_fu_20158_p4.read()));
}
void compute::thread_add_ln700_281_fu_20216_p2() {
add_ln700_281_fu_20216_p2 = (!sext_ln647_22_fu_20189_p1.read().is_01() || !sext_ln647_21_fu_20175_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_22_fu_20189_p1.read()) + sc_bigint<43>(sext_ln647_21_fu_20175_p1.read()));
}
void compute::thread_add_ln700_282_fu_20226_p2() {
add_ln700_282_fu_20226_p2 = (!add_ln700_280_fu_20210_p2.read().is_01() || !sext_ln700_308_fu_20222_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_280_fu_20210_p2.read()) + sc_bigint<48>(sext_ln700_308_fu_20222_p1.read()));
}
void compute::thread_add_ln700_283_fu_20232_p2() {
add_ln700_283_fu_20232_p2 = (!sext_ln700_282_fu_20155_p1.read().is_01() || !sext_ln647_23_fu_20203_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_282_fu_20155_p1.read()) + sc_bigint<43>(sext_ln647_23_fu_20203_p1.read()));
}
void compute::thread_add_ln700_284_fu_20238_p2() {
add_ln700_284_fu_20238_p2 = (!sext_ln700_307_fu_20207_p1.read().is_01() || !sext_ln215_1039_fu_20193_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_307_fu_20207_p1.read()) + sc_bigint<19>(sext_ln215_1039_fu_20193_p1.read()));
}
void compute::thread_add_ln700_285_fu_20248_p2() {
add_ln700_285_fu_20248_p2 = (!sext_ln215_1038_fu_20179_p1.read().is_01() || !sext_ln700_309_fu_20244_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1038_fu_20179_p1.read()) + sc_bigint<20>(sext_ln700_309_fu_20244_p1.read()));
}
void compute::thread_add_ln700_286_fu_20258_p2() {
add_ln700_286_fu_20258_p2 = (!add_ln700_283_fu_20232_p2.read().is_01() || !sext_ln700_310_fu_20254_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_283_fu_20232_p2.read()) + sc_bigint<43>(sext_ln700_310_fu_20254_p1.read()));
}
void compute::thread_add_ln700_287_fu_20268_p2() {
add_ln700_287_fu_20268_p2 = (!add_ln700_282_fu_20226_p2.read().is_01() || !sext_ln700_311_fu_20264_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_282_fu_20226_p2.read()) + sc_bigint<48>(sext_ln700_311_fu_20264_p1.read()));
}
void compute::thread_add_ln700_28_fu_19300_p2() {
add_ln700_28_fu_19300_p2 = (!sext_ln700_8_fu_19247_p1.read().is_01() || !trunc_ln700_fu_19254_p1.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_8_fu_19247_p1.read()) + sc_biguint<48>(trunc_ln700_fu_19254_p1.read()));
}
void compute::thread_add_ln700_290_fu_15412_p2() {
add_ln700_290_fu_15412_p2 = (!grp_fu_25338_p3.read().is_01() || !grp_fu_25330_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25338_p3.read()) + sc_bigint<36>(grp_fu_25330_p3.read()));
}
void compute::thread_add_ln700_293_fu_15416_p2() {
add_ln700_293_fu_15416_p2 = (!grp_fu_25310_p3.read().is_01() || !grp_fu_25302_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25310_p3.read()) + sc_bigint<36>(grp_fu_25302_p3.read()));
}
void compute::thread_add_ln700_294_fu_15420_p2() {
add_ln700_294_fu_15420_p2 = (!add_ln700_290_fu_15412_p2.read().is_01() || !add_ln700_293_fu_15416_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_290_fu_15412_p2.read()) + sc_biguint<36>(add_ln700_293_fu_15416_p2.read()));
}
void compute::thread_add_ln700_297_fu_15452_p2() {
add_ln700_297_fu_15452_p2 = (!grp_fu_25394_p3.read().is_01() || !grp_fu_25386_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25394_p3.read()) + sc_bigint<36>(grp_fu_25386_p3.read()));
}
void compute::thread_add_ln700_29_fu_19306_p2() {
add_ln700_29_fu_19306_p2 = (!sext_ln647_1_fu_19279_p1.read().is_01() || !sext_ln647_fu_19265_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_1_fu_19279_p1.read()) + sc_bigint<43>(sext_ln647_fu_19265_p1.read()));
}
void compute::thread_add_ln700_2_fu_14036_p2() {
add_ln700_2_fu_14036_p2 = (!grp_fu_23546_p3.read().is_01() || !grp_fu_23538_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23546_p3.read()) + sc_bigint<36>(grp_fu_23538_p3.read()));
}
void compute::thread_add_ln700_300_fu_15456_p2() {
add_ln700_300_fu_15456_p2 = (!grp_fu_25366_p3.read().is_01() || !grp_fu_25358_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25366_p3.read()) + sc_bigint<36>(grp_fu_25358_p3.read()));
}
void compute::thread_add_ln700_301_fu_15460_p2() {
add_ln700_301_fu_15460_p2 = (!add_ln700_297_fu_15452_p2.read().is_01() || !add_ln700_300_fu_15456_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_297_fu_15452_p2.read()) + sc_biguint<36>(add_ln700_300_fu_15456_p2.read()));
}
void compute::thread_add_ln700_304_fu_15492_p2() {
add_ln700_304_fu_15492_p2 = (!grp_fu_25450_p3.read().is_01() || !grp_fu_25442_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25450_p3.read()) + sc_bigint<36>(grp_fu_25442_p3.read()));
}
void compute::thread_add_ln700_307_fu_15496_p2() {
add_ln700_307_fu_15496_p2 = (!grp_fu_25422_p3.read().is_01() || !grp_fu_25414_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25422_p3.read()) + sc_bigint<36>(grp_fu_25414_p3.read()));
}
void compute::thread_add_ln700_308_fu_15500_p2() {
add_ln700_308_fu_15500_p2 = (!add_ln700_304_fu_15492_p2.read().is_01() || !add_ln700_307_fu_15496_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_304_fu_15492_p2.read()) + sc_biguint<36>(add_ln700_307_fu_15496_p2.read()));
}
void compute::thread_add_ln700_30_fu_19316_p2() {
add_ln700_30_fu_19316_p2 = (!add_ln700_28_fu_19300_p2.read().is_01() || !sext_ln700_35_fu_19312_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_28_fu_19300_p2.read()) + sc_bigint<48>(sext_ln700_35_fu_19312_p1.read()));
}
void compute::thread_add_ln700_311_fu_15532_p2() {
add_ln700_311_fu_15532_p2 = (!grp_fu_25506_p3.read().is_01() || !grp_fu_25498_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25506_p3.read()) + sc_bigint<36>(grp_fu_25498_p3.read()));
}
void compute::thread_add_ln700_314_fu_15536_p2() {
add_ln700_314_fu_15536_p2 = (!grp_fu_25478_p3.read().is_01() || !grp_fu_25470_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25478_p3.read()) + sc_bigint<36>(grp_fu_25470_p3.read()));
}
void compute::thread_add_ln700_315_fu_15540_p2() {
add_ln700_315_fu_15540_p2 = (!add_ln700_311_fu_15532_p2.read().is_01() || !add_ln700_314_fu_15536_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_311_fu_15532_p2.read()) + sc_biguint<36>(add_ln700_314_fu_15536_p2.read()));
}
void compute::thread_add_ln700_316_fu_20340_p2() {
add_ln700_316_fu_20340_p2 = (!sext_ln700_320_fu_20281_p1.read().is_01() || !tmp_655_i_i_fu_20288_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_320_fu_20281_p1.read()) + sc_biguint<48>(tmp_655_i_i_fu_20288_p4.read()));
}
void compute::thread_add_ln700_317_fu_20346_p2() {
add_ln700_317_fu_20346_p2 = (!sext_ln647_25_fu_20319_p1.read().is_01() || !sext_ln647_24_fu_20305_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_25_fu_20319_p1.read()) + sc_bigint<43>(sext_ln647_24_fu_20305_p1.read()));
}
void compute::thread_add_ln700_318_fu_20356_p2() {
add_ln700_318_fu_20356_p2 = (!add_ln700_316_fu_20340_p2.read().is_01() || !sext_ln700_347_fu_20352_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_316_fu_20340_p2.read()) + sc_bigint<48>(sext_ln700_347_fu_20352_p1.read()));
}
void compute::thread_add_ln700_319_fu_20362_p2() {
add_ln700_319_fu_20362_p2 = (!sext_ln700_321_fu_20285_p1.read().is_01() || !sext_ln647_26_fu_20333_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_321_fu_20285_p1.read()) + sc_bigint<43>(sext_ln647_26_fu_20333_p1.read()));
}
void compute::thread_add_ln700_31_fu_19322_p2() {
add_ln700_31_fu_19322_p2 = (!sext_ln700_9_fu_19251_p1.read().is_01() || !sext_ln647_2_fu_19293_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_9_fu_19251_p1.read()) + sc_bigint<43>(sext_ln647_2_fu_19293_p1.read()));
}
void compute::thread_add_ln700_320_fu_20368_p2() {
add_ln700_320_fu_20368_p2 = (!sext_ln700_346_fu_20337_p1.read().is_01() || !sext_ln215_1041_fu_20323_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_346_fu_20337_p1.read()) + sc_bigint<19>(sext_ln215_1041_fu_20323_p1.read()));
}
void compute::thread_add_ln700_321_fu_20378_p2() {
add_ln700_321_fu_20378_p2 = (!sext_ln215_1040_fu_20309_p1.read().is_01() || !sext_ln700_348_fu_20374_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1040_fu_20309_p1.read()) + sc_bigint<20>(sext_ln700_348_fu_20374_p1.read()));
}
void compute::thread_add_ln700_322_fu_20388_p2() {
add_ln700_322_fu_20388_p2 = (!add_ln700_319_fu_20362_p2.read().is_01() || !sext_ln700_349_fu_20384_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_319_fu_20362_p2.read()) + sc_bigint<43>(sext_ln700_349_fu_20384_p1.read()));
}
void compute::thread_add_ln700_323_fu_20398_p2() {
add_ln700_323_fu_20398_p2 = (!add_ln700_318_fu_20356_p2.read().is_01() || !sext_ln700_350_fu_20394_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_318_fu_20356_p2.read()) + sc_bigint<48>(sext_ln700_350_fu_20394_p1.read()));
}
void compute::thread_add_ln700_326_fu_15572_p2() {
add_ln700_326_fu_15572_p2 = (!grp_fu_25562_p3.read().is_01() || !grp_fu_25554_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25562_p3.read()) + sc_bigint<36>(grp_fu_25554_p3.read()));
}
void compute::thread_add_ln700_329_fu_15576_p2() {
add_ln700_329_fu_15576_p2 = (!grp_fu_25534_p3.read().is_01() || !grp_fu_25526_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25534_p3.read()) + sc_bigint<36>(grp_fu_25526_p3.read()));
}
void compute::thread_add_ln700_32_fu_19328_p2() {
add_ln700_32_fu_19328_p2 = (!sext_ln700_34_fu_19297_p1.read().is_01() || !sext_ln215_1025_fu_19283_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_34_fu_19297_p1.read()) + sc_bigint<19>(sext_ln215_1025_fu_19283_p1.read()));
}
void compute::thread_add_ln700_330_fu_15580_p2() {
add_ln700_330_fu_15580_p2 = (!add_ln700_326_fu_15572_p2.read().is_01() || !add_ln700_329_fu_15576_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_326_fu_15572_p2.read()) + sc_biguint<36>(add_ln700_329_fu_15576_p2.read()));
}
void compute::thread_add_ln700_333_fu_15612_p2() {
add_ln700_333_fu_15612_p2 = (!grp_fu_25618_p3.read().is_01() || !grp_fu_25610_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25618_p3.read()) + sc_bigint<36>(grp_fu_25610_p3.read()));
}
void compute::thread_add_ln700_336_fu_15616_p2() {
add_ln700_336_fu_15616_p2 = (!grp_fu_25590_p3.read().is_01() || !grp_fu_25582_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25590_p3.read()) + sc_bigint<36>(grp_fu_25582_p3.read()));
}
void compute::thread_add_ln700_337_fu_15620_p2() {
add_ln700_337_fu_15620_p2 = (!add_ln700_333_fu_15612_p2.read().is_01() || !add_ln700_336_fu_15616_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_333_fu_15612_p2.read()) + sc_biguint<36>(add_ln700_336_fu_15616_p2.read()));
}
void compute::thread_add_ln700_33_fu_19338_p2() {
add_ln700_33_fu_19338_p2 = (!sext_ln215_1024_fu_19269_p1.read().is_01() || !sext_ln700_36_fu_19334_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1024_fu_19269_p1.read()) + sc_bigint<20>(sext_ln700_36_fu_19334_p1.read()));
}
void compute::thread_add_ln700_340_fu_15652_p2() {
add_ln700_340_fu_15652_p2 = (!grp_fu_25674_p3.read().is_01() || !grp_fu_25666_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25674_p3.read()) + sc_bigint<36>(grp_fu_25666_p3.read()));
}
void compute::thread_add_ln700_343_fu_15656_p2() {
add_ln700_343_fu_15656_p2 = (!grp_fu_25646_p3.read().is_01() || !grp_fu_25638_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25646_p3.read()) + sc_bigint<36>(grp_fu_25638_p3.read()));
}
void compute::thread_add_ln700_344_fu_15660_p2() {
add_ln700_344_fu_15660_p2 = (!add_ln700_340_fu_15652_p2.read().is_01() || !add_ln700_343_fu_15656_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_340_fu_15652_p2.read()) + sc_biguint<36>(add_ln700_343_fu_15656_p2.read()));
}
void compute::thread_add_ln700_347_fu_15692_p2() {
add_ln700_347_fu_15692_p2 = (!grp_fu_25730_p3.read().is_01() || !grp_fu_25722_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25730_p3.read()) + sc_bigint<36>(grp_fu_25722_p3.read()));
}
void compute::thread_add_ln700_34_fu_19348_p2() {
add_ln700_34_fu_19348_p2 = (!add_ln700_31_fu_19322_p2.read().is_01() || !sext_ln700_37_fu_19344_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_31_fu_19322_p2.read()) + sc_bigint<43>(sext_ln700_37_fu_19344_p1.read()));
}
void compute::thread_add_ln700_350_fu_15696_p2() {
add_ln700_350_fu_15696_p2 = (!grp_fu_25702_p3.read().is_01() || !grp_fu_25694_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25702_p3.read()) + sc_bigint<36>(grp_fu_25694_p3.read()));
}
void compute::thread_add_ln700_351_fu_15700_p2() {
add_ln700_351_fu_15700_p2 = (!add_ln700_347_fu_15692_p2.read().is_01() || !add_ln700_350_fu_15696_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_347_fu_15692_p2.read()) + sc_biguint<36>(add_ln700_350_fu_15696_p2.read()));
}
void compute::thread_add_ln700_352_fu_20470_p2() {
add_ln700_352_fu_20470_p2 = (!sext_ln700_359_fu_20411_p1.read().is_01() || !tmp_661_i_i_fu_20418_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_359_fu_20411_p1.read()) + sc_biguint<48>(tmp_661_i_i_fu_20418_p4.read()));
}
void compute::thread_add_ln700_353_fu_20476_p2() {
add_ln700_353_fu_20476_p2 = (!sext_ln647_28_fu_20449_p1.read().is_01() || !sext_ln647_27_fu_20435_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_28_fu_20449_p1.read()) + sc_bigint<43>(sext_ln647_27_fu_20435_p1.read()));
}
void compute::thread_add_ln700_354_fu_20486_p2() {
add_ln700_354_fu_20486_p2 = (!add_ln700_352_fu_20470_p2.read().is_01() || !sext_ln700_386_fu_20482_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_352_fu_20470_p2.read()) + sc_bigint<48>(sext_ln700_386_fu_20482_p1.read()));
}
void compute::thread_add_ln700_355_fu_20492_p2() {
add_ln700_355_fu_20492_p2 = (!sext_ln700_360_fu_20415_p1.read().is_01() || !sext_ln647_29_fu_20463_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_360_fu_20415_p1.read()) + sc_bigint<43>(sext_ln647_29_fu_20463_p1.read()));
}
void compute::thread_add_ln700_356_fu_20498_p2() {
add_ln700_356_fu_20498_p2 = (!sext_ln700_385_fu_20467_p1.read().is_01() || !sext_ln215_1043_fu_20453_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_385_fu_20467_p1.read()) + sc_bigint<19>(sext_ln215_1043_fu_20453_p1.read()));
}
void compute::thread_add_ln700_357_fu_20508_p2() {
add_ln700_357_fu_20508_p2 = (!sext_ln215_1042_fu_20439_p1.read().is_01() || !sext_ln700_387_fu_20504_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1042_fu_20439_p1.read()) + sc_bigint<20>(sext_ln700_387_fu_20504_p1.read()));
}
void compute::thread_add_ln700_358_fu_20518_p2() {
add_ln700_358_fu_20518_p2 = (!add_ln700_355_fu_20492_p2.read().is_01() || !sext_ln700_388_fu_20514_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_355_fu_20492_p2.read()) + sc_bigint<43>(sext_ln700_388_fu_20514_p1.read()));
}
void compute::thread_add_ln700_359_fu_20528_p2() {
add_ln700_359_fu_20528_p2 = (!add_ln700_354_fu_20486_p2.read().is_01() || !sext_ln700_389_fu_20524_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_354_fu_20486_p2.read()) + sc_bigint<48>(sext_ln700_389_fu_20524_p1.read()));
}
void compute::thread_add_ln700_35_fu_19358_p2() {
add_ln700_35_fu_19358_p2 = (!add_ln700_30_fu_19316_p2.read().is_01() || !sext_ln700_38_fu_19354_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_30_fu_19316_p2.read()) + sc_bigint<48>(sext_ln700_38_fu_19354_p1.read()));
}
void compute::thread_add_ln700_362_fu_15732_p2() {
add_ln700_362_fu_15732_p2 = (!grp_fu_25786_p3.read().is_01() || !grp_fu_25778_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25786_p3.read()) + sc_bigint<36>(grp_fu_25778_p3.read()));
}
void compute::thread_add_ln700_365_fu_15736_p2() {
add_ln700_365_fu_15736_p2 = (!grp_fu_25758_p3.read().is_01() || !grp_fu_25750_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25758_p3.read()) + sc_bigint<36>(grp_fu_25750_p3.read()));
}
void compute::thread_add_ln700_366_fu_15740_p2() {
add_ln700_366_fu_15740_p2 = (!add_ln700_362_fu_15732_p2.read().is_01() || !add_ln700_365_fu_15736_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_362_fu_15732_p2.read()) + sc_biguint<36>(add_ln700_365_fu_15736_p2.read()));
}
void compute::thread_add_ln700_369_fu_15772_p2() {
add_ln700_369_fu_15772_p2 = (!grp_fu_25842_p3.read().is_01() || !grp_fu_25834_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25842_p3.read()) + sc_bigint<36>(grp_fu_25834_p3.read()));
}
void compute::thread_add_ln700_372_fu_15776_p2() {
add_ln700_372_fu_15776_p2 = (!grp_fu_25814_p3.read().is_01() || !grp_fu_25806_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25814_p3.read()) + sc_bigint<36>(grp_fu_25806_p3.read()));
}
void compute::thread_add_ln700_373_fu_15780_p2() {
add_ln700_373_fu_15780_p2 = (!add_ln700_369_fu_15772_p2.read().is_01() || !add_ln700_372_fu_15776_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_369_fu_15772_p2.read()) + sc_biguint<36>(add_ln700_372_fu_15776_p2.read()));
}
void compute::thread_add_ln700_376_fu_15812_p2() {
add_ln700_376_fu_15812_p2 = (!grp_fu_25898_p3.read().is_01() || !grp_fu_25890_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25898_p3.read()) + sc_bigint<36>(grp_fu_25890_p3.read()));
}
void compute::thread_add_ln700_379_fu_15816_p2() {
add_ln700_379_fu_15816_p2 = (!grp_fu_25870_p3.read().is_01() || !grp_fu_25862_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25870_p3.read()) + sc_bigint<36>(grp_fu_25862_p3.read()));
}
void compute::thread_add_ln700_380_fu_15820_p2() {
add_ln700_380_fu_15820_p2 = (!add_ln700_376_fu_15812_p2.read().is_01() || !add_ln700_379_fu_15816_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_376_fu_15812_p2.read()) + sc_biguint<36>(add_ln700_379_fu_15816_p2.read()));
}
void compute::thread_add_ln700_383_fu_15852_p2() {
add_ln700_383_fu_15852_p2 = (!grp_fu_25954_p3.read().is_01() || !grp_fu_25946_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25954_p3.read()) + sc_bigint<36>(grp_fu_25946_p3.read()));
}
void compute::thread_add_ln700_386_fu_15856_p2() {
add_ln700_386_fu_15856_p2 = (!grp_fu_25926_p3.read().is_01() || !grp_fu_25918_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25926_p3.read()) + sc_bigint<36>(grp_fu_25918_p3.read()));
}
void compute::thread_add_ln700_387_fu_15860_p2() {
add_ln700_387_fu_15860_p2 = (!add_ln700_383_fu_15852_p2.read().is_01() || !add_ln700_386_fu_15856_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_383_fu_15852_p2.read()) + sc_biguint<36>(add_ln700_386_fu_15856_p2.read()));
}
void compute::thread_add_ln700_388_fu_20600_p2() {
add_ln700_388_fu_20600_p2 = (!sext_ln700_398_fu_20541_p1.read().is_01() || !tmp_667_i_i_fu_20548_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_398_fu_20541_p1.read()) + sc_biguint<48>(tmp_667_i_i_fu_20548_p4.read()));
}
void compute::thread_add_ln700_389_fu_20606_p2() {
add_ln700_389_fu_20606_p2 = (!sext_ln647_31_fu_20579_p1.read().is_01() || !sext_ln647_30_fu_20565_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_31_fu_20579_p1.read()) + sc_bigint<43>(sext_ln647_30_fu_20565_p1.read()));
}
void compute::thread_add_ln700_38_fu_14292_p2() {
add_ln700_38_fu_14292_p2 = (!grp_fu_23770_p3.read().is_01() || !grp_fu_23762_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23770_p3.read()) + sc_bigint<36>(grp_fu_23762_p3.read()));
}
void compute::thread_add_ln700_390_fu_20616_p2() {
add_ln700_390_fu_20616_p2 = (!add_ln700_388_fu_20600_p2.read().is_01() || !sext_ln700_425_fu_20612_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_388_fu_20600_p2.read()) + sc_bigint<48>(sext_ln700_425_fu_20612_p1.read()));
}
void compute::thread_add_ln700_391_fu_20622_p2() {
add_ln700_391_fu_20622_p2 = (!sext_ln700_399_fu_20545_p1.read().is_01() || !sext_ln647_32_fu_20593_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_399_fu_20545_p1.read()) + sc_bigint<43>(sext_ln647_32_fu_20593_p1.read()));
}
void compute::thread_add_ln700_392_fu_20628_p2() {
add_ln700_392_fu_20628_p2 = (!sext_ln700_424_fu_20597_p1.read().is_01() || !sext_ln215_1045_fu_20583_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_424_fu_20597_p1.read()) + sc_bigint<19>(sext_ln215_1045_fu_20583_p1.read()));
}
void compute::thread_add_ln700_393_fu_20638_p2() {
add_ln700_393_fu_20638_p2 = (!sext_ln215_1044_fu_20569_p1.read().is_01() || !sext_ln700_426_fu_20634_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1044_fu_20569_p1.read()) + sc_bigint<20>(sext_ln700_426_fu_20634_p1.read()));
}
void compute::thread_add_ln700_394_fu_20648_p2() {
add_ln700_394_fu_20648_p2 = (!add_ln700_391_fu_20622_p2.read().is_01() || !sext_ln700_427_fu_20644_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_391_fu_20622_p2.read()) + sc_bigint<43>(sext_ln700_427_fu_20644_p1.read()));
}
void compute::thread_add_ln700_395_fu_20658_p2() {
add_ln700_395_fu_20658_p2 = (!add_ln700_390_fu_20616_p2.read().is_01() || !sext_ln700_428_fu_20654_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_390_fu_20616_p2.read()) + sc_bigint<48>(sext_ln700_428_fu_20654_p1.read()));
}
void compute::thread_add_ln700_398_fu_15892_p2() {
add_ln700_398_fu_15892_p2 = (!grp_fu_26010_p3.read().is_01() || !grp_fu_26002_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26010_p3.read()) + sc_bigint<36>(grp_fu_26002_p3.read()));
}
void compute::thread_add_ln700_401_fu_15896_p2() {
add_ln700_401_fu_15896_p2 = (!grp_fu_25982_p3.read().is_01() || !grp_fu_25974_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_25982_p3.read()) + sc_bigint<36>(grp_fu_25974_p3.read()));
}
void compute::thread_add_ln700_402_fu_15900_p2() {
add_ln700_402_fu_15900_p2 = (!add_ln700_398_fu_15892_p2.read().is_01() || !add_ln700_401_fu_15896_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_398_fu_15892_p2.read()) + sc_biguint<36>(add_ln700_401_fu_15896_p2.read()));
}
void compute::thread_add_ln700_405_fu_15932_p2() {
add_ln700_405_fu_15932_p2 = (!grp_fu_26066_p3.read().is_01() || !grp_fu_26058_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26066_p3.read()) + sc_bigint<36>(grp_fu_26058_p3.read()));
}
void compute::thread_add_ln700_408_fu_15936_p2() {
add_ln700_408_fu_15936_p2 = (!grp_fu_26038_p3.read().is_01() || !grp_fu_26030_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26038_p3.read()) + sc_bigint<36>(grp_fu_26030_p3.read()));
}
void compute::thread_add_ln700_409_fu_15940_p2() {
add_ln700_409_fu_15940_p2 = (!add_ln700_405_fu_15932_p2.read().is_01() || !add_ln700_408_fu_15936_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_405_fu_15932_p2.read()) + sc_biguint<36>(add_ln700_408_fu_15936_p2.read()));
}
void compute::thread_add_ln700_412_fu_15972_p2() {
add_ln700_412_fu_15972_p2 = (!grp_fu_26122_p3.read().is_01() || !grp_fu_26114_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26122_p3.read()) + sc_bigint<36>(grp_fu_26114_p3.read()));
}
void compute::thread_add_ln700_415_fu_15976_p2() {
add_ln700_415_fu_15976_p2 = (!grp_fu_26094_p3.read().is_01() || !grp_fu_26086_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26094_p3.read()) + sc_bigint<36>(grp_fu_26086_p3.read()));
}
void compute::thread_add_ln700_416_fu_15980_p2() {
add_ln700_416_fu_15980_p2 = (!add_ln700_412_fu_15972_p2.read().is_01() || !add_ln700_415_fu_15976_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_412_fu_15972_p2.read()) + sc_biguint<36>(add_ln700_415_fu_15976_p2.read()));
}
void compute::thread_add_ln700_419_fu_16012_p2() {
add_ln700_419_fu_16012_p2 = (!grp_fu_26178_p3.read().is_01() || !grp_fu_26170_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26178_p3.read()) + sc_bigint<36>(grp_fu_26170_p3.read()));
}
void compute::thread_add_ln700_41_fu_14296_p2() {
add_ln700_41_fu_14296_p2 = (!grp_fu_23742_p3.read().is_01() || !grp_fu_23734_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23742_p3.read()) + sc_bigint<36>(grp_fu_23734_p3.read()));
}
void compute::thread_add_ln700_422_fu_16016_p2() {
add_ln700_422_fu_16016_p2 = (!grp_fu_26150_p3.read().is_01() || !grp_fu_26142_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26150_p3.read()) + sc_bigint<36>(grp_fu_26142_p3.read()));
}
void compute::thread_add_ln700_423_fu_16020_p2() {
add_ln700_423_fu_16020_p2 = (!add_ln700_419_fu_16012_p2.read().is_01() || !add_ln700_422_fu_16016_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_419_fu_16012_p2.read()) + sc_biguint<36>(add_ln700_422_fu_16016_p2.read()));
}
void compute::thread_add_ln700_424_fu_20730_p2() {
add_ln700_424_fu_20730_p2 = (!sext_ln700_437_fu_20671_p1.read().is_01() || !tmp_673_i_i_fu_20678_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_437_fu_20671_p1.read()) + sc_biguint<48>(tmp_673_i_i_fu_20678_p4.read()));
}
void compute::thread_add_ln700_425_fu_20736_p2() {
add_ln700_425_fu_20736_p2 = (!sext_ln647_34_fu_20709_p1.read().is_01() || !sext_ln647_33_fu_20695_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_34_fu_20709_p1.read()) + sc_bigint<43>(sext_ln647_33_fu_20695_p1.read()));
}
void compute::thread_add_ln700_426_fu_20746_p2() {
add_ln700_426_fu_20746_p2 = (!add_ln700_424_fu_20730_p2.read().is_01() || !sext_ln700_464_fu_20742_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_424_fu_20730_p2.read()) + sc_bigint<48>(sext_ln700_464_fu_20742_p1.read()));
}
void compute::thread_add_ln700_427_fu_20752_p2() {
add_ln700_427_fu_20752_p2 = (!sext_ln700_438_fu_20675_p1.read().is_01() || !sext_ln647_35_fu_20723_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_438_fu_20675_p1.read()) + sc_bigint<43>(sext_ln647_35_fu_20723_p1.read()));
}
void compute::thread_add_ln700_428_fu_20758_p2() {
add_ln700_428_fu_20758_p2 = (!sext_ln700_463_fu_20727_p1.read().is_01() || !sext_ln215_1047_fu_20713_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_463_fu_20727_p1.read()) + sc_bigint<19>(sext_ln215_1047_fu_20713_p1.read()));
}
void compute::thread_add_ln700_429_fu_20768_p2() {
add_ln700_429_fu_20768_p2 = (!sext_ln215_1046_fu_20699_p1.read().is_01() || !sext_ln700_465_fu_20764_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1046_fu_20699_p1.read()) + sc_bigint<20>(sext_ln700_465_fu_20764_p1.read()));
}
void compute::thread_add_ln700_42_fu_14300_p2() {
add_ln700_42_fu_14300_p2 = (!add_ln700_38_fu_14292_p2.read().is_01() || !add_ln700_41_fu_14296_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_38_fu_14292_p2.read()) + sc_biguint<36>(add_ln700_41_fu_14296_p2.read()));
}
void compute::thread_add_ln700_430_fu_20778_p2() {
add_ln700_430_fu_20778_p2 = (!add_ln700_427_fu_20752_p2.read().is_01() || !sext_ln700_466_fu_20774_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_427_fu_20752_p2.read()) + sc_bigint<43>(sext_ln700_466_fu_20774_p1.read()));
}
void compute::thread_add_ln700_431_fu_20788_p2() {
add_ln700_431_fu_20788_p2 = (!add_ln700_426_fu_20746_p2.read().is_01() || !sext_ln700_467_fu_20784_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_426_fu_20746_p2.read()) + sc_bigint<48>(sext_ln700_467_fu_20784_p1.read()));
}
void compute::thread_add_ln700_434_fu_16052_p2() {
add_ln700_434_fu_16052_p2 = (!grp_fu_26234_p3.read().is_01() || !grp_fu_26226_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26234_p3.read()) + sc_bigint<36>(grp_fu_26226_p3.read()));
}
void compute::thread_add_ln700_437_fu_16056_p2() {
add_ln700_437_fu_16056_p2 = (!grp_fu_26206_p3.read().is_01() || !grp_fu_26198_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26206_p3.read()) + sc_bigint<36>(grp_fu_26198_p3.read()));
}
void compute::thread_add_ln700_438_fu_16060_p2() {
add_ln700_438_fu_16060_p2 = (!add_ln700_434_fu_16052_p2.read().is_01() || !add_ln700_437_fu_16056_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_434_fu_16052_p2.read()) + sc_biguint<36>(add_ln700_437_fu_16056_p2.read()));
}
void compute::thread_add_ln700_441_fu_16092_p2() {
add_ln700_441_fu_16092_p2 = (!grp_fu_26290_p3.read().is_01() || !grp_fu_26282_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26290_p3.read()) + sc_bigint<36>(grp_fu_26282_p3.read()));
}
void compute::thread_add_ln700_444_fu_16096_p2() {
add_ln700_444_fu_16096_p2 = (!grp_fu_26262_p3.read().is_01() || !grp_fu_26254_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26262_p3.read()) + sc_bigint<36>(grp_fu_26254_p3.read()));
}
void compute::thread_add_ln700_445_fu_16100_p2() {
add_ln700_445_fu_16100_p2 = (!add_ln700_441_fu_16092_p2.read().is_01() || !add_ln700_444_fu_16096_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_441_fu_16092_p2.read()) + sc_biguint<36>(add_ln700_444_fu_16096_p2.read()));
}
void compute::thread_add_ln700_448_fu_16132_p2() {
add_ln700_448_fu_16132_p2 = (!grp_fu_26346_p3.read().is_01() || !grp_fu_26338_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26346_p3.read()) + sc_bigint<36>(grp_fu_26338_p3.read()));
}
void compute::thread_add_ln700_451_fu_16136_p2() {
add_ln700_451_fu_16136_p2 = (!grp_fu_26318_p3.read().is_01() || !grp_fu_26310_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26318_p3.read()) + sc_bigint<36>(grp_fu_26310_p3.read()));
}
void compute::thread_add_ln700_452_fu_16140_p2() {
add_ln700_452_fu_16140_p2 = (!add_ln700_448_fu_16132_p2.read().is_01() || !add_ln700_451_fu_16136_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_448_fu_16132_p2.read()) + sc_biguint<36>(add_ln700_451_fu_16136_p2.read()));
}
void compute::thread_add_ln700_455_fu_16172_p2() {
add_ln700_455_fu_16172_p2 = (!grp_fu_26402_p3.read().is_01() || !grp_fu_26394_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26402_p3.read()) + sc_bigint<36>(grp_fu_26394_p3.read()));
}
void compute::thread_add_ln700_458_fu_16176_p2() {
add_ln700_458_fu_16176_p2 = (!grp_fu_26374_p3.read().is_01() || !grp_fu_26366_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26374_p3.read()) + sc_bigint<36>(grp_fu_26366_p3.read()));
}
void compute::thread_add_ln700_459_fu_16180_p2() {
add_ln700_459_fu_16180_p2 = (!add_ln700_455_fu_16172_p2.read().is_01() || !add_ln700_458_fu_16176_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_455_fu_16172_p2.read()) + sc_biguint<36>(add_ln700_458_fu_16176_p2.read()));
}
void compute::thread_add_ln700_45_fu_14332_p2() {
add_ln700_45_fu_14332_p2 = (!grp_fu_23826_p3.read().is_01() || !grp_fu_23818_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23826_p3.read()) + sc_bigint<36>(grp_fu_23818_p3.read()));
}
void compute::thread_add_ln700_460_fu_20860_p2() {
add_ln700_460_fu_20860_p2 = (!sext_ln700_476_fu_20801_p1.read().is_01() || !tmp_679_i_i_fu_20808_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_476_fu_20801_p1.read()) + sc_biguint<48>(tmp_679_i_i_fu_20808_p4.read()));
}
void compute::thread_add_ln700_461_fu_20866_p2() {
add_ln700_461_fu_20866_p2 = (!sext_ln647_37_fu_20839_p1.read().is_01() || !sext_ln647_36_fu_20825_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_37_fu_20839_p1.read()) + sc_bigint<43>(sext_ln647_36_fu_20825_p1.read()));
}
void compute::thread_add_ln700_462_fu_20876_p2() {
add_ln700_462_fu_20876_p2 = (!add_ln700_460_fu_20860_p2.read().is_01() || !sext_ln700_503_fu_20872_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_460_fu_20860_p2.read()) + sc_bigint<48>(sext_ln700_503_fu_20872_p1.read()));
}
void compute::thread_add_ln700_463_fu_20882_p2() {
add_ln700_463_fu_20882_p2 = (!sext_ln700_477_fu_20805_p1.read().is_01() || !sext_ln647_38_fu_20853_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_477_fu_20805_p1.read()) + sc_bigint<43>(sext_ln647_38_fu_20853_p1.read()));
}
void compute::thread_add_ln700_464_fu_20888_p2() {
add_ln700_464_fu_20888_p2 = (!sext_ln700_502_fu_20857_p1.read().is_01() || !sext_ln215_1049_fu_20843_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_502_fu_20857_p1.read()) + sc_bigint<19>(sext_ln215_1049_fu_20843_p1.read()));
}
void compute::thread_add_ln700_465_fu_20898_p2() {
add_ln700_465_fu_20898_p2 = (!sext_ln215_1048_fu_20829_p1.read().is_01() || !sext_ln700_504_fu_20894_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1048_fu_20829_p1.read()) + sc_bigint<20>(sext_ln700_504_fu_20894_p1.read()));
}
void compute::thread_add_ln700_466_fu_20908_p2() {
add_ln700_466_fu_20908_p2 = (!add_ln700_463_fu_20882_p2.read().is_01() || !sext_ln700_505_fu_20904_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_463_fu_20882_p2.read()) + sc_bigint<43>(sext_ln700_505_fu_20904_p1.read()));
}
void compute::thread_add_ln700_467_fu_20918_p2() {
add_ln700_467_fu_20918_p2 = (!add_ln700_462_fu_20876_p2.read().is_01() || !sext_ln700_506_fu_20914_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_462_fu_20876_p2.read()) + sc_bigint<48>(sext_ln700_506_fu_20914_p1.read()));
}
void compute::thread_add_ln700_470_fu_16212_p2() {
add_ln700_470_fu_16212_p2 = (!grp_fu_26458_p3.read().is_01() || !grp_fu_26450_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26458_p3.read()) + sc_bigint<36>(grp_fu_26450_p3.read()));
}
void compute::thread_add_ln700_473_fu_16216_p2() {
add_ln700_473_fu_16216_p2 = (!grp_fu_26430_p3.read().is_01() || !grp_fu_26422_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26430_p3.read()) + sc_bigint<36>(grp_fu_26422_p3.read()));
}
void compute::thread_add_ln700_474_fu_16220_p2() {
add_ln700_474_fu_16220_p2 = (!add_ln700_470_fu_16212_p2.read().is_01() || !add_ln700_473_fu_16216_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_470_fu_16212_p2.read()) + sc_biguint<36>(add_ln700_473_fu_16216_p2.read()));
}
void compute::thread_add_ln700_477_fu_16252_p2() {
add_ln700_477_fu_16252_p2 = (!grp_fu_26514_p3.read().is_01() || !grp_fu_26506_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26514_p3.read()) + sc_bigint<36>(grp_fu_26506_p3.read()));
}
void compute::thread_add_ln700_480_fu_16256_p2() {
add_ln700_480_fu_16256_p2 = (!grp_fu_26486_p3.read().is_01() || !grp_fu_26478_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26486_p3.read()) + sc_bigint<36>(grp_fu_26478_p3.read()));
}
void compute::thread_add_ln700_481_fu_16260_p2() {
add_ln700_481_fu_16260_p2 = (!add_ln700_477_fu_16252_p2.read().is_01() || !add_ln700_480_fu_16256_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_477_fu_16252_p2.read()) + sc_biguint<36>(add_ln700_480_fu_16256_p2.read()));
}
void compute::thread_add_ln700_484_fu_16292_p2() {
add_ln700_484_fu_16292_p2 = (!grp_fu_26570_p3.read().is_01() || !grp_fu_26562_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26570_p3.read()) + sc_bigint<36>(grp_fu_26562_p3.read()));
}
void compute::thread_add_ln700_487_fu_16296_p2() {
add_ln700_487_fu_16296_p2 = (!grp_fu_26542_p3.read().is_01() || !grp_fu_26534_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26542_p3.read()) + sc_bigint<36>(grp_fu_26534_p3.read()));
}
void compute::thread_add_ln700_488_fu_16300_p2() {
add_ln700_488_fu_16300_p2 = (!add_ln700_484_fu_16292_p2.read().is_01() || !add_ln700_487_fu_16296_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_484_fu_16292_p2.read()) + sc_biguint<36>(add_ln700_487_fu_16296_p2.read()));
}
void compute::thread_add_ln700_48_fu_14336_p2() {
add_ln700_48_fu_14336_p2 = (!grp_fu_23798_p3.read().is_01() || !grp_fu_23790_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23798_p3.read()) + sc_bigint<36>(grp_fu_23790_p3.read()));
}
void compute::thread_add_ln700_491_fu_16332_p2() {
add_ln700_491_fu_16332_p2 = (!grp_fu_26626_p3.read().is_01() || !grp_fu_26618_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26626_p3.read()) + sc_bigint<36>(grp_fu_26618_p3.read()));
}
void compute::thread_add_ln700_494_fu_16336_p2() {
add_ln700_494_fu_16336_p2 = (!grp_fu_26598_p3.read().is_01() || !grp_fu_26590_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26598_p3.read()) + sc_bigint<36>(grp_fu_26590_p3.read()));
}
void compute::thread_add_ln700_495_fu_16340_p2() {
add_ln700_495_fu_16340_p2 = (!add_ln700_491_fu_16332_p2.read().is_01() || !add_ln700_494_fu_16336_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_491_fu_16332_p2.read()) + sc_biguint<36>(add_ln700_494_fu_16336_p2.read()));
}
void compute::thread_add_ln700_496_fu_20990_p2() {
add_ln700_496_fu_20990_p2 = (!sext_ln700_515_fu_20931_p1.read().is_01() || !tmp_685_i_i_fu_20938_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_515_fu_20931_p1.read()) + sc_biguint<48>(tmp_685_i_i_fu_20938_p4.read()));
}
void compute::thread_add_ln700_497_fu_20996_p2() {
add_ln700_497_fu_20996_p2 = (!sext_ln647_40_fu_20969_p1.read().is_01() || !sext_ln647_39_fu_20955_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_40_fu_20969_p1.read()) + sc_bigint<43>(sext_ln647_39_fu_20955_p1.read()));
}
void compute::thread_add_ln700_498_fu_21006_p2() {
add_ln700_498_fu_21006_p2 = (!add_ln700_496_fu_20990_p2.read().is_01() || !sext_ln700_542_fu_21002_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_496_fu_20990_p2.read()) + sc_bigint<48>(sext_ln700_542_fu_21002_p1.read()));
}
void compute::thread_add_ln700_499_fu_21012_p2() {
add_ln700_499_fu_21012_p2 = (!sext_ln700_516_fu_20935_p1.read().is_01() || !sext_ln647_41_fu_20983_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_516_fu_20935_p1.read()) + sc_bigint<43>(sext_ln647_41_fu_20983_p1.read()));
}
void compute::thread_add_ln700_49_fu_14340_p2() {
add_ln700_49_fu_14340_p2 = (!add_ln700_45_fu_14332_p2.read().is_01() || !add_ln700_48_fu_14336_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_45_fu_14332_p2.read()) + sc_biguint<36>(add_ln700_48_fu_14336_p2.read()));
}
void compute::thread_add_ln700_500_fu_21018_p2() {
add_ln700_500_fu_21018_p2 = (!sext_ln700_541_fu_20987_p1.read().is_01() || !sext_ln215_1051_fu_20973_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_541_fu_20987_p1.read()) + sc_bigint<19>(sext_ln215_1051_fu_20973_p1.read()));
}
void compute::thread_add_ln700_501_fu_21028_p2() {
add_ln700_501_fu_21028_p2 = (!sext_ln215_1050_fu_20959_p1.read().is_01() || !sext_ln700_543_fu_21024_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1050_fu_20959_p1.read()) + sc_bigint<20>(sext_ln700_543_fu_21024_p1.read()));
}
void compute::thread_add_ln700_502_fu_21038_p2() {
add_ln700_502_fu_21038_p2 = (!add_ln700_499_fu_21012_p2.read().is_01() || !sext_ln700_544_fu_21034_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_499_fu_21012_p2.read()) + sc_bigint<43>(sext_ln700_544_fu_21034_p1.read()));
}
void compute::thread_add_ln700_503_fu_21048_p2() {
add_ln700_503_fu_21048_p2 = (!add_ln700_498_fu_21006_p2.read().is_01() || !sext_ln700_545_fu_21044_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_498_fu_21006_p2.read()) + sc_bigint<48>(sext_ln700_545_fu_21044_p1.read()));
}
void compute::thread_add_ln700_506_fu_16372_p2() {
add_ln700_506_fu_16372_p2 = (!grp_fu_26682_p3.read().is_01() || !grp_fu_26674_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26682_p3.read()) + sc_bigint<36>(grp_fu_26674_p3.read()));
}
void compute::thread_add_ln700_509_fu_16376_p2() {
add_ln700_509_fu_16376_p2 = (!grp_fu_26654_p3.read().is_01() || !grp_fu_26646_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26654_p3.read()) + sc_bigint<36>(grp_fu_26646_p3.read()));
}
void compute::thread_add_ln700_510_fu_16380_p2() {
add_ln700_510_fu_16380_p2 = (!add_ln700_506_fu_16372_p2.read().is_01() || !add_ln700_509_fu_16376_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_506_fu_16372_p2.read()) + sc_biguint<36>(add_ln700_509_fu_16376_p2.read()));
}
void compute::thread_add_ln700_513_fu_16412_p2() {
add_ln700_513_fu_16412_p2 = (!grp_fu_26738_p3.read().is_01() || !grp_fu_26730_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26738_p3.read()) + sc_bigint<36>(grp_fu_26730_p3.read()));
}
void compute::thread_add_ln700_516_fu_16416_p2() {
add_ln700_516_fu_16416_p2 = (!grp_fu_26710_p3.read().is_01() || !grp_fu_26702_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26710_p3.read()) + sc_bigint<36>(grp_fu_26702_p3.read()));
}
void compute::thread_add_ln700_517_fu_16420_p2() {
add_ln700_517_fu_16420_p2 = (!add_ln700_513_fu_16412_p2.read().is_01() || !add_ln700_516_fu_16416_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_513_fu_16412_p2.read()) + sc_biguint<36>(add_ln700_516_fu_16416_p2.read()));
}
void compute::thread_add_ln700_520_fu_16452_p2() {
add_ln700_520_fu_16452_p2 = (!grp_fu_26794_p3.read().is_01() || !grp_fu_26786_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26794_p3.read()) + sc_bigint<36>(grp_fu_26786_p3.read()));
}
void compute::thread_add_ln700_523_fu_16456_p2() {
add_ln700_523_fu_16456_p2 = (!grp_fu_26766_p3.read().is_01() || !grp_fu_26758_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26766_p3.read()) + sc_bigint<36>(grp_fu_26758_p3.read()));
}
void compute::thread_add_ln700_524_fu_16460_p2() {
add_ln700_524_fu_16460_p2 = (!add_ln700_520_fu_16452_p2.read().is_01() || !add_ln700_523_fu_16456_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_520_fu_16452_p2.read()) + sc_biguint<36>(add_ln700_523_fu_16456_p2.read()));
}
void compute::thread_add_ln700_527_fu_16492_p2() {
add_ln700_527_fu_16492_p2 = (!grp_fu_26850_p3.read().is_01() || !grp_fu_26842_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26850_p3.read()) + sc_bigint<36>(grp_fu_26842_p3.read()));
}
void compute::thread_add_ln700_52_fu_14372_p2() {
add_ln700_52_fu_14372_p2 = (!grp_fu_23882_p3.read().is_01() || !grp_fu_23874_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23882_p3.read()) + sc_bigint<36>(grp_fu_23874_p3.read()));
}
void compute::thread_add_ln700_530_fu_16496_p2() {
add_ln700_530_fu_16496_p2 = (!grp_fu_26822_p3.read().is_01() || !grp_fu_26814_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26822_p3.read()) + sc_bigint<36>(grp_fu_26814_p3.read()));
}
void compute::thread_add_ln700_531_fu_16500_p2() {
add_ln700_531_fu_16500_p2 = (!add_ln700_527_fu_16492_p2.read().is_01() || !add_ln700_530_fu_16496_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_527_fu_16492_p2.read()) + sc_biguint<36>(add_ln700_530_fu_16496_p2.read()));
}
void compute::thread_add_ln700_532_fu_21120_p2() {
add_ln700_532_fu_21120_p2 = (!sext_ln700_554_fu_21061_p1.read().is_01() || !tmp_691_i_i_fu_21068_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_554_fu_21061_p1.read()) + sc_biguint<48>(tmp_691_i_i_fu_21068_p4.read()));
}
void compute::thread_add_ln700_533_fu_21126_p2() {
add_ln700_533_fu_21126_p2 = (!sext_ln647_43_fu_21099_p1.read().is_01() || !sext_ln647_42_fu_21085_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_43_fu_21099_p1.read()) + sc_bigint<43>(sext_ln647_42_fu_21085_p1.read()));
}
void compute::thread_add_ln700_534_fu_21136_p2() {
add_ln700_534_fu_21136_p2 = (!add_ln700_532_fu_21120_p2.read().is_01() || !sext_ln700_581_fu_21132_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_532_fu_21120_p2.read()) + sc_bigint<48>(sext_ln700_581_fu_21132_p1.read()));
}
void compute::thread_add_ln700_535_fu_21142_p2() {
add_ln700_535_fu_21142_p2 = (!sext_ln700_555_fu_21065_p1.read().is_01() || !sext_ln647_44_fu_21113_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_555_fu_21065_p1.read()) + sc_bigint<43>(sext_ln647_44_fu_21113_p1.read()));
}
void compute::thread_add_ln700_536_fu_21148_p2() {
add_ln700_536_fu_21148_p2 = (!sext_ln700_580_fu_21117_p1.read().is_01() || !sext_ln215_1053_fu_21103_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_580_fu_21117_p1.read()) + sc_bigint<19>(sext_ln215_1053_fu_21103_p1.read()));
}
void compute::thread_add_ln700_537_fu_21158_p2() {
add_ln700_537_fu_21158_p2 = (!sext_ln215_1052_fu_21089_p1.read().is_01() || !sext_ln700_582_fu_21154_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1052_fu_21089_p1.read()) + sc_bigint<20>(sext_ln700_582_fu_21154_p1.read()));
}
void compute::thread_add_ln700_538_fu_21168_p2() {
add_ln700_538_fu_21168_p2 = (!add_ln700_535_fu_21142_p2.read().is_01() || !sext_ln700_583_fu_21164_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_535_fu_21142_p2.read()) + sc_bigint<43>(sext_ln700_583_fu_21164_p1.read()));
}
void compute::thread_add_ln700_539_fu_21178_p2() {
add_ln700_539_fu_21178_p2 = (!add_ln700_534_fu_21136_p2.read().is_01() || !sext_ln700_584_fu_21174_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_534_fu_21136_p2.read()) + sc_bigint<48>(sext_ln700_584_fu_21174_p1.read()));
}
void compute::thread_add_ln700_542_fu_16532_p2() {
add_ln700_542_fu_16532_p2 = (!grp_fu_26906_p3.read().is_01() || !grp_fu_26898_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26906_p3.read()) + sc_bigint<36>(grp_fu_26898_p3.read()));
}
void compute::thread_add_ln700_545_fu_16536_p2() {
add_ln700_545_fu_16536_p2 = (!grp_fu_26878_p3.read().is_01() || !grp_fu_26870_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26878_p3.read()) + sc_bigint<36>(grp_fu_26870_p3.read()));
}
void compute::thread_add_ln700_546_fu_16540_p2() {
add_ln700_546_fu_16540_p2 = (!add_ln700_542_fu_16532_p2.read().is_01() || !add_ln700_545_fu_16536_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_542_fu_16532_p2.read()) + sc_biguint<36>(add_ln700_545_fu_16536_p2.read()));
}
void compute::thread_add_ln700_549_fu_16572_p2() {
add_ln700_549_fu_16572_p2 = (!grp_fu_26962_p3.read().is_01() || !grp_fu_26954_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26962_p3.read()) + sc_bigint<36>(grp_fu_26954_p3.read()));
}
void compute::thread_add_ln700_552_fu_16576_p2() {
add_ln700_552_fu_16576_p2 = (!grp_fu_26934_p3.read().is_01() || !grp_fu_26926_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26934_p3.read()) + sc_bigint<36>(grp_fu_26926_p3.read()));
}
void compute::thread_add_ln700_553_fu_16580_p2() {
add_ln700_553_fu_16580_p2 = (!add_ln700_549_fu_16572_p2.read().is_01() || !add_ln700_552_fu_16576_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_549_fu_16572_p2.read()) + sc_biguint<36>(add_ln700_552_fu_16576_p2.read()));
}
void compute::thread_add_ln700_556_fu_16612_p2() {
add_ln700_556_fu_16612_p2 = (!grp_fu_27018_p3.read().is_01() || !grp_fu_27010_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27018_p3.read()) + sc_bigint<36>(grp_fu_27010_p3.read()));
}
void compute::thread_add_ln700_559_fu_16616_p2() {
add_ln700_559_fu_16616_p2 = (!grp_fu_26990_p3.read().is_01() || !grp_fu_26982_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_26990_p3.read()) + sc_bigint<36>(grp_fu_26982_p3.read()));
}
void compute::thread_add_ln700_55_fu_14376_p2() {
add_ln700_55_fu_14376_p2 = (!grp_fu_23854_p3.read().is_01() || !grp_fu_23846_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23854_p3.read()) + sc_bigint<36>(grp_fu_23846_p3.read()));
}
void compute::thread_add_ln700_560_fu_16620_p2() {
add_ln700_560_fu_16620_p2 = (!add_ln700_556_fu_16612_p2.read().is_01() || !add_ln700_559_fu_16616_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_556_fu_16612_p2.read()) + sc_biguint<36>(add_ln700_559_fu_16616_p2.read()));
}
void compute::thread_add_ln700_563_fu_16652_p2() {
add_ln700_563_fu_16652_p2 = (!grp_fu_27074_p3.read().is_01() || !grp_fu_27066_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27074_p3.read()) + sc_bigint<36>(grp_fu_27066_p3.read()));
}
void compute::thread_add_ln700_566_fu_16656_p2() {
add_ln700_566_fu_16656_p2 = (!grp_fu_27046_p3.read().is_01() || !grp_fu_27038_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27046_p3.read()) + sc_bigint<36>(grp_fu_27038_p3.read()));
}
void compute::thread_add_ln700_567_fu_16660_p2() {
add_ln700_567_fu_16660_p2 = (!add_ln700_563_fu_16652_p2.read().is_01() || !add_ln700_566_fu_16656_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_563_fu_16652_p2.read()) + sc_biguint<36>(add_ln700_566_fu_16656_p2.read()));
}
void compute::thread_add_ln700_568_fu_21250_p2() {
add_ln700_568_fu_21250_p2 = (!sext_ln700_593_fu_21191_p1.read().is_01() || !tmp_697_i_i_fu_21198_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_593_fu_21191_p1.read()) + sc_biguint<48>(tmp_697_i_i_fu_21198_p4.read()));
}
void compute::thread_add_ln700_569_fu_21256_p2() {
add_ln700_569_fu_21256_p2 = (!sext_ln647_46_fu_21229_p1.read().is_01() || !sext_ln647_45_fu_21215_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_46_fu_21229_p1.read()) + sc_bigint<43>(sext_ln647_45_fu_21215_p1.read()));
}
void compute::thread_add_ln700_56_fu_14380_p2() {
add_ln700_56_fu_14380_p2 = (!add_ln700_52_fu_14372_p2.read().is_01() || !add_ln700_55_fu_14376_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_52_fu_14372_p2.read()) + sc_biguint<36>(add_ln700_55_fu_14376_p2.read()));
}
void compute::thread_add_ln700_570_fu_21266_p2() {
add_ln700_570_fu_21266_p2 = (!add_ln700_568_fu_21250_p2.read().is_01() || !sext_ln700_620_fu_21262_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_568_fu_21250_p2.read()) + sc_bigint<48>(sext_ln700_620_fu_21262_p1.read()));
}
void compute::thread_add_ln700_571_fu_21272_p2() {
add_ln700_571_fu_21272_p2 = (!sext_ln700_594_fu_21195_p1.read().is_01() || !sext_ln647_47_fu_21243_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_594_fu_21195_p1.read()) + sc_bigint<43>(sext_ln647_47_fu_21243_p1.read()));
}
void compute::thread_add_ln700_572_fu_21278_p2() {
add_ln700_572_fu_21278_p2 = (!sext_ln700_619_fu_21247_p1.read().is_01() || !sext_ln215_1055_fu_21233_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_619_fu_21247_p1.read()) + sc_bigint<19>(sext_ln215_1055_fu_21233_p1.read()));
}
void compute::thread_add_ln700_573_fu_21288_p2() {
add_ln700_573_fu_21288_p2 = (!sext_ln215_1054_fu_21219_p1.read().is_01() || !sext_ln700_621_fu_21284_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1054_fu_21219_p1.read()) + sc_bigint<20>(sext_ln700_621_fu_21284_p1.read()));
}
void compute::thread_add_ln700_574_fu_21298_p2() {
add_ln700_574_fu_21298_p2 = (!add_ln700_571_fu_21272_p2.read().is_01() || !sext_ln700_622_fu_21294_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_571_fu_21272_p2.read()) + sc_bigint<43>(sext_ln700_622_fu_21294_p1.read()));
}
void compute::thread_add_ln700_575_fu_21308_p2() {
add_ln700_575_fu_21308_p2 = (!add_ln700_570_fu_21266_p2.read().is_01() || !sext_ln700_623_fu_21304_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_570_fu_21266_p2.read()) + sc_bigint<48>(sext_ln700_623_fu_21304_p1.read()));
}
void compute::thread_add_ln700_578_fu_16692_p2() {
add_ln700_578_fu_16692_p2 = (!grp_fu_27130_p3.read().is_01() || !grp_fu_27122_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27130_p3.read()) + sc_bigint<36>(grp_fu_27122_p3.read()));
}
void compute::thread_add_ln700_581_fu_16696_p2() {
add_ln700_581_fu_16696_p2 = (!grp_fu_27102_p3.read().is_01() || !grp_fu_27094_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27102_p3.read()) + sc_bigint<36>(grp_fu_27094_p3.read()));
}
void compute::thread_add_ln700_582_fu_16700_p2() {
add_ln700_582_fu_16700_p2 = (!add_ln700_578_fu_16692_p2.read().is_01() || !add_ln700_581_fu_16696_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_578_fu_16692_p2.read()) + sc_biguint<36>(add_ln700_581_fu_16696_p2.read()));
}
void compute::thread_add_ln700_585_fu_16732_p2() {
add_ln700_585_fu_16732_p2 = (!grp_fu_27186_p3.read().is_01() || !grp_fu_27178_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27186_p3.read()) + sc_bigint<36>(grp_fu_27178_p3.read()));
}
void compute::thread_add_ln700_588_fu_16736_p2() {
add_ln700_588_fu_16736_p2 = (!grp_fu_27158_p3.read().is_01() || !grp_fu_27150_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27158_p3.read()) + sc_bigint<36>(grp_fu_27150_p3.read()));
}
void compute::thread_add_ln700_589_fu_16740_p2() {
add_ln700_589_fu_16740_p2 = (!add_ln700_585_fu_16732_p2.read().is_01() || !add_ln700_588_fu_16736_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_585_fu_16732_p2.read()) + sc_biguint<36>(add_ln700_588_fu_16736_p2.read()));
}
void compute::thread_add_ln700_592_fu_16772_p2() {
add_ln700_592_fu_16772_p2 = (!grp_fu_27242_p3.read().is_01() || !grp_fu_27234_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27242_p3.read()) + sc_bigint<36>(grp_fu_27234_p3.read()));
}
void compute::thread_add_ln700_595_fu_16776_p2() {
add_ln700_595_fu_16776_p2 = (!grp_fu_27214_p3.read().is_01() || !grp_fu_27206_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27214_p3.read()) + sc_bigint<36>(grp_fu_27206_p3.read()));
}
void compute::thread_add_ln700_596_fu_16780_p2() {
add_ln700_596_fu_16780_p2 = (!add_ln700_592_fu_16772_p2.read().is_01() || !add_ln700_595_fu_16776_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_592_fu_16772_p2.read()) + sc_biguint<36>(add_ln700_595_fu_16776_p2.read()));
}
void compute::thread_add_ln700_599_fu_16812_p2() {
add_ln700_599_fu_16812_p2 = (!grp_fu_27298_p3.read().is_01() || !grp_fu_27290_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27298_p3.read()) + sc_bigint<36>(grp_fu_27290_p3.read()));
}
void compute::thread_add_ln700_59_fu_14412_p2() {
add_ln700_59_fu_14412_p2 = (!grp_fu_23938_p3.read().is_01() || !grp_fu_23930_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23938_p3.read()) + sc_bigint<36>(grp_fu_23930_p3.read()));
}
void compute::thread_add_ln700_5_fu_14040_p2() {
add_ln700_5_fu_14040_p2 = (!grp_fu_23518_p3.read().is_01() || !grp_fu_23510_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23518_p3.read()) + sc_bigint<36>(grp_fu_23510_p3.read()));
}
void compute::thread_add_ln700_602_fu_16816_p2() {
add_ln700_602_fu_16816_p2 = (!grp_fu_27270_p3.read().is_01() || !grp_fu_27262_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27270_p3.read()) + sc_bigint<36>(grp_fu_27262_p3.read()));
}
void compute::thread_add_ln700_603_fu_16820_p2() {
add_ln700_603_fu_16820_p2 = (!add_ln700_599_fu_16812_p2.read().is_01() || !add_ln700_602_fu_16816_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_599_fu_16812_p2.read()) + sc_biguint<36>(add_ln700_602_fu_16816_p2.read()));
}
void compute::thread_add_ln700_604_fu_21380_p2() {
add_ln700_604_fu_21380_p2 = (!sext_ln700_632_fu_21321_p1.read().is_01() || !tmp_703_i_i_fu_21328_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_632_fu_21321_p1.read()) + sc_biguint<48>(tmp_703_i_i_fu_21328_p4.read()));
}
void compute::thread_add_ln700_605_fu_21386_p2() {
add_ln700_605_fu_21386_p2 = (!sext_ln647_49_fu_21359_p1.read().is_01() || !sext_ln647_48_fu_21345_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_49_fu_21359_p1.read()) + sc_bigint<43>(sext_ln647_48_fu_21345_p1.read()));
}
void compute::thread_add_ln700_606_fu_21396_p2() {
add_ln700_606_fu_21396_p2 = (!add_ln700_604_fu_21380_p2.read().is_01() || !sext_ln700_659_fu_21392_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_604_fu_21380_p2.read()) + sc_bigint<48>(sext_ln700_659_fu_21392_p1.read()));
}
void compute::thread_add_ln700_607_fu_21402_p2() {
add_ln700_607_fu_21402_p2 = (!sext_ln700_633_fu_21325_p1.read().is_01() || !sext_ln647_50_fu_21373_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_633_fu_21325_p1.read()) + sc_bigint<43>(sext_ln647_50_fu_21373_p1.read()));
}
void compute::thread_add_ln700_608_fu_21408_p2() {
add_ln700_608_fu_21408_p2 = (!sext_ln700_658_fu_21377_p1.read().is_01() || !sext_ln215_1057_fu_21363_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_658_fu_21377_p1.read()) + sc_bigint<19>(sext_ln215_1057_fu_21363_p1.read()));
}
void compute::thread_add_ln700_609_fu_21418_p2() {
add_ln700_609_fu_21418_p2 = (!sext_ln215_1056_fu_21349_p1.read().is_01() || !sext_ln700_660_fu_21414_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1056_fu_21349_p1.read()) + sc_bigint<20>(sext_ln700_660_fu_21414_p1.read()));
}
void compute::thread_add_ln700_610_fu_21428_p2() {
add_ln700_610_fu_21428_p2 = (!add_ln700_607_fu_21402_p2.read().is_01() || !sext_ln700_661_fu_21424_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_607_fu_21402_p2.read()) + sc_bigint<43>(sext_ln700_661_fu_21424_p1.read()));
}
void compute::thread_add_ln700_611_fu_21438_p2() {
add_ln700_611_fu_21438_p2 = (!add_ln700_606_fu_21396_p2.read().is_01() || !sext_ln700_662_fu_21434_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_606_fu_21396_p2.read()) + sc_bigint<48>(sext_ln700_662_fu_21434_p1.read()));
}
void compute::thread_add_ln700_614_fu_16852_p2() {
add_ln700_614_fu_16852_p2 = (!grp_fu_27354_p3.read().is_01() || !grp_fu_27346_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27354_p3.read()) + sc_bigint<36>(grp_fu_27346_p3.read()));
}
void compute::thread_add_ln700_617_fu_16856_p2() {
add_ln700_617_fu_16856_p2 = (!grp_fu_27326_p3.read().is_01() || !grp_fu_27318_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27326_p3.read()) + sc_bigint<36>(grp_fu_27318_p3.read()));
}
void compute::thread_add_ln700_618_fu_16860_p2() {
add_ln700_618_fu_16860_p2 = (!add_ln700_614_fu_16852_p2.read().is_01() || !add_ln700_617_fu_16856_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_614_fu_16852_p2.read()) + sc_biguint<36>(add_ln700_617_fu_16856_p2.read()));
}
void compute::thread_add_ln700_621_fu_16892_p2() {
add_ln700_621_fu_16892_p2 = (!grp_fu_27410_p3.read().is_01() || !grp_fu_27402_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27410_p3.read()) + sc_bigint<36>(grp_fu_27402_p3.read()));
}
void compute::thread_add_ln700_624_fu_16896_p2() {
add_ln700_624_fu_16896_p2 = (!grp_fu_27382_p3.read().is_01() || !grp_fu_27374_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27382_p3.read()) + sc_bigint<36>(grp_fu_27374_p3.read()));
}
void compute::thread_add_ln700_625_fu_16900_p2() {
add_ln700_625_fu_16900_p2 = (!add_ln700_621_fu_16892_p2.read().is_01() || !add_ln700_624_fu_16896_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_621_fu_16892_p2.read()) + sc_biguint<36>(add_ln700_624_fu_16896_p2.read()));
}
void compute::thread_add_ln700_628_fu_16932_p2() {
add_ln700_628_fu_16932_p2 = (!grp_fu_27466_p3.read().is_01() || !grp_fu_27458_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27466_p3.read()) + sc_bigint<36>(grp_fu_27458_p3.read()));
}
void compute::thread_add_ln700_62_fu_14416_p2() {
add_ln700_62_fu_14416_p2 = (!grp_fu_23910_p3.read().is_01() || !grp_fu_23902_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23910_p3.read()) + sc_bigint<36>(grp_fu_23902_p3.read()));
}
void compute::thread_add_ln700_631_fu_16936_p2() {
add_ln700_631_fu_16936_p2 = (!grp_fu_27438_p3.read().is_01() || !grp_fu_27430_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27438_p3.read()) + sc_bigint<36>(grp_fu_27430_p3.read()));
}
void compute::thread_add_ln700_632_fu_16940_p2() {
add_ln700_632_fu_16940_p2 = (!add_ln700_628_fu_16932_p2.read().is_01() || !add_ln700_631_fu_16936_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_628_fu_16932_p2.read()) + sc_biguint<36>(add_ln700_631_fu_16936_p2.read()));
}
void compute::thread_add_ln700_635_fu_16972_p2() {
add_ln700_635_fu_16972_p2 = (!grp_fu_27522_p3.read().is_01() || !grp_fu_27514_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27522_p3.read()) + sc_bigint<36>(grp_fu_27514_p3.read()));
}
void compute::thread_add_ln700_638_fu_16976_p2() {
add_ln700_638_fu_16976_p2 = (!grp_fu_27494_p3.read().is_01() || !grp_fu_27486_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27494_p3.read()) + sc_bigint<36>(grp_fu_27486_p3.read()));
}
void compute::thread_add_ln700_639_fu_16980_p2() {
add_ln700_639_fu_16980_p2 = (!add_ln700_635_fu_16972_p2.read().is_01() || !add_ln700_638_fu_16976_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_635_fu_16972_p2.read()) + sc_biguint<36>(add_ln700_638_fu_16976_p2.read()));
}
void compute::thread_add_ln700_63_fu_14420_p2() {
add_ln700_63_fu_14420_p2 = (!add_ln700_59_fu_14412_p2.read().is_01() || !add_ln700_62_fu_14416_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_59_fu_14412_p2.read()) + sc_biguint<36>(add_ln700_62_fu_14416_p2.read()));
}
void compute::thread_add_ln700_640_fu_21510_p2() {
add_ln700_640_fu_21510_p2 = (!sext_ln700_671_fu_21451_p1.read().is_01() || !tmp_709_i_i_fu_21458_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_671_fu_21451_p1.read()) + sc_biguint<48>(tmp_709_i_i_fu_21458_p4.read()));
}
void compute::thread_add_ln700_641_fu_21516_p2() {
add_ln700_641_fu_21516_p2 = (!sext_ln647_52_fu_21489_p1.read().is_01() || !sext_ln647_51_fu_21475_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_52_fu_21489_p1.read()) + sc_bigint<43>(sext_ln647_51_fu_21475_p1.read()));
}
void compute::thread_add_ln700_642_fu_21526_p2() {
add_ln700_642_fu_21526_p2 = (!add_ln700_640_fu_21510_p2.read().is_01() || !sext_ln700_698_fu_21522_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_640_fu_21510_p2.read()) + sc_bigint<48>(sext_ln700_698_fu_21522_p1.read()));
}
void compute::thread_add_ln700_643_fu_21532_p2() {
add_ln700_643_fu_21532_p2 = (!sext_ln700_672_fu_21455_p1.read().is_01() || !sext_ln647_53_fu_21503_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_672_fu_21455_p1.read()) + sc_bigint<43>(sext_ln647_53_fu_21503_p1.read()));
}
void compute::thread_add_ln700_644_fu_21538_p2() {
add_ln700_644_fu_21538_p2 = (!sext_ln700_697_fu_21507_p1.read().is_01() || !sext_ln215_1059_fu_21493_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_697_fu_21507_p1.read()) + sc_bigint<19>(sext_ln215_1059_fu_21493_p1.read()));
}
void compute::thread_add_ln700_645_fu_21548_p2() {
add_ln700_645_fu_21548_p2 = (!sext_ln215_1058_fu_21479_p1.read().is_01() || !sext_ln700_699_fu_21544_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1058_fu_21479_p1.read()) + sc_bigint<20>(sext_ln700_699_fu_21544_p1.read()));
}
void compute::thread_add_ln700_646_fu_21558_p2() {
add_ln700_646_fu_21558_p2 = (!add_ln700_643_fu_21532_p2.read().is_01() || !sext_ln700_700_fu_21554_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_643_fu_21532_p2.read()) + sc_bigint<43>(sext_ln700_700_fu_21554_p1.read()));
}
void compute::thread_add_ln700_647_fu_21568_p2() {
add_ln700_647_fu_21568_p2 = (!add_ln700_642_fu_21526_p2.read().is_01() || !sext_ln700_701_fu_21564_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_642_fu_21526_p2.read()) + sc_bigint<48>(sext_ln700_701_fu_21564_p1.read()));
}
void compute::thread_add_ln700_64_fu_19430_p2() {
add_ln700_64_fu_19430_p2 = (!sext_ln700_47_fu_19371_p1.read().is_01() || !tmp_613_i_i_fu_19378_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_47_fu_19371_p1.read()) + sc_biguint<48>(tmp_613_i_i_fu_19378_p4.read()));
}
void compute::thread_add_ln700_650_fu_17012_p2() {
add_ln700_650_fu_17012_p2 = (!grp_fu_27578_p3.read().is_01() || !grp_fu_27570_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27578_p3.read()) + sc_bigint<36>(grp_fu_27570_p3.read()));
}
void compute::thread_add_ln700_653_fu_17016_p2() {
add_ln700_653_fu_17016_p2 = (!grp_fu_27550_p3.read().is_01() || !grp_fu_27542_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27550_p3.read()) + sc_bigint<36>(grp_fu_27542_p3.read()));
}
void compute::thread_add_ln700_654_fu_17020_p2() {
add_ln700_654_fu_17020_p2 = (!add_ln700_650_fu_17012_p2.read().is_01() || !add_ln700_653_fu_17016_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_650_fu_17012_p2.read()) + sc_biguint<36>(add_ln700_653_fu_17016_p2.read()));
}
void compute::thread_add_ln700_657_fu_17052_p2() {
add_ln700_657_fu_17052_p2 = (!grp_fu_27634_p3.read().is_01() || !grp_fu_27626_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27634_p3.read()) + sc_bigint<36>(grp_fu_27626_p3.read()));
}
void compute::thread_add_ln700_65_fu_19436_p2() {
add_ln700_65_fu_19436_p2 = (!sext_ln647_4_fu_19409_p1.read().is_01() || !sext_ln647_3_fu_19395_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_4_fu_19409_p1.read()) + sc_bigint<43>(sext_ln647_3_fu_19395_p1.read()));
}
void compute::thread_add_ln700_660_fu_17056_p2() {
add_ln700_660_fu_17056_p2 = (!grp_fu_27606_p3.read().is_01() || !grp_fu_27598_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27606_p3.read()) + sc_bigint<36>(grp_fu_27598_p3.read()));
}
void compute::thread_add_ln700_661_fu_17060_p2() {
add_ln700_661_fu_17060_p2 = (!add_ln700_657_fu_17052_p2.read().is_01() || !add_ln700_660_fu_17056_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_657_fu_17052_p2.read()) + sc_biguint<36>(add_ln700_660_fu_17056_p2.read()));
}
void compute::thread_add_ln700_664_fu_17092_p2() {
add_ln700_664_fu_17092_p2 = (!grp_fu_27690_p3.read().is_01() || !grp_fu_27682_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27690_p3.read()) + sc_bigint<36>(grp_fu_27682_p3.read()));
}
void compute::thread_add_ln700_667_fu_17096_p2() {
add_ln700_667_fu_17096_p2 = (!grp_fu_27662_p3.read().is_01() || !grp_fu_27654_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27662_p3.read()) + sc_bigint<36>(grp_fu_27654_p3.read()));
}
void compute::thread_add_ln700_668_fu_17100_p2() {
add_ln700_668_fu_17100_p2 = (!add_ln700_664_fu_17092_p2.read().is_01() || !add_ln700_667_fu_17096_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_664_fu_17092_p2.read()) + sc_biguint<36>(add_ln700_667_fu_17096_p2.read()));
}
void compute::thread_add_ln700_66_fu_19446_p2() {
add_ln700_66_fu_19446_p2 = (!add_ln700_64_fu_19430_p2.read().is_01() || !sext_ln700_74_fu_19442_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_64_fu_19430_p2.read()) + sc_bigint<48>(sext_ln700_74_fu_19442_p1.read()));
}
void compute::thread_add_ln700_671_fu_17132_p2() {
add_ln700_671_fu_17132_p2 = (!grp_fu_27746_p3.read().is_01() || !grp_fu_27738_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27746_p3.read()) + sc_bigint<36>(grp_fu_27738_p3.read()));
}
void compute::thread_add_ln700_674_fu_17136_p2() {
add_ln700_674_fu_17136_p2 = (!grp_fu_27718_p3.read().is_01() || !grp_fu_27710_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27718_p3.read()) + sc_bigint<36>(grp_fu_27710_p3.read()));
}
void compute::thread_add_ln700_675_fu_17140_p2() {
add_ln700_675_fu_17140_p2 = (!add_ln700_671_fu_17132_p2.read().is_01() || !add_ln700_674_fu_17136_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_671_fu_17132_p2.read()) + sc_biguint<36>(add_ln700_674_fu_17136_p2.read()));
}
void compute::thread_add_ln700_676_fu_21640_p2() {
add_ln700_676_fu_21640_p2 = (!sext_ln700_710_fu_21581_p1.read().is_01() || !tmp_715_i_i_fu_21588_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_710_fu_21581_p1.read()) + sc_biguint<48>(tmp_715_i_i_fu_21588_p4.read()));
}
void compute::thread_add_ln700_677_fu_21646_p2() {
add_ln700_677_fu_21646_p2 = (!sext_ln647_55_fu_21619_p1.read().is_01() || !sext_ln647_54_fu_21605_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_55_fu_21619_p1.read()) + sc_bigint<43>(sext_ln647_54_fu_21605_p1.read()));
}
void compute::thread_add_ln700_678_fu_21656_p2() {
add_ln700_678_fu_21656_p2 = (!add_ln700_676_fu_21640_p2.read().is_01() || !sext_ln700_737_fu_21652_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_676_fu_21640_p2.read()) + sc_bigint<48>(sext_ln700_737_fu_21652_p1.read()));
}
void compute::thread_add_ln700_679_fu_21662_p2() {
add_ln700_679_fu_21662_p2 = (!sext_ln700_711_fu_21585_p1.read().is_01() || !sext_ln647_56_fu_21633_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_711_fu_21585_p1.read()) + sc_bigint<43>(sext_ln647_56_fu_21633_p1.read()));
}
void compute::thread_add_ln700_67_fu_19452_p2() {
add_ln700_67_fu_19452_p2 = (!sext_ln700_48_fu_19375_p1.read().is_01() || !sext_ln647_5_fu_19423_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_48_fu_19375_p1.read()) + sc_bigint<43>(sext_ln647_5_fu_19423_p1.read()));
}
void compute::thread_add_ln700_680_fu_21668_p2() {
add_ln700_680_fu_21668_p2 = (!sext_ln700_736_fu_21637_p1.read().is_01() || !sext_ln215_1061_fu_21623_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_736_fu_21637_p1.read()) + sc_bigint<19>(sext_ln215_1061_fu_21623_p1.read()));
}
void compute::thread_add_ln700_681_fu_21678_p2() {
add_ln700_681_fu_21678_p2 = (!sext_ln215_1060_fu_21609_p1.read().is_01() || !sext_ln700_738_fu_21674_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1060_fu_21609_p1.read()) + sc_bigint<20>(sext_ln700_738_fu_21674_p1.read()));
}
void compute::thread_add_ln700_682_fu_21688_p2() {
add_ln700_682_fu_21688_p2 = (!add_ln700_679_fu_21662_p2.read().is_01() || !sext_ln700_739_fu_21684_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_679_fu_21662_p2.read()) + sc_bigint<43>(sext_ln700_739_fu_21684_p1.read()));
}
void compute::thread_add_ln700_683_fu_21698_p2() {
add_ln700_683_fu_21698_p2 = (!add_ln700_678_fu_21656_p2.read().is_01() || !sext_ln700_740_fu_21694_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_678_fu_21656_p2.read()) + sc_bigint<48>(sext_ln700_740_fu_21694_p1.read()));
}
void compute::thread_add_ln700_686_fu_17172_p2() {
add_ln700_686_fu_17172_p2 = (!grp_fu_27802_p3.read().is_01() || !grp_fu_27794_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27802_p3.read()) + sc_bigint<36>(grp_fu_27794_p3.read()));
}
void compute::thread_add_ln700_689_fu_17176_p2() {
add_ln700_689_fu_17176_p2 = (!grp_fu_27774_p3.read().is_01() || !grp_fu_27766_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27774_p3.read()) + sc_bigint<36>(grp_fu_27766_p3.read()));
}
void compute::thread_add_ln700_68_fu_19458_p2() {
add_ln700_68_fu_19458_p2 = (!sext_ln700_73_fu_19427_p1.read().is_01() || !sext_ln215_1027_fu_19413_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_73_fu_19427_p1.read()) + sc_bigint<19>(sext_ln215_1027_fu_19413_p1.read()));
}
void compute::thread_add_ln700_690_fu_17180_p2() {
add_ln700_690_fu_17180_p2 = (!add_ln700_686_fu_17172_p2.read().is_01() || !add_ln700_689_fu_17176_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_686_fu_17172_p2.read()) + sc_biguint<36>(add_ln700_689_fu_17176_p2.read()));
}
void compute::thread_add_ln700_693_fu_17212_p2() {
add_ln700_693_fu_17212_p2 = (!grp_fu_27858_p3.read().is_01() || !grp_fu_27850_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27858_p3.read()) + sc_bigint<36>(grp_fu_27850_p3.read()));
}
void compute::thread_add_ln700_696_fu_17216_p2() {
add_ln700_696_fu_17216_p2 = (!grp_fu_27830_p3.read().is_01() || !grp_fu_27822_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27830_p3.read()) + sc_bigint<36>(grp_fu_27822_p3.read()));
}
void compute::thread_add_ln700_697_fu_17220_p2() {
add_ln700_697_fu_17220_p2 = (!add_ln700_693_fu_17212_p2.read().is_01() || !add_ln700_696_fu_17216_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_693_fu_17212_p2.read()) + sc_biguint<36>(add_ln700_696_fu_17216_p2.read()));
}
void compute::thread_add_ln700_69_fu_19468_p2() {
add_ln700_69_fu_19468_p2 = (!sext_ln215_1026_fu_19399_p1.read().is_01() || !sext_ln700_75_fu_19464_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1026_fu_19399_p1.read()) + sc_bigint<20>(sext_ln700_75_fu_19464_p1.read()));
}
void compute::thread_add_ln700_6_fu_14044_p2() {
add_ln700_6_fu_14044_p2 = (!add_ln700_2_fu_14036_p2.read().is_01() || !add_ln700_5_fu_14040_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_2_fu_14036_p2.read()) + sc_biguint<36>(add_ln700_5_fu_14040_p2.read()));
}
void compute::thread_add_ln700_700_fu_17252_p2() {
add_ln700_700_fu_17252_p2 = (!grp_fu_27914_p3.read().is_01() || !grp_fu_27906_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27914_p3.read()) + sc_bigint<36>(grp_fu_27906_p3.read()));
}
void compute::thread_add_ln700_703_fu_17256_p2() {
add_ln700_703_fu_17256_p2 = (!grp_fu_27886_p3.read().is_01() || !grp_fu_27878_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27886_p3.read()) + sc_bigint<36>(grp_fu_27878_p3.read()));
}
void compute::thread_add_ln700_704_fu_17260_p2() {
add_ln700_704_fu_17260_p2 = (!add_ln700_700_fu_17252_p2.read().is_01() || !add_ln700_703_fu_17256_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_700_fu_17252_p2.read()) + sc_biguint<36>(add_ln700_703_fu_17256_p2.read()));
}
void compute::thread_add_ln700_707_fu_17292_p2() {
add_ln700_707_fu_17292_p2 = (!grp_fu_27970_p3.read().is_01() || !grp_fu_27962_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27970_p3.read()) + sc_bigint<36>(grp_fu_27962_p3.read()));
}
void compute::thread_add_ln700_70_fu_19478_p2() {
add_ln700_70_fu_19478_p2 = (!add_ln700_67_fu_19452_p2.read().is_01() || !sext_ln700_76_fu_19474_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_67_fu_19452_p2.read()) + sc_bigint<43>(sext_ln700_76_fu_19474_p1.read()));
}
void compute::thread_add_ln700_710_fu_17296_p2() {
add_ln700_710_fu_17296_p2 = (!grp_fu_27942_p3.read().is_01() || !grp_fu_27934_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27942_p3.read()) + sc_bigint<36>(grp_fu_27934_p3.read()));
}
void compute::thread_add_ln700_711_fu_17300_p2() {
add_ln700_711_fu_17300_p2 = (!add_ln700_707_fu_17292_p2.read().is_01() || !add_ln700_710_fu_17296_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_707_fu_17292_p2.read()) + sc_biguint<36>(add_ln700_710_fu_17296_p2.read()));
}
void compute::thread_add_ln700_712_fu_21770_p2() {
add_ln700_712_fu_21770_p2 = (!sext_ln700_749_fu_21711_p1.read().is_01() || !tmp_721_i_i_fu_21718_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_749_fu_21711_p1.read()) + sc_biguint<48>(tmp_721_i_i_fu_21718_p4.read()));
}
void compute::thread_add_ln700_713_fu_21776_p2() {
add_ln700_713_fu_21776_p2 = (!sext_ln647_58_fu_21749_p1.read().is_01() || !sext_ln647_57_fu_21735_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_58_fu_21749_p1.read()) + sc_bigint<43>(sext_ln647_57_fu_21735_p1.read()));
}
void compute::thread_add_ln700_714_fu_21786_p2() {
add_ln700_714_fu_21786_p2 = (!add_ln700_712_fu_21770_p2.read().is_01() || !sext_ln700_776_fu_21782_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_712_fu_21770_p2.read()) + sc_bigint<48>(sext_ln700_776_fu_21782_p1.read()));
}
void compute::thread_add_ln700_715_fu_21792_p2() {
add_ln700_715_fu_21792_p2 = (!sext_ln700_750_fu_21715_p1.read().is_01() || !sext_ln647_59_fu_21763_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_750_fu_21715_p1.read()) + sc_bigint<43>(sext_ln647_59_fu_21763_p1.read()));
}
void compute::thread_add_ln700_716_fu_21798_p2() {
add_ln700_716_fu_21798_p2 = (!sext_ln700_775_fu_21767_p1.read().is_01() || !sext_ln215_1063_fu_21753_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_775_fu_21767_p1.read()) + sc_bigint<19>(sext_ln215_1063_fu_21753_p1.read()));
}
void compute::thread_add_ln700_717_fu_21808_p2() {
add_ln700_717_fu_21808_p2 = (!sext_ln215_1062_fu_21739_p1.read().is_01() || !sext_ln700_777_fu_21804_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1062_fu_21739_p1.read()) + sc_bigint<20>(sext_ln700_777_fu_21804_p1.read()));
}
void compute::thread_add_ln700_718_fu_21818_p2() {
add_ln700_718_fu_21818_p2 = (!add_ln700_715_fu_21792_p2.read().is_01() || !sext_ln700_778_fu_21814_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_715_fu_21792_p2.read()) + sc_bigint<43>(sext_ln700_778_fu_21814_p1.read()));
}
void compute::thread_add_ln700_719_fu_21828_p2() {
add_ln700_719_fu_21828_p2 = (!add_ln700_714_fu_21786_p2.read().is_01() || !sext_ln700_779_fu_21824_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_714_fu_21786_p2.read()) + sc_bigint<48>(sext_ln700_779_fu_21824_p1.read()));
}
void compute::thread_add_ln700_71_fu_19488_p2() {
add_ln700_71_fu_19488_p2 = (!add_ln700_66_fu_19446_p2.read().is_01() || !sext_ln700_77_fu_19484_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_66_fu_19446_p2.read()) + sc_bigint<48>(sext_ln700_77_fu_19484_p1.read()));
}
void compute::thread_add_ln700_722_fu_17332_p2() {
add_ln700_722_fu_17332_p2 = (!grp_fu_28026_p3.read().is_01() || !grp_fu_28018_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28026_p3.read()) + sc_bigint<36>(grp_fu_28018_p3.read()));
}
void compute::thread_add_ln700_725_fu_17336_p2() {
add_ln700_725_fu_17336_p2 = (!grp_fu_27998_p3.read().is_01() || !grp_fu_27990_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_27998_p3.read()) + sc_bigint<36>(grp_fu_27990_p3.read()));
}
void compute::thread_add_ln700_726_fu_17340_p2() {
add_ln700_726_fu_17340_p2 = (!add_ln700_722_fu_17332_p2.read().is_01() || !add_ln700_725_fu_17336_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_722_fu_17332_p2.read()) + sc_biguint<36>(add_ln700_725_fu_17336_p2.read()));
}
void compute::thread_add_ln700_729_fu_17372_p2() {
add_ln700_729_fu_17372_p2 = (!grp_fu_28082_p3.read().is_01() || !grp_fu_28074_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28082_p3.read()) + sc_bigint<36>(grp_fu_28074_p3.read()));
}
void compute::thread_add_ln700_732_fu_17376_p2() {
add_ln700_732_fu_17376_p2 = (!grp_fu_28054_p3.read().is_01() || !grp_fu_28046_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28054_p3.read()) + sc_bigint<36>(grp_fu_28046_p3.read()));
}
void compute::thread_add_ln700_733_fu_17380_p2() {
add_ln700_733_fu_17380_p2 = (!add_ln700_729_fu_17372_p2.read().is_01() || !add_ln700_732_fu_17376_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_729_fu_17372_p2.read()) + sc_biguint<36>(add_ln700_732_fu_17376_p2.read()));
}
void compute::thread_add_ln700_736_fu_17412_p2() {
add_ln700_736_fu_17412_p2 = (!grp_fu_28138_p3.read().is_01() || !grp_fu_28130_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28138_p3.read()) + sc_bigint<36>(grp_fu_28130_p3.read()));
}
void compute::thread_add_ln700_739_fu_17416_p2() {
add_ln700_739_fu_17416_p2 = (!grp_fu_28110_p3.read().is_01() || !grp_fu_28102_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28110_p3.read()) + sc_bigint<36>(grp_fu_28102_p3.read()));
}
void compute::thread_add_ln700_740_fu_17420_p2() {
add_ln700_740_fu_17420_p2 = (!add_ln700_736_fu_17412_p2.read().is_01() || !add_ln700_739_fu_17416_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_736_fu_17412_p2.read()) + sc_biguint<36>(add_ln700_739_fu_17416_p2.read()));
}
void compute::thread_add_ln700_743_fu_17452_p2() {
add_ln700_743_fu_17452_p2 = (!grp_fu_28194_p3.read().is_01() || !grp_fu_28186_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28194_p3.read()) + sc_bigint<36>(grp_fu_28186_p3.read()));
}
void compute::thread_add_ln700_746_fu_17456_p2() {
add_ln700_746_fu_17456_p2 = (!grp_fu_28166_p3.read().is_01() || !grp_fu_28158_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28166_p3.read()) + sc_bigint<36>(grp_fu_28158_p3.read()));
}
void compute::thread_add_ln700_747_fu_17460_p2() {
add_ln700_747_fu_17460_p2 = (!add_ln700_743_fu_17452_p2.read().is_01() || !add_ln700_746_fu_17456_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_743_fu_17452_p2.read()) + sc_biguint<36>(add_ln700_746_fu_17456_p2.read()));
}
void compute::thread_add_ln700_748_fu_21900_p2() {
add_ln700_748_fu_21900_p2 = (!sext_ln700_788_fu_21841_p1.read().is_01() || !tmp_727_i_i_fu_21848_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_788_fu_21841_p1.read()) + sc_biguint<48>(tmp_727_i_i_fu_21848_p4.read()));
}
void compute::thread_add_ln700_749_fu_21906_p2() {
add_ln700_749_fu_21906_p2 = (!sext_ln647_61_fu_21879_p1.read().is_01() || !sext_ln647_60_fu_21865_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_61_fu_21879_p1.read()) + sc_bigint<43>(sext_ln647_60_fu_21865_p1.read()));
}
void compute::thread_add_ln700_74_fu_14452_p2() {
add_ln700_74_fu_14452_p2 = (!grp_fu_23994_p3.read().is_01() || !grp_fu_23986_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23994_p3.read()) + sc_bigint<36>(grp_fu_23986_p3.read()));
}
void compute::thread_add_ln700_750_fu_21916_p2() {
add_ln700_750_fu_21916_p2 = (!add_ln700_748_fu_21900_p2.read().is_01() || !sext_ln700_815_fu_21912_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_748_fu_21900_p2.read()) + sc_bigint<48>(sext_ln700_815_fu_21912_p1.read()));
}
void compute::thread_add_ln700_751_fu_21922_p2() {
add_ln700_751_fu_21922_p2 = (!sext_ln700_789_fu_21845_p1.read().is_01() || !sext_ln647_62_fu_21893_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_789_fu_21845_p1.read()) + sc_bigint<43>(sext_ln647_62_fu_21893_p1.read()));
}
void compute::thread_add_ln700_752_fu_21928_p2() {
add_ln700_752_fu_21928_p2 = (!sext_ln700_814_fu_21897_p1.read().is_01() || !sext_ln215_1065_fu_21883_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_814_fu_21897_p1.read()) + sc_bigint<19>(sext_ln215_1065_fu_21883_p1.read()));
}
void compute::thread_add_ln700_753_fu_21938_p2() {
add_ln700_753_fu_21938_p2 = (!sext_ln215_1064_fu_21869_p1.read().is_01() || !sext_ln700_816_fu_21934_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1064_fu_21869_p1.read()) + sc_bigint<20>(sext_ln700_816_fu_21934_p1.read()));
}
void compute::thread_add_ln700_754_fu_21948_p2() {
add_ln700_754_fu_21948_p2 = (!add_ln700_751_fu_21922_p2.read().is_01() || !sext_ln700_817_fu_21944_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_751_fu_21922_p2.read()) + sc_bigint<43>(sext_ln700_817_fu_21944_p1.read()));
}
void compute::thread_add_ln700_755_fu_21958_p2() {
add_ln700_755_fu_21958_p2 = (!add_ln700_750_fu_21916_p2.read().is_01() || !sext_ln700_818_fu_21954_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_750_fu_21916_p2.read()) + sc_bigint<48>(sext_ln700_818_fu_21954_p1.read()));
}
void compute::thread_add_ln700_758_fu_17492_p2() {
add_ln700_758_fu_17492_p2 = (!grp_fu_28250_p3.read().is_01() || !grp_fu_28242_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28250_p3.read()) + sc_bigint<36>(grp_fu_28242_p3.read()));
}
void compute::thread_add_ln700_761_fu_17496_p2() {
add_ln700_761_fu_17496_p2 = (!grp_fu_28222_p3.read().is_01() || !grp_fu_28214_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28222_p3.read()) + sc_bigint<36>(grp_fu_28214_p3.read()));
}
void compute::thread_add_ln700_762_fu_17500_p2() {
add_ln700_762_fu_17500_p2 = (!add_ln700_758_fu_17492_p2.read().is_01() || !add_ln700_761_fu_17496_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_758_fu_17492_p2.read()) + sc_biguint<36>(add_ln700_761_fu_17496_p2.read()));
}
void compute::thread_add_ln700_765_fu_17532_p2() {
add_ln700_765_fu_17532_p2 = (!grp_fu_28306_p3.read().is_01() || !grp_fu_28298_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28306_p3.read()) + sc_bigint<36>(grp_fu_28298_p3.read()));
}
void compute::thread_add_ln700_768_fu_17536_p2() {
add_ln700_768_fu_17536_p2 = (!grp_fu_28278_p3.read().is_01() || !grp_fu_28270_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28278_p3.read()) + sc_bigint<36>(grp_fu_28270_p3.read()));
}
void compute::thread_add_ln700_769_fu_17540_p2() {
add_ln700_769_fu_17540_p2 = (!add_ln700_765_fu_17532_p2.read().is_01() || !add_ln700_768_fu_17536_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_765_fu_17532_p2.read()) + sc_biguint<36>(add_ln700_768_fu_17536_p2.read()));
}
void compute::thread_add_ln700_772_fu_17572_p2() {
add_ln700_772_fu_17572_p2 = (!grp_fu_28362_p3.read().is_01() || !grp_fu_28354_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28362_p3.read()) + sc_bigint<36>(grp_fu_28354_p3.read()));
}
void compute::thread_add_ln700_775_fu_17576_p2() {
add_ln700_775_fu_17576_p2 = (!grp_fu_28334_p3.read().is_01() || !grp_fu_28326_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28334_p3.read()) + sc_bigint<36>(grp_fu_28326_p3.read()));
}
void compute::thread_add_ln700_776_fu_17580_p2() {
add_ln700_776_fu_17580_p2 = (!add_ln700_772_fu_17572_p2.read().is_01() || !add_ln700_775_fu_17576_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_772_fu_17572_p2.read()) + sc_biguint<36>(add_ln700_775_fu_17576_p2.read()));
}
void compute::thread_add_ln700_779_fu_17612_p2() {
add_ln700_779_fu_17612_p2 = (!grp_fu_28418_p3.read().is_01() || !grp_fu_28410_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28418_p3.read()) + sc_bigint<36>(grp_fu_28410_p3.read()));
}
void compute::thread_add_ln700_77_fu_14456_p2() {
add_ln700_77_fu_14456_p2 = (!grp_fu_23966_p3.read().is_01() || !grp_fu_23958_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23966_p3.read()) + sc_bigint<36>(grp_fu_23958_p3.read()));
}
void compute::thread_add_ln700_782_fu_17616_p2() {
add_ln700_782_fu_17616_p2 = (!grp_fu_28390_p3.read().is_01() || !grp_fu_28382_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28390_p3.read()) + sc_bigint<36>(grp_fu_28382_p3.read()));
}
void compute::thread_add_ln700_783_fu_17620_p2() {
add_ln700_783_fu_17620_p2 = (!add_ln700_779_fu_17612_p2.read().is_01() || !add_ln700_782_fu_17616_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_779_fu_17612_p2.read()) + sc_biguint<36>(add_ln700_782_fu_17616_p2.read()));
}
void compute::thread_add_ln700_784_fu_22030_p2() {
add_ln700_784_fu_22030_p2 = (!sext_ln700_827_fu_21971_p1.read().is_01() || !tmp_733_i_i_fu_21978_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_827_fu_21971_p1.read()) + sc_biguint<48>(tmp_733_i_i_fu_21978_p4.read()));
}
void compute::thread_add_ln700_785_fu_22036_p2() {
add_ln700_785_fu_22036_p2 = (!sext_ln647_64_fu_22009_p1.read().is_01() || !sext_ln647_63_fu_21995_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_64_fu_22009_p1.read()) + sc_bigint<43>(sext_ln647_63_fu_21995_p1.read()));
}
void compute::thread_add_ln700_786_fu_22046_p2() {
add_ln700_786_fu_22046_p2 = (!add_ln700_784_fu_22030_p2.read().is_01() || !sext_ln700_854_fu_22042_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_784_fu_22030_p2.read()) + sc_bigint<48>(sext_ln700_854_fu_22042_p1.read()));
}
void compute::thread_add_ln700_787_fu_22052_p2() {
add_ln700_787_fu_22052_p2 = (!sext_ln700_828_fu_21975_p1.read().is_01() || !sext_ln647_65_fu_22023_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_828_fu_21975_p1.read()) + sc_bigint<43>(sext_ln647_65_fu_22023_p1.read()));
}
void compute::thread_add_ln700_788_fu_22058_p2() {
add_ln700_788_fu_22058_p2 = (!sext_ln700_853_fu_22027_p1.read().is_01() || !sext_ln215_1067_fu_22013_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_853_fu_22027_p1.read()) + sc_bigint<19>(sext_ln215_1067_fu_22013_p1.read()));
}
void compute::thread_add_ln700_789_fu_22068_p2() {
add_ln700_789_fu_22068_p2 = (!sext_ln215_1066_fu_21999_p1.read().is_01() || !sext_ln700_855_fu_22064_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1066_fu_21999_p1.read()) + sc_bigint<20>(sext_ln700_855_fu_22064_p1.read()));
}
void compute::thread_add_ln700_78_fu_14460_p2() {
add_ln700_78_fu_14460_p2 = (!add_ln700_74_fu_14452_p2.read().is_01() || !add_ln700_77_fu_14456_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_74_fu_14452_p2.read()) + sc_biguint<36>(add_ln700_77_fu_14456_p2.read()));
}
void compute::thread_add_ln700_790_fu_22078_p2() {
add_ln700_790_fu_22078_p2 = (!add_ln700_787_fu_22052_p2.read().is_01() || !sext_ln700_856_fu_22074_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_787_fu_22052_p2.read()) + sc_bigint<43>(sext_ln700_856_fu_22074_p1.read()));
}
void compute::thread_add_ln700_791_fu_22088_p2() {
add_ln700_791_fu_22088_p2 = (!add_ln700_786_fu_22046_p2.read().is_01() || !sext_ln700_857_fu_22084_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_786_fu_22046_p2.read()) + sc_bigint<48>(sext_ln700_857_fu_22084_p1.read()));
}
void compute::thread_add_ln700_794_fu_17652_p2() {
add_ln700_794_fu_17652_p2 = (!grp_fu_28474_p3.read().is_01() || !grp_fu_28466_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28474_p3.read()) + sc_bigint<36>(grp_fu_28466_p3.read()));
}
void compute::thread_add_ln700_797_fu_17656_p2() {
add_ln700_797_fu_17656_p2 = (!grp_fu_28446_p3.read().is_01() || !grp_fu_28438_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28446_p3.read()) + sc_bigint<36>(grp_fu_28438_p3.read()));
}
void compute::thread_add_ln700_798_fu_17660_p2() {
add_ln700_798_fu_17660_p2 = (!add_ln700_794_fu_17652_p2.read().is_01() || !add_ln700_797_fu_17656_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_794_fu_17652_p2.read()) + sc_biguint<36>(add_ln700_797_fu_17656_p2.read()));
}
void compute::thread_add_ln700_801_fu_17692_p2() {
add_ln700_801_fu_17692_p2 = (!grp_fu_28530_p3.read().is_01() || !grp_fu_28522_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28530_p3.read()) + sc_bigint<36>(grp_fu_28522_p3.read()));
}
void compute::thread_add_ln700_804_fu_17696_p2() {
add_ln700_804_fu_17696_p2 = (!grp_fu_28502_p3.read().is_01() || !grp_fu_28494_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28502_p3.read()) + sc_bigint<36>(grp_fu_28494_p3.read()));
}
void compute::thread_add_ln700_805_fu_17700_p2() {
add_ln700_805_fu_17700_p2 = (!add_ln700_801_fu_17692_p2.read().is_01() || !add_ln700_804_fu_17696_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_801_fu_17692_p2.read()) + sc_biguint<36>(add_ln700_804_fu_17696_p2.read()));
}
void compute::thread_add_ln700_808_fu_17732_p2() {
add_ln700_808_fu_17732_p2 = (!grp_fu_28586_p3.read().is_01() || !grp_fu_28578_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28586_p3.read()) + sc_bigint<36>(grp_fu_28578_p3.read()));
}
void compute::thread_add_ln700_811_fu_17736_p2() {
add_ln700_811_fu_17736_p2 = (!grp_fu_28558_p3.read().is_01() || !grp_fu_28550_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28558_p3.read()) + sc_bigint<36>(grp_fu_28550_p3.read()));
}
void compute::thread_add_ln700_812_fu_17740_p2() {
add_ln700_812_fu_17740_p2 = (!add_ln700_808_fu_17732_p2.read().is_01() || !add_ln700_811_fu_17736_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_808_fu_17732_p2.read()) + sc_biguint<36>(add_ln700_811_fu_17736_p2.read()));
}
void compute::thread_add_ln700_815_fu_17772_p2() {
add_ln700_815_fu_17772_p2 = (!grp_fu_28642_p3.read().is_01() || !grp_fu_28634_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28642_p3.read()) + sc_bigint<36>(grp_fu_28634_p3.read()));
}
void compute::thread_add_ln700_818_fu_17776_p2() {
add_ln700_818_fu_17776_p2 = (!grp_fu_28614_p3.read().is_01() || !grp_fu_28606_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28614_p3.read()) + sc_bigint<36>(grp_fu_28606_p3.read()));
}
void compute::thread_add_ln700_819_fu_17780_p2() {
add_ln700_819_fu_17780_p2 = (!add_ln700_815_fu_17772_p2.read().is_01() || !add_ln700_818_fu_17776_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_815_fu_17772_p2.read()) + sc_biguint<36>(add_ln700_818_fu_17776_p2.read()));
}
void compute::thread_add_ln700_81_fu_14492_p2() {
add_ln700_81_fu_14492_p2 = (!grp_fu_24050_p3.read().is_01() || !grp_fu_24042_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24050_p3.read()) + sc_bigint<36>(grp_fu_24042_p3.read()));
}
void compute::thread_add_ln700_820_fu_22160_p2() {
add_ln700_820_fu_22160_p2 = (!sext_ln700_866_fu_22101_p1.read().is_01() || !tmp_739_i_i_fu_22108_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_866_fu_22101_p1.read()) + sc_biguint<48>(tmp_739_i_i_fu_22108_p4.read()));
}
void compute::thread_add_ln700_821_fu_22166_p2() {
add_ln700_821_fu_22166_p2 = (!sext_ln647_67_fu_22139_p1.read().is_01() || !sext_ln647_66_fu_22125_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_67_fu_22139_p1.read()) + sc_bigint<43>(sext_ln647_66_fu_22125_p1.read()));
}
void compute::thread_add_ln700_822_fu_22176_p2() {
add_ln700_822_fu_22176_p2 = (!add_ln700_820_fu_22160_p2.read().is_01() || !sext_ln700_893_fu_22172_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_820_fu_22160_p2.read()) + sc_bigint<48>(sext_ln700_893_fu_22172_p1.read()));
}
void compute::thread_add_ln700_823_fu_22182_p2() {
add_ln700_823_fu_22182_p2 = (!sext_ln700_867_fu_22105_p1.read().is_01() || !sext_ln647_68_fu_22153_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_867_fu_22105_p1.read()) + sc_bigint<43>(sext_ln647_68_fu_22153_p1.read()));
}
void compute::thread_add_ln700_824_fu_22188_p2() {
add_ln700_824_fu_22188_p2 = (!sext_ln700_892_fu_22157_p1.read().is_01() || !sext_ln215_1069_fu_22143_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_892_fu_22157_p1.read()) + sc_bigint<19>(sext_ln215_1069_fu_22143_p1.read()));
}
void compute::thread_add_ln700_825_fu_22198_p2() {
add_ln700_825_fu_22198_p2 = (!sext_ln215_1068_fu_22129_p1.read().is_01() || !sext_ln700_894_fu_22194_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1068_fu_22129_p1.read()) + sc_bigint<20>(sext_ln700_894_fu_22194_p1.read()));
}
void compute::thread_add_ln700_826_fu_22208_p2() {
add_ln700_826_fu_22208_p2 = (!add_ln700_823_fu_22182_p2.read().is_01() || !sext_ln700_895_fu_22204_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_823_fu_22182_p2.read()) + sc_bigint<43>(sext_ln700_895_fu_22204_p1.read()));
}
void compute::thread_add_ln700_827_fu_22218_p2() {
add_ln700_827_fu_22218_p2 = (!add_ln700_822_fu_22176_p2.read().is_01() || !sext_ln700_896_fu_22214_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_822_fu_22176_p2.read()) + sc_bigint<48>(sext_ln700_896_fu_22214_p1.read()));
}
void compute::thread_add_ln700_830_fu_17812_p2() {
add_ln700_830_fu_17812_p2 = (!grp_fu_28698_p3.read().is_01() || !grp_fu_28690_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28698_p3.read()) + sc_bigint<36>(grp_fu_28690_p3.read()));
}
void compute::thread_add_ln700_833_fu_17816_p2() {
add_ln700_833_fu_17816_p2 = (!grp_fu_28670_p3.read().is_01() || !grp_fu_28662_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28670_p3.read()) + sc_bigint<36>(grp_fu_28662_p3.read()));
}
void compute::thread_add_ln700_834_fu_17820_p2() {
add_ln700_834_fu_17820_p2 = (!add_ln700_830_fu_17812_p2.read().is_01() || !add_ln700_833_fu_17816_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_830_fu_17812_p2.read()) + sc_biguint<36>(add_ln700_833_fu_17816_p2.read()));
}
void compute::thread_add_ln700_837_fu_17852_p2() {
add_ln700_837_fu_17852_p2 = (!grp_fu_28754_p3.read().is_01() || !grp_fu_28746_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28754_p3.read()) + sc_bigint<36>(grp_fu_28746_p3.read()));
}
void compute::thread_add_ln700_840_fu_17856_p2() {
add_ln700_840_fu_17856_p2 = (!grp_fu_28726_p3.read().is_01() || !grp_fu_28718_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28726_p3.read()) + sc_bigint<36>(grp_fu_28718_p3.read()));
}
void compute::thread_add_ln700_841_fu_17860_p2() {
add_ln700_841_fu_17860_p2 = (!add_ln700_837_fu_17852_p2.read().is_01() || !add_ln700_840_fu_17856_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_837_fu_17852_p2.read()) + sc_biguint<36>(add_ln700_840_fu_17856_p2.read()));
}
void compute::thread_add_ln700_844_fu_17892_p2() {
add_ln700_844_fu_17892_p2 = (!grp_fu_28810_p3.read().is_01() || !grp_fu_28802_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28810_p3.read()) + sc_bigint<36>(grp_fu_28802_p3.read()));
}
void compute::thread_add_ln700_847_fu_17896_p2() {
add_ln700_847_fu_17896_p2 = (!grp_fu_28782_p3.read().is_01() || !grp_fu_28774_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28782_p3.read()) + sc_bigint<36>(grp_fu_28774_p3.read()));
}
void compute::thread_add_ln700_848_fu_17900_p2() {
add_ln700_848_fu_17900_p2 = (!add_ln700_844_fu_17892_p2.read().is_01() || !add_ln700_847_fu_17896_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_844_fu_17892_p2.read()) + sc_biguint<36>(add_ln700_847_fu_17896_p2.read()));
}
void compute::thread_add_ln700_84_fu_14496_p2() {
add_ln700_84_fu_14496_p2 = (!grp_fu_24022_p3.read().is_01() || !grp_fu_24014_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24022_p3.read()) + sc_bigint<36>(grp_fu_24014_p3.read()));
}
void compute::thread_add_ln700_851_fu_17932_p2() {
add_ln700_851_fu_17932_p2 = (!grp_fu_28866_p3.read().is_01() || !grp_fu_28858_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28866_p3.read()) + sc_bigint<36>(grp_fu_28858_p3.read()));
}
void compute::thread_add_ln700_854_fu_17936_p2() {
add_ln700_854_fu_17936_p2 = (!grp_fu_28838_p3.read().is_01() || !grp_fu_28830_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28838_p3.read()) + sc_bigint<36>(grp_fu_28830_p3.read()));
}
void compute::thread_add_ln700_855_fu_17940_p2() {
add_ln700_855_fu_17940_p2 = (!add_ln700_851_fu_17932_p2.read().is_01() || !add_ln700_854_fu_17936_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_851_fu_17932_p2.read()) + sc_biguint<36>(add_ln700_854_fu_17936_p2.read()));
}
void compute::thread_add_ln700_856_fu_22290_p2() {
add_ln700_856_fu_22290_p2 = (!sext_ln700_905_fu_22231_p1.read().is_01() || !tmp_745_i_i_fu_22238_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_905_fu_22231_p1.read()) + sc_biguint<48>(tmp_745_i_i_fu_22238_p4.read()));
}
void compute::thread_add_ln700_857_fu_22296_p2() {
add_ln700_857_fu_22296_p2 = (!sext_ln647_70_fu_22269_p1.read().is_01() || !sext_ln647_69_fu_22255_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_70_fu_22269_p1.read()) + sc_bigint<43>(sext_ln647_69_fu_22255_p1.read()));
}
void compute::thread_add_ln700_858_fu_22306_p2() {
add_ln700_858_fu_22306_p2 = (!add_ln700_856_fu_22290_p2.read().is_01() || !sext_ln700_932_fu_22302_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_856_fu_22290_p2.read()) + sc_bigint<48>(sext_ln700_932_fu_22302_p1.read()));
}
void compute::thread_add_ln700_859_fu_22312_p2() {
add_ln700_859_fu_22312_p2 = (!sext_ln700_906_fu_22235_p1.read().is_01() || !sext_ln647_71_fu_22283_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_906_fu_22235_p1.read()) + sc_bigint<43>(sext_ln647_71_fu_22283_p1.read()));
}
void compute::thread_add_ln700_85_fu_14500_p2() {
add_ln700_85_fu_14500_p2 = (!add_ln700_81_fu_14492_p2.read().is_01() || !add_ln700_84_fu_14496_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_81_fu_14492_p2.read()) + sc_biguint<36>(add_ln700_84_fu_14496_p2.read()));
}
void compute::thread_add_ln700_860_fu_22318_p2() {
add_ln700_860_fu_22318_p2 = (!sext_ln700_931_fu_22287_p1.read().is_01() || !sext_ln215_1071_fu_22273_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_931_fu_22287_p1.read()) + sc_bigint<19>(sext_ln215_1071_fu_22273_p1.read()));
}
void compute::thread_add_ln700_861_fu_22328_p2() {
add_ln700_861_fu_22328_p2 = (!sext_ln215_1070_fu_22259_p1.read().is_01() || !sext_ln700_933_fu_22324_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1070_fu_22259_p1.read()) + sc_bigint<20>(sext_ln700_933_fu_22324_p1.read()));
}
void compute::thread_add_ln700_862_fu_22338_p2() {
add_ln700_862_fu_22338_p2 = (!add_ln700_859_fu_22312_p2.read().is_01() || !sext_ln700_934_fu_22334_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_859_fu_22312_p2.read()) + sc_bigint<43>(sext_ln700_934_fu_22334_p1.read()));
}
void compute::thread_add_ln700_863_fu_22348_p2() {
add_ln700_863_fu_22348_p2 = (!add_ln700_858_fu_22306_p2.read().is_01() || !sext_ln700_935_fu_22344_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_858_fu_22306_p2.read()) + sc_bigint<48>(sext_ln700_935_fu_22344_p1.read()));
}
void compute::thread_add_ln700_866_fu_17972_p2() {
add_ln700_866_fu_17972_p2 = (!grp_fu_28922_p3.read().is_01() || !grp_fu_28914_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28922_p3.read()) + sc_bigint<36>(grp_fu_28914_p3.read()));
}
void compute::thread_add_ln700_869_fu_17976_p2() {
add_ln700_869_fu_17976_p2 = (!grp_fu_28894_p3.read().is_01() || !grp_fu_28886_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28894_p3.read()) + sc_bigint<36>(grp_fu_28886_p3.read()));
}
void compute::thread_add_ln700_870_fu_17980_p2() {
add_ln700_870_fu_17980_p2 = (!add_ln700_866_fu_17972_p2.read().is_01() || !add_ln700_869_fu_17976_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_866_fu_17972_p2.read()) + sc_biguint<36>(add_ln700_869_fu_17976_p2.read()));
}
void compute::thread_add_ln700_873_fu_18012_p2() {
add_ln700_873_fu_18012_p2 = (!grp_fu_28978_p3.read().is_01() || !grp_fu_28970_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28978_p3.read()) + sc_bigint<36>(grp_fu_28970_p3.read()));
}
void compute::thread_add_ln700_876_fu_18016_p2() {
add_ln700_876_fu_18016_p2 = (!grp_fu_28950_p3.read().is_01() || !grp_fu_28942_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_28950_p3.read()) + sc_bigint<36>(grp_fu_28942_p3.read()));
}
void compute::thread_add_ln700_877_fu_18020_p2() {
add_ln700_877_fu_18020_p2 = (!add_ln700_873_fu_18012_p2.read().is_01() || !add_ln700_876_fu_18016_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_873_fu_18012_p2.read()) + sc_biguint<36>(add_ln700_876_fu_18016_p2.read()));
}
void compute::thread_add_ln700_880_fu_18052_p2() {
add_ln700_880_fu_18052_p2 = (!grp_fu_29034_p3.read().is_01() || !grp_fu_29026_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29034_p3.read()) + sc_bigint<36>(grp_fu_29026_p3.read()));
}
void compute::thread_add_ln700_883_fu_18056_p2() {
add_ln700_883_fu_18056_p2 = (!grp_fu_29006_p3.read().is_01() || !grp_fu_28998_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29006_p3.read()) + sc_bigint<36>(grp_fu_28998_p3.read()));
}
void compute::thread_add_ln700_884_fu_18060_p2() {
add_ln700_884_fu_18060_p2 = (!add_ln700_880_fu_18052_p2.read().is_01() || !add_ln700_883_fu_18056_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_880_fu_18052_p2.read()) + sc_biguint<36>(add_ln700_883_fu_18056_p2.read()));
}
void compute::thread_add_ln700_887_fu_18092_p2() {
add_ln700_887_fu_18092_p2 = (!grp_fu_29090_p3.read().is_01() || !grp_fu_29082_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29090_p3.read()) + sc_bigint<36>(grp_fu_29082_p3.read()));
}
void compute::thread_add_ln700_88_fu_14532_p2() {
add_ln700_88_fu_14532_p2 = (!grp_fu_24106_p3.read().is_01() || !grp_fu_24098_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24106_p3.read()) + sc_bigint<36>(grp_fu_24098_p3.read()));
}
void compute::thread_add_ln700_890_fu_18096_p2() {
add_ln700_890_fu_18096_p2 = (!grp_fu_29062_p3.read().is_01() || !grp_fu_29054_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29062_p3.read()) + sc_bigint<36>(grp_fu_29054_p3.read()));
}
void compute::thread_add_ln700_891_fu_18100_p2() {
add_ln700_891_fu_18100_p2 = (!add_ln700_887_fu_18092_p2.read().is_01() || !add_ln700_890_fu_18096_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_887_fu_18092_p2.read()) + sc_biguint<36>(add_ln700_890_fu_18096_p2.read()));
}
void compute::thread_add_ln700_892_fu_22420_p2() {
add_ln700_892_fu_22420_p2 = (!sext_ln700_944_fu_22361_p1.read().is_01() || !tmp_751_i_i_fu_22368_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_944_fu_22361_p1.read()) + sc_biguint<48>(tmp_751_i_i_fu_22368_p4.read()));
}
void compute::thread_add_ln700_893_fu_22426_p2() {
add_ln700_893_fu_22426_p2 = (!sext_ln647_73_fu_22399_p1.read().is_01() || !sext_ln647_72_fu_22385_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_73_fu_22399_p1.read()) + sc_bigint<43>(sext_ln647_72_fu_22385_p1.read()));
}
void compute::thread_add_ln700_894_fu_22436_p2() {
add_ln700_894_fu_22436_p2 = (!add_ln700_892_fu_22420_p2.read().is_01() || !sext_ln700_971_fu_22432_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_892_fu_22420_p2.read()) + sc_bigint<48>(sext_ln700_971_fu_22432_p1.read()));
}
void compute::thread_add_ln700_895_fu_22442_p2() {
add_ln700_895_fu_22442_p2 = (!sext_ln700_945_fu_22365_p1.read().is_01() || !sext_ln647_74_fu_22413_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_945_fu_22365_p1.read()) + sc_bigint<43>(sext_ln647_74_fu_22413_p1.read()));
}
void compute::thread_add_ln700_896_fu_22448_p2() {
add_ln700_896_fu_22448_p2 = (!sext_ln700_970_fu_22417_p1.read().is_01() || !sext_ln215_1073_fu_22403_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_970_fu_22417_p1.read()) + sc_bigint<19>(sext_ln215_1073_fu_22403_p1.read()));
}
void compute::thread_add_ln700_897_fu_22458_p2() {
add_ln700_897_fu_22458_p2 = (!sext_ln215_1072_fu_22389_p1.read().is_01() || !sext_ln700_972_fu_22454_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1072_fu_22389_p1.read()) + sc_bigint<20>(sext_ln700_972_fu_22454_p1.read()));
}
void compute::thread_add_ln700_898_fu_22468_p2() {
add_ln700_898_fu_22468_p2 = (!add_ln700_895_fu_22442_p2.read().is_01() || !sext_ln700_973_fu_22464_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_895_fu_22442_p2.read()) + sc_bigint<43>(sext_ln700_973_fu_22464_p1.read()));
}
void compute::thread_add_ln700_899_fu_22478_p2() {
add_ln700_899_fu_22478_p2 = (!add_ln700_894_fu_22436_p2.read().is_01() || !sext_ln700_974_fu_22474_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_894_fu_22436_p2.read()) + sc_bigint<48>(sext_ln700_974_fu_22474_p1.read()));
}
void compute::thread_add_ln700_902_fu_18132_p2() {
add_ln700_902_fu_18132_p2 = (!grp_fu_29146_p3.read().is_01() || !grp_fu_29138_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29146_p3.read()) + sc_bigint<36>(grp_fu_29138_p3.read()));
}
void compute::thread_add_ln700_905_fu_18136_p2() {
add_ln700_905_fu_18136_p2 = (!grp_fu_29118_p3.read().is_01() || !grp_fu_29110_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29118_p3.read()) + sc_bigint<36>(grp_fu_29110_p3.read()));
}
void compute::thread_add_ln700_906_fu_18140_p2() {
add_ln700_906_fu_18140_p2 = (!add_ln700_902_fu_18132_p2.read().is_01() || !add_ln700_905_fu_18136_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_902_fu_18132_p2.read()) + sc_biguint<36>(add_ln700_905_fu_18136_p2.read()));
}
void compute::thread_add_ln700_909_fu_18172_p2() {
add_ln700_909_fu_18172_p2 = (!grp_fu_29202_p3.read().is_01() || !grp_fu_29194_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29202_p3.read()) + sc_bigint<36>(grp_fu_29194_p3.read()));
}
void compute::thread_add_ln700_912_fu_18176_p2() {
add_ln700_912_fu_18176_p2 = (!grp_fu_29174_p3.read().is_01() || !grp_fu_29166_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29174_p3.read()) + sc_bigint<36>(grp_fu_29166_p3.read()));
}
void compute::thread_add_ln700_913_fu_18180_p2() {
add_ln700_913_fu_18180_p2 = (!add_ln700_909_fu_18172_p2.read().is_01() || !add_ln700_912_fu_18176_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_909_fu_18172_p2.read()) + sc_biguint<36>(add_ln700_912_fu_18176_p2.read()));
}
void compute::thread_add_ln700_916_fu_18212_p2() {
add_ln700_916_fu_18212_p2 = (!grp_fu_29258_p3.read().is_01() || !grp_fu_29250_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29258_p3.read()) + sc_bigint<36>(grp_fu_29250_p3.read()));
}
void compute::thread_add_ln700_919_fu_18216_p2() {
add_ln700_919_fu_18216_p2 = (!grp_fu_29230_p3.read().is_01() || !grp_fu_29222_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29230_p3.read()) + sc_bigint<36>(grp_fu_29222_p3.read()));
}
void compute::thread_add_ln700_91_fu_14536_p2() {
add_ln700_91_fu_14536_p2 = (!grp_fu_24078_p3.read().is_01() || !grp_fu_24070_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24078_p3.read()) + sc_bigint<36>(grp_fu_24070_p3.read()));
}
void compute::thread_add_ln700_920_fu_18220_p2() {
add_ln700_920_fu_18220_p2 = (!add_ln700_916_fu_18212_p2.read().is_01() || !add_ln700_919_fu_18216_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_916_fu_18212_p2.read()) + sc_biguint<36>(add_ln700_919_fu_18216_p2.read()));
}
void compute::thread_add_ln700_923_fu_18252_p2() {
add_ln700_923_fu_18252_p2 = (!grp_fu_29314_p3.read().is_01() || !grp_fu_29306_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29314_p3.read()) + sc_bigint<36>(grp_fu_29306_p3.read()));
}
void compute::thread_add_ln700_926_fu_18256_p2() {
add_ln700_926_fu_18256_p2 = (!grp_fu_29286_p3.read().is_01() || !grp_fu_29278_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29286_p3.read()) + sc_bigint<36>(grp_fu_29278_p3.read()));
}
void compute::thread_add_ln700_927_fu_18260_p2() {
add_ln700_927_fu_18260_p2 = (!add_ln700_923_fu_18252_p2.read().is_01() || !add_ln700_926_fu_18256_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_923_fu_18252_p2.read()) + sc_biguint<36>(add_ln700_926_fu_18256_p2.read()));
}
void compute::thread_add_ln700_928_fu_22550_p2() {
add_ln700_928_fu_22550_p2 = (!sext_ln700_983_fu_22491_p1.read().is_01() || !tmp_757_i_i_fu_22498_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_983_fu_22491_p1.read()) + sc_biguint<48>(tmp_757_i_i_fu_22498_p4.read()));
}
void compute::thread_add_ln700_929_fu_22556_p2() {
add_ln700_929_fu_22556_p2 = (!sext_ln647_76_fu_22529_p1.read().is_01() || !sext_ln647_75_fu_22515_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_76_fu_22529_p1.read()) + sc_bigint<43>(sext_ln647_75_fu_22515_p1.read()));
}
void compute::thread_add_ln700_92_fu_14540_p2() {
add_ln700_92_fu_14540_p2 = (!add_ln700_88_fu_14532_p2.read().is_01() || !add_ln700_91_fu_14536_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_88_fu_14532_p2.read()) + sc_biguint<36>(add_ln700_91_fu_14536_p2.read()));
}
void compute::thread_add_ln700_930_fu_22566_p2() {
add_ln700_930_fu_22566_p2 = (!add_ln700_928_fu_22550_p2.read().is_01() || !sext_ln700_1010_fu_22562_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_928_fu_22550_p2.read()) + sc_bigint<48>(sext_ln700_1010_fu_22562_p1.read()));
}
void compute::thread_add_ln700_931_fu_22572_p2() {
add_ln700_931_fu_22572_p2 = (!sext_ln700_984_fu_22495_p1.read().is_01() || !sext_ln647_77_fu_22543_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_984_fu_22495_p1.read()) + sc_bigint<43>(sext_ln647_77_fu_22543_p1.read()));
}
void compute::thread_add_ln700_932_fu_22578_p2() {
add_ln700_932_fu_22578_p2 = (!sext_ln700_1009_fu_22547_p1.read().is_01() || !sext_ln215_1075_fu_22533_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1009_fu_22547_p1.read()) + sc_bigint<19>(sext_ln215_1075_fu_22533_p1.read()));
}
void compute::thread_add_ln700_933_fu_22588_p2() {
add_ln700_933_fu_22588_p2 = (!sext_ln215_1074_fu_22519_p1.read().is_01() || !sext_ln700_1011_fu_22584_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1074_fu_22519_p1.read()) + sc_bigint<20>(sext_ln700_1011_fu_22584_p1.read()));
}
void compute::thread_add_ln700_934_fu_22598_p2() {
add_ln700_934_fu_22598_p2 = (!add_ln700_931_fu_22572_p2.read().is_01() || !sext_ln700_1012_fu_22594_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_931_fu_22572_p2.read()) + sc_bigint<43>(sext_ln700_1012_fu_22594_p1.read()));
}
void compute::thread_add_ln700_935_fu_22608_p2() {
add_ln700_935_fu_22608_p2 = (!add_ln700_930_fu_22566_p2.read().is_01() || !sext_ln700_1013_fu_22604_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_930_fu_22566_p2.read()) + sc_bigint<48>(sext_ln700_1013_fu_22604_p1.read()));
}
void compute::thread_add_ln700_938_fu_18292_p2() {
add_ln700_938_fu_18292_p2 = (!grp_fu_29370_p3.read().is_01() || !grp_fu_29362_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29370_p3.read()) + sc_bigint<36>(grp_fu_29362_p3.read()));
}
void compute::thread_add_ln700_941_fu_18296_p2() {
add_ln700_941_fu_18296_p2 = (!grp_fu_29342_p3.read().is_01() || !grp_fu_29334_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29342_p3.read()) + sc_bigint<36>(grp_fu_29334_p3.read()));
}
void compute::thread_add_ln700_942_fu_18300_p2() {
add_ln700_942_fu_18300_p2 = (!add_ln700_938_fu_18292_p2.read().is_01() || !add_ln700_941_fu_18296_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_938_fu_18292_p2.read()) + sc_biguint<36>(add_ln700_941_fu_18296_p2.read()));
}
void compute::thread_add_ln700_945_fu_18332_p2() {
add_ln700_945_fu_18332_p2 = (!grp_fu_29426_p3.read().is_01() || !grp_fu_29418_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29426_p3.read()) + sc_bigint<36>(grp_fu_29418_p3.read()));
}
void compute::thread_add_ln700_948_fu_18336_p2() {
add_ln700_948_fu_18336_p2 = (!grp_fu_29398_p3.read().is_01() || !grp_fu_29390_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29398_p3.read()) + sc_bigint<36>(grp_fu_29390_p3.read()));
}
void compute::thread_add_ln700_949_fu_18340_p2() {
add_ln700_949_fu_18340_p2 = (!add_ln700_945_fu_18332_p2.read().is_01() || !add_ln700_948_fu_18336_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_945_fu_18332_p2.read()) + sc_biguint<36>(add_ln700_948_fu_18336_p2.read()));
}
void compute::thread_add_ln700_952_fu_18372_p2() {
add_ln700_952_fu_18372_p2 = (!grp_fu_29482_p3.read().is_01() || !grp_fu_29474_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29482_p3.read()) + sc_bigint<36>(grp_fu_29474_p3.read()));
}
void compute::thread_add_ln700_955_fu_18376_p2() {
add_ln700_955_fu_18376_p2 = (!grp_fu_29454_p3.read().is_01() || !grp_fu_29446_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29454_p3.read()) + sc_bigint<36>(grp_fu_29446_p3.read()));
}
void compute::thread_add_ln700_956_fu_18380_p2() {
add_ln700_956_fu_18380_p2 = (!add_ln700_952_fu_18372_p2.read().is_01() || !add_ln700_955_fu_18376_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_952_fu_18372_p2.read()) + sc_biguint<36>(add_ln700_955_fu_18376_p2.read()));
}
void compute::thread_add_ln700_959_fu_18412_p2() {
add_ln700_959_fu_18412_p2 = (!grp_fu_29538_p3.read().is_01() || !grp_fu_29530_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29538_p3.read()) + sc_bigint<36>(grp_fu_29530_p3.read()));
}
void compute::thread_add_ln700_95_fu_14572_p2() {
add_ln700_95_fu_14572_p2 = (!grp_fu_24162_p3.read().is_01() || !grp_fu_24154_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24162_p3.read()) + sc_bigint<36>(grp_fu_24154_p3.read()));
}
void compute::thread_add_ln700_962_fu_18416_p2() {
add_ln700_962_fu_18416_p2 = (!grp_fu_29510_p3.read().is_01() || !grp_fu_29502_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29510_p3.read()) + sc_bigint<36>(grp_fu_29502_p3.read()));
}
void compute::thread_add_ln700_963_fu_18420_p2() {
add_ln700_963_fu_18420_p2 = (!add_ln700_959_fu_18412_p2.read().is_01() || !add_ln700_962_fu_18416_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_959_fu_18412_p2.read()) + sc_biguint<36>(add_ln700_962_fu_18416_p2.read()));
}
void compute::thread_add_ln700_964_fu_22680_p2() {
add_ln700_964_fu_22680_p2 = (!sext_ln700_1022_fu_22621_p1.read().is_01() || !tmp_763_i_i_fu_22628_p4.read().is_01())? sc_lv<48>(): (sc_bigint<48>(sext_ln700_1022_fu_22621_p1.read()) + sc_biguint<48>(tmp_763_i_i_fu_22628_p4.read()));
}
void compute::thread_add_ln700_965_fu_22686_p2() {
add_ln700_965_fu_22686_p2 = (!sext_ln647_79_fu_22659_p1.read().is_01() || !sext_ln647_78_fu_22645_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln647_79_fu_22659_p1.read()) + sc_bigint<43>(sext_ln647_78_fu_22645_p1.read()));
}
void compute::thread_add_ln700_966_fu_22696_p2() {
add_ln700_966_fu_22696_p2 = (!add_ln700_964_fu_22680_p2.read().is_01() || !sext_ln700_1049_fu_22692_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_964_fu_22680_p2.read()) + sc_bigint<48>(sext_ln700_1049_fu_22692_p1.read()));
}
void compute::thread_add_ln700_967_fu_22702_p2() {
add_ln700_967_fu_22702_p2 = (!sext_ln700_1023_fu_22625_p1.read().is_01() || !sext_ln647_80_fu_22673_p1.read().is_01())? sc_lv<43>(): (sc_bigint<43>(sext_ln700_1023_fu_22625_p1.read()) + sc_bigint<43>(sext_ln647_80_fu_22673_p1.read()));
}
void compute::thread_add_ln700_968_fu_22708_p2() {
add_ln700_968_fu_22708_p2 = (!sext_ln700_1048_fu_22677_p1.read().is_01() || !sext_ln215_1077_fu_22663_p1.read().is_01())? sc_lv<19>(): (sc_bigint<19>(sext_ln700_1048_fu_22677_p1.read()) + sc_bigint<19>(sext_ln215_1077_fu_22663_p1.read()));
}
void compute::thread_add_ln700_969_fu_22718_p2() {
add_ln700_969_fu_22718_p2 = (!sext_ln215_1076_fu_22649_p1.read().is_01() || !sext_ln700_1050_fu_22714_p1.read().is_01())? sc_lv<20>(): (sc_bigint<20>(sext_ln215_1076_fu_22649_p1.read()) + sc_bigint<20>(sext_ln700_1050_fu_22714_p1.read()));
}
void compute::thread_add_ln700_970_fu_22728_p2() {
add_ln700_970_fu_22728_p2 = (!add_ln700_967_fu_22702_p2.read().is_01() || !sext_ln700_1051_fu_22724_p1.read().is_01())? sc_lv<43>(): (sc_biguint<43>(add_ln700_967_fu_22702_p2.read()) + sc_bigint<43>(sext_ln700_1051_fu_22724_p1.read()));
}
void compute::thread_add_ln700_971_fu_22738_p2() {
add_ln700_971_fu_22738_p2 = (!add_ln700_966_fu_22696_p2.read().is_01() || !sext_ln700_1052_fu_22734_p1.read().is_01())? sc_lv<48>(): (sc_biguint<48>(add_ln700_966_fu_22696_p2.read()) + sc_bigint<48>(sext_ln700_1052_fu_22734_p1.read()));
}
void compute::thread_add_ln700_974_fu_18452_p2() {
add_ln700_974_fu_18452_p2 = (!grp_fu_29594_p3.read().is_01() || !grp_fu_29586_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29594_p3.read()) + sc_bigint<36>(grp_fu_29586_p3.read()));
}
void compute::thread_add_ln700_977_fu_18456_p2() {
add_ln700_977_fu_18456_p2 = (!grp_fu_29566_p3.read().is_01() || !grp_fu_29558_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29566_p3.read()) + sc_bigint<36>(grp_fu_29558_p3.read()));
}
void compute::thread_add_ln700_978_fu_18460_p2() {
add_ln700_978_fu_18460_p2 = (!add_ln700_974_fu_18452_p2.read().is_01() || !add_ln700_977_fu_18456_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_974_fu_18452_p2.read()) + sc_biguint<36>(add_ln700_977_fu_18456_p2.read()));
}
void compute::thread_add_ln700_981_fu_18492_p2() {
add_ln700_981_fu_18492_p2 = (!grp_fu_29650_p3.read().is_01() || !grp_fu_29642_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29650_p3.read()) + sc_bigint<36>(grp_fu_29642_p3.read()));
}
void compute::thread_add_ln700_984_fu_18496_p2() {
add_ln700_984_fu_18496_p2 = (!grp_fu_29622_p3.read().is_01() || !grp_fu_29614_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29622_p3.read()) + sc_bigint<36>(grp_fu_29614_p3.read()));
}
void compute::thread_add_ln700_985_fu_18500_p2() {
add_ln700_985_fu_18500_p2 = (!add_ln700_981_fu_18492_p2.read().is_01() || !add_ln700_984_fu_18496_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_981_fu_18492_p2.read()) + sc_biguint<36>(add_ln700_984_fu_18496_p2.read()));
}
void compute::thread_add_ln700_988_fu_18532_p2() {
add_ln700_988_fu_18532_p2 = (!grp_fu_29706_p3.read().is_01() || !grp_fu_29698_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29706_p3.read()) + sc_bigint<36>(grp_fu_29698_p3.read()));
}
void compute::thread_add_ln700_98_fu_14576_p2() {
add_ln700_98_fu_14576_p2 = (!grp_fu_24134_p3.read().is_01() || !grp_fu_24126_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_24134_p3.read()) + sc_bigint<36>(grp_fu_24126_p3.read()));
}
void compute::thread_add_ln700_991_fu_18536_p2() {
add_ln700_991_fu_18536_p2 = (!grp_fu_29678_p3.read().is_01() || !grp_fu_29670_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29678_p3.read()) + sc_bigint<36>(grp_fu_29670_p3.read()));
}
void compute::thread_add_ln700_992_fu_18540_p2() {
add_ln700_992_fu_18540_p2 = (!add_ln700_988_fu_18532_p2.read().is_01() || !add_ln700_991_fu_18536_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_988_fu_18532_p2.read()) + sc_biguint<36>(add_ln700_991_fu_18536_p2.read()));
}
void compute::thread_add_ln700_995_fu_18572_p2() {
add_ln700_995_fu_18572_p2 = (!grp_fu_29762_p3.read().is_01() || !grp_fu_29754_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29762_p3.read()) + sc_bigint<36>(grp_fu_29754_p3.read()));
}
void compute::thread_add_ln700_998_fu_18576_p2() {
add_ln700_998_fu_18576_p2 = (!grp_fu_29734_p3.read().is_01() || !grp_fu_29726_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_29734_p3.read()) + sc_bigint<36>(grp_fu_29726_p3.read()));
}
void compute::thread_add_ln700_999_fu_18580_p2() {
add_ln700_999_fu_18580_p2 = (!add_ln700_995_fu_18572_p2.read().is_01() || !add_ln700_998_fu_18576_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_995_fu_18572_p2.read()) + sc_biguint<36>(add_ln700_998_fu_18576_p2.read()));
}
void compute::thread_add_ln700_99_fu_14580_p2() {
add_ln700_99_fu_14580_p2 = (!add_ln700_95_fu_14572_p2.read().is_01() || !add_ln700_98_fu_14576_p2.read().is_01())? sc_lv<36>(): (sc_biguint<36>(add_ln700_95_fu_14572_p2.read()) + sc_biguint<36>(add_ln700_98_fu_14576_p2.read()));
}
void compute::thread_add_ln700_9_fu_14108_p2() {
add_ln700_9_fu_14108_p2 = (!grp_fu_23602_p3.read().is_01() || !grp_fu_23594_p3.read().is_01())? sc_lv<36>(): (sc_bigint<36>(grp_fu_23602_p3.read()) + sc_bigint<36>(grp_fu_23594_p3.read()));
}
void compute::thread_and_ln140_fu_13124_p2() {
and_ln140_fu_13124_p2 = (icmp_ln140_2_fu_13120_p2.read() & xor_ln140_2_fu_13114_p2.read());
}
void compute::thread_ap_CS_fsm_pp0_stage0() {
ap_CS_fsm_pp0_stage0 = ap_CS_fsm.read()[33];
}
void compute::thread_ap_CS_fsm_state1() {
ap_CS_fsm_state1 = ap_CS_fsm.read()[0];
}
void compute::thread_ap_CS_fsm_state10() {
ap_CS_fsm_state10 = ap_CS_fsm.read()[9];
}
void compute::thread_ap_CS_fsm_state11() {
ap_CS_fsm_state11 = ap_CS_fsm.read()[10];
}
void compute::thread_ap_CS_fsm_state12() {
ap_CS_fsm_state12 = ap_CS_fsm.read()[11];
}
void compute::thread_ap_CS_fsm_state13() {
ap_CS_fsm_state13 = ap_CS_fsm.read()[12];
}
void compute::thread_ap_CS_fsm_state14() {
ap_CS_fsm_state14 = ap_CS_fsm.read()[13];
}
void compute::thread_ap_CS_fsm_state15() {
ap_CS_fsm_state15 = ap_CS_fsm.read()[14];
}
void compute::thread_ap_CS_fsm_state16() {
ap_CS_fsm_state16 = ap_CS_fsm.read()[15];
}
void compute::thread_ap_CS_fsm_state17() {
ap_CS_fsm_state17 = ap_CS_fsm.read()[16];
}
void compute::thread_ap_CS_fsm_state2() {
ap_CS_fsm_state2 = ap_CS_fsm.read()[1];
}
void compute::thread_ap_CS_fsm_state3() {
ap_CS_fsm_state3 = ap_CS_fsm.read()[2];
}
void compute::thread_ap_CS_fsm_state33() {
ap_CS_fsm_state33 = ap_CS_fsm.read()[32];
}
void compute::thread_ap_CS_fsm_state39() {
ap_CS_fsm_state39 = ap_CS_fsm.read()[34];
}
void compute::thread_ap_CS_fsm_state4() {
ap_CS_fsm_state4 = ap_CS_fsm.read()[3];
}
void compute::thread_ap_CS_fsm_state5() {
ap_CS_fsm_state5 = ap_CS_fsm.read()[4];
}
void compute::thread_ap_CS_fsm_state6() {
ap_CS_fsm_state6 = ap_CS_fsm.read()[5];
}
void compute::thread_ap_CS_fsm_state7() {
ap_CS_fsm_state7 = ap_CS_fsm.read()[6];
}
void compute::thread_ap_CS_fsm_state8() {
ap_CS_fsm_state8 = ap_CS_fsm.read()[7];
}
void compute::thread_ap_CS_fsm_state9() {
ap_CS_fsm_state9 = ap_CS_fsm.read()[8];
}
void compute::thread_ap_block_pp0() {
ap_block_pp0 = (esl_seteq<1,35,35>(ap_ST_fsm_pp0_stage0, ap_CS_fsm.read()) && esl_seteq<1,1,1>(ap_const_boolean_1, ap_block_pp0_stage0_subdone.read()));
}
void compute::thread_ap_block_pp0_stage0() {
ap_block_pp0_stage0 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_pp0_stage0_11001() {
ap_block_pp0_stage0_11001 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_pp0_stage0_subdone() {
ap_block_pp0_stage0_subdone = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_state1() {
ap_block_state1 = (esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) || esl_seteq<1,1,1>(ap_done_reg.read(), ap_const_logic_1) || esl_seteq<1,1,1>(ap_const_logic_0, OSIZE_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TO_r_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, TI_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, S_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, P_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, l_0_empty_n.read()) || esl_seteq<1,1,1>(ap_const_logic_0, K_empty_n.read()));
}
void compute::thread_ap_block_state34_pp0_stage0_iter0() {
ap_block_state34_pp0_stage0_iter0 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_state35_pp0_stage0_iter1() {
ap_block_state35_pp0_stage0_iter1 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_state36_pp0_stage0_iter2() {
ap_block_state36_pp0_stage0_iter2 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_state37_pp0_stage0_iter3() {
ap_block_state37_pp0_stage0_iter3 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_block_state38_pp0_stage0_iter4() {
ap_block_state38_pp0_stage0_iter4 = !esl_seteq<1,1,1>(ap_const_boolean_1, ap_const_boolean_1);
}
void compute::thread_ap_condition_pp0_exit_iter0_state34() {
if (esl_seteq<1,1,1>(icmp_ln135_fu_12998_p2.read(), ap_const_lv1_1)) {
ap_condition_pp0_exit_iter0_state34 = ap_const_logic_1;
} else {
ap_condition_pp0_exit_iter0_state34 = ap_const_logic_0;
}
}
void compute::thread_ap_done() {
if (esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state39.read())) {
ap_done = ap_const_logic_1;
} else {
ap_done = ap_done_reg.read();
}
}
void compute::thread_ap_enable_operation_2298() {
ap_enable_operation_2298 = esl_seteq<1,1,1>(ap_const_boolean_1, ap_predicate_op2298_load_state34.read());
}
void compute::thread_ap_enable_operation_5645() {
ap_enable_operation_5645 = esl_seteq<1,1,1>(ap_const_boolean_1, ap_predicate_op5645_load_state37.read());
}
void compute::thread_ap_enable_operation_6444() {
ap_enable_operation_6444 = esl_seteq<1,1,1>(ap_const_boolean_1, ap_predicate_op6444_store_state37.read());
}
void compute::thread_ap_enable_operation_6508() {
ap_enable_operation_6508 = esl_seteq<1,1,1>(ap_const_boolean_1, ap_predicate_op6508_store_state38.read());
}
void compute::thread_ap_enable_pp0() {
ap_enable_pp0 = (ap_idle_pp0.read() ^ ap_const_logic_1);
}
void compute::thread_ap_enable_state34_pp0_iter0_stage0() {
ap_enable_state34_pp0_iter0_stage0 = (esl_seteq<1,1,1>(ap_enable_reg_pp0_iter0.read(), ap_const_logic_1) && esl_seteq<1,1,1>(ap_CS_fsm_pp0_stage0.read(), ap_const_logic_1));
}
void compute::thread_ap_enable_state37_pp0_iter3_stage0() {
ap_enable_state37_pp0_iter3_stage0 = (esl_seteq<1,1,1>(ap_CS_fsm_pp0_stage0.read(), ap_const_logic_1) && esl_seteq<1,1,1>(ap_enable_reg_pp0_iter3.read(), ap_const_logic_1));
}
void compute::thread_ap_enable_state38_pp0_iter4_stage0() {
ap_enable_state38_pp0_iter4_stage0 = (esl_seteq<1,1,1>(ap_CS_fsm_pp0_stage0.read(), ap_const_logic_1) && esl_seteq<1,1,1>(ap_enable_reg_pp0_iter4.read(), ap_const_logic_1));
}
void compute::thread_ap_idle() {
if ((esl_seteq<1,1,1>(ap_const_logic_0, ap_start.read()) &&
esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state1.read()))) {
ap_idle = ap_const_logic_1;
} else {
ap_idle = ap_const_logic_0;
}
}
void compute::thread_ap_idle_pp0() {
if ((esl_seteq<1,1,1>(ap_const_logic_0, ap_enable_reg_pp0_iter0.read()) &&
esl_seteq<1,1,1>(ap_const_logic_0, ap_enable_reg_pp0_iter1.read()) &&
esl_seteq<1,1,1>(ap_const_logic_0, ap_enable_reg_pp0_iter2.read()) &&
esl_seteq<1,1,1>(ap_const_logic_0, ap_enable_reg_pp0_iter3.read()) &&
esl_seteq<1,1,1>(ap_const_logic_0, ap_enable_reg_pp0_iter4.read()))) {
ap_idle_pp0 = ap_const_logic_1;
} else {
ap_idle_pp0 = ap_const_logic_0;
}
}
void compute::thread_ap_phi_mux_row_0_i_i_phi_fu_8691_p4() {
if ((esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_pp0_stage0.read()) &&
esl_seteq<1,1,1>(ap_const_logic_1, ap_enable_reg_pp0_iter1.read()) &&
esl_seteq<1,1,1>(icmp_ln135_reg_35945.read(), ap_const_lv1_0) &&
esl_seteq<1,1,1>(ap_block_pp0_stage0.read(), ap_const_boolean_0))) {
ap_phi_mux_row_0_i_i_phi_fu_8691_p4 = select_ln140_2_reg_35954.read();
} else {
ap_phi_mux_row_0_i_i_phi_fu_8691_p4 = row_0_i_i_reg_8687.read();
}
}
void compute::thread_ap_predicate_op2298_load_state34() {
ap_predicate_op2298_load_state34 = (esl_seteq<1,1,1>(icmp_ln135_fu_12998_p2.read(), ap_const_lv1_0) && esl_seteq<1,1,1>(ap_const_lv1_0, select_ln140_3_fu_13087_p3.read()) && esl_seteq<1,1,1>(and_ln140_fu_13124_p2.read(), ap_const_lv1_1));
}
void compute::thread_ap_predicate_op5645_load_state37() {
ap_predicate_op5645_load_state37 = (esl_seteq<1,1,1>(ap_const_lv1_0, select_ln140_3_reg_35959_pp0_iter2_reg.read()) && esl_seteq<1,1,1>(and_ln140_reg_35963_pp0_iter2_reg.read(), ap_const_lv1_1));
}
void compute::thread_ap_predicate_op6444_store_state37() {
ap_predicate_op6444_store_state37 = (esl_seteq<1,1,1>(ap_const_lv1_0, select_ln140_3_reg_35959_pp0_iter2_reg.read()) && esl_seteq<1,1,1>(and_ln140_reg_35963_pp0_iter2_reg.read(), ap_const_lv1_1));
}
void compute::thread_ap_predicate_op6508_store_state38() {
ap_predicate_op6508_store_state38 = (esl_seteq<1,1,1>(ap_const_lv1_0, select_ln140_3_reg_35959_pp0_iter3_reg.read()) && esl_seteq<1,1,1>(and_ln140_reg_35963_pp0_iter3_reg.read(), ap_const_lv1_1));
}
void compute::thread_ap_ready() {
if (esl_seteq<1,1,1>(ap_const_logic_1, ap_CS_fsm_state39.read())) {
ap_ready = ap_const_logic_1;
} else {
ap_ready = ap_const_logic_0;
}
}
void compute::thread_bound_fu_12965_p0() {
bound_fu_12965_p0 = (sc_lv<6>) (zext_ln140_1_fu_8815_p1.read());
}
void compute::thread_bound_fu_12965_p1() {
bound_fu_12965_p1 = (sc_lv<6>) (zext_ln140_1_fu_8815_p1.read());
}
void compute::thread_bound_fu_12965_p2() {
bound_fu_12965_p2 = (!bound_fu_12965_p0.read().is_01() || !bound_fu_12965_p1.read().is_01())? sc_lv<12>(): sc_biguint<6>(bound_fu_12965_p0.read()) * sc_biguint<6>(bound_fu_12965_p1.read());
}
void compute::thread_col_fu_13150_p2() {
col_fu_13150_p2 = (!select_ln140_fu_13014_p3.read().is_01() || !ap_const_lv6_1.is_01())? sc_lv<6>(): (sc_biguint<6>(select_ln140_fu_13014_p3.read()) + sc_biguint<6>(ap_const_lv6_1));
}
void compute::thread_empty_fu_8798_p1() {
empty_fu_8798_p1 = grp_fu_8776_p2.read().range(7-1, 0);
}
void compute::thread_grp_fu_23463_p0() {
grp_fu_23463_p0 = (sc_lv<2>) (zext_ln140_cast_reg_30775.read());
}
void compute::thread_grp_fu_23463_p1() {
grp_fu_23463_p1 = (sc_lv<6>) (grp_fu_23463_p10.read());
}
void compute::thread_grp_fu_23463_p10() {
grp_fu_23463_p10 = esl_zext<8,6>(ap_phi_mux_row_0_i_i_phi_fu_8691_p4.read());
}
void compute::thread_grp_fu_23463_p2() {
grp_fu_23463_p2 = (sc_lv<3>) (sext_ln140_reg_30797.read());
}
void compute::thread_grp_fu_23472_p0() {
grp_fu_23472_p0 = (sc_lv<2>) (zext_ln140_cast_reg_30775.read());
}
void compute::thread_grp_fu_23472_p1() {
grp_fu_23472_p1 = (sc_lv<6>) (grp_fu_23472_p10.read());
}
void compute::thread_grp_fu_23472_p10() {
grp_fu_23472_p10 = esl_zext<8,6>(add_ln135_1_fu_13022_p2.read());
}
void compute::thread_grp_fu_23472_p2() {
grp_fu_23472_p2 = (sc_lv<3>) (sext_ln140_reg_30797.read());
}
void compute::thread_grp_fu_23481_p0() {
grp_fu_23481_p0 = (sc_lv<6>) (grp_fu_23481_p00.read());
}
void compute::thread_grp_fu_23481_p00() {
grp_fu_23481_p00 = esl_zext<8,6>(select_ln140_fu_13014_p3.read());
}
void compute::thread_grp_fu_23481_p1() {
grp_fu_23481_p1 = (sc_lv<2>) (zext_ln140_cast_reg_30775.read());
}
void compute::thread_grp_fu_23481_p2() {
grp_fu_23481_p2 = (sc_lv<3>) (sext_ln135_1_reg_30815.read());
}
void compute::thread_grp_fu_23489_p0() {
grp_fu_23489_p0 = (sc_lv<5>) (zext_ln140_reg_30782.read());
}
void compute::thread_grp_fu_23489_p1() {
grp_fu_23489_p1 = (sc_lv<12>) (grp_fu_23489_p10.read());
}
void compute::thread_grp_fu_23489_p10() {
grp_fu_23489_p10 = esl_zext<17,12>(add_ln156_fu_13136_p2.read());
}
void compute::thread_grp_fu_23489_p2() {
grp_fu_23489_p2 = (sc_lv<13>) (zext_ln213_reg_30755.read());
}
void compute::thread_grp_fu_23496_p0() {
grp_fu_23496_p0 = (sc_lv<2>) (S_cast2_i_i_cast2686_reg_30770.read());
}
void compute::thread_grp_fu_23496_p1() {
grp_fu_23496_p1 = (sc_lv<15>) (grp_fu_23496_p10.read());
}
void compute::thread_grp_fu_23496_p10() {
grp_fu_23496_p10 = esl_zext<17,15>(tmp_i_i_reg_35967.read());
}
void compute::thread_grp_fu_23496_p2() {
grp_fu_23496_p2 = (sc_lv<3>) (sext_ln135_reg_30810.read());
}
void compute::thread_grp_fu_23503_p0() {
grp_fu_23503_p0 = (sc_lv<6>) (zext_ln144_reg_30760.read());
}
void compute::thread_grp_fu_23503_p2() {
grp_fu_23503_p2 = (sc_lv<7>) (ti_cast_i_i_cast5_reg_30765.read());
}
void compute::thread_grp_fu_23510_p0() {
grp_fu_23510_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_23510_p1() {
grp_fu_23510_p1 = (sc_lv<27>) (sext_ln215_reg_30820.read());
}
void compute::thread_grp_fu_23518_p0() {
grp_fu_23518_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_23518_p1() {
grp_fu_23518_p1 = (sc_lv<27>) (sext_ln215_1_reg_30825.read());
}
void compute::thread_grp_fu_23538_p0() {
grp_fu_23538_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_23538_p1() {
grp_fu_23538_p1 = (sc_lv<27>) (sext_ln215_4_reg_30840.read());
}
void compute::thread_grp_fu_23546_p0() {
grp_fu_23546_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_23546_p1() {
grp_fu_23546_p1 = (sc_lv<27>) (sext_ln215_5_reg_30845.read());
}
void compute::thread_grp_fu_23566_p0() {
grp_fu_23566_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_23566_p1() {
grp_fu_23566_p1 = (sc_lv<27>) (sext_ln215_8_reg_30860.read());
}
void compute::thread_grp_fu_23574_p0() {
grp_fu_23574_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_23574_p1() {
grp_fu_23574_p1 = (sc_lv<27>) (sext_ln215_9_reg_30865.read());
}
void compute::thread_grp_fu_23594_p0() {
grp_fu_23594_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_23594_p1() {
grp_fu_23594_p1 = (sc_lv<27>) (sext_ln215_12_reg_30880.read());
}
void compute::thread_grp_fu_23602_p0() {
grp_fu_23602_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_23602_p1() {
grp_fu_23602_p1 = (sc_lv<27>) (sext_ln215_13_reg_30885.read());
}
void compute::thread_grp_fu_23622_p0() {
grp_fu_23622_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_23622_p1() {
grp_fu_23622_p1 = (sc_lv<27>) (sext_ln215_16_reg_30900.read());
}
void compute::thread_grp_fu_23630_p0() {
grp_fu_23630_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_23630_p1() {
grp_fu_23630_p1 = (sc_lv<27>) (sext_ln215_17_reg_30905.read());
}
void compute::thread_grp_fu_23650_p0() {
grp_fu_23650_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_23650_p1() {
grp_fu_23650_p1 = (sc_lv<27>) (sext_ln215_20_reg_30920.read());
}
void compute::thread_grp_fu_23658_p0() {
grp_fu_23658_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_23658_p1() {
grp_fu_23658_p1 = (sc_lv<27>) (sext_ln215_21_reg_30925.read());
}
void compute::thread_grp_fu_23678_p0() {
grp_fu_23678_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_23678_p1() {
grp_fu_23678_p1 = (sc_lv<27>) (sext_ln215_24_reg_30940.read());
}
void compute::thread_grp_fu_23686_p0() {
grp_fu_23686_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_23686_p1() {
grp_fu_23686_p1 = (sc_lv<27>) (sext_ln215_25_reg_30945.read());
}
void compute::thread_grp_fu_23706_p0() {
grp_fu_23706_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_23706_p1() {
grp_fu_23706_p1 = (sc_lv<27>) (sext_ln215_28_reg_30960.read());
}
void compute::thread_grp_fu_23714_p0() {
grp_fu_23714_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_23714_p1() {
grp_fu_23714_p1 = (sc_lv<27>) (sext_ln215_29_reg_30965.read());
}
void compute::thread_grp_fu_23734_p0() {
grp_fu_23734_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_23734_p1() {
grp_fu_23734_p1 = (sc_lv<27>) (sext_ln215_32_reg_30980.read());
}
void compute::thread_grp_fu_23742_p0() {
grp_fu_23742_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_23742_p1() {
grp_fu_23742_p1 = (sc_lv<27>) (sext_ln215_33_reg_30985.read());
}
void compute::thread_grp_fu_23762_p0() {
grp_fu_23762_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_23762_p1() {
grp_fu_23762_p1 = (sc_lv<27>) (sext_ln215_36_reg_31000.read());
}
void compute::thread_grp_fu_23770_p0() {
grp_fu_23770_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_23770_p1() {
grp_fu_23770_p1 = (sc_lv<27>) (sext_ln215_37_reg_31005.read());
}
void compute::thread_grp_fu_23790_p0() {
grp_fu_23790_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_23790_p1() {
grp_fu_23790_p1 = (sc_lv<27>) (sext_ln215_40_reg_31020.read());
}
void compute::thread_grp_fu_23798_p0() {
grp_fu_23798_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_23798_p1() {
grp_fu_23798_p1 = (sc_lv<27>) (sext_ln215_41_reg_31025.read());
}
void compute::thread_grp_fu_23818_p0() {
grp_fu_23818_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_23818_p1() {
grp_fu_23818_p1 = (sc_lv<27>) (sext_ln215_44_reg_31040.read());
}
void compute::thread_grp_fu_23826_p0() {
grp_fu_23826_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_23826_p1() {
grp_fu_23826_p1 = (sc_lv<27>) (sext_ln215_45_reg_31045.read());
}
void compute::thread_grp_fu_23846_p0() {
grp_fu_23846_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_23846_p1() {
grp_fu_23846_p1 = (sc_lv<27>) (sext_ln215_48_reg_31060.read());
}
void compute::thread_grp_fu_23854_p0() {
grp_fu_23854_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_23854_p1() {
grp_fu_23854_p1 = (sc_lv<27>) (sext_ln215_49_reg_31065.read());
}
void compute::thread_grp_fu_23874_p0() {
grp_fu_23874_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_23874_p1() {
grp_fu_23874_p1 = (sc_lv<27>) (sext_ln215_52_reg_31080.read());
}
void compute::thread_grp_fu_23882_p0() {
grp_fu_23882_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_23882_p1() {
grp_fu_23882_p1 = (sc_lv<27>) (sext_ln215_53_reg_31085.read());
}
void compute::thread_grp_fu_23902_p0() {
grp_fu_23902_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_23902_p1() {
grp_fu_23902_p1 = (sc_lv<27>) (sext_ln215_56_reg_31100.read());
}
void compute::thread_grp_fu_23910_p0() {
grp_fu_23910_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_23910_p1() {
grp_fu_23910_p1 = (sc_lv<27>) (sext_ln215_57_reg_31105.read());
}
void compute::thread_grp_fu_23930_p0() {
grp_fu_23930_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_23930_p1() {
grp_fu_23930_p1 = (sc_lv<27>) (sext_ln215_60_reg_31120.read());
}
void compute::thread_grp_fu_23938_p0() {
grp_fu_23938_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_23938_p1() {
grp_fu_23938_p1 = (sc_lv<27>) (sext_ln215_61_reg_31125.read());
}
void compute::thread_grp_fu_23958_p0() {
grp_fu_23958_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_23958_p1() {
grp_fu_23958_p1 = (sc_lv<27>) (sext_ln215_64_reg_31140.read());
}
void compute::thread_grp_fu_23966_p0() {
grp_fu_23966_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_23966_p1() {
grp_fu_23966_p1 = (sc_lv<27>) (sext_ln215_65_reg_31145.read());
}
void compute::thread_grp_fu_23986_p0() {
grp_fu_23986_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_23986_p1() {
grp_fu_23986_p1 = (sc_lv<27>) (sext_ln215_68_reg_31160.read());
}
void compute::thread_grp_fu_23994_p0() {
grp_fu_23994_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_23994_p1() {
grp_fu_23994_p1 = (sc_lv<27>) (sext_ln215_69_reg_31165.read());
}
void compute::thread_grp_fu_24014_p0() {
grp_fu_24014_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_24014_p1() {
grp_fu_24014_p1 = (sc_lv<27>) (sext_ln215_72_reg_31180.read());
}
void compute::thread_grp_fu_24022_p0() {
grp_fu_24022_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_24022_p1() {
grp_fu_24022_p1 = (sc_lv<27>) (sext_ln215_73_reg_31185.read());
}
void compute::thread_grp_fu_24042_p0() {
grp_fu_24042_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_24042_p1() {
grp_fu_24042_p1 = (sc_lv<27>) (sext_ln215_76_reg_31200.read());
}
void compute::thread_grp_fu_24050_p0() {
grp_fu_24050_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_24050_p1() {
grp_fu_24050_p1 = (sc_lv<27>) (sext_ln215_77_reg_31205.read());
}
void compute::thread_grp_fu_24070_p0() {
grp_fu_24070_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_24070_p1() {
grp_fu_24070_p1 = (sc_lv<27>) (sext_ln215_80_reg_31220.read());
}
void compute::thread_grp_fu_24078_p0() {
grp_fu_24078_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_24078_p1() {
grp_fu_24078_p1 = (sc_lv<27>) (sext_ln215_81_reg_31225.read());
}
void compute::thread_grp_fu_24098_p0() {
grp_fu_24098_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_24098_p1() {
grp_fu_24098_p1 = (sc_lv<27>) (sext_ln215_84_reg_31240.read());
}
void compute::thread_grp_fu_24106_p0() {
grp_fu_24106_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_24106_p1() {
grp_fu_24106_p1 = (sc_lv<27>) (sext_ln215_85_reg_31245.read());
}
void compute::thread_grp_fu_24126_p0() {
grp_fu_24126_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_24126_p1() {
grp_fu_24126_p1 = (sc_lv<27>) (sext_ln215_88_reg_31260.read());
}
void compute::thread_grp_fu_24134_p0() {
grp_fu_24134_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_24134_p1() {
grp_fu_24134_p1 = (sc_lv<27>) (sext_ln215_89_reg_31265.read());
}
void compute::thread_grp_fu_24154_p0() {
grp_fu_24154_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_24154_p1() {
grp_fu_24154_p1 = (sc_lv<27>) (sext_ln215_92_reg_31280.read());
}
void compute::thread_grp_fu_24162_p0() {
grp_fu_24162_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_24162_p1() {
grp_fu_24162_p1 = (sc_lv<27>) (sext_ln215_93_reg_31285.read());
}
void compute::thread_grp_fu_24182_p0() {
grp_fu_24182_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_24182_p1() {
grp_fu_24182_p1 = (sc_lv<27>) (sext_ln215_96_reg_31300.read());
}
void compute::thread_grp_fu_24190_p0() {
grp_fu_24190_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_24190_p1() {
grp_fu_24190_p1 = (sc_lv<27>) (sext_ln215_97_reg_31305.read());
}
void compute::thread_grp_fu_24210_p0() {
grp_fu_24210_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_24210_p1() {
grp_fu_24210_p1 = (sc_lv<27>) (sext_ln215_100_reg_31320.read());
}
void compute::thread_grp_fu_24218_p0() {
grp_fu_24218_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_24218_p1() {
grp_fu_24218_p1 = (sc_lv<27>) (sext_ln215_101_reg_31325.read());
}
void compute::thread_grp_fu_24238_p0() {
grp_fu_24238_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_24238_p1() {
grp_fu_24238_p1 = (sc_lv<27>) (sext_ln215_104_reg_31340.read());
}
void compute::thread_grp_fu_24246_p0() {
grp_fu_24246_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_24246_p1() {
grp_fu_24246_p1 = (sc_lv<27>) (sext_ln215_105_reg_31345.read());
}
void compute::thread_grp_fu_24266_p0() {
grp_fu_24266_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_24266_p1() {
grp_fu_24266_p1 = (sc_lv<27>) (sext_ln215_108_reg_31360.read());
}
void compute::thread_grp_fu_24274_p0() {
grp_fu_24274_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_24274_p1() {
grp_fu_24274_p1 = (sc_lv<27>) (sext_ln215_109_reg_31365.read());
}
void compute::thread_grp_fu_24294_p0() {
grp_fu_24294_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_24294_p1() {
grp_fu_24294_p1 = (sc_lv<27>) (sext_ln215_112_reg_31380.read());
}
void compute::thread_grp_fu_24302_p0() {
grp_fu_24302_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_24302_p1() {
grp_fu_24302_p1 = (sc_lv<27>) (sext_ln215_113_reg_31385.read());
}
void compute::thread_grp_fu_24322_p0() {
grp_fu_24322_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_24322_p1() {
grp_fu_24322_p1 = (sc_lv<27>) (sext_ln215_116_reg_31400.read());
}
void compute::thread_grp_fu_24330_p0() {
grp_fu_24330_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_24330_p1() {
grp_fu_24330_p1 = (sc_lv<27>) (sext_ln215_117_reg_31405.read());
}
void compute::thread_grp_fu_24350_p0() {
grp_fu_24350_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_24350_p1() {
grp_fu_24350_p1 = (sc_lv<27>) (sext_ln215_120_reg_31420.read());
}
void compute::thread_grp_fu_24358_p0() {
grp_fu_24358_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_24358_p1() {
grp_fu_24358_p1 = (sc_lv<27>) (sext_ln215_121_reg_31425.read());
}
void compute::thread_grp_fu_24378_p0() {
grp_fu_24378_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_24378_p1() {
grp_fu_24378_p1 = (sc_lv<27>) (sext_ln215_124_reg_31440.read());
}
void compute::thread_grp_fu_24386_p0() {
grp_fu_24386_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_24386_p1() {
grp_fu_24386_p1 = (sc_lv<27>) (sext_ln215_125_reg_31445.read());
}
void compute::thread_grp_fu_24406_p0() {
grp_fu_24406_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_24406_p1() {
grp_fu_24406_p1 = (sc_lv<27>) (sext_ln215_128_reg_31460.read());
}
void compute::thread_grp_fu_24414_p0() {
grp_fu_24414_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_24414_p1() {
grp_fu_24414_p1 = (sc_lv<27>) (sext_ln215_129_reg_31465.read());
}
void compute::thread_grp_fu_24434_p0() {
grp_fu_24434_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_24434_p1() {
grp_fu_24434_p1 = (sc_lv<27>) (sext_ln215_132_reg_31480.read());
}
void compute::thread_grp_fu_24442_p0() {
grp_fu_24442_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_24442_p1() {
grp_fu_24442_p1 = (sc_lv<27>) (sext_ln215_133_reg_31485.read());
}
void compute::thread_grp_fu_24462_p0() {
grp_fu_24462_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_24462_p1() {
grp_fu_24462_p1 = (sc_lv<27>) (sext_ln215_136_reg_31500.read());
}
void compute::thread_grp_fu_24470_p0() {
grp_fu_24470_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_24470_p1() {
grp_fu_24470_p1 = (sc_lv<27>) (sext_ln215_137_reg_31505.read());
}
void compute::thread_grp_fu_24490_p0() {
grp_fu_24490_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_24490_p1() {
grp_fu_24490_p1 = (sc_lv<27>) (sext_ln215_140_reg_31520.read());
}
void compute::thread_grp_fu_24498_p0() {
grp_fu_24498_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_24498_p1() {
grp_fu_24498_p1 = (sc_lv<27>) (sext_ln215_141_reg_31525.read());
}
void compute::thread_grp_fu_24518_p0() {
grp_fu_24518_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_24518_p1() {
grp_fu_24518_p1 = (sc_lv<27>) (sext_ln215_144_reg_31540.read());
}
void compute::thread_grp_fu_24526_p0() {
grp_fu_24526_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_24526_p1() {
grp_fu_24526_p1 = (sc_lv<27>) (sext_ln215_145_reg_31545.read());
}
void compute::thread_grp_fu_24546_p0() {
grp_fu_24546_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_24546_p1() {
grp_fu_24546_p1 = (sc_lv<27>) (sext_ln215_148_reg_31560.read());
}
void compute::thread_grp_fu_24554_p0() {
grp_fu_24554_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_24554_p1() {
grp_fu_24554_p1 = (sc_lv<27>) (sext_ln215_149_reg_31565.read());
}
void compute::thread_grp_fu_24574_p0() {
grp_fu_24574_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_24574_p1() {
grp_fu_24574_p1 = (sc_lv<27>) (sext_ln215_152_reg_31580.read());
}
void compute::thread_grp_fu_24582_p0() {
grp_fu_24582_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_24582_p1() {
grp_fu_24582_p1 = (sc_lv<27>) (sext_ln215_153_reg_31585.read());
}
void compute::thread_grp_fu_24602_p0() {
grp_fu_24602_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_24602_p1() {
grp_fu_24602_p1 = (sc_lv<27>) (sext_ln215_156_reg_31600.read());
}
void compute::thread_grp_fu_24610_p0() {
grp_fu_24610_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_24610_p1() {
grp_fu_24610_p1 = (sc_lv<27>) (sext_ln215_157_reg_31605.read());
}
void compute::thread_grp_fu_24630_p0() {
grp_fu_24630_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_24630_p1() {
grp_fu_24630_p1 = (sc_lv<27>) (sext_ln215_160_reg_31620.read());
}
void compute::thread_grp_fu_24638_p0() {
grp_fu_24638_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_24638_p1() {
grp_fu_24638_p1 = (sc_lv<27>) (sext_ln215_161_reg_31625.read());
}
void compute::thread_grp_fu_24658_p0() {
grp_fu_24658_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_24658_p1() {
grp_fu_24658_p1 = (sc_lv<27>) (sext_ln215_164_reg_31640.read());
}
void compute::thread_grp_fu_24666_p0() {
grp_fu_24666_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_24666_p1() {
grp_fu_24666_p1 = (sc_lv<27>) (sext_ln215_165_reg_31645.read());
}
void compute::thread_grp_fu_24686_p0() {
grp_fu_24686_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_24686_p1() {
grp_fu_24686_p1 = (sc_lv<27>) (sext_ln215_168_reg_31660.read());
}
void compute::thread_grp_fu_24694_p0() {
grp_fu_24694_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_24694_p1() {
grp_fu_24694_p1 = (sc_lv<27>) (sext_ln215_169_reg_31665.read());
}
void compute::thread_grp_fu_24714_p0() {
grp_fu_24714_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_24714_p1() {
grp_fu_24714_p1 = (sc_lv<27>) (sext_ln215_172_reg_31680.read());
}
void compute::thread_grp_fu_24722_p0() {
grp_fu_24722_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_24722_p1() {
grp_fu_24722_p1 = (sc_lv<27>) (sext_ln215_173_reg_31685.read());
}
void compute::thread_grp_fu_24742_p0() {
grp_fu_24742_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_24742_p1() {
grp_fu_24742_p1 = (sc_lv<27>) (sext_ln215_176_reg_31700.read());
}
void compute::thread_grp_fu_24750_p0() {
grp_fu_24750_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_24750_p1() {
grp_fu_24750_p1 = (sc_lv<27>) (sext_ln215_177_reg_31705.read());
}
void compute::thread_grp_fu_24770_p0() {
grp_fu_24770_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_24770_p1() {
grp_fu_24770_p1 = (sc_lv<27>) (sext_ln215_180_reg_31720.read());
}
void compute::thread_grp_fu_24778_p0() {
grp_fu_24778_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_24778_p1() {
grp_fu_24778_p1 = (sc_lv<27>) (sext_ln215_181_reg_31725.read());
}
void compute::thread_grp_fu_24798_p0() {
grp_fu_24798_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_24798_p1() {
grp_fu_24798_p1 = (sc_lv<27>) (sext_ln215_184_reg_31740.read());
}
void compute::thread_grp_fu_24806_p0() {
grp_fu_24806_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_24806_p1() {
grp_fu_24806_p1 = (sc_lv<27>) (sext_ln215_185_reg_31745.read());
}
void compute::thread_grp_fu_24826_p0() {
grp_fu_24826_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_24826_p1() {
grp_fu_24826_p1 = (sc_lv<27>) (sext_ln215_188_reg_31760.read());
}
void compute::thread_grp_fu_24834_p0() {
grp_fu_24834_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_24834_p1() {
grp_fu_24834_p1 = (sc_lv<27>) (sext_ln215_189_reg_31765.read());
}
void compute::thread_grp_fu_24854_p0() {
grp_fu_24854_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_24854_p1() {
grp_fu_24854_p1 = (sc_lv<27>) (sext_ln215_192_reg_31780.read());
}
void compute::thread_grp_fu_24862_p0() {
grp_fu_24862_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_24862_p1() {
grp_fu_24862_p1 = (sc_lv<27>) (sext_ln215_193_reg_31785.read());
}
void compute::thread_grp_fu_24882_p0() {
grp_fu_24882_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_24882_p1() {
grp_fu_24882_p1 = (sc_lv<27>) (sext_ln215_196_reg_31800.read());
}
void compute::thread_grp_fu_24890_p0() {
grp_fu_24890_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_24890_p1() {
grp_fu_24890_p1 = (sc_lv<27>) (sext_ln215_197_reg_31805.read());
}
void compute::thread_grp_fu_24910_p0() {
grp_fu_24910_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_24910_p1() {
grp_fu_24910_p1 = (sc_lv<27>) (sext_ln215_200_reg_31820.read());
}
void compute::thread_grp_fu_24918_p0() {
grp_fu_24918_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_24918_p1() {
grp_fu_24918_p1 = (sc_lv<27>) (sext_ln215_201_reg_31825.read());
}
void compute::thread_grp_fu_24938_p0() {
grp_fu_24938_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_24938_p1() {
grp_fu_24938_p1 = (sc_lv<27>) (sext_ln215_204_reg_31840.read());
}
void compute::thread_grp_fu_24946_p0() {
grp_fu_24946_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_24946_p1() {
grp_fu_24946_p1 = (sc_lv<27>) (sext_ln215_205_reg_31845.read());
}
void compute::thread_grp_fu_24966_p0() {
grp_fu_24966_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_24966_p1() {
grp_fu_24966_p1 = (sc_lv<27>) (sext_ln215_208_reg_31860.read());
}
void compute::thread_grp_fu_24974_p0() {
grp_fu_24974_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_24974_p1() {
grp_fu_24974_p1 = (sc_lv<27>) (sext_ln215_209_reg_31865.read());
}
void compute::thread_grp_fu_24994_p0() {
grp_fu_24994_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_24994_p1() {
grp_fu_24994_p1 = (sc_lv<27>) (sext_ln215_212_reg_31880.read());
}
void compute::thread_grp_fu_25002_p0() {
grp_fu_25002_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_25002_p1() {
grp_fu_25002_p1 = (sc_lv<27>) (sext_ln215_213_reg_31885.read());
}
void compute::thread_grp_fu_25022_p0() {
grp_fu_25022_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_25022_p1() {
grp_fu_25022_p1 = (sc_lv<27>) (sext_ln215_216_reg_31900.read());
}
void compute::thread_grp_fu_25030_p0() {
grp_fu_25030_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_25030_p1() {
grp_fu_25030_p1 = (sc_lv<27>) (sext_ln215_217_reg_31905.read());
}
void compute::thread_grp_fu_25050_p0() {
grp_fu_25050_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_25050_p1() {
grp_fu_25050_p1 = (sc_lv<27>) (sext_ln215_220_reg_31920.read());
}
void compute::thread_grp_fu_25058_p0() {
grp_fu_25058_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_25058_p1() {
grp_fu_25058_p1 = (sc_lv<27>) (sext_ln215_221_reg_31925.read());
}
void compute::thread_grp_fu_25078_p0() {
grp_fu_25078_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_25078_p1() {
grp_fu_25078_p1 = (sc_lv<27>) (sext_ln215_224_reg_31940.read());
}
void compute::thread_grp_fu_25086_p0() {
grp_fu_25086_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_25086_p1() {
grp_fu_25086_p1 = (sc_lv<27>) (sext_ln215_225_reg_31945.read());
}
void compute::thread_grp_fu_25106_p0() {
grp_fu_25106_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_25106_p1() {
grp_fu_25106_p1 = (sc_lv<27>) (sext_ln215_228_reg_31960.read());
}
void compute::thread_grp_fu_25114_p0() {
grp_fu_25114_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_25114_p1() {
grp_fu_25114_p1 = (sc_lv<27>) (sext_ln215_229_reg_31965.read());
}
void compute::thread_grp_fu_25134_p0() {
grp_fu_25134_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_25134_p1() {
grp_fu_25134_p1 = (sc_lv<27>) (sext_ln215_232_reg_31980.read());
}
void compute::thread_grp_fu_25142_p0() {
grp_fu_25142_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_25142_p1() {
grp_fu_25142_p1 = (sc_lv<27>) (sext_ln215_233_reg_31985.read());
}
void compute::thread_grp_fu_25162_p0() {
grp_fu_25162_p0 = (sc_lv<8>) (zext_ln215_43_fu_14086_p1.read());
}
void compute::thread_grp_fu_25162_p1() {
grp_fu_25162_p1 = (sc_lv<27>) (sext_ln215_236_reg_32000.read());
}
void compute::thread_grp_fu_25170_p0() {
grp_fu_25170_p0 = (sc_lv<8>) (zext_ln215_44_fu_14090_p1.read());
}
void compute::thread_grp_fu_25170_p1() {
grp_fu_25170_p1 = (sc_lv<27>) (sext_ln215_237_reg_32005.read());
}
void compute::thread_grp_fu_25190_p0() {
grp_fu_25190_p0 = (sc_lv<8>) (zext_ln215_47_fu_14136_p1.read());
}
void compute::thread_grp_fu_25190_p1() {
grp_fu_25190_p1 = (sc_lv<27>) (sext_ln215_240_reg_32020.read());
}
void compute::thread_grp_fu_25198_p0() {
grp_fu_25198_p0 = (sc_lv<8>) (zext_ln215_48_fu_14140_p1.read());
}
void compute::thread_grp_fu_25198_p1() {
grp_fu_25198_p1 = (sc_lv<27>) (sext_ln215_241_reg_32025.read());
}
void compute::thread_grp_fu_25218_p0() {
grp_fu_25218_p0 = (sc_lv<8>) (zext_ln215_51_fu_14158_p1.read());
}
void compute::thread_grp_fu_25218_p1() {
grp_fu_25218_p1 = (sc_lv<27>) (sext_ln215_244_reg_32040.read());
}
void compute::thread_grp_fu_25226_p0() {
grp_fu_25226_p0 = (sc_lv<8>) (zext_ln215_52_fu_14162_p1.read());
}
void compute::thread_grp_fu_25226_p1() {
grp_fu_25226_p1 = (sc_lv<27>) (sext_ln215_245_reg_32045.read());
}
void compute::thread_grp_fu_25246_p0() {
grp_fu_25246_p0 = (sc_lv<8>) (zext_ln215_55_fu_14208_p1.read());
}
void compute::thread_grp_fu_25246_p1() {
grp_fu_25246_p1 = (sc_lv<27>) (sext_ln215_248_reg_32060.read());
}
void compute::thread_grp_fu_25254_p0() {
grp_fu_25254_p0 = (sc_lv<8>) (zext_ln215_56_fu_14212_p1.read());
}
void compute::thread_grp_fu_25254_p1() {
grp_fu_25254_p1 = (sc_lv<27>) (sext_ln215_249_reg_32065.read());
}
void compute::thread_grp_fu_25274_p0() {
grp_fu_25274_p0 = (sc_lv<8>) (zext_ln215_59_fu_14230_p1.read());
}
void compute::thread_grp_fu_25274_p1() {
grp_fu_25274_p1 = (sc_lv<27>) (sext_ln215_252_reg_32080.read());
}
void compute::thread_grp_fu_25282_p0() {
grp_fu_25282_p0 = (sc_lv<8>) (zext_ln215_60_fu_14234_p1.read());
}
void compute::thread_grp_fu_25282_p1() {
grp_fu_25282_p1 = (sc_lv<27>) (sext_ln215_253_reg_32085.read());
}
void compute::thread_grp_fu_25302_p0() {
grp_fu_25302_p0 = (sc_lv<8>) (zext_ln215_fu_13992_p1.read());
}
void compute::thread_grp_fu_25302_p1() {
grp_fu_25302_p1 = (sc_lv<27>) (sext_ln215_256_reg_32100.read());
}
void compute::thread_grp_fu_25310_p0() {
grp_fu_25310_p0 = (sc_lv<8>) (zext_ln215_32_fu_13996_p1.read());
}
void compute::thread_grp_fu_25310_p1() {
grp_fu_25310_p1 = (sc_lv<27>) (sext_ln215_257_reg_32105.read());
}
void compute::thread_grp_fu_25330_p0() {
grp_fu_25330_p0 = (sc_lv<8>) (zext_ln215_35_fu_14014_p1.read());
}
void compute::thread_grp_fu_25330_p1() {
grp_fu_25330_p1 = (sc_lv<27>) (sext_ln215_260_reg_32120.read());
}
void compute::thread_grp_fu_25338_p0() {
grp_fu_25338_p0 = (sc_lv<8>) (zext_ln215_36_fu_14018_p1.read());
}
void compute::thread_grp_fu_25338_p1() {
grp_fu_25338_p1 = (sc_lv<27>) (sext_ln215_261_reg_32125.read());
}
void compute::thread_grp_fu_25358_p0() {
grp_fu_25358_p0 = (sc_lv<8>) (zext_ln215_39_fu_14064_p1.read());
}
void compute::thread_grp_fu_25358_p1() {
grp_fu_25358_p1 = (sc_lv<27>) (sext_ln215_264_reg_32140.read());
}
void compute::thread_grp_fu_25366_p0() {
grp_fu_25366_p0 = (sc_lv<8>) (zext_ln215_40_fu_14068_p1.read());
}
void compute::thread_grp_fu_25366_p1() {
grp_fu_25366_p1 = (sc_lv<27>) (sext_ln215_265_reg_32145.read());
}
}
| [
"yasu@am.ics.keio.ac.jp"
] | yasu@am.ics.keio.ac.jp |
5687765e199ca4f4299a106726073d8e28d7dc82 | 533ee31facdfced297d6b481ed68a6cc6a1650ee | /367.cpp | 8154d8a7ed9d6e1833a655a7698146ef5e6e37d7 | [] | no_license | xcheng85/leetcode | 3e2b6f54e4b1f2cef14a16823eb0ada79690a42e | bf60249d061007a53fe8cfb49babfddb750580b5 | refs/heads/dev | 2021-10-11T13:40:54.387840 | 2018-10-23T23:29:19 | 2018-10-23T23:29:19 | 111,881,819 | 0 | 0 | null | 2018-10-23T23:31:15 | 2017-11-24T06:02:13 | C++ | UTF-8 | C++ | false | false | 290 | cpp | bool isPerfectSquare(int num) {
long long l = 0, r = num;
while (l <= r) {
long long mid = (l + r) >> 1;
long long sqmid = mid * mid;
if (sqmid > num) r = mid - 1;
else if (sqmid < num) l = mid + 1;
else return true;
}
return false;
} | [
"chengxiao1985@gmail.com"
] | chengxiao1985@gmail.com |
40130625d38c8f67df9c1196e0c8258ab85b561c | 4387582d74c407e1e25ae3706312cee3a50bdf73 | /16/16_2.cc | 6d5d4abc39749b05207963e8ca881fe9bb231e87 | [] | no_license | stephan-windischmann/adventofcode_2020 | d75cd546d5a126e4e08ac6209cd24013c1b07b3a | 320f5bff90c5951adf5f07f6877cc51918fff602 | refs/heads/master | 2023-02-21T00:11:20.027734 | 2021-01-19T20:56:06 | 2021-01-19T20:56:06 | 317,503,403 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,310 | cc | #include <fstream>
#include <iostream>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INPUT "INPUT"
class TicketField {
private:
int low1;
int low2;
int high1;
int high2;
std::string name;
public:
TicketField(int low1, int high1, int low2, int high2, std::string name) {
this->low1 = low1;
this->low2 = low2;
this->high1 = high1;
this->high2 = high2;
this->name = name;
}
bool isValid(int num) {
if ((num >= low1 && num <= high1) || (num >= low2 && num <= high2)) {
return true;
}
return false;
}
std::string getName() {
return this->name;
}
};
void loadInput(std::vector<TicketField> &fields, std::vector<int> &myTicket,\
std::vector<std::vector<int > > &otherTickets) {
std::ifstream file;
file.open(INPUT);
std::string line;
while (std::getline(file, line)) {
if (line == "") {
continue;
}
if (line == "your ticket:") {
break;
}
std::regex e("(.+):\\s(\\d+)-(\\d+)\\sor\\s(\\d+)-(\\d+)");
std::smatch sm;
std::regex_match(line.cbegin(), line.cend(), sm, e);
std::string name = sm[1];
int low1 = std::stoi(sm[2]);
int high1 = std::stoi(sm[3]);
int low2 = std::stoi(sm[4]);
int high2 = std::stoi(sm[5]);
fields.push_back(TicketField(low1, high1, low2, high2, name));
}
std::getline(file, line);
std::stringstream ss(line);
std::string num;
while (std::getline(ss, num, ',')) {
myTicket.push_back(std::stoi(num));
}
std::getline(file, line);
std::getline(file, line);
while (std::getline(file, line)) {
std::stringstream ss(line);
std::vector<int> curTicket;
while (std::getline(ss, num, ',')) {
curTicket.push_back(std::stoi(num));
}
otherTickets.push_back(curTicket);
}
file.close();
}
bool isValidField(int num, std::vector<TicketField> &fields) {
bool foundValid = false;
for (auto &field : fields) {
if (field.isValid(num)) {
foundValid = true;
break;
}
}
return foundValid;
}
void removeInvalidTickets(std::vector<TicketField> &fields, \
std::vector<std::vector<int> > &otherTickets) {
for (auto it = otherTickets.begin(); it != otherTickets.end();) {
bool isValid = true;
for (auto const& num : *it) {
if (!isValidField(num, fields)) {
isValid = false;
break;
}
}
if (isValid) {
++it;
} else {
it = otherTickets.erase(it);
}
}
}
bool isFieldValid(TicketField &field, const std::vector<std::vector<int > > &otherTickets, int col) {
for (auto const& ticket: otherTickets) {
if (!field.isValid(ticket[col])) {
return false;
}
}
return true;
}
void getPossibleFields(std::vector<TicketField> &fields, \
std::vector<std::vector<int> > &otherTickets, \
std::vector<std::set<int> > &possibleFields) {
for (int i = 0; i < otherTickets[0].size(); ++i) {
std::set<int> p;
for (int j = 0; j < fields.size(); ++j) {
if(isFieldValid(fields[j], otherTickets, i)) {
p.insert(j);
}
}
possibleFields.push_back(p);
}
}
void cleanFields(std::vector<std::set<int> > &possibleFields) {
bool changes = false;
std::set<int> used;
do {
changes = false;
for (auto& fields : possibleFields) {
if (fields.size() == 1) {
if (used.find(*fields.begin()) == used.end()) {
used.insert(*fields.begin());
}
} else {
for (auto& i : used) {
if (fields.find(i) != fields.end()) {
fields.erase(i);
changes = true;
}
}
}
}
} while(changes);
}
long getRes(const std::vector<std::set<int> > possibleFields, \
std::vector<int> myTicket, \
std::vector<TicketField> fields) {
long res = 1;
for (int i = 0; i < myTicket.size(); ++i) {
if (fields[*possibleFields[i].begin()].getName().substr(0, 9) == "departure") {
res *= myTicket[i];
}
}
return res;
}
int main() {
std::vector<TicketField> fields;
std::vector<int> myTicket;
std::vector<std::vector<int> > otherTickets;
loadInput(fields, myTicket, otherTickets);
// First remove all invalid tickets.
removeInvalidTickets(fields, otherTickets);
// First loop, check which fields could be valid for a column.
std::vector<std::set<int> > possibleFields;
getPossibleFields(fields, otherTickets, possibleFields);
// Now continiously loop through until only one field remains per column.
cleanFields(possibleFields);
long res = getRes(possibleFields, myTicket, fields);
std::cout << "Result: " << res << std::endl;
return 0;
}
| [
"stephan.windischmann@swisscom.com"
] | stephan.windischmann@swisscom.com |
bdac4d8363fa6592e633633bc375ff801f9de464 | 55a5dc8f886808660e163f2908c12fe36a17fa28 | /tests/MiscTests.cpp | 806f16e9bfb54a79c7e36d27e8fd5da88b96b917 | [] | no_license | tyoma/wpl | 4fac7a021ab7ffab4e8fce9310b9bbd8cd4a7e40 | 32e33921261ea49b14f14ea3cc5c95097def96f6 | refs/heads/master | 2022-12-02T23:54:25.191018 | 2022-10-24T00:01:44 | 2022-10-24T01:16:58 | 36,181,780 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,131 | cpp | #include <wpl/view_helpers.h>
#include <wpl/view.h>
#include <ut/assert.h>
#include <ut/test.h>
namespace wpl
{
namespace tests
{
begin_test_suite( MiscTests )
test( HasNoFocusOnCreation )
{
// INIT / ACT
on_focus_invalidate<view> v;
// ASSERT
assert_is_false(v.has_focus);
}
test( FocusInOutSetsFlag )
{
// INIT
on_focus_invalidate<view> v;
// ACT
static_cast<keyboard_input &>(v).got_focus();
// ASSERT
assert_is_true(v.has_focus);
// ACT
static_cast<keyboard_input &>(v).lost_focus();
// ASSERT
assert_is_false(v.has_focus);
}
test( FocusInOutInvalidatesView )
{
// INIT
auto invalidates = 0;
on_focus_invalidate<view> v;
auto c = v.invalidate += [&] (const void *r) {
assert_null(r);
invalidates++;
};
// ACT
static_cast<keyboard_input &>(v).got_focus();
// ASSERT
assert_equal(1, invalidates);
// ACT
static_cast<keyboard_input &>(v).lost_focus();
static_cast<keyboard_input &>(v).got_focus();
// ASSERT
assert_equal(3, invalidates);
}
end_test_suite
}
}
| [
"artem.gevorkyan@gmail.com"
] | artem.gevorkyan@gmail.com |
86d7b46b5b5cd5270019388c425d2e2bd5820d55 | 93e52c988b2129ec4803e9a2879220e5489e1200 | /InfInt.h | 8f253daca0768d079f42f97c63dbe9f7c3100799 | [] | no_license | AviYM/Infinite-Roman-nums-library | 69900c3e721ae66231d31f8e75d16aeee98e6ede | 7931ae9af5ccc4580a67b5587798388ef7f786ed | refs/heads/main | 2023-06-02T16:09:23.886664 | 2021-06-13T15:21:02 | 2021-06-13T15:21:02 | 376,575,287 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,890 | h | //
// Created by avi on 11/8/18.
//
#ifndef EX1_INFINT_H
#define EX1_INFINT_H
#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <regex>
using namespace std;
class InfInt {
private:
// members
vector<bool> digits;
bool sign;
public:
// constructors
InfInt();
InfInt(string cobigNum);
InfInt(long num);
InfInt(vector<bool> num, bool sign);
InfInt(InfInt const& numToCopy);
~InfInt();
explicit operator int() const;
// binary operators
InfInt operator++();
InfInt operator++(int);
InfInt operator+=(InfInt other);
InfInt operator+=(int other);
InfInt operator+(InfInt num);
InfInt operator-(InfInt other);
InfInt operator-(); // unary operator
InfInt operator-=(InfInt other);
InfInt operator--();
InfInt operator--(int);
InfInt operator*(InfInt other);
InfInt operator/(InfInt other);
InfInt operator%(InfInt other);
// boolian operators
bool operator==(InfInt other);
bool operator<=(InfInt other);
bool operator>=(InfInt other);
bool operator<(InfInt other);
bool operator>(InfInt other);
// bitwise operators
InfInt operator&(InfInt other);
InfInt operator|(InfInt other);
InfInt operator^(InfInt other);
InfInt operator&=(InfInt other);
InfInt operator<<(int mult);
InfInt operator>>(int mult);
InfInt operator>>=(int mult);
//iostream operators
friend ostream& operator<<(ostream& os, const InfInt& num);
friend istream& operator>>(istream& is, InfInt& num);
private:
typedef bool (*bitwiseOprator) (bool b1, bool b2);
InfInt operatBitwiseOperators(InfInt num1, InfInt num2, bitwiseOprator func);
InfInt getDivisionOrModulo(InfInt other, bool flag);
};
#endif //EX1_INFINT_H
#pragma once
| [
"noreply@github.com"
] | noreply@github.com |
a1ac8a25e841bd357e6f68c85c17ad065c1d41ff | b8b9b18d80bc7b1fb9dc5dbc4f62932489991754 | /Week 09/Polymorphism/polymorphism.cpp | 9f078d5a6f49c556528f5b8368d198aa3d550097 | [] | no_license | luchev/uni-object-oriented-programming-2021 | 324381ddc615e84dbf0461f039640fa03d67225c | 0a572372b927549587342d022da99d68e8a4cfcc | refs/heads/main | 2023-05-29T05:16:08.881713 | 2021-06-07T15:34:02 | 2021-06-07T15:34:02 | 341,157,127 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 531 | cpp | #include <iostream>
class Parent {
public:
virtual void print() {
std::cout << "Parent\n";
}
virtual ~Parent() {}
};
class Child : public Parent {
public:
std::string name = "Josh";
void print() override {
std::cout << "Child";
printName();
}
void printName() {
std::cout << " with name " << this->name << "\n";
}
};
int main() {
Parent * p = new Parent();
p->print();
Parent * c = new Child();
c->print();
delete p;
delete c;
}
| [
"luchevz@gmail.com"
] | luchevz@gmail.com |
59bbaa156f8f01818dba5d5505ce1bda4c4cbd07 | fde761f535cfcefaacc734ac43884b99d35f7e1b | /zoom笔试/zoom笔试/test.cpp | 9613d4e4baeee1c1ca2a51fc3a9d750c1c028b43 | [] | no_license | lvxinup/LeetCode | b0720c3b90a3e1c5dee61ae39f3568d4b9997175 | 95c596ec91cb4e03bd2ba1ef6437656e90c1d7ba | refs/heads/master | 2020-04-29T21:29:45.322693 | 2019-08-30T01:16:23 | 2019-08-30T01:16:23 | 176,414,642 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,509 | cpp | #define _CRT_SECURE_NO_WARNINGS 1
//#include<iostream>
//
//using namespace std;
//
//int main()
//{
// int w, m, n;
// while (cin >> w >> m >> n){
// //6 8 2
// //4
// //首先计算行数，然后判断在奇数行还是偶数行
// int tmp1 = m / w;
// int tmp2 = n / w;
// if (m%w != 0){
// tmp1++;
// }
// if (n%w != 0){
// tmp2++;
// }
// int index1 = m % w;//在行中的位置
// int index2 = n % w;
// //奇数行不变，偶数行变位置
// if (tmp1 % 2 == 0){
// index1 = w - index1 + 1;
// }
// if (tmp2 % 2 == 0){
// index2 = w - index2 + 1;
// }
//
// int output = (tmp1 - tmp2) > 0 ? (tmp1 - tmp2) : (tmp2 - tmp1);
// output += (index1 - index2) > 0 ? (index1 - index2) : (index2 - index1);
// cout << output << endl;
// }
//
// return 0;
//}
#include<iostream>
#include<string>
using namespace std;
std::string mySteryFunc(std::string src)
{
std::string tmp = src;
for (int i = 0; i<tmp.size(); i++){
//如果是字母，跳过
if (tmp[i] <='Z' && tmp[i]>='A'){
continue;
}
int flag = 0;
//如果是数字
if (tmp[i] <= '9' && tmp[i] >='0'){
flag = tmp[i] - '0';
}
//不断插入字符
while (flag--){
tmp += " ";
//所有元素往后挪
for (int j = tmp.size() - 1; j >= i; j--){
tmp[j] = tmp[j - 1];
}
//插入元素
tmp[i] = tmp[i - 1];
}
}
return tmp;
}
int main()
{
std::string input;
std::string output;
std::cin >> input;
output = mySteryFunc(input);
std::cout << output << std::endl;
return 0;
} | [
"1564605677@qq.com"
] | 1564605677@qq.com |
13f1a0464de347479d69dfd04db328e610e996ab | e1ac3d9b7a05552f0370c05b58a5a4d64a76cdc8 | /1003.cpp | c369a7215f99748ea0fca1ee5a322dc7394cb861 | [] | no_license | Carlineos/Uri-Iniciante | 0571c8d19e5e6a0069a1c2b332c540a39fec23af | 21fd856bc8afffe67732d45f7950ef792bdf1ff5 | refs/heads/main | 2023-05-10T15:32:56.260164 | 2021-06-15T18:08:16 | 2021-06-15T18:08:16 | 377,251,604 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 158 | cpp | #include <stdio.h>
int main()
{
int A,B,SOMA;
scanf("%d", &A);
scanf("%d", &B);
SOMA = A + B;
printf("SOMA = %d\n",SOMA);
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
cf8338aee7ce70d7ee616dabf604e7bbcd9a1209 | d3e2196ae8cead141e8a25add5f4c85cc2bbb21a | /CPP/Compailer/tokenizer.cpp | 2e12c09528735cb08f289553a2c2040ac93f2966 | [] | no_license | orenswisa123/ALL | 52e6c47acede5edc605a889bf18e419e92b37392 | cd05b9303aed99eb3dabc67f6ede5325d547dbb6 | refs/heads/master | 2020-07-28T03:02:06.693207 | 2019-12-09T12:16:15 | 2019-12-09T12:16:15 | 209,288,286 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,244 | cpp | #include <cstring>
#include "tokenizer.h"
const char tokenizer_t::s_tokensDelimitersArr[] = "()[]{};<>=+-*&";
const char tokenizer_t::s_blankDelimitersArr[] = " \t\n\r\0";
const string tokenizer_t::s_emptyString("");
const set<char> tokenizer_t::s_tokensDelimiters
(s_tokensDelimitersArr, s_tokensDelimitersArr+strlen(s_tokensDelimitersArr));
const set<char> tokenizer_t::s_blankDelimiters
(s_blankDelimitersArr, s_blankDelimitersArr+strlen(s_blankDelimitersArr));
void tokenizer_t::tokenize(const string& _str)
{
size_t pos, next, len = _str.length();
m_tokens.clear();
for(pos = 0, next = 0; next <= len ; ++next)
{
if(s_blankDelimiters.find(_str[next]) != s_blankDelimiters.end())
{
if(next > pos)
{
m_tokens.push_back(string(_str,pos,next-pos));
}
pos = next+1;
continue;
}
if(s_tokensDelimiters.find(_str[next]) != s_tokensDelimiters.end())
{
if(next > pos)
{
m_tokens.push_back(string(_str,pos,next-pos));
}
m_tokens.push_back(string(1,_str[next]));
pos = next+1;
}
}
m_nextToken = m_tokens.begin();
}
const string &tokenizer_t::getNextToken()
{
if (m_nextToken == m_tokens.end())
{
return s_emptyString;
}
return *(m_nextToken++);
} | [
"noreply@github.com"
] | noreply@github.com |
10429c5de32b0e195fd033ed775011e54e4f476f | 45799ccc3a16c785ab3c65f3296d66f8463590dc | /gcc/leetcode/acsl/q1295/main.cpp | c499b0cb9211c964f8de283fd9459201b268dcc6 | [
"MIT"
] | permissive | odys-z/hello | 9d29b7af68ea8c490b43994cf16d75c0e8ace08e | fedd0aec7273f3170aa77316d0d5f317cc18a979 | refs/heads/master | 2023-08-19T03:25:58.684050 | 2023-08-18T08:07:27 | 2023-08-18T08:07:27 | 154,006,292 | 0 | 0 | MIT | 2023-04-18T22:50:56 | 2018-10-21T12:34:12 | C++ | UTF-8 | C++ | false | false | 860 | cpp | #include <solution.h>
#include <QtTest>
int main()
{
int ok = 0;
Solution* s = new Solution();
vector<int> r = {12,345,2,6,7896};
assert(2 == s->findNumbers(r));
ok++;
r = {12};
assert(1 == s->findNumbers(r));
ok++;
r = {0};
assert(0 == s->findNumbers(r));
ok++;
r = {1};
assert(0 == s->findNumbers(r));
ok++;
r = {10, 11};
assert(2 == s->findNumbers(r));
ok++;
r = {100, 111, 110};
assert(0 == s->findNumbers(r));
ok++;
r = {1000, 1111, 1110, 1010, 1000, 1100};
assert(6 == s->findNumbers(r));
ok++;
r = {10000};
r = {10000};
assert(0 == s->findNumbers(r));
ok++;
r = {555,901,482,1771};
assert(1 == s->findNumbers(r));
ok++;
r = {1,1,101,100,01,11,13,100000};
assert(3 == s->findNumbers(r));
ok++;
return ok;
}
| [
"odysseusj@163.com"
] | odysseusj@163.com |
a6a17c33179e7aea002ce2f016751d9d9d916bbf | fb5b25b4fbe66c532672c14dacc520b96ff90a04 | /export/release/macos/obj/include/polymod/format/XMLMerge.h | 748ddb2c3b1fbed0f1b7d705183901bdb303f40c | [
"Apache-2.0"
] | permissive | Tyrcnex/tai-mod | c3849f817fe871004ed171245d63c5e447c4a9c3 | b83152693bb3139ee2ae73002623934f07d35baf | refs/heads/main | 2023-08-15T07:15:43.884068 | 2021-09-29T23:39:23 | 2021-09-29T23:39:23 | 383,313,424 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 2,674 | h | // Generated by Haxe 4.1.5
#ifndef INCLUDED_polymod_format_XMLMerge
#define INCLUDED_polymod_format_XMLMerge
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS0(Xml)
HX_DECLARE_CLASS1(haxe,IMap)
HX_DECLARE_CLASS2(haxe,ds,StringMap)
HX_DECLARE_CLASS2(polymod,format,XMLMerge)
namespace polymod{
namespace format{
class HXCPP_CLASS_ATTRIBUTES XMLMerge_obj : public ::hx::Object
{
public:
typedef ::hx::Object super;
typedef XMLMerge_obj OBJ_;
XMLMerge_obj();
public:
enum { _hx_ClassId = 0x6b7b2bae };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="polymod.format.XMLMerge")
{ return ::hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return ::hx::Object::operator new(inSize+extra,false,"polymod.format.XMLMerge"); }
inline static ::hx::ObjectPtr< XMLMerge_obj > __new() {
::hx::ObjectPtr< XMLMerge_obj > __this = new XMLMerge_obj();
__this->__construct();
return __this;
}
inline static ::hx::ObjectPtr< XMLMerge_obj > __alloc(::hx::Ctx *_hx_ctx) {
XMLMerge_obj *__this = (XMLMerge_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(XMLMerge_obj), false, "polymod.format.XMLMerge"));
*(void **)__this = XMLMerge_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(::hx::DynamicArray inArgs);
//~XMLMerge_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, ::hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("XMLMerge",81,71,5f,27); }
static void mergeXMLWork( ::Xml a, ::Xml b,::hx::Null< bool > children,::hx::Null< bool > attributes);
static ::Dynamic mergeXMLWork_dyn();
static int countNodes( ::Xml xml,::String nodeName);
static ::Dynamic countNodes_dyn();
static void mergeXML( ::Xml a, ::Xml b,::Array< ::String > allSigs, ::haxe::ds::StringMap mergeMap);
static ::Dynamic mergeXML_dyn();
static void mergeXMLNodes( ::Xml a, ::Xml b);
static ::Dynamic mergeXMLNodes_dyn();
static ::haxe::ds::StringMap getNodeMergeMap( ::Xml xml,::Array< ::String > addToArray);
static ::Dynamic getNodeMergeMap_dyn();
static ::String getNodeSignature( ::Xml xml);
static ::Dynamic getNodeSignature_dyn();
static ::haxe::ds::StringMap mergeMapsDestructively( ::haxe::ds::StringMap a, ::haxe::ds::StringMap b);
static ::Dynamic mergeMapsDestructively_dyn();
};
} // end namespace polymod
} // end namespace format
#endif /* INCLUDED_polymod_format_XMLMerge */
| [
"80244419+Tyrcnex@users.noreply.github.com"
] | 80244419+Tyrcnex@users.noreply.github.com |
b63f30448c94edab5778c9a53475a4fd55d47e6b | 0758066960d0990bd4ce76805f93d9bc7c2b9b0f | /SDL Work/Lada-old/LADASetupDlg.cpp | 148f83f7c238e77ac9b8bc76e05ca1e5cb97d533 | [] | no_license | mrsalt/USU | 4acf7ecf84663491582a834f31f69cfd17938d58 | 49cbc7bbc597f6780338f11bf341c86579bb3c02 | refs/heads/master | 2020-08-26T22:39:36.728764 | 2019-10-24T00:50:08 | 2019-10-24T02:18:11 | 217,167,673 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 16,309 | cpp | // This is Version 1.0 PLEASE DOCUMENT CHANGES
// LADASetupDlg.cpp : implementation file
// 1-11-01 12:30 pm added * to display bitmap
#include "stdafx.h"
#include "Lada Control Module.h"
#include "LADASetupDlg.h"
#include "Step.h"
#include "LADA Control ModuleDoc.h"
#include "Ladastrings.h"
#include "SystemDiagDlg.h"
#include "Verify.h"
#include "ParamDlg.h"
#include "LadaTest.h"
#include "fstream.h"
#include "Checkout.h"
#include "Display.h"
#include "WetupSettingsDlg.h"
#include "LString.h"
#include "Camera.h"
#include "inputlocations.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define TURN_ON_POWER 0
#define POWER_ON 1
#define INITIALIZE_CR10X 2
#define VIEW_VOLTAGES 3
#define VIEW_MEASUREMENTS 4
#define MAIN_TEST 5
#define DISPLAY 6
#define TAKE_PICTURE 7
extern CFont RussianArial;
extern CCamera * cameraDlg;
extern void SetItemFont(UINT controlID, CWnd *window);
extern LString Strings;
extern UINT NotificationBox(UINT MessageID, UINT MessageTitleID = NO_TITLE, DWORD mFlags = MB_OK, BOOL IsModal = FALSE, DWORD Duration = INFINITE);
extern UINT MyMessageBox(UINT MessageID, UINT MessageTitleID = NO_TITLE, DWORD mFlags = MB_OK); // Message Box
extern UINT MyMessageBox(const char *text, const char *title = NULL, DWORD mFlags = MB_OK); // Message Box
extern UINT MyMessageBox(CString text, CString title = "", DWORD mFlags = MB_OK); // Message Box
#undef MessageBox
#define MessageBox MyMessageBox
extern BOOL LoadBMPImage(LPCTSTR sBMPFile, CBitmap &bitmap, CPalette *pPal);
/////////////////////////////////////////////////////////////////////////////
// CLADASetupDlg dialog
// Constructor
// setup if this is Setup or Checkout
// op is the current document
CLADASetupDlg::CLADASetupDlg(BOOL setup, CLADAControlModuleDoc* op,CWnd* pParent /*=NULL*/)
: CDialog(CLADASetupDlg::IDD, pParent), fout("hello.txt")
{
//{{AFX_DATA_INIT(CLADASetupDlg)
m_VStep = _T("");
m_VTitle = _T("");
m_VText = _T("");
m_VPicture = _T("");
pDoc = op;
Setup=setup;
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
print = NULL;
m_step = NULL;
m_IsAutomatic = false;
ppal = NULL;
m_Bitmap = NULL;
}
CLADASetupDlg::~CLADASetupDlg()
{
delete [] m_StepsPerPage;
delete print;
delete [] m_step;
delete ppal;
delete m_Bitmap;
}
// Data Exchange
void CLADASetupDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CLADASetupDlg)
DDX_Control(pDX, IDC_PICTURE, m_CPicture);
DDX_Control(pDX, IDC_TEXT, m_CText);
DDX_Control(pDX, ID_NEXT, m_CNext);
DDX_Control(pDX, ID_BACK, m_CBack);
DDX_Text(pDX, IDC_STEP, m_VStep);
DDV_MaxChars(pDX, m_VStep, 9);
DDX_Text(pDX, IDC_TITLE, m_VTitle);
DDV_MaxChars(pDX, m_VTitle, 60);
DDX_Text(pDX, IDC_TEXT, m_VText);
DDX_Text(pDX, IDC_PICTURE, m_VPicture);
//}}AFX_DATA_MAP
}
// Message Maps
BEGIN_MESSAGE_MAP(CLADASetupDlg, CDialog)
//{{AFX_MSG_MAP(CLADASetupDlg)
ON_WM_DESTROY()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(ID_NEXT, OnNext)
ON_BN_CLICKED(ID_BACK, OnBack)
ON_COMMAND_RANGE(IDC_CHECK1, IDC_CHECK9, OnCheck)
ON_WM_SYSCOMMAND()
ON_WM_KEYDOWN()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CLADASetupDlg message handlers
// Initialization
// Sets fonts, loads first picture, and sets step info
BOOL CLADASetupDlg::OnInitDialog()
{
checknumber=0;
m_stepnumber=0;
CheckTrue=FALSE;
CDialog::OnInitDialog();
SetFont(&RussianArial);
for (int x=0;x<9;x++)
SetItemFont(IDC_CHECK1+x,this);
SetItemFont(ID_NEXT,this);
SetItemFont(ID_BACK,this);
SetItemFont(IDC_STEP,this);
SetItemFont(IDC_TITLE,this);
SetItemFont(IDC_TEXT,this);
SetItemFont(IDC_TEXT1,this);
ppal=new CPalette;
m_Bitmap=new CBitmap;
LoadBMPImage("C:\\Windows\\Clouds.bmp",*m_Bitmap,ppal);
if (Setup)
{
SetWindowText(Strings.get(IDS_A1));
m_numsteps=5;
m_step=new Stepinfo[m_numsteps];
m_StepsPerPage = new int[m_numsteps];
m_StepsPerPage[0] = 9;
m_StepsPerPage[1] = 4;
m_StepsPerPage[2] = 3;
m_StepsPerPage[3] = 3;
m_StepsPerPage[4] = 4;
for (int x=0;x<m_numsteps;x++)
{
CString temp[9];
for (int y=0;y<9;y++)
temp[y]=Strings.get(IDS_S11+10*x+y);
m_step[x]=Stepinfo(x+1,Strings.get(IDS_S10+10*x),m_StepsPerPage[x],temp,Strings.get(IDS_S10+10*x));
}
}
else
{
SetWindowText(Strings.get(IDS_A2));
print=new CCheckout;
if (MessageBox(IDS_M_AUTOMATIC_CHECK_OUT,IDS_PROGRAM_NAME,MB_YESNO|MB_ICONQUESTION)==IDYES)
m_IsAutomatic = true;
m_numsteps=1;
m_step=new Stepinfo[1];
m_StepsPerPage = new int[m_numsteps];
m_StepsPerPage[0] = 8;
for (int x=0;x<m_numsteps;x++)
{
CString temp[9];
for (int y=0;y<9;y++)
temp[y]=Strings.get(IDS_CO11+10*x+y);
m_step[x]=Stepinfo(x+1,Strings.get(IDS_CO10+10*x),m_StepsPerPage[x],temp,Strings.get(IDS_CO10+10*x));
}
fout << "Parameter Designation\tIndication" << endl;
}
ResetStrings();
checknumber=0;
m_stepnumber=0;
Reset(0);
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
SetStrings();
return TRUE; // return TRUE unless you set the focus to a control
}
// ???????????
void CLADASetupDlg::OnDestroy()
{
// WinHelp(0L, HELP_QUIT);
CDialog::OnDestroy();
}
// Paints to the screen
void CLADASetupDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CLADASetupDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
// This is called when the Next-> button is pressed and proceeds to the next step
void CLADASetupDlg::OnNext()
{
m_stepnumber++;
if (m_stepnumber==m_numsteps)
OnOK();
else
Reset(m_stepnumber);
}
// This is called when the <-Back button is pressed and returns to the previous step
void CLADASetupDlg::OnBack()
{
m_stepnumber--;
if (m_stepnumber<0)
m_stepnumber=0;
Reset(m_stepnumber);
}
// This is called after the Next-> or <-Back button is pressed
// to reset the dialog and load the next step where int is the next step
void CLADASetupDlg::Reset(int Step)
{
CheckTrue=FALSE;
int y=m_step[Step].m_checks;
for (int x=0;x<9;x++)
{
((CButton*)GetDlgItem(IDC_CHECK1+x))->SetCheck(FALSE);
if (y<(x+1))
((CButton*)GetDlgItem(IDC_CHECK1+x))->ShowWindow(SW_HIDE);
else
((CButton*)GetDlgItem(IDC_CHECK1+x))->ShowWindow(SW_SHOW);
((CButton*)GetDlgItem(IDC_CHECK1+x))->EnableWindow(FALSE);
((CButton*)GetDlgItem(IDC_CHECK1+x))->SetWindowText(m_step[Step].m_Steps[x]);
UpdateData(TRUE);
}
((CButton*)GetDlgItem(IDC_CHECK1))->EnableWindow(TRUE);
if (Step==0)
m_CBack.EnableWindow(FALSE);
else
m_CBack.EnableWindow(TRUE);
if (Step==m_numsteps-1)
m_CNext.SetWindowText(Strings.get(IDS_S4));
else
m_CNext.SetWindowText(Strings.get(IDS_S3));
m_VStep=Strings.get(IDS_S1)+CString(m_step[Step].m_step/10+'0')+CString(m_step[Step].m_step%10+'0');
m_VTitle=m_step[Step].m_title;
m_VText=m_step[Step].m_Text;
UpdateData(FALSE);
GetDlgItem(IDC_CHECK1)->SetFocus();
checknumber=0;
CheckCheck(m_stepnumber);
}
// This is called when a check is checked and changes the explanation and picture for the next step
void CLADASetupDlg::CheckCheck(int temp)
{
UpdateData(TRUE);
if (!(m_step[m_stepnumber].m_checks-checknumber-1))
{
m_CNext.EnableWindow(TRUE);
m_CNext.SetFocus();
if ((m_stepnumber+1)==m_numsteps)
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_ALL_STEPS_COMPLETE));
else
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_STEPS_COMPLETE));
}
else
{
m_CNext.EnableWindow(FALSE);
if (Setup)
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber+CheckTrue));
else
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_AB0+9*m_stepnumber+checknumber+CheckTrue));
}
m_CPicture.SetBitmap((HBITMAP)*m_Bitmap);
}
// During Checkout this will perform the tasks specified in each step
void CLADASetupDlg::DoSomething()
{
if (!Setup)
{
if (checknumber==TURN_ON_POWER) // Starts Checkout and records the time
{
CTime Start=CTime::GetCurrentTime();
CString temp;
temp=Start.Format("%d.%m.%y");
print->data[0][1]=temp;
temp=Start.Format(" %H:%M");
print->data[1][1]=temp;
if (m_IsAutomatic)
{
GetDlgItem(IDC_CHECK2)->EnableWindow();
((CButton*)GetDlgItem(IDC_CHECK2))->SetCheck(TRUE);
GetDlgItem(IDC_CHECK3)->EnableWindow();
((CButton*)GetDlgItem(IDC_CHECK3))->SetCheck(TRUE);
checknumber=INITIALIZE_CR10X;
}
}
if (checknumber==INITIALIZE_CR10X) // Connects to the CR10
{
pDoc->m_ControlMode = ManualControlMode;
if (pDoc->Connect(FALSE, Regular, FALSE))
{
// don't start data retrieval mode, make sure regular program is running on CR10, don't do initialization
BOOL Success;
Success = pDoc->commObject->UpdateCR10Time();
if (!Success)
{
GetDlgItem(IDC_CHECK3)->SetFocus();
return;
}
if (!m_IsAutomatic && !Success)
NotificationBox(IDS_M_TIME_NOT_UPDATED,IDS_PROGRAM_NAME,MB_OK,FALSE,1000);
if (m_IsAutomatic)
{
((CButton*)GetDlgItem(IDC_CHECK4))->SetCheck(TRUE);
GetDlgItem(IDC_CHECK4)->EnableWindow();
checknumber=VIEW_VOLTAGES;
}
}
else
{
GetDlgItem(IDC_CHECK3)->SetFocus();
((CButton*)GetDlgItem(IDC_CHECK3))->SetCheck(FALSE);
GetDlgItem(IDC_CHECK4)->EnableWindow(FALSE);
}
}
if (checknumber==VIEW_VOLTAGES) // Checks the voltages on the CR10
{
int listSize = 8;
int * InputList = new int[listSize];
for (int x=0;x<8;x++)
InputList[x] = x+VOLTAGE_1;
double * returnData = new double[listSize];
CSystemDiagDlg dlg(pDoc, -1, FALSE, InputList, listSize, returnData,m_IsAutomatic,FALSE);
dlg.DoModal();
SetStrings();
ResetStrings();
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber));
m_VStep=Strings.get(IDS_S1)+CString(m_step[m_stepnumber].m_step/10+'0')+CString(m_step[m_stepnumber].m_step%10+'0');
m_VTitle=m_step[m_stepnumber].m_title;
m_VText=m_step[m_stepnumber].m_Text;
UpdateData(FALSE);
delete [] InputList;
delete [] returnData;
if (m_IsAutomatic)
{
((CButton*)GetDlgItem(IDC_CHECK5))->SetCheck(TRUE);
GetDlgItem(IDC_CHECK5)->EnableWindow();
checknumber=VIEW_MEASUREMENTS;
}
}
if (checknumber==VIEW_MEASUREMENTS) // Verifies certain values from the CR10 to the user
{
Verify dlga(pDoc,m_IsAutomatic,print);
dlga.DoModal();
SetStrings();
ResetStrings();
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber));
m_VStep=Strings.get(IDS_S1)+CString(m_step[m_stepnumber].m_step/10+'0')+CString(m_step[m_stepnumber].m_step%10+'0');
m_VTitle=m_step[m_stepnumber].m_title;
m_VText=m_step[m_stepnumber].m_Text;
UpdateData(FALSE);
if (m_IsAutomatic)
{
((CButton*)GetDlgItem(IDC_CHECK6))->SetCheck(TRUE);
GetDlgItem(IDC_CHECK6)->EnableWindow();
checknumber=MAIN_TEST;
}
}
if (checknumber==MAIN_TEST) // Runs the Diagnostic Tests and compares value with the user
{
LadaTest dlgc(pDoc, print,m_IsAutomatic,this);
dlgc.DoModal();
SetStrings();
ResetStrings();
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber));
m_VStep=Strings.get(IDS_S1)+CString(m_step[m_stepnumber].m_step/10+'0')+CString(m_step[m_stepnumber].m_step%10+'0');
m_VTitle=m_step[m_stepnumber].m_title;
m_VText=m_step[m_stepnumber].m_Text;
UpdateData(FALSE);
if (m_IsAutomatic)
{
((CButton*)GetDlgItem(IDC_CHECK7))->SetCheck(TRUE);
GetDlgItem(IDC_CHECK7)->EnableWindow();
checknumber=DISPLAY;
}
}
if (checknumber==DISPLAY)
{
Display ddlg(print);
ddlg.DoModal();
SetStrings();
ResetStrings();
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber));
m_VStep=Strings.get(IDS_S1)+CString(m_step[m_stepnumber].m_step/10+'0')+CString(m_step[m_stepnumber].m_step%10+'0');
m_VTitle=m_step[m_stepnumber].m_title;
m_VText=m_step[m_stepnumber].m_Text;
UpdateData(FALSE);
print->output(fout);
if (m_IsAutomatic)
{
GetDlgItem(IDC_CHECK8)->EnableWindow();
GetDlgItem(IDC_CHECK8)->SetFocus();
}
}
if (checknumber==TAKE_PICTURE)
{
if (cameraDlg)
{
cameraDlg->ShowWindow(SW_SHOW);
cameraDlg->AutoPicture(0);
}
}
}
}
// This sets the text to the current language
void CLADASetupDlg::SetStrings()
{
// SetWindowText(Strings.get(IDS_S0));
GetDlgItem(ID_BACK)->SetWindowText(Strings.get(IDS_S2));
// GetDlgItem(ID_NEXT)->SetWindowText(Strings.get(IDS_S3));
GetDlgItem(ID_HELP)->SetWindowText(Strings.get(IDS_S5));
}
BOOL CLADASetupDlg::PreTranslateMessage(MSG* pMsg)
{
if (pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_F2)
{
Strings.ToggleLanguage();
SetStrings();
ResetStrings();
//GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber));
m_VStep=Strings.get(IDS_S1)+CString(m_step[m_stepnumber].m_step/10+'0')+CString(m_step[m_stepnumber].m_step%10+'0');
m_VTitle=m_step[m_stepnumber].m_title;
m_VText=m_step[m_stepnumber].m_Text;
UpdateData(FALSE);
return TRUE;
}
if (pMsg->message == WM_KEYDOWN && pMsg->wParam==13)
{
return TRUE;
}
return CDialog::PreTranslateMessage(pMsg);
}
void CLADASetupDlg::OnCheck(UINT nID)
{
checknumber=nID-IDC_CHECK1;
UpdateData(TRUE);
CheckTrue=((CButton*)GetDlgItem(nID))->GetCheck();
CheckCheck(m_stepnumber);
if (CheckTrue)
{
if (m_step[m_stepnumber].m_checks>(checknumber+1))
{
((CButton*)GetDlgItem(nID+1))->EnableWindow();
GetDlgItem(nID+1)->SetFocus();
}
DoSomething();
}
}
void CLADASetupDlg::ResetStrings()
{
if (!(m_step[m_stepnumber].m_checks-checknumber-1))
{
m_CNext.EnableWindow(TRUE);
if ((m_stepnumber+1)==m_numsteps)
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_ALL_STEPS_COMPLETE));
else
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_STEPS_COMPLETE));
}
else
{
m_CNext.EnableWindow(FALSE);
if (Setup)
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_V0+10*m_stepnumber+checknumber+CheckTrue));
else
GetDlgItem(IDC_TEXT1)->SetWindowText(Strings.get(IDS_AB0+9*m_stepnumber+checknumber+CheckTrue));
}
if (m_stepnumber==m_numsteps-1)
m_CNext.SetWindowText(Strings.get(IDS_S4));
else
m_CNext.SetWindowText(Strings.get(IDS_S3));
if (Setup)
{
SetWindowText(Strings.get(IDS_A1));
for (int x=0;x<m_numsteps;x++)
{
CString temp[9];
for (int y=0;y<9;y++)
{
temp[y]=Strings.get(IDS_S11+10*x+y);
if (x==m_stepnumber)
GetDlgItem(IDC_CHECK1+y)->SetWindowText(temp[y]);
}
m_step[x]=Stepinfo(x+1,Strings.get(IDS_S10+10*x),m_StepsPerPage[x],temp,Strings.get(IDS_S10+10*x));
}
}
else
{
SetWindowText(Strings.get(IDS_A2));
for (int x=0;x<m_numsteps;x++)
{
CString temp[9];
for (int y=0;y<9;y++)
{
temp[y]=Strings.get(IDS_CO11+10*x+y);
GetDlgItem(IDC_CHECK1+y)->SetWindowText(temp[y]);
}
m_step[x]=Stepinfo(x+1,Strings.get(IDS_CO10+10*x),m_StepsPerPage[x],temp,Strings.get(IDS_CO10+10*x));
}
}
}
| [
"fmark.salisbury@gmail.com"
] | fmark.salisbury@gmail.com |
e6753534e116ce376a308c2a0235823e57ff9d30 | 9d7649ca193d5e62b6752ba4098c43eb5a16aa5f | /third_party/gips/gipsVideoLinux351/include/GIPSVEFile.h | 4c573401fe6cd199d7501cbf0c5b28f22acc8d5c | [] | no_license | yiw2/ikran | 6aafe7d2b6ede852bdcffd9fc3ac4613ee9976a8 | cc8a3205cdbcb34f7807373db01c7f8b2558a639 | refs/heads/master | 2020-12-25T17:12:41.280090 | 2012-03-13T05:42:58 | 2012-03-13T05:42:58 | 3,196,837 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,479 | h | // GIPSVEFile.h
//
// Copyright (c) 1999-2008 Global IP Solutions. All rights reserved.
#if !defined(__GIPSVE_FILE_H__)
#define __GIPSVE_FILE_H__
#include "GIPSVECommon.h"
class GIPSVoiceEngine;
enum GIPS_FileFormats
{
FILE_PCM_16KHZ = 0, // PCM 16 bits/sample, mono, 16 kHz sampling rate
FILE_WAV = 1, // PCM or u/A-law, 8/16 bits/sample, mono/stereo, 8,11,16,22,32,44,48 kHz sampling rates
FILE_COMPRESSED = 2, // compressed with either iLBC or AMR
FILE_PCM_8KHZ = 3 // PCM 16 bits/sample, mono, 8 kHz
};
class VOICEENGINE_DLLEXPORT GIPSVEFile
{
public:
static GIPSVEFile* GetInterface(GIPSVoiceEngine* voiceEngine);
// Playout file locally
virtual int GIPSVE_StartPlayingFileLocally(int channel, const char* fileNameUTF8, bool loop = false, GIPS_FileFormats format = FILE_PCM_16KHZ, float volumeScaling = 1.0,int startPointMs = 0, int stopPointMs = 0) = 0;
virtual int GIPSVE_StartPlayingFileLocally(int channel, InStream* stream, GIPS_FileFormats format = FILE_PCM_16KHZ, float volumeScaling = 1.0, int startPointMs = 0, int stopPointMs = 0) = 0;
virtual int GIPSVE_StopPlayingFileLocally(int channel) = 0;
virtual int GIPSVE_IsPlayingFileLocally(int channel) = 0;
virtual int GIPSVE_ScaleLocalFilePlayout(int channel, float scale) = 0;
// Use file as microphone input
virtual int GIPSVE_StartPlayingFileAsMicrophone(int channel, const char* fileNameUTF8, bool loop = false , bool mixWithMicrophone = false, GIPS_FileFormats format = FILE_PCM_16KHZ, float volumeScaling = 1.0) = 0;
virtual int GIPSVE_StartPlayingFileAsMicrophone(int channel, InStream* stream, bool mixWithMicrophone = false, GIPS_FileFormats format = FILE_PCM_16KHZ, float volumeScaling = 1.0) = 0;
virtual int GIPSVE_StopPlayingFileAsMicrophone(int channel) = 0;
virtual int GIPSVE_IsPlayingFileAsMicrophone(int channel) = 0;
virtual int GIPSVE_ScaleFileAsMicrophonePlayout(int channel, float scale) = 0;
// Record speaker signal to file
virtual int GIPSVE_StartRecordingPlayout(int channel, const char* fileNameUTF8, GIPS_CodecInst* compression = NULL, int maxSizeBytes = -1) = 0;
virtual int GIPSVE_StartRecordingPlayout(int channel, OutStream* stream, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_StopRecordingPlayout(int channel) = 0;
// Record microphone signal to file
virtual int GIPSVE_StartRecordingMicrophone(const char* fileNameUTF8, GIPS_CodecInst* compression = NULL, int channel = -1, int maxSizeBytes = -1) = 0;
virtual int GIPSVE_StartRecordingMicrophone(OutStream* stream, GIPS_CodecInst* compression = NULL, int channel = -1) = 0;
virtual int GIPSVE_StopRecordingMicrophone() = 0;
// Record mixed (speaker + microphone) signal to file
virtual int GIPSVE_StartRecordingCall(const char* fileNameUTF8, GIPS_CodecInst* compression = NULL, int maxSizeBytes = -1) = 0;
virtual int GIPSVE_StartRecordingCall(OutStream* stream, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_PauseRecordingCall(bool enable) = 0;
virtual int GIPSVE_StopRecordingCall() = 0;
// Record left/right speaker signals to file
virtual int GIPSVE_StartRecordingPlayoutStereo(const char* fileNameLeftUTF8, const char* fileNameRightUTF8, GIPS_StereoChannel select, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_StartRecordingPlayoutStereo(OutStream* streamLeft, OutStream* streamRight, GIPS_StereoChannel select, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_StopRecordingPlayoutStereo(GIPS_StereoChannel select) = 0;
// Conversion between different file formats
virtual int GIPSVE_ConvertPCMToWAV(const char* fileNameInUTF8, const char* fileNameOutUTF8) = 0;
virtual int GIPSVE_ConvertPCMToWAV(InStream* streamIn, OutStream* streamOut, int lengthInBytes) = 0;
virtual int GIPSVE_ConvertWAVToPCM(const char* fileNameInUTF8, const char* fileNameOutUTF8) = 0;
virtual int GIPSVE_ConvertWAVToPCM(InStream* streamIn, OutStream* streamOut) = 0;
virtual int GIPSVE_ConvertPCMToCompressed(const char* fileNameInUTF8, const char* fileNameOutUTF8, GIPS_CodecInst* compression) = 0;
virtual int GIPSVE_ConvertPCMToCompressed(InStream* streamIn, OutStream* streamOut, GIPS_CodecInst* compression) = 0;
virtual int GIPSVE_ConvertCompressedToPCM(const char* fileNameInUTF8, const char* fileNameOutUTF8) = 0;
virtual int GIPSVE_ConvertCompressedToPCM(InStream* streamIn, OutStream* streamOut) = 0;
// Conversion from RTP packets to file
virtual int GIPSVE_InitRTPToFileConversion(const char* fileNameUTF8, unsigned int conversionDelay, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_InitRTPToFileConversion(OutStream* stream, unsigned int conversionDelay, GIPS_CodecInst* compression = NULL) = 0;
virtual int GIPSVE_StartRTPToFileConversion(int channel) = 0;
virtual int GIPSVE_StopRTPToFileConversion(int channel) = 0;
virtual int GIPSVE_ConvertRTPToFile(int channel, char* rtpPacketBuffer, unsigned int length, unsigned int incomingTimeStamp) = 0;
// Misc file functions
virtual int GIPSVE_GetFileDuration(const char* fileNameUTF8, int& durationMs, GIPS_FileFormats format = FILE_PCM_16KHZ) = 0;
virtual int GIPSVE_GetPlaybackPosition(int channel, int& positionMs) = 0;
virtual int Release() = 0;
protected:
virtual ~GIPSVEFile();
};
#endif // #if !defined(__GIPSVE_FILE_H__)
| [
"ehugg@cisco.com"
] | ehugg@cisco.com |
1287e6c6185c0c418dd3978b32a899d739c07fdb | b22ef51e237b3b5492eb3e8b4922485ab0975b33 | /rok_3/jezyki_formalne_i_techniki_translacji/laboratoria/lista_2/zadanie_3/new_test.cpp | af46e39642442dbe3d365d578033967210f0f285 | [] | no_license | GabrielWechta/warm_cedar | 6e71480e0ecada05b4a5ab19399110f404a9d1b3 | 0bad374d25fbe76d59299494c4b9d061f82c6e08 | refs/heads/master | 2021-12-09T10:14:59.352419 | 2021-12-08T21:41:01 | 2021-12-08T21:41:01 | 217,345,267 | 0 | 3 | null | 2021-11-22T17:57:44 | 2019-10-24T16:33:46 | Jupyter Notebook | UTF-8 | C++ | false | false | 1,518 | cpp | #include<iostream>
#include<cstdio>
/** Maly przyklad programu
*
* // autor Maciej Gebala
*
*/
// /*
using namespace std;
// */
//! Komentarz dokumentacyjny \
i jego // ciag dalszy\
/* i dalszy */
int some_function(int a) {
return a << (1 << 4);
}
/*! Nieco inny komentarz dokumentacyjny
// Komentarz w komentarzu
*/
int main()
{
/// Komentarz dokumentacyjny \
ciag dalszy jednolinijkowego komentarza
int i = 5;
// Komentarz jednolinijkowy\
i jego ciąg dalszy\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
i dalszy */
cout << "Jakis program" << endl; // ;
// A tutaj taki komentarz \
cout << "Poczatek komentarza /*" << endl; // ala
/*
Taki sobie komentarz
/** z komentarzem w srodku */
/*
/// Komentarz nie-dokumentacyjny
*/
// /// Komentarz /** rozne rzeczy /
///// Komentarz TODO: Sprawdzić jak to jest interpretowane
//! i jeszcze inny komentarz */
cout << "Koniec komentarza */ "<< endl; // kot
cout << "Komentarz /* ala */" << endl;
/*! I jeszcze jeden
**/
/* komentarz "taki z c\"zyms w cudzyslowie""""""""""""""""
/*
*/
/** "Dokumentujemy nasz \" kod"
*/
// nie moze byc "za latwo", a co!
// i jeszcze jeden */
cout << "Zabawa \" // \\\\\"ala i kot \\\\" << endl;
cout << "Komentarz // kot " << endl;
cout << "Pulapka \" \
// ma \
/* \\\"ma\" */ \
/** doc */\
\\\\" << endl;
cout << /*Proba*/"Zabawa \" // ala i kot " << endl;
printf("Zabawa \" // ala i kot ");
}
| [
"wechtagabriel@gmail.com"
] | wechtagabriel@gmail.com |
6d863a049c82947f4603b51217d61ced0e3dacb7 | f4e17640afef6d1b4d4a85f583a90e37f705dbd5 | /B2G/gecko/dom/plugins/ipc/PluginModuleParent.h | 2005929d7bbc448b76586a6ef187a22e43cf7909 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | wilebeast/FireFox-OS | d370362916f0c5a5408fa08285dbf4779f8b5eb3 | 43067f28711d78c429a1d6d58c77130f6899135f | refs/heads/master | 2016-09-05T22:06:54.838558 | 2013-09-03T13:49:21 | 2013-09-03T13:49:21 | 12,572,236 | 4 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 11,700 | h | /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: sw=4 ts=4 et :
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef dom_plugins_PluginModuleParent_h
#define dom_plugins_PluginModuleParent_h 1
#include <cstring>
#include "base/basictypes.h"
#include "prlink.h"
#include "npapi.h"
#include "npfunctions.h"
#include "base/string_util.h"
#include "mozilla/FileUtils.h"
#include "mozilla/PluginLibrary.h"
#include "mozilla/plugins/PPluginModuleParent.h"
#include "mozilla/plugins/PluginInstanceParent.h"
#include "mozilla/plugins/PluginProcessParent.h"
#include "mozilla/plugins/PluginIdentifierParent.h"
#include "nsAutoPtr.h"
#include "nsDataHashtable.h"
#include "nsHashKeys.h"
#include "nsIFileStreams.h"
#ifdef MOZ_CRASHREPORTER
#include "nsExceptionHandler.h"
#endif
namespace mozilla {
namespace dom {
class PCrashReporterParent;
class CrashReporterParent;
}
namespace plugins {
//-----------------------------------------------------------------------------
class BrowserStreamParent;
/**
* PluginModuleParent
*
* This class implements the NPP API from the perspective of the rest
* of Gecko, forwarding NPP calls along to the child process that is
* actually running the plugin.
*
* This class /also/ implements a version of the NPN API, because the
* child process needs to make these calls back into Gecko proper.
* This class is responsible for "actually" making those function calls.
*/
class PluginModuleParent
: public PPluginModuleParent
, public PluginLibrary
#ifdef MOZ_CRASHREPORTER_INJECTOR
, public CrashReporter::InjectorCrashCallback
#endif
{
private:
typedef mozilla::PluginLibrary PluginLibrary;
typedef mozilla::dom::PCrashReporterParent PCrashReporterParent;
typedef mozilla::dom::CrashReporterParent CrashReporterParent;
protected:
virtual PPluginIdentifierParent*
AllocPPluginIdentifier(const nsCString& aString,
const int32_t& aInt,
const bool& aTemporary);
virtual bool
DeallocPPluginIdentifier(PPluginIdentifierParent* aActor);
PPluginInstanceParent*
AllocPPluginInstance(const nsCString& aMimeType,
const uint16_t& aMode,
const InfallibleTArray<nsCString>& aNames,
const InfallibleTArray<nsCString>& aValues,
NPError* rv);
virtual bool
DeallocPPluginInstance(PPluginInstanceParent* aActor);
public:
// aFilePath is UTF8, not native!
PluginModuleParent(const char* aFilePath);
virtual ~PluginModuleParent();
virtual void SetPlugin(nsNPAPIPlugin* plugin) MOZ_OVERRIDE
{
mPlugin = plugin;
}
virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
/**
* LoadModule
*
* This may or may not launch a plugin child process,
* and may or may not be very expensive.
*/
static PluginLibrary* LoadModule(const char* aFilePath);
const NPNetscapeFuncs* GetNetscapeFuncs() {
return mNPNIface;
}
PluginProcessParent* Process() const { return mSubprocess; }
base::ProcessHandle ChildProcessHandle() { return mSubprocess->GetChildProcessHandle(); }
bool OkToCleanup() const {
return !IsOnCxxStack();
}
/**
* Get an identifier actor for this NPIdentifier. If this is a temporary
* identifier, the temporary refcount is increased by one. This method
* is intended only for use by StackIdentifier and the scriptable
* Enumerate hook.
*/
PluginIdentifierParent*
GetIdentifierForNPIdentifier(NPP npp, NPIdentifier aIdentifier);
void ProcessRemoteNativeEventsInRPCCall();
protected:
virtual mozilla::ipc::RPCChannel::RacyRPCPolicy
MediateRPCRace(const Message& parent, const Message& child) MOZ_OVERRIDE
{
return MediateRace(parent, child);
}
virtual bool RecvXXX_HACK_FIXME_cjones(Shmem& mem) { NS_RUNTIMEABORT("not reached"); return false; }
virtual bool ShouldContinueFromReplyTimeout() MOZ_OVERRIDE;
virtual bool
RecvBackUpXResources(const FileDescriptor& aXSocketFd) MOZ_OVERRIDE;
virtual bool
AnswerNPN_UserAgent(nsCString* userAgent);
virtual bool
AnswerNPN_GetValue_WithBoolReturn(const NPNVariable& aVariable,
NPError* aError,
bool* aBoolVal);
virtual bool AnswerProcessSomeEvents() MOZ_OVERRIDE;
virtual bool
RecvProcessNativeEventsInRPCCall() MOZ_OVERRIDE;
virtual bool
RecvPluginShowWindow(const uint32_t& aWindowId, const bool& aModal,
const int32_t& aX, const int32_t& aY,
const size_t& aWidth, const size_t& aHeight) MOZ_OVERRIDE;
virtual bool
RecvPluginHideWindow(const uint32_t& aWindowId) MOZ_OVERRIDE;
virtual PCrashReporterParent*
AllocPCrashReporter(mozilla::dom::NativeThreadId* id,
uint32_t* processType) MOZ_OVERRIDE;
virtual bool
DeallocPCrashReporter(PCrashReporterParent* actor) MOZ_OVERRIDE;
virtual bool
RecvSetCursor(const NSCursorInfo& aCursorInfo) MOZ_OVERRIDE;
virtual bool
RecvShowCursor(const bool& aShow) MOZ_OVERRIDE;
virtual bool
RecvPushCursor(const NSCursorInfo& aCursorInfo) MOZ_OVERRIDE;
virtual bool
RecvPopCursor() MOZ_OVERRIDE;
virtual bool
RecvGetNativeCursorsSupported(bool* supported) MOZ_OVERRIDE;
virtual bool
RecvNPN_SetException(PPluginScriptableObjectParent* aActor,
const nsCString& aMessage) MOZ_OVERRIDE;
virtual bool
RecvNPN_ReloadPlugins(const bool& aReloadPages) MOZ_OVERRIDE;
static PluginInstanceParent* InstCast(NPP instance);
static BrowserStreamParent* StreamCast(NPP instance, NPStream* s);
private:
void SetPluginFuncs(NPPluginFuncs* aFuncs);
// Implement the module-level functions from NPAPI; these are
// normally resolved directly from the DSO.
#ifdef OS_LINUX
NPError NP_Initialize(const NPNetscapeFuncs* npnIface,
NPPluginFuncs* nppIface);
#else
NPError NP_Initialize(const NPNetscapeFuncs* npnIface);
NPError NP_GetEntryPoints(NPPluginFuncs* nppIface);
#endif
// NPP-like API that Gecko calls are trampolined into. These
// messages then get forwarded along to the plugin instance,
// and then eventually the child process.
static NPError NPP_Destroy(NPP instance, NPSavedData** save);
static NPError NPP_SetWindow(NPP instance, NPWindow* window);
static NPError NPP_NewStream(NPP instance, NPMIMEType type, NPStream* stream,
NPBool seekable, uint16_t* stype);
static NPError NPP_DestroyStream(NPP instance,
NPStream* stream, NPReason reason);
static int32_t NPP_WriteReady(NPP instance, NPStream* stream);
static int32_t NPP_Write(NPP instance, NPStream* stream,
int32_t offset, int32_t len, void* buffer);
static void NPP_StreamAsFile(NPP instance,
NPStream* stream, const char* fname);
static void NPP_Print(NPP instance, NPPrint* platformPrint);
static int16_t NPP_HandleEvent(NPP instance, void* event);
static void NPP_URLNotify(NPP instance, const char* url,
NPReason reason, void* notifyData);
static NPError NPP_GetValue(NPP instance,
NPPVariable variable, void *ret_value);
static NPError NPP_SetValue(NPP instance, NPNVariable variable,
void *value);
static void NPP_URLRedirectNotify(NPP instance, const char* url,
int32_t status, void* notifyData);
virtual bool HasRequiredFunctions();
virtual nsresult AsyncSetWindow(NPP instance, NPWindow* window);
virtual nsresult GetImageContainer(NPP instance, mozilla::layers::ImageContainer** aContainer);
virtual nsresult GetImageSize(NPP instance, nsIntSize* aSize);
virtual bool IsOOP() MOZ_OVERRIDE { return true; }
virtual nsresult SetBackgroundUnknown(NPP instance) MOZ_OVERRIDE;
virtual nsresult BeginUpdateBackground(NPP instance,
const nsIntRect& aRect,
gfxContext** aCtx) MOZ_OVERRIDE;
virtual nsresult EndUpdateBackground(NPP instance,
gfxContext* aCtx,
const nsIntRect& aRect) MOZ_OVERRIDE;
#if defined(XP_UNIX) && !defined(XP_MACOSX) && !defined(MOZ_WIDGET_GONK)
virtual nsresult NP_Initialize(NPNetscapeFuncs* bFuncs, NPPluginFuncs* pFuncs, NPError* error);
#else
virtual nsresult NP_Initialize(NPNetscapeFuncs* bFuncs, NPError* error);
#endif
virtual nsresult NP_Shutdown(NPError* error);
virtual nsresult NP_GetMIMEDescription(const char** mimeDesc);
virtual nsresult NP_GetValue(void *future, NPPVariable aVariable,
void *aValue, NPError* error);
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(XP_OS2)
virtual nsresult NP_GetEntryPoints(NPPluginFuncs* pFuncs, NPError* error);
#endif
virtual nsresult NPP_New(NPMIMEType pluginType, NPP instance,
uint16_t mode, int16_t argc, char* argn[],
char* argv[], NPSavedData* saved,
NPError* error);
virtual nsresult NPP_ClearSiteData(const char* site, uint64_t flags,
uint64_t maxAge);
virtual nsresult NPP_GetSitesWithData(InfallibleTArray<nsCString>& result);
#if defined(XP_MACOSX)
virtual nsresult IsRemoteDrawingCoreAnimation(NPP instance, bool *aDrawing);
virtual nsresult ContentsScaleFactorChanged(NPP instance, double aContentsScaleFactor);
#endif
#if defined(MOZ_WIDGET_QT) && (MOZ_PLATFORM_MAEMO == 6)
virtual nsresult HandleGUIEvent(NPP instance, const nsGUIEvent& anEvent,
bool* handled);
#endif
private:
CrashReporterParent* CrashReporter();
#ifdef MOZ_CRASHREPORTER
void ProcessFirstMinidump();
void WriteExtraDataForMinidump(CrashReporter::AnnotationTable& notes);
#endif
void CleanupFromTimeout();
static int TimeoutChanged(const char* aPref, void* aModule);
void NotifyPluginCrashed();
PluginProcessParent* mSubprocess;
// the plugin thread in mSubprocess
NativeThreadId mPluginThread;
bool mShutdown;
bool mClearSiteDataSupported;
bool mGetSitesWithDataSupported;
const NPNetscapeFuncs* mNPNIface;
nsDataHashtable<nsPtrHashKey<void>, PluginIdentifierParent*> mIdentifiers;
nsNPAPIPlugin* mPlugin;
ScopedRunnableMethodFactory<PluginModuleParent> mTaskFactory;
nsString mPluginDumpID;
nsString mBrowserDumpID;
nsString mHangID;
#ifdef XP_WIN
InfallibleTArray<float> mPluginCpuUsageOnHang;
#endif
#ifdef MOZ_X11
// Dup of plugin's X socket, used to scope its resources to this
// object instead of the plugin process's lifetime
ScopedClose mPluginXSocketFdDup;
#endif
friend class mozilla::dom::CrashReporterParent;
#ifdef MOZ_CRASHREPORTER_INJECTOR
void InitializeInjector();
void OnCrash(DWORD processID) MOZ_OVERRIDE;
DWORD mFlashProcess1;
DWORD mFlashProcess2;
#endif
};
} // namespace plugins
} // namespace mozilla
#endif // ifndef dom_plugins_PluginModuleParent_h
| [
"info@hadrons.me"
] | info@hadrons.me |
75f9abc035fc9a2d3a4532dd20fcbb13305d6210 | 25ab7b537e5e6e13866461956f50d55555157dd3 | /Problem Solving/Algorithms/Dynamic Programming/TheLongestIncreasingSubsequence.cpp | 97414568f233b8d9a182f1a66dc25c109cf5c61c | [] | no_license | weirdrag08/HackerRank | 23522ddd837a060d46e57cfd7fcca9c9fab220c8 | 8d510de21980eb00cb458f0cd782dbabe4b96010 | refs/heads/master | 2023-07-03T19:52:51.361244 | 2021-08-14T17:02:29 | 2021-08-14T17:02:29 | 356,377,172 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,466 | cpp | #include <iostream>
#include <unordered_map>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <string>
#include <climits>
#include <utility>
using namespace std;
#define mp make_pair
#define INFI 10e8
#define INF 10e7
#define mod 1000000007
#define sieve_limit 10e6
typedef long long ll;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<long long int> vlli;
typedef vector<bool> vb;
typedef vector<vector<int> > vvi;
typedef vector<vector<long long> > vvll;
typedef vector<vector<long long int> > vvlli;
typedef vector<vector<bool> > vvb;
int lis(vi &v){
int n = v.size(), left = 0, right = 0, midpoint = 0;
vi dp;
dp.push_back(v[0]);
for(int i = 1; i < n; i++){
left = 0, right = dp.size() - 1;
while(left < right){
midpoint = left + (right - left)/2;
dp[midpoint] < v[i] ? left = midpoint + 1 : right = midpoint;
}
if(left == dp.size() - 1){
if(dp[left] >= v[i]) dp[left] = v[i];
else dp.push_back(v[i]);
}
else{
if(dp[left] > v[i]) dp[left] = v[i];
}
}
return dp.size();
}
int main(){
std::ios_base::sync_with_stdio(false);
cin.tie();
int n;
cin >> n;
vi v(n);
for(int i = 0; i < n; i++){
cin >> v[i];
}
int max_len = lis(v);
cout << max_len << '\n';
}
| [
"noreply@github.com"
] | noreply@github.com |
203e08809f5a778dd382d26b5826ac4f3669cd89 | fb27f155e78b6f7ee9c26594b71ae7f816b269be | /pro/src/testSQL/main.cpp | a7e68019f42832c98369a8729265c50db1e91db3 | [] | no_license | andarm/study | 352e0275868e42fa8ef7b8d39d69309cec2f3fba | 139b5214f56702d295d1257e6f0b806d4d337355 | refs/heads/master | 2020-04-12T02:31:42.461235 | 2019-09-05T11:10:37 | 2019-09-05T11:10:37 | 41,783,060 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 2,286 | cpp | /*
* =====================================================================================
*
* Filename: main.cpp
*
* Description:
*
* Version: 1.0
* Created: 2016年03月29日 21时24分28秒
* Revision: none
* Compiler: gcc
*
* Author: YOUR NAME (),
* Organization:
*
* =====================================================================================
*/
#include <stdlib.h>
#include <iostream>
using namespace std;
#include "./linux_sqlite/sqlite3.h"
int callback(void*,int,char**,char**);
int main()
{
sqlite3* db;
int nResult = sqlite3_open("test.db",&db);
if (nResult != SQLITE_OK)
{
cout<<"打开数据库失败："<<sqlite3_errmsg(db)<<endl;
return 0;
}
else
{
cout<<"数据库打开成功"<<endl;
}
char* errmsg;
nResult = sqlite3_exec(db,"create table fuck(id integer primary key autoincrement,name varchar(100))",NULL,NULL,&errmsg);
if (nResult != SQLITE_OK)
{
sqlite3_close(db);
cout<<errmsg;
sqlite3_free(errmsg);
return 0;
}
string strSql;
strSql+="begin;\n";
for (int i=0;i<100;i++)
{
strSql+="insert into fuck values(null,'heh');\n";
}
strSql+="commit;";
//cout<<strSql<<endl;
nResult = sqlite3_exec(db,strSql.c_str(),NULL,NULL,&errmsg);
if (nResult != SQLITE_OK)
{
sqlite3_close(db);
cout<<errmsg<<endl;
sqlite3_free(errmsg);
return 0;
}
strSql = "select * from fuck";
//nResult = sqlite3_exec(db,strSql.c_str(),callback,NULL,&errmsg);
char** pResult;
int nRow;
int nCol;
nResult = sqlite3_get_table(db,strSql.c_str(),&pResult,&nRow,&nCol,&errmsg);
if (nResult != SQLITE_OK)
{
sqlite3_close(db);
cout<<errmsg<<endl;
sqlite3_free(errmsg);
return 0;
}
string strOut;
int nIndex = nCol;
for(int i=0;i<nRow;i++)
{
for(int j=0;j<nCol;j++)
{
strOut+=pResult[j];
strOut+=":";
strOut+=pResult[nIndex];
strOut+="\n";
++nIndex;
}
}
sqlite3_free_table(pResult);
cout<<strOut<<endl;
sqlite3_close(db);
return 0;
} | [
"andarm@foxmail.com"
] | andarm@foxmail.com |
b1c6f8104fe7cb15d4409dc10a0a0a8782aa3147 | 2dc39c2212640e9f34eb6f6522c7a0fd9a5132e9 | /src/RcppExports.cpp | f6d89a697ba132fb94087133ef1b8b6912d584e6 | [] | no_license | vjcitn/smallcount | b5205609d82d14d8d0b1e24ee64aa7805744c73e | 1b4c2c27edeafce8b342a8713952a76f1e9d8767 | refs/heads/main | 2023-05-04T14:34:11.157801 | 2021-05-26T14:25:24 | 2021-05-26T14:25:24 | 365,404,967 | 0 | 0 | null | 2021-05-08T02:56:59 | 2021-05-08T02:56:59 | null | UTF-8 | C++ | false | false | 897 | cpp | // Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
#include <RcppArmadillo.h>
#include <Rcpp.h>
using namespace Rcpp;
// parse_sparse_csv_impl
List parse_sparse_csv_impl(SEXP fname);
RcppExport SEXP _smallcount_parse_sparse_csv_impl(SEXP fnameSEXP) {
BEGIN_RCPP
Rcpp::RObject rcpp_result_gen;
Rcpp::RNGScope rcpp_rngScope_gen;
Rcpp::traits::input_parameter< SEXP >::type fname(fnameSEXP);
rcpp_result_gen = Rcpp::wrap(parse_sparse_csv_impl(fname));
return rcpp_result_gen;
END_RCPP
}
static const R_CallMethodDef CallEntries[] = {
{"_smallcount_parse_sparse_csv_impl", (DL_FUNC) &_smallcount_parse_sparse_csv_impl, 1},
{NULL, NULL, 0}
};
RcppExport void R_init_smallcount(DllInfo *dll) {
R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
R_useDynamicSymbols(dll, FALSE);
}
| [
"stvjc@channing.harvard.edu"
] | stvjc@channing.harvard.edu |
c43b3d3106fb6f73a8b3080482c14a47880c4243 | 106cbc5b7f8716480e57c48ae2227d9091442c7e | /tensorflow/compiler/xla/python/outfeed_receiver_test.cc | 2fde02950dcfad7a5ec9bac46fa5d94951e80aa0 | [
"Apache-2.0",
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | litaohe/tensorflow | d381bbf95ba43c4fe7b81a6701b7413e715a4926 | 46020d9f356d17cb5e4390b98cd2dfaa09faae88 | refs/heads/master | 2022-08-17T04:39:38.561208 | 2022-07-22T03:42:42 | 2022-07-22T03:42:42 | 116,329,987 | 1 | 0 | Apache-2.0 | 2019-01-08T03:50:28 | 2018-01-05T02:18:39 | C++ | UTF-8 | C++ | false | false | 13,075 | cc | /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/python/outfeed_receiver.h"
#include <memory>
#include "absl/synchronization/mutex.h"
#include "tensorflow/compiler/xla/client/client_library.h"
#include "tensorflow/compiler/xla/client/executable_build_options.h"
#include "tensorflow/compiler/xla/client/xla_builder.h"
#include "tensorflow/compiler/xla/pjrt/cpu_device.h"
#include "tensorflow/compiler/xla/pjrt/pjrt_client.h"
#include "tensorflow/compiler/xla/pjrt/pjrt_stream_executor_client.h"
#include "tensorflow/compiler/xla/service/platform_util.h"
#include "tensorflow/compiler/xla/test.h"
namespace xla {
namespace {
Status CompileAndExecute(XlaBuilder* builder, XlaOp root, int device_id,
PjRtClient* client) {
XlaComputation computation = builder->Build(root).ValueOrDie();
CompileOptions compile_options;
compile_options.executable_build_options.set_num_replicas(1);
compile_options.executable_build_options.set_num_partitions(1);
DeviceAssignment device_assignment(1, 1);
device_assignment(0, 0) = device_id;
compile_options.executable_build_options.set_device_assignment(
device_assignment);
TF_ASSIGN_OR_RETURN(std::unique_ptr<PjRtExecutable> executable,
client->Compile(computation, std::move(compile_options)));
ExecuteOptions execute_options;
TF_ASSIGN_OR_RETURN(
std::vector<std::vector<std::unique_ptr<PjRtBuffer>>> output_buffers,
executable->Execute({{}}, execute_options));
return OkStatus();
}
// Accumulates the received data.
class Accumulator {
public:
struct Data {
uint32_t consumer_id;
std::shared_ptr<Literal> data;
};
void Receive(uint32_t consumer_id, std::shared_ptr<Literal> data) {
absl::MutexLock lock(&mutex_);
received_.push_back(Data{consumer_id, data});
}
std::vector<Data> received() {
absl::MutexLock lock(&mutex_);
return received_;
}
private:
absl::Mutex mutex_;
std::vector<Data> received_ ABSL_GUARDED_BY(mutex_);
};
StatusOr<std::unique_ptr<PjRtClient>> GetCpuClientWithNonLocalDevice() {
TF_ASSIGN_OR_RETURN(se::Platform * platform,
PlatformUtil::GetPlatform("Host"));
if (platform->VisibleDeviceCount() <= 0) {
return FailedPrecondition("CPU platform has no visible devices.");
}
LocalClientOptions options;
options.set_platform(platform);
TF_ASSIGN_OR_RETURN(LocalClient * client,
ClientLibrary::GetOrCreateLocalClient(options));
se::StreamExecutorConfig config(0);
TF_ASSIGN_OR_RETURN(se::StreamExecutor * executor,
platform->GetExecutor(config));
auto device_state = std::make_unique<LocalDeviceState>(
executor, client, LocalDeviceState::kSynchronous,
/*max_inflight_computations=*/32,
/*allow_event_reuse=*/false, /*use_callback_stream=*/false);
std::vector<std::unique_ptr<PjRtStreamExecutorDevice>> devices;
devices.push_back(std::make_unique<CpuDevice>(0, std::move(device_state)));
devices.push_back(std::make_unique<CpuDevice>(1, nullptr));
return std::unique_ptr<PjRtClient>(std::make_unique<PjRtStreamExecutorClient>(
CpuName(), client, std::move(devices), /*process_index=*/0,
/*allocator=*/nullptr, /*host_memory_allocator=*/nullptr,
/*should_stage_host_to_device_transfers=*/false,
/*gpu_run_options=*/nullptr));
}
TEST(OutfeedReceiverTest, ReceiveOutfeedSimple) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClient(true));
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder("execute_test_outfeed");
constexpr int consumer_id0 = 5;
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data = Iota(&builder, shape0, 0);
XlaOp send = outfeed_receiver
->AddOutfeedToBuilder(&builder, CreateToken(&builder),
consumer_id0, {data})
.ValueOrDie();
EXPECT_TRUE(CompileAndExecute(&builder, send, 0, cpu_client.get()).ok());
// Shutdown the receiver, to force it to wait to deliver the callbacks.
outfeed_receiver = nullptr;
std::vector<Accumulator::Data> received = receiver->received();
EXPECT_EQ(1, received.size());
EXPECT_EQ(consumer_id0, received[0].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape0}), received[0].data->shape());
}
TEST(OutfeedReceiverTest, ReceiveOutfeedTwoComputations) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClient(true));
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder0("execute_test_outfeed_0");
constexpr int consumer_id0 = 5;
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data0 = Iota(&builder0, shape0, 0);
XlaOp send0 = outfeed_receiver
->AddOutfeedToBuilder(&builder0, CreateToken(&builder0),
consumer_id0, {data0})
.ValueOrDie();
EXPECT_TRUE(CompileAndExecute(&builder0, send0, 0, cpu_client.get()).ok());
XlaBuilder builder1("execute_test_outfeed_1");
constexpr int consumer_id1 = 6;
const Shape shape1 = ShapeUtil::MakeShape(U32, {128});
XlaOp data1 = Iota(&builder1, shape1, 0);
XlaOp send1 = outfeed_receiver
->AddOutfeedToBuilder(&builder1, CreateToken(&builder1),
consumer_id1, {data1})
.ValueOrDie();
EXPECT_TRUE(CompileAndExecute(&builder1, send1, 0, cpu_client.get()).ok());
// Shutdown the receiver, to force it to wait to deliver the callbacks.
outfeed_receiver = nullptr;
std::vector<Accumulator::Data> received = receiver->received();
EXPECT_EQ(2, received.size());
EXPECT_EQ(consumer_id0, received[0].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape0}), received[0].data->shape());
EXPECT_EQ(consumer_id1, received[1].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape1}), received[1].data->shape());
}
TEST(OutfeedReceiverTest, ReceiveOutfeedTwoOutfeed) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClient(true));
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder("execute_test_outfeed");
constexpr int consumer_id0 = 5;
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data0 = Iota(&builder, shape0, 0);
XlaOp send0 = outfeed_receiver
->AddOutfeedToBuilder(&builder, CreateToken(&builder),
consumer_id0, {data0})
.ValueOrDie();
constexpr int consumer_id1 = 6;
const Shape shape1 = ShapeUtil::MakeShape(U32, {128});
XlaOp data1 = Iota(&builder, shape1, 0);
XlaOp send1 =
outfeed_receiver
->AddOutfeedToBuilder(&builder, send0, consumer_id1, {data1})
.ValueOrDie();
EXPECT_TRUE(CompileAndExecute(&builder, send1, 0, cpu_client.get()).ok());
// Shutdown the receiver, to force it to wait to deliver the callbacks.
outfeed_receiver = nullptr;
std::vector<Accumulator::Data> received = receiver->received();
EXPECT_EQ(2, received.size());
EXPECT_EQ(consumer_id0, received[0].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape0}), received[0].data->shape());
EXPECT_EQ(consumer_id1, received[1].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape1}), received[1].data->shape());
}
TEST(OutfeedReceiverTest, DifferentShapeForConsumerIdError) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClient(true));
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder("execute_test_outfeed");
constexpr int consumer_id0 = 5;
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data0 = Iota(&builder, shape0, 0);
XlaOp send0 = outfeed_receiver
->AddOutfeedToBuilder(&builder, CreateToken(&builder),
consumer_id0, {data0})
.ValueOrDie();
const Shape shape1 = ShapeUtil::MakeShape(U32, {128});
XlaOp data1 = Iota(&builder, shape1, 0);
// A different shape for the same consumer ID.
StatusOr<XlaOp> send1 = outfeed_receiver->AddOutfeedToBuilder(
&builder, send0, consumer_id0, {data1});
EXPECT_FALSE(send1.ok());
EXPECT_THAT(send1.status().ToString(),
testing::HasSubstr("does not match previous shape element_type"));
}
TEST(OutfeedReceiverTest, InvalidConsumerIdError) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClient(true));
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder("execute_test_outfeed");
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data0 = Iota(&builder, shape0, 0);
StatusOr<XlaOp> send0 = outfeed_receiver->AddOutfeedToBuilder(
&builder, CreateToken(&builder), 0, {data0});
EXPECT_FALSE(send0.ok());
EXPECT_THAT(send0.status().ToString(),
testing::HasSubstr("Consumer ID cannot be a reserved value"));
}
TEST(OutfeedReceiverTest, NonLocalDevicesIgnored) {
TF_ASSERT_OK_AND_ASSIGN(std::shared_ptr<PjRtClient> cpu_client,
GetCpuClientWithNonLocalDevice());
std::vector<PjRtClient*> clients{cpu_client.get()};
auto receiver = std::make_unique<Accumulator>();
OutfeedReceiver::Callback callback =
[&receiver](PjRtDevice* device, uint32_t consumer_id,
std::shared_ptr<Literal> data) {
receiver->Receive(consumer_id, data);
};
auto outfeed_receiver =
std::make_shared<OutfeedReceiver>(callback, clients, 128);
outfeed_receiver->Start();
XlaBuilder builder("execute_test_outfeed");
constexpr int consumer_id0 = 5;
const Shape shape0 = ShapeUtil::MakeShape(U32, {16});
XlaOp data = Iota(&builder, shape0, 0);
XlaOp send = outfeed_receiver
->AddOutfeedToBuilder(&builder, CreateToken(&builder),
consumer_id0, {data})
.ValueOrDie();
EXPECT_TRUE(CompileAndExecute(&builder, send, 0, cpu_client.get()).ok());
// Shutdown the receiver, to force it to wait to deliver the callbacks.
outfeed_receiver = nullptr;
std::vector<Accumulator::Data> received = receiver->received();
EXPECT_EQ(1, received.size());
EXPECT_EQ(consumer_id0, received[0].consumer_id);
EXPECT_EQ(ShapeUtil::MakeTupleShape({shape0}), received[0].data->shape());
}
} // namespace
} // namespace xla
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
6903197bb368ae5e96750ef2709c1a1c33ecc899 | 543d9580b9c69f20cfb58c6ba7865e0362308a2a | /703A.cpp | 047be887fb0608b8c3e4351aa8a6b8cc1bd7e32a | [] | no_license | rikvdk/codeforces | d387513cc20654b78b229a3129b65cd19026a0e6 | b5ecd2f9a81ca4bac7bf0442d483f07494eb716b | refs/heads/master | 2022-12-11T11:55:32.368980 | 2020-09-19T20:07:33 | 2020-09-19T20:07:33 | 252,754,772 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 353 | cpp | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main()
{
int n, c, m, r=0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> m >> c;
r += m > c;
r -= c > m;
}
if(r == 0) cout << "Friendship is magic!^^\n";
else if(r > 0) cout << "Mishka\n";
else cout << "Chris\n";
}
| [
"rikvanderkooij@gmail.com"
] | rikvanderkooij@gmail.com |
93d6f43af9a8adf4d0497885f7beedfdd635ec29 | ab2da9b6efd12c3694b6730f6460870da879bcc7 | /Save/VirtualMachine/GB.h | 26c67862758a9401f0e8228ba0565a6c6130be24 | [] | no_license | tetradog/Gabriel.Cat.3DS | 751c72328a2638732a6a7dd1b566f280f03d6e3c | be594b6d1da1d569598fda3dc136a917c41c479d | refs/heads/master | 2020-05-24T18:57:33.400669 | 2019-12-03T02:15:38 | 2019-12-03T02:15:38 | 187,422,040 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 78 | h | #include "SaveData.h"
class GB:public SaveData{
public:
const u8 TYPE=0;
} | [
"tetradog@gmail.com"
] | tetradog@gmail.com |
b4142dd8ad889c31a9c5474c5d2b605d1196e1b3 | b538ad8b58864b4d206ed07a00dc9c37c482d280 | /Module06/ex02/includes/B.h | 1c9e49fbd8a18723ac68eb7f9399279c341e96d1 | [] | no_license | aberry-21/CPP_Module | 0083035a4bc7be7cf83035738458660c23a2389c | 42f08b10e6ebada9d0034464a0bed9a8a2dfada6 | refs/heads/main | 2023-04-21T21:37:51.882909 | 2021-04-29T17:30:32 | 2021-04-29T17:30:32 | 357,558,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 113 | h | //
// Created by Aaron Berry on 4/28/21.
//
#pragma once
#include "includes/Base.h"
class B : public Base {};
| [
"lot.lebedevok@gmail.com"
] | lot.lebedevok@gmail.com |
4b531715a799d3e4a0aee5ab069434153eb94562 | 425fedcd4b2fbbb58103f5be412707de4ba4191f | /src/Log.hpp | 76129edeb1b08768759b43842c32894776c36239 | [
"MIT"
] | permissive | matheuscscp/metallicar | 754146bc1210af751ba31eff18bc88172465691f | 6508735a7f3ce526637622834fdb95f6d6297687 | refs/heads/master | 2020-12-24T14:57:10.003946 | 2017-02-21T04:51:51 | 2017-02-21T04:51:51 | 21,802,332 | 0 | 0 | null | 2014-08-23T05:26:39 | 2014-07-13T23:59:12 | C | UTF-8 | C++ | false | false | 349 | hpp | /*
* Log.hpp
*
* Created on: Jul 14, 2014
* Author: Pimenta
*/
#ifndef LOG_HPP_
#define LOG_HPP_
// standard
#include <string>
class Log {
public:
enum MessageLevel {
Error = 0,
Warning
};
static void message(MessageLevel level, const std::string& msg);
};
#endif /* LOG_HPP_ */
| [
"matheuscscp@gmail.com"
] | matheuscscp@gmail.com |
a48d04557ec20ab9de184f8476eaccef3c7b0866 | 7cea56866439e07b62b98a1fbe0922d8a3cd05ee | /RTC1302_DigitalClock/RTC1302_DigitalClock.ino | 10312ce037d6bdc0c2d704ef15cb4208c51e7e0a | [] | no_license | tlelson/arduino-demos | 2706288b6dab934cf8e7c10bf64b9b4e3ff3997a | 1d4b1703b0e24adbfe7dda18e4819ef47478078a | refs/heads/main | 2023-05-31T03:24:40.481482 | 2021-06-06T22:34:56 | 2021-06-06T22:34:56 | 374,061,754 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 966 | ino | /*
https://github.com/chrisfryer78/ArduinoRTClibrary
*/
#include <virtuabotixRTC.h>
// Creation of the Real Time Clock Object
virtuabotixRTC myRTC(6, 7, 8);
void setup() {
Serial.begin(9600);
// Set the current date, and time in the following format:
// seconds, minutes, hours, day of the week, day of the month, month, year
//myRTC.setDS1302Time(00, 23, 18, 6, 5, 6, 2021);
}
void loop() {
// This allows for the update of variables for time or accessing the individual elements.
myRTC.updateTime();
// Start printing elements as individuals
Serial.print("Current Date / Time: ");
Serial.print(myRTC.dayofmonth);
Serial.print("/");
Serial.print(myRTC.month);
Serial.print("/");
Serial.print(myRTC.year);
Serial.print(" ");
Serial.print(myRTC.hours);
Serial.print(":");
Serial.print(myRTC.minutes);
Serial.print(":");
Serial.println(myRTC.seconds);
// Delay so the program doesn't print non-stop
delay(4000);
}
| [
"tpj800@gmail.com"
] | tpj800@gmail.com |
ac8528423fac15cf7ccff00e1d6278398384a053 | c9137a6352f8c288915d3c9b21b99f935b86086a | /MKShare/MKShare/Debug/rcc/qrc_MKShare.cpp | 84a3514b7e13ca74b49f1f8a8db466703f9f7dcb | [] | no_license | soheul/MKShare | c2cde35e2a337bd2fe086fe573303495c31e5109 | 2b3c1b1c18ec4388fac3c6bb6619c1892d689c51 | refs/heads/master | 2020-09-13T09:11:00.412022 | 2019-11-28T13:00:58 | 2019-11-28T13:00:58 | 222,721,188 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,350 | cpp | /****************************************************************************
** Resource object code
**
** Created by: The Resource Compiler for Qt version 5.9.8
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#ifdef QT_NAMESPACE
# define QT_RCC_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
# define QT_RCC_MANGLE_NAMESPACE0(x) x
# define QT_RCC_MANGLE_NAMESPACE1(a, b) a##_##b
# define QT_RCC_MANGLE_NAMESPACE2(a, b) QT_RCC_MANGLE_NAMESPACE1(a,b)
# define QT_RCC_MANGLE_NAMESPACE(name) QT_RCC_MANGLE_NAMESPACE2( \
QT_RCC_MANGLE_NAMESPACE0(name), QT_RCC_MANGLE_NAMESPACE0(QT_NAMESPACE))
#else
# define QT_RCC_PREPEND_NAMESPACE(name) name
# define QT_RCC_MANGLE_NAMESPACE(name) name
#endif
#ifdef QT_NAMESPACE
namespace QT_NAMESPACE {
#endif
#ifdef QT_NAMESPACE
}
#endif
int QT_RCC_MANGLE_NAMESPACE(qInitResources_MKShare)();
int QT_RCC_MANGLE_NAMESPACE(qInitResources_MKShare)()
{
return 1;
}
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_MKShare)();
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_MKShare)()
{
return 1;
}
namespace {
struct initializer {
initializer() { QT_RCC_MANGLE_NAMESPACE(qInitResources_MKShare)(); }
~initializer() { QT_RCC_MANGLE_NAMESPACE(qCleanupResources_MKShare)(); }
} dummy;
}
| [
"parkpro6954@gmail.com"
] | parkpro6954@gmail.com |
c28a847c62e28d11cb6f2389a7a8b8e50c371ff0 | 8e9f3ee2725fd9aadcfa9a64f7a14b36a1d71cf3 | /include/hashtable.h | 6e7f4ead505c4e18a3005c87668cd6eb13b8038b | [] | no_license | krafczyk/AMS | 22ee800171a573ce824284aea096385dc5066d3e | 69da68c0482c80289adfa5b1162a1dce3aa53392 | refs/heads/master | 2020-06-01T09:31:14.378220 | 2015-06-19T14:39:22 | 2015-06-19T14:39:22 | 22,605,281 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,229 | h | //Author P. Zuccon -- MIT
//
#ifndef hashtable_h
#define hashtable_h
#include <map>
template <typename T> class hashtable{
public:
typedef unsigned long ulong;
typedef typename std::map<ulong,T>::pointer pointer;
typedef typename std::map<ulong,T>::const_pointer const_pointer;
typedef typename std::map<ulong,T>::reference reference;
typedef typename std::map<ulong,T>::const_reference const_reference;
typedef typename std::map<ulong,T>::iterator iterator;
typedef typename std::map<ulong,T>::const_iterator const_iterator;
typedef typename std::map<ulong,T>::size_type size_type;
typedef typename std::map<ulong,T>::difference_type difference_type;
typedef typename std::map<ulong,T>::reverse_iterator reverse_iterator;
typedef typename std::map<ulong,T>::const_reverse_iterator const_reverse_iterator;
private:
std::map<ulong, T> hmap;
ulong hmaphash(const char *str)
{
ulong hash = 5381;
int c;
while ((c = *str++))
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
return hash;
}
public:
hashtable(){}
virtual ~hashtable(){hmap.clear();}
iterator begin () {return hmap.begin();}
const_iterator begin () const {return hmap.begin();}
iterator end (){return hmap.end();}
const_iterator end () const {return hmap.end();}
reverse_iterator rbegin() {return hmap.rbegin();}
const_reverse_iterator rbegin() const {return hmap.rbegin();}
reverse_iterator rend() {return hmap.rend();}
const_reverse_iterator rend() const {return hmap.rend();}
bool empty ( ) const {return hmap.size()==0;}
size_type size() const {return hmap.size();}
size_type max_size() const {return hmap.max_size();}
T& operator[] ( const char * str ){
ulong ll=hmaphash(str);
return hmap[ll];
}
void Add ( const char * str,const T& aa ){
ulong ll=hmaphash(str);
hmap[ll]=aa;
return;
}
size_type erase ( const char* str ){
return hmap.erase( hmaphash(str));
}
void clear ( ){hmap.clear();}
int find ( const char* str, const_iterator& aa){
ulong ll=hmaphash(str);
aa=hmap.find(ll);
if(aa==hmap.end()) return 0;
return 1;
}
};
#endif
| [
"pzuccon"
] | pzuccon |
295344f1804600ab2a50e944dd8f474e75a1981c | 7ca0e4253d9d8769d87ed681507d8e3c1997b71f | /contracts/multi_index_test/multi_index_test.cpp | 48bc9f654707163aaeff2f6f3df2fb84155b2382 | [
"MIT"
] | permissive | ETAIO/ETAChain | 1080261250515f69f4ff511e84d5da163d85174b | cdf2427f5b955ba2cde9b3978cf1f268053306ef | refs/heads/master | 2020-03-27T13:30:31.566701 | 2018-08-29T15:24:20 | 2018-08-29T15:24:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,685 | cpp | #include <ETAiolib/ETAio.hpp>
#include <ETAiolib/dispatcher.hpp>
#include <ETAiolib/multi_index.hpp>
using namespace ETAio;
namespace multi_index_test {
struct limit_order {
uint64_t id;
uint64_t padding = 0;
uint128_t price;
uint64_t expiration;
account_name owner;
auto primary_key()const { return id; }
uint64_t get_expiration()const { return expiration; }
uint128_t get_price()const { return price; }
ETALIB_SERIALIZE( limit_order, (id)(price)(expiration)(owner) )
};
struct test_k256 {
uint64_t id;
key256 val;
auto primary_key()const { return id; }
key256 get_val()const { return val; }
ETALIB_SERIALIZE( test_k256, (id)(val) )
};
class multi_index_test {
public:
ACTION(N(multitest), trigger) {
trigger(): what(0) {}
trigger(uint32_t w): what(w) {}
uint32_t what;
ETALIB_SERIALIZE(trigger, (what))
};
static void on(const trigger& act)
{
auto payer = act.get_account();
print("Acting on trigger action.\n");
switch(act.what)
{
case 0:
{
print("Testing uint128_t secondary index.\n");
ETAio::multi_index<N(orders), limit_order,
indexed_by< N(byexp), const_mem_fun<limit_order, uint64_t, &limit_order::get_expiration> >,
indexed_by< N(byprice), const_mem_fun<limit_order, uint128_t, &limit_order::get_price> >
> orders( N(multitest), N(multitest) );
orders.emplace( payer, [&]( auto& o ) {
o.id = 1;
o.expiration = 300;
o.owner = N(dan);
});
auto order2 = orders.emplace( payer, [&]( auto& o ) {
o.id = 2;
o.expiration = 200;
o.owner = N(alice);
});
print("Items sorted by primary key:\n");
for( const auto& item : orders ) {
print(" ID=", item.id, ", expiration=", item.expiration, ", owner=", name{item.owner}, "\n");
}
auto expidx = orders.get_index<N(byexp)>();
print("Items sorted by expiration:\n");
for( const auto& item : expidx ) {
print(" ID=", item.id, ", expiration=", item.expiration, ", owner=", name{item.owner}, "\n");
}
print("Modifying expiration of order with ID=2 to 400.\n");
orders.modify( order2, payer, [&]( auto& o ) {
o.expiration = 400;
});
print("Items sorted by expiration:\n");
for( const auto& item : expidx ) {
print(" ID=", item.id, ", expiration=", item.expiration, ", owner=", name{item.owner}, "\n");
}
auto lower = expidx.lower_bound(100);
print("First order with an expiration of at least 100 has ID=", lower->id, " and expiration=", lower->get_expiration(), "\n");
}
break;
case 1: // Test key265 secondary index
{
print("Testing key256 secondary index.\n");
ETAio::multi_index<N(test1), test_k256,
indexed_by< N(byval), const_mem_fun<test_k256, key256, &test_k256::get_val> >
> testtable( N(multitest), N(exchange) ); // Code must be same as the receiver? Scope doesn't have to be.
testtable.emplace( payer, [&]( auto& o ) {
o.id = 1;
o.val = key256::make_from_word_sequence<uint64_t>(0ULL, 0ULL, 0ULL, 42ULL);
});
testtable.emplace( payer, [&]( auto& o ) {
o.id = 2;
o.val = key256::make_from_word_sequence<uint64_t>(1ULL, 2ULL, 3ULL, 4ULL);
});
testtable.emplace( payer, [&]( auto& o ) {
o.id = 3;
o.val = key256::make_from_word_sequence<uint64_t>(0ULL, 0ULL, 0ULL, 42ULL);
});
auto itr = testtable.find( 2 );
print("Items sorted by primary key:\n");
for( const auto& item : testtable ) {
print(" ID=", item.primary_key(), ", val=", item.val, "\n");
}
auto validx = testtable.get_index<N(byval)>();
auto lower1 = validx.lower_bound(key256::make_from_word_sequence<uint64_t>(0ULL, 0ULL, 0ULL, 40ULL));
print("First entry with a val of at least 40 has ID=", lower1->id, ".\n");
auto lower2 = validx.lower_bound(key256::make_from_word_sequence<uint64_t>(0ULL, 0ULL, 0ULL, 50ULL));
print("First entry with a val of at least 50 has ID=", lower2->id, ".\n");
if( testtable.iterator_to(*lower2) == itr ) {
print("Previously found entry is the same as the one found earlier with a primary key value of 2.\n");
}
print("Items sorted by val (secondary key):\n");
for( const auto& item : validx ) {
print(" ID=", item.primary_key(), ", val=", item.val, "\n");
}
auto upper = validx.upper_bound(key256::make_from_word_sequence<uint64_t>(0ULL, 0ULL, 0ULL, 42ULL));
print("First entry with a val greater than 42 has ID=", upper->id, ".\n");
print("Removed entry with ID=", lower1->id, ".\n");
validx.erase( lower1 );
print("Items sorted by primary key:\n");
for( const auto& item : testtable ) {
print(" ID=", item.primary_key(), ", val=", item.val, "\n");
}
}
break;
default:
ETAio_assert(0, "Given what code is not supported.");
break;
}
}
};
} /// multi_index_test
namespace multi_index_test {
extern "C" {
/// The apply method implements the dispatch of events to this contract
void apply( uint64_t /* receiver */, uint64_t code, uint64_t action ) {
require_auth(code);
ETAio_assert(ETAio::dispatch<multi_index_test, multi_index_test::trigger>(code, action),
"Could not dispatch");
}
}
}
| [
"etachain@sina.com"
] | etachain@sina.com |
fb990b8170a67097f64ee7d3d0bf3b5efa2aa206 | ec8e541701ce422836ca97bd6d85a111fd030fea | /dq_project/Timer.h | 95e2ee1993ff66fb316697106c8bd21c1305d282 | [] | no_license | dimalit/dialog-quest | 0dff481532fa31efb1091651324eb8801dec7bf7 | 38eed0bdd0523eef0c91740fc0b1870a18796f6a | refs/heads/master | 2021-01-13T00:15:16.646231 | 2014-05-10T11:55:25 | 2014-05-10T11:55:25 | 36,687,987 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,821 | h | #pragma once
#include "Entity/Component.h"
#include <iostream>
#include <boost/signal.hpp>
template<class Callee>
class Timer: public EntityComponent
{
public:
Timer(Callee c, float dt = - 1.0f); // default = -1 - don't start
virtual void OnUpdate(VariantList *params);
void start(){ // default - start immediately
return restart(0.0f);
}
void start(float dt){
return restart(dt);
}
void restart(float dt); // default - restart previous interval
void restart(){
restart(-1.0);
}
void cancel(){
running = false;
}
void setCallback(Callee arg){sig.disconntect_all_slots(); sig.connect(arg);}
protected:
float elapsed;
float interval; // if <0 - not started
bool running;
private:
boost::signal<void ()> sig;
float start_time;
};
template<class Callee>
Timer<Callee>::Timer(Callee c, float dt)
{
elapsed = 0.0f;
interval = dt;
start_time = GetBaseApp()->GetTickTimingSystem(TIMER_GAME)/1000.0f;
running = false;
sig.connect(c);
if(interval >= 0.0f)
start(interval);
// TODO Maybe attach ourselves to some Entity rather than to root? This can disable timer appropriately...
GetBaseApp()->m_sig_update.connect(1, boost::bind(&Timer<Callee>::OnUpdate, this, _1));
}
template<class Callee>
void Timer<Callee>::OnUpdate(VariantList *params){
// PROFILE_FUNC();
// TODO if not running?!
elapsed = GetBaseApp()->GetTickTimingSystem(TIMER_GAME)/1000.0f - start_time;
if(running && elapsed >= interval){
running = false;
sig();
}
}
template<class Callee>
void Timer<Callee>::restart(float dt){
if(dt >= 0) interval = dt; // else use old interval
assert(interval >= 0.0f);
elapsed = 0.0f;
start_time = GetBaseApp()->GetTickTimingSystem(TIMER_GAME)/1000.0f;
running = true;
} | [
"dim2lit@gmail.com"
] | dim2lit@gmail.com |
5e149fc23993f9f32b687f7975a66236a2e3a41a | 99e494d9ca83ebafdbe6fbebc554ab229edcbacc | /.history/Day 2/Practice/Answers/MinimumWasteCells_20210305182342.cpp | 1d6d6c0ed914d88dec6a5c697212f376fb78d7f9 | [] | no_license | Datta2901/CCC | c0364caa1e4937bc7bce68e4847c8d599aef0f59 | 4debb2c1c70df693d0e5f68b5798bd9c7a7ef3dc | refs/heads/master | 2023-04-19T10:05:12.372578 | 2021-04-23T12:50:08 | 2021-04-23T12:50:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 194 | cpp | #include<bits/stdc++.h>
using namespace std;
int main(){
string name;
getline(cin,name);
int size = name.size();
int n = sqrt(size);
cout << size << << endl;
return 0;
} | [
"manikanta2901@gmail.com"
] | manikanta2901@gmail.com |
a4c0014317950a13f19a4985583a380fbfd717a4 | c91c35950304b83a147f41f66e3794bf831eec2f | /onnxruntime/test/onnx/TestCaseResult.h | ce967facf1d0d422078871f1a61221bfa9c0af05 | [
"MIT"
] | permissive | nihui/onnxruntime | a62aa5d7c6dae02c6f45a3373457fc9be3e5e15b | 192dcfaa8ea4ad1b2258ae88a02f8dbc6c4b971c | refs/heads/master | 2020-09-08T16:29:19.810439 | 2019-11-12T08:48:31 | 2019-11-12T08:48:31 | 221,184,016 | 3 | 1 | MIT | 2019-11-12T09:52:19 | 2019-11-12T09:52:18 | null | UTF-8 | C++ | false | false | 1,494 | h | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#include <string>
#include <vector>
#include <core/platform/env_time.h>
#include <cstring>
//result of a single test run: 1 model with 1 test dataset
enum class EXECUTE_RESULT {
SUCCESS = 0,
UNKNOWN_ERROR = -1,
WITH_EXCEPTION = -2,
RESULT_DIFFERS = -3,
SHAPE_MISMATCH = -4,
TYPE_MISMATCH = -5,
NOT_SUPPORT = -6,
LOAD_MODEL_FAILED = -7,
INVALID_GRAPH = -8,
INVALID_ARGUMENT = -9,
MODEL_SHAPE_MISMATCH = -10,
MODEL_TYPE_MISMATCH = -11,
};
class TestCaseResult {
public:
TestCaseResult(size_t count, EXECUTE_RESULT result, const std::string& node_name1) : node_name(node_name1), excution_result_(count, result) {
::onnxruntime::SetTimeSpecToZero(&spent_time_);
}
void SetResult(size_t task_id, EXECUTE_RESULT r);
const std::vector<EXECUTE_RESULT>& GetExcutionResult() const {
return excution_result_;
}
//Time spent in Session::Run. It only make sense when SeqTestRunner was used
::onnxruntime::TIME_SPEC GetSpentTime() const {
return spent_time_;
}
//Time spent in Session::Run. It only make sense when SeqTestRunner was used
void SetSpentTime(const ::onnxruntime::TIME_SPEC& input) const {
memcpy((void*)&spent_time_, &input, sizeof(input));
}
//only valid for single node tests;
const std::string node_name;
private:
::onnxruntime::TIME_SPEC spent_time_;
std::vector<EXECUTE_RESULT> excution_result_;
};
| [
"prs@microsoft.com"
] | prs@microsoft.com |
3383e33012bcec0d0be22eecb8d77b541666cd53 | 19d0ce325216c56a0260edfb38ff8c328cb754f4 | /Export/android/release/obj/include/openfl/display/GraphicsStroke.h | 0db18b473ec68d844fdbda5cf33aa4caf2879ce4 | [] | no_license | HerbinCommando/TokyoTrail | 42fcb0569e5028c2e96b100ad20008304370c16e | 8737240e8782f5357f472dead574fb956243e48a | refs/heads/master | 2021-01-01T20:08:20.336935 | 2017-08-06T05:58:30 | 2017-08-06T05:58:30 | 98,772,096 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 2,824 | h | // Generated by Haxe 3.4.2
#ifndef INCLUDED_openfl_display_GraphicsStroke
#define INCLUDED_openfl_display_GraphicsStroke
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#ifndef INCLUDED_openfl_display_IGraphicsStroke
#include <openfl/display/IGraphicsStroke.h>
#endif
#ifndef INCLUDED_openfl_display_IGraphicsData
#include <openfl/display/IGraphicsData.h>
#endif
HX_DECLARE_CLASS2(openfl,display,GraphicsDataType)
HX_DECLARE_CLASS2(openfl,display,GraphicsStroke)
HX_DECLARE_CLASS2(openfl,display,IGraphicsData)
HX_DECLARE_CLASS2(openfl,display,IGraphicsFill)
HX_DECLARE_CLASS2(openfl,display,IGraphicsStroke)
namespace openfl{
namespace display{
class HXCPP_CLASS_ATTRIBUTES GraphicsStroke_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef GraphicsStroke_obj OBJ_;
GraphicsStroke_obj();
public:
enum { _hx_ClassId = 0x7fc28725 };
void __construct( ::Dynamic thickness,hx::Null< bool > __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float > __o_miterLimit,::Dynamic fill);
inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.display.GraphicsStroke")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,true,"openfl.display.GraphicsStroke"); }
static hx::ObjectPtr< GraphicsStroke_obj > __new( ::Dynamic thickness,hx::Null< bool > __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float > __o_miterLimit,::Dynamic fill);
static hx::ObjectPtr< GraphicsStroke_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic thickness,hx::Null< bool > __o_pixelHinting, ::Dynamic __o_scaleMode, ::Dynamic __o_caps, ::Dynamic __o_joints,hx::Null< Float > __o_miterLimit,::Dynamic fill);
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~GraphicsStroke_obj();
HX_DO_RTTI_ALL;
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
void __GetFields(Array< ::String> &outFields);
static void __register();
void __Mark(HX_MARK_PARAMS);
void __Visit(HX_VISIT_PARAMS);
bool _hx_isInstanceOf(int inClassId);
void *_hx_getInterface(int inHash);
::String __ToString() const { return HX_HCSTRING("GraphicsStroke","\x03","\xdf","\x55","\x0e"); }
::Dynamic caps;
::Dynamic fill;
::Dynamic joints;
Float miterLimit;
bool pixelHinting;
::Dynamic scaleMode;
Float thickness;
::openfl::display::GraphicsDataType _hx___graphicsDataType;
};
} // end namespace openfl
} // end namespace display
#endif /* INCLUDED_openfl_display_GraphicsStroke */
| [
"heath@wgcells.com"
] | heath@wgcells.com |
31bed406b67f9ad40a36fff089b30c893ee15130 | 782d956cd3b4b725f38cd54b559773a4470c55da | /霍纳.cpp | b3f66fafc15c9f66589167e98de3c1fe85e18445 | [] | no_license | chenzuhai/data-structure | e7fdad56c790dba111af6b37d262dc3bb61e3a58 | 24304ddf4a130b2c169926c5385cb24ae488c207 | refs/heads/master | 2020-09-13T22:56:00.692730 | 2019-11-20T12:18:18 | 2019-11-20T12:18:18 | 221,637,129 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 603 | cpp | #include <stdio.h>
long int
horner(int coefficient[], int n, int x) //coefficient[]为待求多项式的系数数组，n为数组大小，x为多项式中未知数x的具体值
{ //注意：coefficient[0]存放系数a0，coefficient[1]存放系数a1，以此类推…
int i;
long int result;
result = coefficient[n - 1];
for (i = 1; i <= n - 1; i++)
{
result = result * x + coefficient[n - 1 - i];
}
return result;
}
int
main(void)
{
long int p;
int a[4] = { 1, 2, 1,1 };
p = horner(a, 4, 1);
printf("polynomial 1x^3 + 1x^2 + 1x + 1 = %ld\n", p);
} | [
"56181238+chenzuhai@users.noreply.github.com"
] | 56181238+chenzuhai@users.noreply.github.com |
c02591a49c891e2d25e0f0e27d56897ee6f19301 | 23261a852e52eea52fde88c6eb927e7ccb9eb2c7 | /Model/Hexbattlefield/Hexagon.h | 3c83d6f4ea26d709056f8b24a046d568903f6c73 | [] | no_license | ankelesh/UnitsBasics | 7cc5b665abae8f1f2cd8d168d28b77018462d4d9 | bd166de5eb9e48a7163a69e358d1dd515b761216 | refs/heads/master | 2022-03-28T07:22:41.441372 | 2019-11-21T12:06:27 | 2019-11-21T12:06:27 | 198,302,109 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 1,199 | h | #pragma once
#include <QPolygon>
#include <Model/CubeCoords.h>
#include <vector>
/*
Этот файл содержит класс шестиугольника. Он важен для View, поэтому частично основан на Qt, но его можно легко перенести на обычные плюсы
*/
struct Hexagon
{
QPolygon polygonOfThis; // вектор из точек шестиугольника
QPoint center; // центр
int size; // радиус
Hexagon(const QPoint& center = QPoint(0,0), const int size = 2);
};
// эта неприметная функция рассчитывает точку на расстоянии size от точки center, при угле равном corner_num * 60 (-30 если заострённый треугольник)
// она очень активно используется в рисовании, поскольку сама задача "найти точку" используется очень часто
QPoint find_corner(const QPoint center, const int size,
const int corner_num, const bool pointy = true);
QPoint find_point_on(const QPoint center, const int distance, const double grades); | [
"ankeleshbnet@inbox.ru"
] | ankeleshbnet@inbox.ru |
6b2490cafaaa48c1f1e10a8a0eb0669a0ccf749d | 1f63dde39fcc5f8be29f2acb947c41f1b6f1683e | /Boss2D/addon/webrtc-jumpingyang001_for_boss/rtc_base/swap_queue_unittest.cc | fb38a5c927a1da64710c5dba64b8097c030bc565 | [
"BSD-3-Clause",
"LicenseRef-scancode-google-patent-license-webm",
"LicenseRef-scancode-google-patent-license-webrtc",
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | koobonil/Boss2D | 09ca948823e0df5a5a53b64a10033c4f3665483a | e5eb355b57228a701495f2660f137bd05628c202 | refs/heads/master | 2022-10-20T09:02:51.341143 | 2019-07-18T02:13:44 | 2019-07-18T02:13:44 | 105,999,368 | 7 | 2 | MIT | 2022-10-04T23:31:12 | 2017-10-06T11:57:07 | C++ | UTF-8 | C++ | false | false | 6,497 | cc | /*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include BOSS_WEBRTC_U_rtc_base__swap_queue_h //original-code:"rtc_base/swap_queue.h"
#include <vector>
#include "test/gtest.h"
namespace webrtc {
namespace {
// Test parameter for the basic sample based SwapQueue Tests.
const size_t kChunkSize = 3;
// Queue item verification function for the vector test.
bool LengthVerifierFunction(const std::vector<int>& v) {
return v.size() == kChunkSize;
}
// Queue item verifier for the vector test.
class LengthVerifierFunctor {
public:
explicit LengthVerifierFunctor(size_t length) : length_(length) {}
bool operator()(const std::vector<int>& v) const {
return v.size() == length_;
}
private:
size_t length_;
};
} // anonymous namespace
TEST(SwapQueueTest, BasicOperation) {
std::vector<int> i(kChunkSize, 0);
SwapQueue<std::vector<int>> queue(2, i);
EXPECT_TRUE(queue.Insert(&i));
EXPECT_EQ(i.size(), kChunkSize);
EXPECT_TRUE(queue.Insert(&i));
EXPECT_EQ(i.size(), kChunkSize);
EXPECT_TRUE(queue.Remove(&i));
EXPECT_EQ(i.size(), kChunkSize);
EXPECT_TRUE(queue.Remove(&i));
EXPECT_EQ(i.size(), kChunkSize);
}
TEST(SwapQueueTest, FullQueue) {
SwapQueue<int> queue(2);
// Fill the queue.
int i = 0;
EXPECT_TRUE(queue.Insert(&i));
i = 1;
EXPECT_TRUE(queue.Insert(&i));
// Ensure that the value is not swapped when doing an Insert
// on a full queue.
i = 2;
EXPECT_FALSE(queue.Insert(&i));
EXPECT_EQ(i, 2);
// Ensure that the Insert didn't overwrite anything in the queue.
EXPECT_TRUE(queue.Remove(&i));
EXPECT_EQ(i, 0);
EXPECT_TRUE(queue.Remove(&i));
EXPECT_EQ(i, 1);
}
TEST(SwapQueueTest, EmptyQueue) {
SwapQueue<int> queue(2);
int i = 0;
EXPECT_FALSE(queue.Remove(&i));
EXPECT_TRUE(queue.Insert(&i));
EXPECT_TRUE(queue.Remove(&i));
EXPECT_FALSE(queue.Remove(&i));
}
TEST(SwapQueueTest, Clear) {
SwapQueue<int> queue(2);
int i = 0;
// Fill the queue.
EXPECT_TRUE(queue.Insert(&i));
EXPECT_TRUE(queue.Insert(&i));
// Ensure full queue.
EXPECT_FALSE(queue.Insert(&i));
// Empty the queue.
queue.Clear();
// Ensure that the queue is empty
EXPECT_FALSE(queue.Remove(&i));
// Ensure that the queue is no longer full.
EXPECT_TRUE(queue.Insert(&i));
}
TEST(SwapQueueTest, SuccessfulItemVerifyFunction) {
std::vector<int> template_element(kChunkSize);
SwapQueue<std::vector<int>,
SwapQueueItemVerifier<std::vector<int>, LengthVerifierFunction>>
queue(2, template_element);
std::vector<int> valid_chunk(kChunkSize, 0);
EXPECT_TRUE(queue.Insert(&valid_chunk));
EXPECT_EQ(valid_chunk.size(), kChunkSize);
EXPECT_TRUE(queue.Remove(&valid_chunk));
EXPECT_EQ(valid_chunk.size(), kChunkSize);
}
TEST(SwapQueueTest, SuccessfulItemVerifyFunctor) {
std::vector<int> template_element(kChunkSize);
LengthVerifierFunctor verifier(kChunkSize);
SwapQueue<std::vector<int>, LengthVerifierFunctor> queue(2, template_element,
verifier);
std::vector<int> valid_chunk(kChunkSize, 0);
EXPECT_TRUE(queue.Insert(&valid_chunk));
EXPECT_EQ(valid_chunk.size(), kChunkSize);
EXPECT_TRUE(queue.Remove(&valid_chunk));
EXPECT_EQ(valid_chunk.size(), kChunkSize);
}
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
TEST(SwapQueueTest, UnsuccessfulItemVerifyFunctor) {
// Queue item verifier for the test.
auto minus_2_verifier = [](const int& i) { return i > -2; };
SwapQueue<int, decltype(minus_2_verifier)> queue(2, minus_2_verifier);
int valid_value = 1;
int invalid_value = -4;
EXPECT_TRUE(queue.Insert(&valid_value));
EXPECT_TRUE(queue.Remove(&valid_value));
bool result;
EXPECT_DEATH(result = queue.Insert(&invalid_value), "");
}
TEST(SwapQueueTest, UnSuccessfulItemVerifyInsert) {
std::vector<int> template_element(kChunkSize);
SwapQueue<std::vector<int>,
SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
queue(2, template_element);
std::vector<int> invalid_chunk(kChunkSize - 1, 0);
bool result;
EXPECT_DEATH(result = queue.Insert(&invalid_chunk), "");
}
TEST(SwapQueueTest, UnSuccessfulItemVerifyRemove) {
std::vector<int> template_element(kChunkSize);
SwapQueue<std::vector<int>,
SwapQueueItemVerifier<std::vector<int>, &LengthVerifierFunction>>
queue(2, template_element);
std::vector<int> invalid_chunk(kChunkSize - 1, 0);
std::vector<int> valid_chunk(kChunkSize, 0);
EXPECT_TRUE(queue.Insert(&valid_chunk));
EXPECT_EQ(valid_chunk.size(), kChunkSize);
bool result;
EXPECT_DEATH(result = queue.Remove(&invalid_chunk), "");
}
#endif
TEST(SwapQueueTest, VectorContentTest) {
const size_t kQueueSize = 10;
const size_t kFrameLength = 160;
const size_t kDataLength = kQueueSize * kFrameLength;
std::vector<int16_t> buffer_reader(kFrameLength, 0);
std::vector<int16_t> buffer_writer(kFrameLength, 0);
SwapQueue<std::vector<int16_t>> queue(kQueueSize,
std::vector<int16_t>(kFrameLength));
std::vector<int16_t> samples(kDataLength);
for (size_t k = 0; k < kDataLength; k++) {
samples[k] = k % 9;
}
for (size_t k = 0; k < kQueueSize; k++) {
buffer_writer.clear();
buffer_writer.insert(buffer_writer.end(), &samples[0] + k * kFrameLength,
&samples[0] + (k + 1) * kFrameLength);
EXPECT_TRUE(queue.Insert(&buffer_writer));
}
for (size_t k = 0; k < kQueueSize; k++) {
EXPECT_TRUE(queue.Remove(&buffer_reader));
for (size_t j = 0; j < buffer_reader.size(); j++) {
EXPECT_EQ(buffer_reader[j], samples[k * kFrameLength + j]);
}
}
}
TEST(SwapQueueTest, ZeroSlotQueue) {
SwapQueue<int> queue(0);
int i = 42;
EXPECT_FALSE(queue.Insert(&i));
EXPECT_FALSE(queue.Remove(&i));
EXPECT_EQ(i, 42);
}
TEST(SwapQueueTest, OneSlotQueue) {
SwapQueue<int> queue(1);
int i = 42;
EXPECT_TRUE(queue.Insert(&i));
i = 43;
EXPECT_FALSE(queue.Insert(&i));
EXPECT_EQ(i, 43);
EXPECT_TRUE(queue.Remove(&i));
EXPECT_EQ(i, 42);
EXPECT_FALSE(queue.Remove(&i));
}
} // namespace webrtc
| [
"slacealic@nate.com"
] | slacealic@nate.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.