blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 905
values | visit_date
timestamp[us]date 2015-08-09 11:21:18
2023-09-06 10:45:07
| revision_date
timestamp[us]date 1997-09-14 05:04:47
2023-09-17 19:19:19
| committer_date
timestamp[us]date 1997-09-14 05:04:47
2023-09-06 06:22:19
| github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 22
values | gha_event_created_at
timestamp[us]date 2012-06-07 00:51:45
2023-09-14 21:58:39
⌀ | gha_created_at
timestamp[us]date 2008-03-27 23:40:48
2023-08-21 23:17:38
⌀ | gha_language
stringclasses 141
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 115
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
2a8dbed6dc79310d1ef09dd3d496c60084ba3580 | 6701eae4550c7cd3d8703565c7be3a5e26248676 | /src/qt/transactionview.cpp | 9f35effafd14d73cd59bd7b57f10d3cf566fb181 | [
"MIT"
] | permissive | stochastic-thread/bootstrapping-ellocash | 91de56a330090c004af31d861e6d4cfb8d8b9e36 | 9495f1e3741c7f893457e4f6602d6ef0d84b7b3d | refs/heads/master | 2021-09-05T05:00:19.403780 | 2018-01-24T08:09:44 | 2018-01-24T08:09:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,485 | cpp | // Copyright (c) 2011-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "transactionview.h"
#include "addresstablemodel.h"
#include "ellocashunits.h"
#include "csvmodelwriter.h"
#include "editaddressdialog.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include "platformstyle.h"
#include "sendcoinsdialog.h"
#include "transactiondescdialog.h"
#include "transactionfilterproxy.h"
#include "transactionrecord.h"
#include "transactiontablemodel.h"
#include "walletmodel.h"
#include "ui_interface.h"
#include <QComboBox>
#include <QDateTimeEdit>
#include <QDesktopServices>
#include <QDoubleValidator>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QPoint>
#include <QScrollBar>
#include <QSignalMapper>
#include <QTableView>
#include <QTimer>
#include <QUrl>
#include <QVBoxLayout>
TransactionView::TransactionView(const PlatformStyle* platformStyle, QWidget* parent) : QWidget(parent), model(0), transactionProxyModel(0),
transactionView(0), abandonAction(0), bumpFeeAction(0), columnResizingFixer(0)
{
// Build filter row
setContentsMargins(0, 0, 0, 0);
QHBoxLayout* hlayout = new QHBoxLayout();
hlayout->setContentsMargins(0, 0, 0, 0);
if (platformStyle->getUseExtraSpacing()) {
hlayout->setSpacing(5);
hlayout->addSpacing(26);
} else {
hlayout->setSpacing(0);
hlayout->addSpacing(23);
}
watchOnlyWidget = new QComboBox(this);
watchOnlyWidget->setFixedWidth(24);
watchOnlyWidget->addItem("", TransactionFilterProxy::WatchOnlyFilter_All);
watchOnlyWidget->addItem(platformStyle->SingleColorIcon(":/icons/eye_plus"), "", TransactionFilterProxy::WatchOnlyFilter_Yes);
watchOnlyWidget->addItem(platformStyle->SingleColorIcon(":/icons/eye_minus"), "", TransactionFilterProxy::WatchOnlyFilter_No);
hlayout->addWidget(watchOnlyWidget);
dateWidget = new QComboBox(this);
if (platformStyle->getUseExtraSpacing()) {
dateWidget->setFixedWidth(121);
} else {
dateWidget->setFixedWidth(120);
}
dateWidget->addItem(tr("All"), All);
dateWidget->addItem(tr("Today"), Today);
dateWidget->addItem(tr("This week"), ThisWeek);
dateWidget->addItem(tr("This month"), ThisMonth);
dateWidget->addItem(tr("Last month"), LastMonth);
dateWidget->addItem(tr("This year"), ThisYear);
dateWidget->addItem(tr("Range..."), Range);
hlayout->addWidget(dateWidget);
typeWidget = new QComboBox(this);
if (platformStyle->getUseExtraSpacing()) {
typeWidget->setFixedWidth(121);
} else {
typeWidget->setFixedWidth(120);
}
typeWidget->addItem(tr("All"), TransactionFilterProxy::ALL_TYPES);
typeWidget->addItem(tr("Received with"), TransactionFilterProxy::TYPE(TransactionRecord::RecvWithAddress) |
TransactionFilterProxy::TYPE(TransactionRecord::RecvFromOther));
typeWidget->addItem(tr("Sent to"), TransactionFilterProxy::TYPE(TransactionRecord::SendToAddress) |
TransactionFilterProxy::TYPE(TransactionRecord::SendToOther));
typeWidget->addItem(tr("To yourself"), TransactionFilterProxy::TYPE(TransactionRecord::SendToSelf));
typeWidget->addItem(tr("Mined"), TransactionFilterProxy::TYPE(TransactionRecord::Generated));
typeWidget->addItem(tr("Other"), TransactionFilterProxy::TYPE(TransactionRecord::Other));
hlayout->addWidget(typeWidget);
addressWidget = new QLineEdit(this);
#if QT_VERSION >= 0x040700
addressWidget->setPlaceholderText(tr("Enter address or label to search"));
#endif
hlayout->addWidget(addressWidget);
amountWidget = new QLineEdit(this);
#if QT_VERSION >= 0x040700
amountWidget->setPlaceholderText(tr("Min amount"));
#endif
if (platformStyle->getUseExtraSpacing()) {
amountWidget->setFixedWidth(97);
} else {
amountWidget->setFixedWidth(100);
}
amountWidget->setValidator(new QDoubleValidator(0, 1e20, 8, this));
hlayout->addWidget(amountWidget);
// Delay before filtering transactions in ms
static const int input_filter_delay = 200;
QTimer* amount_typing_delay = new QTimer(this);
amount_typing_delay->setSingleShot(true);
amount_typing_delay->setInterval(input_filter_delay);
QTimer* prefix_typing_delay = new QTimer(this);
prefix_typing_delay->setSingleShot(true);
prefix_typing_delay->setInterval(input_filter_delay);
QVBoxLayout* vlayout = new QVBoxLayout(this);
vlayout->setContentsMargins(0, 0, 0, 0);
vlayout->setSpacing(0);
QTableView* view = new QTableView(this);
vlayout->addLayout(hlayout);
vlayout->addWidget(createDateRangeWidget());
vlayout->addWidget(view);
vlayout->setSpacing(0);
int width = view->verticalScrollBar()->sizeHint().width();
// Cover scroll bar width with spacing
if (platformStyle->getUseExtraSpacing()) {
hlayout->addSpacing(width + 2);
} else {
hlayout->addSpacing(width);
}
// Always show scroll bar
view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
view->setTabKeyNavigation(false);
view->setContextMenuPolicy(Qt::CustomContextMenu);
view->installEventFilter(this);
transactionView = view;
transactionView->setObjectName("transactionView");
// Actions
abandonAction = new QAction(tr("Abandon transaction"), this);
bumpFeeAction = new QAction(tr("Increase transaction fee"), this);
bumpFeeAction->setObjectName("bumpFeeAction");
QAction* copyAddressAction = new QAction(tr("Copy address"), this);
QAction* copyLabelAction = new QAction(tr("Copy label"), this);
QAction* copyAmountAction = new QAction(tr("Copy amount"), this);
QAction* copyTxIDAction = new QAction(tr("Copy transaction ID"), this);
QAction* copyTxHexAction = new QAction(tr("Copy raw transaction"), this);
QAction* copyTxPlainText = new QAction(tr("Copy full transaction details"), this);
QAction* editLabelAction = new QAction(tr("Edit label"), this);
QAction* showDetailsAction = new QAction(tr("Show transaction details"), this);
contextMenu = new QMenu(this);
contextMenu->setObjectName("contextMenu");
contextMenu->addAction(copyAddressAction);
contextMenu->addAction(copyLabelAction);
contextMenu->addAction(copyAmountAction);
contextMenu->addAction(copyTxIDAction);
contextMenu->addAction(copyTxHexAction);
contextMenu->addAction(copyTxPlainText);
contextMenu->addAction(showDetailsAction);
contextMenu->addSeparator();
contextMenu->addAction(bumpFeeAction);
contextMenu->addAction(abandonAction);
contextMenu->addAction(editLabelAction);
mapperThirdPartyTxUrls = new QSignalMapper(this);
// Connect actions
connect(mapperThirdPartyTxUrls, SIGNAL(mapped(QString)), this, SLOT(openThirdPartyTxUrl(QString)));
connect(dateWidget, SIGNAL(activated(int)), this, SLOT(chooseDate(int)));
connect(typeWidget, SIGNAL(activated(int)), this, SLOT(chooseType(int)));
connect(watchOnlyWidget, SIGNAL(activated(int)), this, SLOT(chooseWatchonly(int)));
connect(amountWidget, SIGNAL(textChanged(QString)), amount_typing_delay, SLOT(start()));
connect(amount_typing_delay, SIGNAL(timeout()), this, SLOT(changedAmount()));
connect(addressWidget, SIGNAL(textChanged(QString)), prefix_typing_delay, SLOT(start()));
connect(prefix_typing_delay, SIGNAL(timeout()), this, SLOT(changedPrefix()));
connect(view, SIGNAL(doubleClicked(QModelIndex)), this, SIGNAL(doubleClicked(QModelIndex)));
connect(view, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextualMenu(QPoint)));
connect(bumpFeeAction, SIGNAL(triggered()), this, SLOT(bumpFee()));
connect(abandonAction, SIGNAL(triggered()), this, SLOT(abandonTx()));
connect(copyAddressAction, SIGNAL(triggered()), this, SLOT(copyAddress()));
connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(copyLabel()));
connect(copyAmountAction, SIGNAL(triggered()), this, SLOT(copyAmount()));
connect(copyTxIDAction, SIGNAL(triggered()), this, SLOT(copyTxID()));
connect(copyTxHexAction, SIGNAL(triggered()), this, SLOT(copyTxHex()));
connect(copyTxPlainText, SIGNAL(triggered()), this, SLOT(copyTxPlainText()));
connect(editLabelAction, SIGNAL(triggered()), this, SLOT(editLabel()));
connect(showDetailsAction, SIGNAL(triggered()), this, SLOT(showDetails()));
}
void TransactionView::setModel(WalletModel* _model)
{
this->model = _model;
if (_model) {
transactionProxyModel = new TransactionFilterProxy(this);
transactionProxyModel->setSourceModel(_model->getTransactionTableModel());
transactionProxyModel->setDynamicSortFilter(true);
transactionProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
transactionProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
transactionProxyModel->setSortRole(Qt::EditRole);
transactionView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
transactionView->setModel(transactionProxyModel);
transactionView->setAlternatingRowColors(true);
transactionView->setSelectionBehavior(QAbstractItemView::SelectRows);
transactionView->setSelectionMode(QAbstractItemView::ExtendedSelection);
transactionView->setSortingEnabled(true);
transactionView->sortByColumn(TransactionTableModel::Date, Qt::DescendingOrder);
transactionView->verticalHeader()->hide();
transactionView->setColumnWidth(TransactionTableModel::Status, STATUS_COLUMN_WIDTH);
transactionView->setColumnWidth(TransactionTableModel::Watchonly, WATCHONLY_COLUMN_WIDTH);
transactionView->setColumnWidth(TransactionTableModel::Date, DATE_COLUMN_WIDTH);
transactionView->setColumnWidth(TransactionTableModel::Type, TYPE_COLUMN_WIDTH);
transactionView->setColumnWidth(TransactionTableModel::Amount, AMOUNT_MINIMUM_COLUMN_WIDTH);
columnResizingFixer = new GUIUtil::TableViewLastColumnResizingFixer(transactionView, AMOUNT_MINIMUM_COLUMN_WIDTH, MINIMUM_COLUMN_WIDTH, this);
if (_model->getOptionsModel()) {
// Add third party transaction URLs to context menu
QStringList listUrls = _model->getOptionsModel()->getThirdPartyTxUrls().split("|", QString::SkipEmptyParts);
for (int i = 0; i < listUrls.size(); ++i) {
QString host = QUrl(listUrls[i].trimmed(), QUrl::StrictMode).host();
if (!host.isEmpty()) {
QAction* thirdPartyTxUrlAction = new QAction(host, this); // use host as menu item label
if (i == 0)
contextMenu->addSeparator();
contextMenu->addAction(thirdPartyTxUrlAction);
connect(thirdPartyTxUrlAction, SIGNAL(triggered()), mapperThirdPartyTxUrls, SLOT(map()));
mapperThirdPartyTxUrls->setMapping(thirdPartyTxUrlAction, listUrls[i].trimmed());
}
}
}
// show/hide column Watch-only
updateWatchOnlyColumn(_model->haveWatchOnly());
// Watch-only signal
connect(_model, SIGNAL(notifyWatchonlyChanged(bool)), this, SLOT(updateWatchOnlyColumn(bool)));
}
}
void TransactionView::chooseDate(int idx)
{
if (!transactionProxyModel)
return;
QDate current = QDate::currentDate();
dateRangeWidget->setVisible(false);
switch (dateWidget->itemData(idx).toInt()) {
case All:
transactionProxyModel->setDateRange(
TransactionFilterProxy::MIN_DATE,
TransactionFilterProxy::MAX_DATE);
break;
case Today:
transactionProxyModel->setDateRange(
QDateTime(current),
TransactionFilterProxy::MAX_DATE);
break;
case ThisWeek: {
// Find last Monday
QDate startOfWeek = current.addDays(-(current.dayOfWeek() - 1));
transactionProxyModel->setDateRange(
QDateTime(startOfWeek),
TransactionFilterProxy::MAX_DATE);
} break;
case ThisMonth:
transactionProxyModel->setDateRange(
QDateTime(QDate(current.year(), current.month(), 1)),
TransactionFilterProxy::MAX_DATE);
break;
case LastMonth:
transactionProxyModel->setDateRange(
QDateTime(QDate(current.year(), current.month(), 1).addMonths(-1)),
QDateTime(QDate(current.year(), current.month(), 1)));
break;
case ThisYear:
transactionProxyModel->setDateRange(
QDateTime(QDate(current.year(), 1, 1)),
TransactionFilterProxy::MAX_DATE);
break;
case Range:
dateRangeWidget->setVisible(true);
dateRangeChanged();
break;
}
}
void TransactionView::chooseType(int idx)
{
if (!transactionProxyModel)
return;
transactionProxyModel->setTypeFilter(
typeWidget->itemData(idx).toInt());
}
void TransactionView::chooseWatchonly(int idx)
{
if (!transactionProxyModel)
return;
transactionProxyModel->setWatchOnlyFilter(
(TransactionFilterProxy::WatchOnlyFilter)watchOnlyWidget->itemData(idx).toInt());
}
void TransactionView::changedPrefix()
{
if (!transactionProxyModel)
return;
transactionProxyModel->setAddressPrefix(addressWidget->text());
}
void TransactionView::changedAmount()
{
if (!transactionProxyModel)
return;
CAmount amount_parsed = 0;
if (EllocashUnits::parse(model->getOptionsModel()->getDisplayUnit(), amountWidget->text(), &amount_parsed)) {
transactionProxyModel->setMinAmount(amount_parsed);
} else {
transactionProxyModel->setMinAmount(0);
}
}
void TransactionView::exportClicked()
{
if (!model || !model->getOptionsModel()) {
return;
}
// CSV is currently the only supported format
QString filename = GUIUtil::getSaveFileName(this,
tr("Export Transaction History"), QString(),
tr("Comma separated file (*.csv)"), nullptr);
if (filename.isNull())
return;
CSVModelWriter writer(filename);
// name, column, role
writer.setModel(transactionProxyModel);
writer.addColumn(tr("Confirmed"), 0, TransactionTableModel::ConfirmedRole);
if (model && model->haveWatchOnly())
writer.addColumn(tr("Watch-only"), TransactionTableModel::Watchonly);
writer.addColumn(tr("Date"), 0, TransactionTableModel::DateRole);
writer.addColumn(tr("Type"), TransactionTableModel::Type, Qt::EditRole);
writer.addColumn(tr("Label"), 0, TransactionTableModel::LabelRole);
writer.addColumn(tr("Address"), 0, TransactionTableModel::AddressRole);
writer.addColumn(EllocashUnits::getAmountColumnTitle(model->getOptionsModel()->getDisplayUnit()), 0, TransactionTableModel::FormattedAmountRole);
writer.addColumn(tr("ID"), 0, TransactionTableModel::TxIDRole);
if (!writer.write()) {
Q_EMIT message(tr("Exporting Failed"), tr("There was an error trying to save the transaction history to %1.").arg(filename),
CClientUIInterface::MSG_ERROR);
} else {
Q_EMIT message(tr("Exporting Successful"), tr("The transaction history was successfully saved to %1.").arg(filename),
CClientUIInterface::MSG_INFORMATION);
}
}
void TransactionView::contextualMenu(const QPoint& point)
{
QModelIndex index = transactionView->indexAt(point);
QModelIndexList selection = transactionView->selectionModel()->selectedRows(0);
if (selection.empty())
return;
// check if transaction can be abandoned, disable context menu action in case it doesn't
uint256 hash;
hash.SetHex(selection.at(0).data(TransactionTableModel::TxHashRole).toString().toStdString());
abandonAction->setEnabled(model->transactionCanBeAbandoned(hash));
bumpFeeAction->setEnabled(model->transactionCanBeBumped(hash));
if (index.isValid()) {
contextMenu->popup(transactionView->viewport()->mapToGlobal(point));
}
}
void TransactionView::abandonTx()
{
if (!transactionView || !transactionView->selectionModel())
return;
QModelIndexList selection = transactionView->selectionModel()->selectedRows(0);
// get the hash from the TxHashRole (QVariant / QString)
uint256 hash;
QString hashQStr = selection.at(0).data(TransactionTableModel::TxHashRole).toString();
hash.SetHex(hashQStr.toStdString());
// Abandon the wallet transaction over the walletModel
model->abandonTransaction(hash);
// Update the table
model->getTransactionTableModel()->updateTransaction(hashQStr, CT_UPDATED, false);
}
void TransactionView::bumpFee()
{
if (!transactionView || !transactionView->selectionModel())
return;
QModelIndexList selection = transactionView->selectionModel()->selectedRows(0);
// get the hash from the TxHashRole (QVariant / QString)
uint256 hash;
QString hashQStr = selection.at(0).data(TransactionTableModel::TxHashRole).toString();
hash.SetHex(hashQStr.toStdString());
// Bump tx fee over the walletModel
if (model->bumpFee(hash)) {
// Update the table
model->getTransactionTableModel()->updateTransaction(hashQStr, CT_UPDATED, true);
}
}
void TransactionView::copyAddress()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::AddressRole);
}
void TransactionView::copyLabel()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::LabelRole);
}
void TransactionView::copyAmount()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::FormattedAmountRole);
}
void TransactionView::copyTxID()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::TxIDRole);
}
void TransactionView::copyTxHex()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::TxHexRole);
}
void TransactionView::copyTxPlainText()
{
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::TxPlainTextRole);
}
void TransactionView::editLabel()
{
if (!transactionView->selectionModel() || !model)
return;
QModelIndexList selection = transactionView->selectionModel()->selectedRows();
if (!selection.isEmpty()) {
AddressTableModel* addressBook = model->getAddressTableModel();
if (!addressBook)
return;
QString address = selection.at(0).data(TransactionTableModel::AddressRole).toString();
if (address.isEmpty()) {
// If this transaction has no associated address, exit
return;
}
// Is address in address book? Address book can miss address when a transaction is
// sent from outside the UI.
int idx = addressBook->lookupAddress(address);
if (idx != -1) {
// Edit sending / receiving address
QModelIndex modelIdx = addressBook->index(idx, 0, QModelIndex());
// Determine type of address, launch appropriate editor dialog type
QString type = modelIdx.data(AddressTableModel::TypeRole).toString();
EditAddressDialog dlg(
type == AddressTableModel::Receive ? EditAddressDialog::EditReceivingAddress : EditAddressDialog::EditSendingAddress, this);
dlg.setModel(addressBook);
dlg.loadRow(idx);
dlg.exec();
} else {
// Add sending address
EditAddressDialog dlg(EditAddressDialog::NewSendingAddress,
this);
dlg.setModel(addressBook);
dlg.setAddress(address);
dlg.exec();
}
}
}
void TransactionView::showDetails()
{
if (!transactionView->selectionModel())
return;
QModelIndexList selection = transactionView->selectionModel()->selectedRows();
if (!selection.isEmpty()) {
TransactionDescDialog* dlg = new TransactionDescDialog(selection.at(0));
dlg->setAttribute(Qt::WA_DeleteOnClose);
dlg->show();
}
}
void TransactionView::openThirdPartyTxUrl(QString url)
{
if (!transactionView || !transactionView->selectionModel())
return;
QModelIndexList selection = transactionView->selectionModel()->selectedRows(0);
if (!selection.isEmpty())
QDesktopServices::openUrl(QUrl::fromUserInput(url.replace("%s", selection.at(0).data(TransactionTableModel::TxHashRole).toString())));
}
QWidget* TransactionView::createDateRangeWidget()
{
dateRangeWidget = new QFrame();
dateRangeWidget->setFrameStyle(QFrame::Panel | QFrame::Raised);
dateRangeWidget->setContentsMargins(1, 1, 1, 1);
QHBoxLayout* layout = new QHBoxLayout(dateRangeWidget);
layout->setContentsMargins(0, 0, 0, 0);
layout->addSpacing(23);
layout->addWidget(new QLabel(tr("Range:")));
dateFrom = new QDateTimeEdit(this);
dateFrom->setDisplayFormat("dd/MM/yy");
dateFrom->setCalendarPopup(true);
dateFrom->setMinimumWidth(100);
dateFrom->setDate(QDate::currentDate().addDays(-7));
layout->addWidget(dateFrom);
layout->addWidget(new QLabel(tr("to")));
dateTo = new QDateTimeEdit(this);
dateTo->setDisplayFormat("dd/MM/yy");
dateTo->setCalendarPopup(true);
dateTo->setMinimumWidth(100);
dateTo->setDate(QDate::currentDate());
layout->addWidget(dateTo);
layout->addStretch();
// Hide by default
dateRangeWidget->setVisible(false);
// Notify on change
connect(dateFrom, SIGNAL(dateChanged(QDate)), this, SLOT(dateRangeChanged()));
connect(dateTo, SIGNAL(dateChanged(QDate)), this, SLOT(dateRangeChanged()));
return dateRangeWidget;
}
void TransactionView::dateRangeChanged()
{
if (!transactionProxyModel)
return;
transactionProxyModel->setDateRange(
QDateTime(dateFrom->date()),
QDateTime(dateTo->date()).addDays(1));
}
void TransactionView::focusTransaction(const QModelIndex& idx)
{
if (!transactionProxyModel)
return;
QModelIndex targetIdx = transactionProxyModel->mapFromSource(idx);
transactionView->scrollTo(targetIdx);
transactionView->setCurrentIndex(targetIdx);
transactionView->setFocus();
}
// We override the virtual resizeEvent of the QWidget to adjust tables column
// sizes as the tables width is proportional to the dialogs width.
void TransactionView::resizeEvent(QResizeEvent* event)
{
QWidget::resizeEvent(event);
columnResizingFixer->stretchColumnWidth(TransactionTableModel::ToAddress);
}
// Need to override default Ctrl+C action for amount as default behaviour is just to copy DisplayRole text
bool TransactionView::eventFilter(QObject* obj, QEvent* event)
{
if (event->type() == QEvent::KeyPress) {
QKeyEvent* ke = static_cast<QKeyEvent*>(event);
if (ke->key() == Qt::Key_C && ke->modifiers().testFlag(Qt::ControlModifier)) {
GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::TxPlainTextRole);
return true;
}
}
return QWidget::eventFilter(obj, event);
}
// show/hide column Watch-only
void TransactionView::updateWatchOnlyColumn(bool fHaveWatchOnly)
{
watchOnlyWidget->setVisible(fHaveWatchOnly);
transactionView->setColumnHidden(TransactionTableModel::Watchonly, !fHaveWatchOnly);
}
| [
"[email protected]"
] | |
b45840a4db7129bc3605758e9a27f0628c37171b | 5270bd701facc1aff767822884580e0cd65fa4e9 | /Uabd.cpp | 92343847cc0cfcb264eea8f0afa1e5dfed3a2317 | [] | no_license | prasidha/programing | f9d4f0e2bf11d118c15c3a6fb6321215cf25e1b6 | 5ad5059cbb501dcd2c679f9c0dc7b056b674d96e | refs/heads/master | 2021-01-21T09:39:10.647076 | 2017-05-18T07:31:19 | 2017-05-18T07:31:19 | 91,662,550 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 322 | cpp | #include<stdio.h>
#include<string.h>
int main(){
FILE*fptr;
char str[50]=" LRIG DOOG YREV";
char rev[50];
fptr=fopen("file.txt","w");
if(fptr==NULL){
printf("file cannot be open");
}else{
fputs(str,fptr);
fclose(fptr);}
FILE*fptr2;
fptr2=fopen("file.txt","w");
fputs(strrev(str),fptr2);
fclose(fptr2);}
| [
"[email protected]"
] | |
5522104d4ece6a3f9a90f397fc1140a7f9504869 | 5a403bd5b2d6a9022d27f9920505c0c511f48cf9 | /codilityg.cpp | 5f68a263c2969b31b380eae28b8ca9113dcca410 | [] | no_license | dawno/Coding | c2762939993e28ce633886aa15f0bc74434ef163 | c712a729fb8c7919b5fe82b8cbee1d17ddd454b1 | refs/heads/master | 2021-04-15T08:28:34.851039 | 2019-07-01T06:15:56 | 2019-07-01T06:15:56 | 126,705,169 | 0 | 3 | null | 2018-10-30T15:47:26 | 2018-03-25T14:21:57 | C++ | UTF-8 | C++ | false | false | 614 | cpp | // you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int solution(int K, vector<int> &A) {
if(A.size()==1){
if(A[0]>=K){
return 1;
}
else{
return 0;
}
}
int sum=A[0];
int c=0;
for(int i=1;i<A.size();i++){
if(sum<K){
sum=sum+A[i];
if(i==((A.size()-1))&&sum>K){
c=c+1;
}
}
else{
c=c+1;
sum=A[i];
}
}
return c;
}
| [
"[email protected]"
] | |
cbf5eefbdc953da5a0a5cc73e87f6b02852e9c12 | 36184239a2d964ed5f587ad8e83f66355edb17aa | /lec5/booleanzen.cpp | c975b3e78f5ec65586a713962b061c410fdc58cb | [] | no_license | xich4932/csci3010 | 89c342dc445f5ec15ac7885cd7b7c26a225dae3e | 23f0124a99c4e8e44a28ff31ededc42d9f326ccc | refs/heads/master | 2023-08-24T04:03:12.748713 | 2021-10-22T08:22:58 | 2021-10-22T08:22:58 | 415,140,207 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 575 | cpp | #include <iostream>
#include <vector>
bool IsEven(const int num) {
if (num % 2 == 0) {
return true;
}
return false;
}
int AbsoluteValue(int num) {
if (num > 0 ) {
} else {
num = num * -1;
}
return num;
}
int main() {
std::cout << IsEven(7) << std::endl;
std::cout << IsEven(2) << std::endl;
std::cout << IsEven(-16) << std::endl;
std::cout << std::endl;
std::cout << AbsoluteValue(7) << std::endl;
std::cout << AbsoluteValue(2) << std::endl;
std::cout << AbsoluteValue(-16) << std::endl;
}
| [
"[email protected]"
] | |
bc7131904b5db1e11a275d53a51d7ad70fcd27d6 | f5d87ed79a91f17cdf2aee7bea7c15f5b5258c05 | /cuts/utils/template/Template_Engine.inl | df0571f183895ce02982a01896ed0882032a01e6 | [] | no_license | SEDS/CUTS | a4449214a894e2b47bdea42090fa6cfc56befac8 | 0ad462fadcd3adefd91735aef6d87952022db2b7 | refs/heads/master | 2020-04-06T06:57:35.710601 | 2016-08-16T19:37:34 | 2016-08-16T19:37:34 | 25,653,522 | 0 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 259 | inl | // -*- C++ -*-
// $Id$
//
// CUTS_Template_Engine
//
CUTS_INLINE
CUTS_Template_Engine::
CUTS_Template_Engine (const CUTS_Property_Map & map)
: tp_ (map)
{
}
//
// ~CUTS_Template_Engine
//
CUTS_INLINE
CUTS_Template_Engine::~CUTS_Template_Engine (void)
{
}
| [
"[email protected]"
] | |
acc9334624041053d6e329c73eba12e4e0fbd8bc | aa65ba6a02358421faedde247072447168905cb0 | /UmaCruise/Utility/CodeConvert.cpp | 7334cb631ad095f1a83ed52894eb1e0a190c59fd | [] | no_license | joon-won/UmaUmaCruise | c9ff7748f221363a8d40238449ec910af12fab9d | 9a1582fb48a62a6c04138c989dc4c11e2594b253 | refs/heads/master | 2023-08-29T17:10:43.651833 | 2021-11-08T20:11:15 | 2021-11-08T20:11:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,930 | cpp |
#include "stdafx.h"
#include "CodeConvert.h"
#include <Windows.h>
namespace CodeConvert
{
std::string ShiftJISfromUTF16(const std::wstring & utf16)
{
int requireBytes = ::WideCharToMultiByte(CP_ACP, 0, utf16.c_str(), utf16.length(), nullptr, 0, NULL, NULL);
if (requireBytes > 0) {
std::string sjis;
sjis.resize(requireBytes);
int ret = ::WideCharToMultiByte(CP_ACP, 0, utf16.c_str(), utf16.length(), (LPSTR)sjis.data(), requireBytes, NULL, NULL);
if (ret > 0) {
return sjis;
}
}
return std::string();
}
std::wstring UTF16fromShiftJIS(const std::string& sjis)
{
int requireChars = ::MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, sjis.c_str(), sjis.length(), nullptr, 0);
if (requireChars > 0) {
std::wstring utf16;
utf16.resize(requireChars);
int ret = ::MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, sjis.c_str(), sjis.length(), (LPWSTR)utf16.data(), requireChars);
if (ret > 0) {
return utf16;
}
}
return std::wstring();
}
std::string UTF8fromUTF16(const std::wstring& utf16)
{
int requireBytes = ::WideCharToMultiByte(CP_UTF8, 0, utf16.c_str(), utf16.length(), nullptr, 0, NULL, NULL);
if (requireBytes > 0) {
std::string utf8;
utf8.resize(requireBytes);
int ret = ::WideCharToMultiByte(CP_UTF8, 0, utf16.c_str(), utf16.length(), (LPSTR)utf8.data(), requireBytes, NULL, NULL);
if (ret > 0) {
return utf8;
}
}
return std::string();
}
std::wstring UTF16fromUTF8(const std::string& utf8)
{
int requireChars = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.c_str(), utf8.length(), nullptr, 0);
if (requireChars > 0) {
std::wstring utf16;
utf16.resize(requireChars);
int ret = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.c_str(), utf8.length(), (LPWSTR)utf16.data(), requireChars);
if (ret > 0) {
return utf16;
}
}
return std::wstring();
}
} // namespace CodeConvert | [
"[email protected]"
] | |
186c040aac3b2595f9044096479a36ac7b7e239f | 9cb280bce37dc0c8b91ed271dc3fa7b9b06b39b0 | /practice/program4.3.cpp | bab0135cf2df97f1eb1f67ffe3094c1d73870e70 | [] | no_license | bhattathakur/ResearchStuff | 158d0039f05eb3d4a8c1f98943aa0821a543757c | 7d8fc4caff553bd69f31b8b89193b028c2bf19c7 | refs/heads/master | 2020-03-22T22:50:57.103338 | 2018-07-13T00:43:59 | 2018-07-13T00:43:59 | 140,773,885 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 261 | cpp | #include <iostream>
using namespace std;
long fact(int n)
{
if(n==0)
return 1;
return (n*fact(n-1));
}
int main()
{
int num;
cout<<"Enter a positive integer:";
cin>>num;
cout<<"Factorial of \t"<<num<<" is\t"<<fact(num);
cout<<endl;
return 0;
} | [
"[email protected]"
] | |
cb7392bc196c1c442df0ce6335372bfb98fae12d | 59418b5794f251391650d8593704190606fa2b41 | /plugin_api/em5/em5/ai/em4Router/actor/base/EGenericObjectBase.h | 0d09ca4ff2d3e2b64d53e922b47d31cdee5705d8 | [] | no_license | JeveruBerry/emergency5_sdk | 8e5726f28123962541f7e9e4d70b2d8d5cc76cff | e5b23d905c356aab6f8b26432c72d18e5838ccf6 | refs/heads/master | 2023-08-25T12:25:19.117165 | 2018-12-18T16:55:16 | 2018-12-18T17:09:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,136 | h | // Copyright (C) 2012-2018 Promotion Software GmbH
//[-------------------------------------------------------]
//[ Header guard ]
//[-------------------------------------------------------]
#pragma once
//[-------------------------------------------------------]
//[ Includes ]
//[-------------------------------------------------------]
#include "em5/ai/em4Router/actor/base/EActorBase.h"
#include <qsf_ai/navigation/em4Router/wrapper/actor/EGenericObject.h>
#include <qsf/component/base/TransformComponent.h>
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
namespace em5
{
//[-------------------------------------------------------]
//[ Classes ]
//[-------------------------------------------------------]
/**
* @brief
* EGenericObjectBase wrapper base class
*/
class EGenericObjectBase : public EActorBase
{
//[-------------------------------------------------------]
//[ Protected methods ]
//[-------------------------------------------------------]
protected:
EGenericObjectBase(qsf::Entity& entity);
virtual ~EGenericObjectBase();
const glm::vec3& GetPosition();
const glm::mat3x3& GetRotationMatrix();
qsf::ai::EObjectTerrainClass GetTerrainClass();
qsf::ai::EFloorPlacement GetPlacement();
void UpdatePlacement(glm::vec3& position_, glm::mat3x3& rotation_);
int GetCarriedPersonID() const;
//[-------------------------------------------------------]
//[ Private data ]
//[-------------------------------------------------------]
private:
qsf::WeakPtr<qsf::TransformComponent> mTransformComponent;
glm::mat3x3 mCachedRotationMatrix;
};
//[-------------------------------------------------------]
//[ Namespace ]
//[-------------------------------------------------------]
} // em5
| [
"[email protected]"
] | |
1972531dd15e9c780d815c8ccb0dbb56e8f9bdcd | c301c81f7560125e130a9eb67f5231b3d08a9d67 | /lc/lc/2021_target/core/arrays/lc_128_longest_consequtive_seq.cpp | 8ffb043712d0f49637ad7a821674b2f6794d11d4 | [] | no_license | vikashkumarjha/missionpeace | f55f593b52754c9681e6c32d46337e5e4b2d5f8b | 7d5db52486c55b48fe761e0616d550439584f199 | refs/heads/master | 2021-07-11T07:34:08.789819 | 2021-07-06T04:25:18 | 2021-07-06T04:25:18 | 241,745,271 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,533 | cpp | /*
Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.
Follow up: Could you implement the O(n) solution?
Example 1:
Input: nums = [100,4,200,1,3,2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
Example 2:
Input: nums = [0,3,7,2,5,8,4,6,0,1]
Output: 9
*/
#include "../../header.hpp"
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
if ( nums.empty()) return 0;
unordered_set<int> x(begin(nums), end(nums));
int res = 1;
for ( auto n : nums) {
int curr = 1;
if ( x.count(n-1)) {
int v = n;
while (x.count(v)) {
curr++;
v++;
}
}
res = max(res, curr);
}
return res;
}
};
class Solution {
public:
int longestConsecutive(vector<int>& nums) {
int n = nums.size();
if (n == 0) return 0;
map<int, int>hm;
for (int i = 0; i < n; i++)
hm[nums[i]];
auto prev = hm.begin();
int c = 1, ans = 0;
for (auto it = hm.begin(); it != hm.end(); it++) {
if (prev->first+1 == it->first) {
c++;
} else {
ans = max(ans, c); c = 1;
}
prev = it;
}
return max(ans, c);
}
}; | [
"[email protected]"
] | |
98da7225add12797c8f95b9ed8bc7012a3911301 | 7aa189c718f8a63c256685a435d027ace3833f6b | /include/ogonek/normalization_forms/nfkd.h++ | 51427ae50e97ef0a4c0139d0bc1b3ae6537dba0c | [
"CC0-1.0"
] | permissive | rmartinho/ogonek | d5523145108de1255298a17c1c25065beb19b82c | 0042f30c6c674effd21d379c53658c88054c58b9 | refs/heads/devel | 2020-05-21T15:17:39.490890 | 2019-09-29T10:58:31 | 2019-09-29T10:58:31 | 8,255,019 | 16 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,185 | // Ogonek
//
// Written in 2017 by Martinho Fernandes <[email protected]>
//
// To the extent possible under law, the author(s) have dedicated all copyright and related
// and neighboring rights to this software to the public domain worldwide. This software is
// distributed without any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication along with this software.
// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
#ifndef OGONEK_NORMALIZATION_FORMS_NFKD_HPP
#define OGONEK_NORMALIZATION_FORMS_NFKD_HPP
#include <ogonek/concepts.h++>
#include <ogonek/types.h++>
#include <ogonek/ucd.h++>
namespace ogonek {
struct nfkd {
template <typename Out,
CONCEPT_REQUIRES_(OutputIterator<Out, code_point>())>
static void decompose_into(code_point u, Out out) {
if(ucd::get_decomposition_type(u) != ucd::decomposition_type::none) {
ucd::detail::get_full_decomposition(u, out, false);
} else {
*out++ = u;
}
}
};
CONCEPT_ASSERT(NormalizationForm<nfkd>());
} // namespace ogonek
#endif // OGONEK_NORMALIZATION_FORMS_NFKD_HPP
| [
"[email protected]"
] | ||
014bdc9e3913bb02c8df13e6275b744725633645 | 03a146294aee9187472fc89f6d58d08bcf7dccab | /end-2-term-projects/wcc2/load-geojson-test/src/SandLine.h | 1ff4a6a8091833dff5ac23a549adaca530009598 | [] | no_license | vvzen/MACA | c36f0113e1e65cd296769d2c60097c45039f61d6 | e7fb422939c7627e493fd95fa4d3a7fdb700af6f | refs/heads/master | 2021-10-08T15:04:48.061607 | 2018-12-13T19:56:36 | 2018-12-13T19:56:36 | 113,078,541 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,045 | h | #include "ofMain.h"
#include <random>
struct Grain {
ofPoint pos;
ofColor col;
float size;
};
class SandLine {
public:
void setup(float w, float h, float max_size, float max_alpha);
void update();
void add_point(ofVec3f p, int max_offset, int max_radius);
ofFbo * get_fbo_pointer();
void set_target(ofVec2f target);
void set_mode(int mode);
void enable_draw(bool val);
ofFbo fbo;
int current_mode;
// used in bezier mode
deque <Grain> sand_grains;
deque <ofPoint> main_sand_points;
int points_added;
// used in attractor mode
ofPoint latest_target;
ofVec2f acceleration, velocity, position;
// drawing modes
static const int BEZIER_MODE = 1;
static const int ATTRACTOR_MODE = 2;
// for getting gaussian distribution
std::default_random_engine generator;
private:
bool _enable_draw;
float _max_size, _max_alpha;
// int _max_offset;
};
| [
"[email protected]"
] | |
a6c133b13c4eb230f741e091e88ff4f10c305fb1 | db84bf6382c21920c3649b184f20ea48f54c3048 | /validation/AlphaInteractions/MaterialInteraction.cxx | 9ad81a0ff52752490d389ec20b189d13c1931d9a | [] | no_license | liebercanis/MaGeLAr | 85c540e3b4c5a48edea9bc0520c9d1a1dcbae73c | aa30b01f3c9c0f5de0f040d05681d358860a31b3 | refs/heads/master | 2020-09-20T12:48:38.106634 | 2020-03-06T18:43:19 | 2020-03-06T18:43:19 | 224,483,424 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,968 | cxx | /*
* MaterialInteraction.cxx
*
* Created on: Jun 9, 2011
* Author: fraenkle
*/
#include <iostream>
#include <sstream>
#include "TCanvas.h"
#include "TPad.h"
#include "TF1.h"
#include "MaterialInteraction.h"
#include "../VaLi/RComp.h"
MaterialInteraction::MaterialInteraction() {
token = "";
materialName = "";
energy = 0;
attenuationLiterature = 0;
hisEndZ = 0;
}
MaterialInteraction::MaterialInteraction(std::string t, std::string m, double e, double a){
token = t;
materialName = m;
energy = e;
attenuationLiterature = a;
hisEndZ = 0;
}
std::string MaterialInteraction::GetMaterialName(){
return materialName;
}
void MaterialInteraction::SetMaterialName(std::string name){
materialName = name;
}
std::string MaterialInteraction::GetToken(){
return token;
}
void MaterialInteraction::SetToken(std::string name){
token = name;
}
double MaterialInteraction::GetAttenuationLiterature(){
return attenuationLiterature;
}
std::string MaterialInteraction::GetAttenuationLiteratureToken(){
std::stringstream label;
label.str("");
label.clear();
label.precision(4);
label << token.substr(0,token.size()-3) << "_attenuation_literature:XX\t" << GetAttenuationLiterature();
return label.str();
}
void MaterialInteraction::SetAttenuationLiterature(double a){
attenuationLiterature = a;
}
double MaterialInteraction::GetEnergy(){
if(energy == 0){
if(tracks.size() > 0)
energy = tracks[0]->GetInitialEnergy();
}
return energy;
}
std::string MaterialInteraction::GetEnergyToken(){
std::stringstream label;
label.str("");
label.clear();
label << token.substr(0,token.size()-3) << "_energy:XX\t" << GetEnergy();
return label.str();
}
void MaterialInteraction::SetEnergy(double e){
energy = e;
}
void MaterialInteraction::AddInteractionNode(int eventID,double x, double y, double z, double Ekin,double Edep){
if(tracks.size() <= eventID){
ParticleTrack *newtrack = new ParticleTrack();
tracks.push_back(newtrack);
}
tracks[eventID]->AddNode(x,y,z,Ekin,Edep);
}
void MaterialInteraction::TrackReport(int eventID){
if(eventID < tracks.size()){
tracks[eventID]->Report();
std::cout << "Track Length: " << tracks[eventID]->GetTrackLength() << "\n";
}
}
void MaterialInteraction::TrackPlot(int eventID){
if(eventID < tracks.size())
tracks[eventID]->PlotTrack();
}
void MaterialInteraction::CreateHistogramEndZ(){
double maxZ = 0.0;
for(int i=0;i<tracks.size();i++){
if(tracks[i]->GetTrackLength() > maxZ)
maxZ = tracks[i]->GetTrackLength();
}
if(hisEndZ){
delete hisEndZ;
std::cout << "WARNING from MaterialInteraction: Replacing internal histogram!\n";
}
std::stringstream label;
label.str("");
label.clear();
label << "hisEndZ_" << GetEnergy() << "MeV";
hisEndZ = new TH1F(label.str().c_str(),"track length",1000,0.0,maxZ * 1.1);
for(int i=0;i<tracks.size();i++){
hisEndZ->Fill(tracks[i]->GetTrackLength());
}
}
void MaterialInteraction::PlotHistogramEndZ(){
if(hisEndZ==0)
CreateHistogramEndZ();
hisEndZ->SetLineWidth(2);
hisEndZ->SetLineColor(kRed);
hisEndZ->SetXTitle("penetration depth [mm]");
hisEndZ->Draw();
}
double MaterialInteraction::GetAttenuationSimulation(){
if(hisEndZ==0)
CreateHistogramEndZ();
TF1 *expfit = new TF1("expfit","expo",0.0,1000.0);
hisEndZ->Fit(expfit,"Q");
return -10.0 * expfit->GetParameter(1);
}
std::string MaterialInteraction::GetAttenuationSimulationToken(){
std::stringstream label;
label.str("");
label.clear();
label.precision(4);
label << token.substr(0,token.size()-3) << "_attenuation_simulation:XX\t" << GetAttenuationSimulation() << " $\\pm$ ";
label.precision(2);
label << GetAttenuationSimulationSigma();
return label.str();
}
double MaterialInteraction::GetAttenuationSimulationSigma(){
if(hisEndZ==0)
CreateHistogramEndZ();
TF1 *expfit = new TF1("expfit","expo",0.0,1000.0);
hisEndZ->Fit(expfit,"Q");
return 10.0 * expfit->GetParError(1);
}
std::string MaterialInteraction::GetAttenuationDifferenceToken(){
std::stringstream label;
RComp *rcomp = new RComp();
label.str("");
label.clear();
label << token.substr(0,token.size()-3) << "_attenuation_difference:XX\t";
label << rcomp->GetAgreementColourString(GetAverageTotalRange(),GetAttenuationLiterature()*0.005,GetAttenuationLiterature(),0.0,10.0);
delete rcomp;
return label.str();
}
double MaterialInteraction::GetAverageTotalRange(){
double range = 0.0;
for(int i=0;i<tracks.size();i++){
range += tracks[i]->GetTrackLength();
}
range /= (double)(tracks.size());
return range;
}
std::string MaterialInteraction::GetAverageTotalRangeToken(){
std::stringstream label;
label.str("");
label.clear();
label << token.substr(0,token.size()-3) << "_attenuation_simulation:XX\t";
label << GetAverageTotalRange();
return label.str();
}
MaterialInteraction::~MaterialInteraction() {
for(int i=0;i<tracks.size();i++)
delete tracks[i];
tracks.clear();
// if(hisEndZ)
// delete hisEndZ;
}
| [
"[email protected]"
] | |
cf52174c039a708cb46cdd51375decbf7b53411d | 8dfdc9e6c86e00a14fa1eaf3fc260e55a52831f6 | /node_modules/cordova-plugin-vibrate-intense/src/blackberry10/native/src/vibration_js.cpp | 25a9d8ca989db43720bc169b33f16c38e9d41df5 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | sarahbarretto/Barretto_Sarah-Midterm | 893eec2339910729cc381815c6e395bbac1454e7 | 8531927189ac06af7c210867c11ea1d1ae945eb8 | refs/heads/master | 2020-04-03T01:00:27.168079 | 2018-10-27T02:18:24 | 2018-10-27T02:18:24 | 154,828,383 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,769 | cpp | /*
* Copyright 2013-2014 Blackberry Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <string>
#include "../public/tokenizer.h"
#include "vibration_js.hpp"
#include "vibration_ndk.hpp"
using namespace std;
/**
* Default constructor.
*/
VibrationJS::VibrationJS(const std::string& id) :
m_id(id) {
m_pVibrationController = new webworks::VibrationNDK(this);
}
/**
* VibrationJS destructor.
*/
VibrationJS::~VibrationJS() {
if (m_pVibrationController)
delete m_pVibrationController;
}
/**
* This method returns the list of objects implemented by this native
* extension.
*/
char* onGetObjList() {
static char name[] = "VibrationJS";
return name;
}
/**
* This method is used by JNext to instantiate the VibrationJS object when
* an object is created on the JavaScript server side.
*/
JSExt* onCreateObject(const string& className, const string& id) {
if (className == "VibrationJS") {
return new VibrationJS(id);
}
return NULL;
}
/**
* Method used by JNext to determine if the object can be deleted.
*/
bool VibrationJS::CanDelete() {
return true;
}
/**
* It will be called from JNext JavaScript side with passed string.
* This method implements the interface for the JavaScript to native binding
* for invoking native code. This method is triggered when JNext.invoke is
* called on the JavaScript side with this native objects id.
*/
string VibrationJS::InvokeMethod(const string& command) {
size_t commandIndex = command.find_first_of(" ");
std::string strCommand = command.substr(0, commandIndex);
size_t callbackIndex = command.find_first_of(" ", commandIndex + 1);
std::string callbackId = command.substr(commandIndex + 1, callbackIndex - commandIndex - 1);
std::string arg = command.substr(callbackIndex + 1, command.length());
// command appears with parameters following after a space
if (strCommand == "vibration_request") {
m_pVibrationController->vibrationRequest(callbackId, arg);
}
strCommand.append(";");
strCommand.append(command);
return strCommand;
}
// Notifies JavaScript of an event
void VibrationJS::NotifyEvent(const std::string& event) {
std::string eventString = m_id + " ";
eventString.append(event);
SendPluginEvent(eventString.c_str(), m_pContext);
}
| [
"[email protected]"
] | |
7aac4d7a7d754bdebdc1b3fb9fe1c9d7e331979c | 6e0b51a1442fcd2691a81db261a0586e95b8c103 | /main.cpp | 2820d1419e8c2fa077c10676adf6ee3de1b83560 | [] | no_license | rhedman32/GroupProject | 970482f5bae133b4d4944563533de0f203363d24 | 240014f3096245d2203b9c39df28f94a72d6c7a8 | refs/heads/master | 2021-01-18T07:31:04.573229 | 2015-04-19T15:46:15 | 2015-04-19T15:46:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,624 | cpp | //
// main.cpp
// ArenaLogic
//
// Created by Andrew Francis on 4/15/15.
// Copyright (c) 2015 Andrew Francis. All rights reserved.
//
#include <iostream>
#include "Arena.h"
#include "Player.h"
using namespace std;
// Main HELPER METHOD Definitions
void textSeparator() {
cout << "-------------------------\n";
}
// FUNCTION TO DISPLAYS THE GAME RULES
void displayRules() {
cout << "Rules go here\n";
textSeparator();
}
// FUNCTION THAT DISPLAYS THE MENU OPTIONS
void displayMenu() {
cout << "1. Enter the battle Arena\n";
cout << "2. View Items\n";
cout << "3. View Monsters\n";
cout << "4. Quit\n";
textSeparator();
}
void createArena() {
Player player = Player();
Arena ourArena = Arena(player);
//Debugging code
}
void viewItems() {
}
void viewMonsters() {
}
void parseSelection(int selection) {
// FILL IN LOGIC
cout << selection;
if (selection == 1)
createArena(); // Creates the arena if the selection is 1.
else if (selection == 2)
viewItems();
else if (selection == 3)
viewMonsters();
else if (selection == 4)
cout << "Thank you for playing!";
else throw invalid_argument("Invalid selection");
}
// THE MAIN of the Program
int main() {
displayRules();
displayMenu();
int selection;
cin >> selection;
try {
parseSelection(selection);
}
catch( ... ) { cout << "Invalid selection try again.";
cin >> selection;
parseSelection(selection);
throw;
}
return 0;
}
| [
"[email protected]"
] | |
95285a25e61ade5363989a711c8c6c17f7655b3d | 4f3ca870385f532dccff9602131d15bfdd2ea961 | /components/offline_pages/core/background/mark_attempt_completed_task_unittest.cc | e4585540eb0aca1e3a19266de398591af411bb73 | [
"BSD-3-Clause"
] | permissive | nmhung1210/chromium | 6090ef1b8812990ce5f437900a9951d67c577d26 | 67d0ec786c8fac2dfe4bd92851aa70c96aae9829 | refs/heads/master | 2023-01-07T02:47:49.751768 | 2018-11-25T06:52:39 | 2018-11-25T06:52:39 | 159,008,512 | 1 | 0 | NOASSERTION | 2018-11-25T07:31:29 | 2018-11-25T07:31:29 | null | UTF-8 | C++ | false | false | 3,646 | cc | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/offline_pages/core/background/mark_attempt_completed_task.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "components/offline_pages/core/background/request_queue_store.h"
#include "components/offline_pages/core/background/request_queue_task_test_base.h"
#include "components/offline_pages/core/background/test_request_queue_store.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace offline_pages {
namespace {
const int64_t kRequestId1 = 42;
const int64_t kRequestId2 = 44;
const GURL kUrl1("http://example.com");
const ClientId kClientId1("download", "1234");
class MarkAttemptCompletedTaskTest : public RequestQueueTaskTestBase {
public:
MarkAttemptCompletedTaskTest() {}
~MarkAttemptCompletedTaskTest() override {}
void AddStartedItemToStore();
void ChangeRequestsStateCallback(UpdateRequestsResult result);
UpdateRequestsResult* last_result() const { return result_.get(); }
private:
void AddRequestDone(ItemActionStatus status);
std::unique_ptr<UpdateRequestsResult> result_;
};
void MarkAttemptCompletedTaskTest::AddStartedItemToStore() {
base::Time creation_time = base::Time::Now();
SavePageRequest request_1(kRequestId1, kUrl1, kClientId1, creation_time,
true);
request_1.MarkAttemptStarted(base::Time::Now());
store_.AddRequest(
request_1, base::BindOnce(&MarkAttemptCompletedTaskTest::AddRequestDone,
base::Unretained(this)));
PumpLoop();
}
void MarkAttemptCompletedTaskTest::ChangeRequestsStateCallback(
UpdateRequestsResult result) {
result_ = std::make_unique<UpdateRequestsResult>(std::move(result));
}
void MarkAttemptCompletedTaskTest::AddRequestDone(ItemActionStatus status) {
ASSERT_EQ(ItemActionStatus::SUCCESS, status);
}
TEST_F(MarkAttemptCompletedTaskTest, MarkAttemptCompletedWhenExists) {
InitializeStore();
AddStartedItemToStore();
MarkAttemptCompletedTask task(
&store_, kRequestId1, FailState::CANNOT_DOWNLOAD,
base::BindOnce(&MarkAttemptCompletedTaskTest::ChangeRequestsStateCallback,
base::Unretained(this)));
task.Run();
PumpLoop();
ASSERT_TRUE(last_result());
EXPECT_EQ(1UL, last_result()->item_statuses.size());
EXPECT_EQ(kRequestId1, last_result()->item_statuses.at(0).first);
EXPECT_EQ(ItemActionStatus::SUCCESS,
last_result()->item_statuses.at(0).second);
EXPECT_EQ(1UL, last_result()->updated_items.size());
EXPECT_EQ(1, last_result()->updated_items.at(0).completed_attempt_count());
EXPECT_EQ(SavePageRequest::RequestState::AVAILABLE,
last_result()->updated_items.at(0).request_state());
}
TEST_F(MarkAttemptCompletedTaskTest, MarkAttemptCompletedWhenItemMissing) {
InitializeStore();
// Add request 1 to the store.
AddStartedItemToStore();
// Try to mark request 2 (not in the store).
MarkAttemptCompletedTask task(
&store_, kRequestId2, FailState::CANNOT_DOWNLOAD,
base::BindOnce(&MarkAttemptCompletedTaskTest::ChangeRequestsStateCallback,
base::Unretained(this)));
task.Run();
PumpLoop();
ASSERT_TRUE(last_result());
EXPECT_EQ(1UL, last_result()->item_statuses.size());
EXPECT_EQ(kRequestId2, last_result()->item_statuses.at(0).first);
EXPECT_EQ(ItemActionStatus::NOT_FOUND,
last_result()->item_statuses.at(0).second);
EXPECT_EQ(0UL, last_result()->updated_items.size());
}
} // namespace
} // namespace offline_pages
| [
"[email protected]"
] | |
48a528b8ab343ed9208be3cc7e5573ab29f6793b | a09400aa22a27c7859030ec470b5ddee93e0fdf0 | /stalkersoc/source/Level_Bullet_Manager.cpp | 4aef30ec9db4d08badebb9e699aa1859b7e1e80d | [] | no_license | BearIvan/Stalker | 4f1af7a9d6fc5ed1597ff13bd4a34382e7fdaab1 | c0008c5103049ce356793b37a9d5890a996eed23 | refs/heads/master | 2022-04-04T02:07:11.747666 | 2020-02-16T10:51:57 | 2020-02-16T10:51:57 | 160,668,112 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 15,879 | cpp | // Level_Bullet_Manager.cpp: ��� ����������� ������ ���� �� ����������
// ��� ���� � ������� ���������� ����
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Level.h"
#include "Level_Bullet_Manager.h"
#include "game_cl_base.h"
#include "Actor.h"
#include "gamepersistent.h"
#include "mt_config.h"
#include "game_cl_base_weapon_usage_statistic.h"
#include "xrRender/UIRender.h"
#ifdef DEBUG
# include "debug_renderer.h"
#endif
#define HIT_POWER_EPSILON 0.05f
#define WALLMARK_SIZE 0.04f
float CBulletManager::m_fMinBulletSpeed = 2.f;
SBullet::SBullet()
{
}
SBullet::~SBullet()
{
}
void SBullet::Init(const Fvector& position,
const Fvector& direction,
float starting_speed,
float power,
float impulse,
u16 sender_id,
u16 sendersweapon_id,
ALife::EHitType e_hit_type,
float maximum_distance,
const CCartridge& cartridge,
bool SendHit)
{
flags._storage = 0;
pos = position;
speed = max_speed = starting_speed;
VERIFY (speed>0);
VERIFY(direction.magnitude()>0);
dir.normalize (direction);
hit_power = power * cartridge.m_kHit;
hit_impulse = impulse * cartridge.m_kImpulse;
max_dist = maximum_distance * cartridge.m_kDist;
fly_dist = 0;
parent_id = sender_id;
flags.allow_sendhit = SendHit;
weapon_id = sendersweapon_id;
hit_type = e_hit_type;
pierce = cartridge.m_kPierce;
ap = cartridge.m_kAP;
air_resistance = cartridge.m_kAirRes;
wallmark_size = cartridge.fWallmarkSize;
m_u8ColorID = cartridge.m_u8ColorID;
bullet_material_idx = cartridge.bullet_material_idx;
VERIFY (u16(-1)!=bullet_material_idx);
flags.allow_tracer = !!cartridge.m_flags.test(CCartridge::cfTracer);
flags.allow_ricochet = !!cartridge.m_flags.test(CCartridge::cfRicochet);
flags.explosive = !!cartridge.m_flags.test(CCartridge::cfExplosive);
flags.skipped_frame = 0;
targetID = 0;
}
//////////////////////////////////////////////////////////
//
CBulletManager::CBulletManager()
#ifdef PROFILE_CRITICAL_SECTIONS
:m_Lock(MUTEX_PROFILE_ID(CBulletManager))
#endif // PROFILE_CRITICAL_SECTIONS
{
m_Bullets.clear ();
m_Bullets.reserve (100);
}
CBulletManager::~CBulletManager()
{
m_Bullets.clear ();
m_WhineSounds.clear ();
m_Events.clear ();
}
#define BULLET_MANAGER_SECTION "bullet_manager"
void CBulletManager::Load ()
{
m_fTracerWidth = pSettings->r_float(BULLET_MANAGER_SECTION, "tracer_width");
m_fTracerLengthMax = pSettings->r_float(BULLET_MANAGER_SECTION, "tracer_length_max");
m_fTracerLengthMin = pSettings->r_float(BULLET_MANAGER_SECTION, "tracer_length_min");
m_fGravityConst = pSettings->r_float(BULLET_MANAGER_SECTION, "gravity_const");
m_fAirResistanceK = pSettings->r_float(BULLET_MANAGER_SECTION, "air_resistance_k");
m_dwStepTime = pSettings->r_u32 (BULLET_MANAGER_SECTION, "time_step");
m_fMinBulletSpeed = pSettings->r_float(BULLET_MANAGER_SECTION, "min_bullet_speed");
m_fCollisionEnergyMin = pSettings->r_float(BULLET_MANAGER_SECTION, "collision_energy_min");
m_fCollisionEnergyMax = pSettings->r_float(BULLET_MANAGER_SECTION, "collision_energy_max");
m_fHPMaxDist = pSettings->r_float(BULLET_MANAGER_SECTION, "hit_probability_max_dist");
LPCSTR whine_sounds = pSettings->r_string(BULLET_MANAGER_SECTION, "whine_sounds");
int cnt = XrTrims::GetItemCount(whine_sounds);
xr_string tmp;
for (int k=0; k<cnt; ++k){
m_WhineSounds.push_back (ref_sound());
m_WhineSounds.back().create(XrTrims::GetItem(whine_sounds,k,tmp),st_Effect,sg_SourceType);
}
LPCSTR explode_particles= pSettings->r_string(BULLET_MANAGER_SECTION, "explode_particles");
cnt = XrTrims::GetItemCount(explode_particles);
for (int k=0; k<cnt; ++k)
m_ExplodeParticles.push_back (XrTrims::GetItem(explode_particles,k,tmp));
}
void CBulletManager::PlayExplodePS (const Fmatrix& xf)
{
if (!m_ExplodeParticles.empty()){
const shared_str& ps_name = m_ExplodeParticles[Random.randI(0, m_ExplodeParticles.size())];
CParticlesObject* ps = CParticlesObject::Create(*ps_name,TRUE);
ps->UpdateParent(xf,zero_vel);
GamePersistent().ps_needtoplay.push_back(ps);
}
}
void CBulletManager::PlayWhineSound(SBullet* bullet, CObject* object, const Fvector& pos)
{
if (m_WhineSounds.empty()) return;
if (bullet->m_whine_snd._feedback() != NULL) return;
if(bullet->hit_type!=ALife::eHitTypeFireWound ) return;
bullet->m_whine_snd = m_WhineSounds[Random.randI(0, m_WhineSounds.size())];
bullet->m_whine_snd.play_at_pos (object,pos);
}
void CBulletManager::Clear ()
{
m_Bullets.clear ();
m_Events.clear ();
}
void CBulletManager::AddBullet(const Fvector& position,
const Fvector& direction,
float starting_speed,
float power,
float impulse,
u16 sender_id,
u16 sendersweapon_id,
ALife::EHitType e_hit_type,
float maximum_distance,
const CCartridge& cartridge,
bool SendHit,
bool AimBullet)
{
m_Lock.Enter ();
VERIFY (u16(-1)!=cartridge.bullet_material_idx);
// u32 CurID = Level().CurrentControlEntity()->ID();
// u32 OwnerID = sender_id;
m_Bullets.push_back(SBullet());
SBullet& bullet = m_Bullets.back();
bullet.Init (position, direction, starting_speed, power, impulse, sender_id, sendersweapon_id, e_hit_type, maximum_distance, cartridge, SendHit);
bullet.frame_num = Device.dwFrame;
bullet.flags.aim_bullet = AimBullet;
if (SendHit && GameID() != GAME_SINGLE)
Game().m_WeaponUsageStatistic->OnBullet_Fire(&bullet, cartridge);
m_Lock.Leave ();
}
void CBulletManager::UpdateWorkload()
{
m_Lock.Enter () ;
u32 delta_time = Device.dwTimeDelta + m_dwTimeRemainder;
u32 step_num = delta_time/m_dwStepTime;
m_dwTimeRemainder = delta_time%m_dwStepTime;
rq_storage.r_clear ();
rq_spatial.clear_not_free ();
for(int k=m_Bullets.size()-1; k>=0; k--){
SBullet& bullet = m_Bullets[k];
//��� ���� �������� �� ���� �� ����� ������� ������ 1 ���
//(���� �� ������ ������ ������ ������� �� ����)
//������� ��������� �� ��������� �����,
//��� �������� ��� ���� ���� ��� ������� FPS �� ���������
//� 2� ������
u32 cur_step_num = step_num;
u32 frames_pass = Device.dwFrame - bullet.frame_num;
if(frames_pass == 0) cur_step_num = 1;
else if (frames_pass == 1 && step_num>0) cur_step_num -= 1;
// calculate bullet
for(u32 i=0; i<cur_step_num; i++){
if(!CalcBullet(rq_storage,rq_spatial,&bullet, m_dwStepTime)){
collide::rq_result res;
RegisterEvent(EVENT_REMOVE, FALSE, &bullet, Fvector().set(0, 0, 0), res, (u16)k);
// if (bullet.flags.allow_sendhit && GameID() != GAME_SINGLE)
// Game().m_WeaponUsageStatistic->OnBullet_Remove(&bullet);
// m_Bullets[k] = m_Bullets.back();
// m_Bullets.pop_back();
break;
}
}
}
m_Lock.Leave ();
}
bool CBulletManager::CalcBullet (collide::rq_results & rq_storage1, xr_vector<ISpatial*>& rq_spatial1, SBullet* bullet, u32 delta_time)
{
VERIFY (bullet);
float delta_time_sec = float(delta_time)/1000.f;
float range = bullet->speed*delta_time_sec;
float max_range = bullet->max_dist - bullet->fly_dist;
if(range>max_range)
range = max_range;
//��������� ������� �������� ����, �.�. �
//RayQuery() ��� ����� ���������� ��-�� ���������
//� ������������ � ���������
Fvector cur_dir = bullet->dir;
bullet_test_callback_data bullet_data;
bullet_data.pBullet = bullet;
bullet_data.bStopTracing = true;
bullet->flags.ricochet_was = 0;
collide::ray_defs RD (bullet->pos, bullet->dir, range, CDB::OPT_CULL, collide::rqtBoth);
BOOL result = FALSE;
VERIFY (!XrMath::fis_zero(RD.dir.square_magnitude()));
result = Level().ObjectSpace.RayQuery(rq_storage1, RD, firetrace_callback, &bullet_data, test_callback, NULL);
if (result && bullet_data.bStopTracing)
{
range = (rq_storage1.r_begin()+rq_storage1.r_count()-1)->range;
}
range = XrMath::max (XrMath::EPS_L,range);
bullet->flags.skipped_frame = (Device.dwFrame >= bullet->frame_num);
if(!bullet->flags.ricochet_was) {
//�������� ��������� ����
bullet->pos.mad(bullet->pos, cur_dir, range);
bullet->fly_dist += range;
if(bullet->fly_dist>=bullet->max_dist)
return false;
Fbox level_box = Level().ObjectSpace.GetBoundingVolume();
/* if(!level_box.contains(bullet->pos))
return false;
*/
if(!((bullet->pos.x>=level_box.x1) &&
(bullet->pos.x<=level_box.x2) &&
(bullet->pos.y>=level_box.y1) &&
// (bullet->pos.y<=level_box.y2) &&
(bullet->pos.z>=level_box.z1) &&
(bullet->pos.z<=level_box.z2)) )
return false;
//�������� �������� � ����������� �� ������
//� ������ ����������
bullet->dir.mul(bullet->speed);
Fvector air_resistance = bullet->dir;
if (GameID() == GAME_SINGLE)
air_resistance.mul(-m_fAirResistanceK*delta_time_sec);
else
air_resistance.mul(-bullet->air_resistance*(bullet->speed)/(bullet->max_speed)*delta_time_sec);
/// Msg("Speed - %f; ar - %f, %f", bullet->dir.magnitude(), air_resistance.magnitude(), air_resistance.magnitude()/bullet->dir.magnitude()*100);
bullet->dir.add(air_resistance);
bullet->dir.y -= m_fGravityConst*delta_time_sec;
bullet->speed = bullet->dir.magnitude();
VERIFY(_valid(bullet->speed));
VERIFY(!XrMath::fis_zero(bullet->speed));
//������ normalize(), ���� �� ������� 2 ���� magnitude()
#pragma todo("� ��� ������ bullet->speed==0")
bullet->dir.x /= bullet->speed;
bullet->dir.y /= bullet->speed;
bullet->dir.z /= bullet->speed;
}
if(bullet->speed<m_fMinBulletSpeed)
return false;
return true;
}
#ifdef DEBUG
BOOL g_bDrawBulletHit = FALSE;
#endif
float SqrDistancePointToSegment(const Fvector& pt, const Fvector& orig, const Fvector& dir)
{
Fvector diff; diff.sub(pt,orig);
float fT = diff.dotproduct(dir);
if ( fT <= 0.0f ){
fT = 0.0f;
}else{
float fSqrLen= dir.square_magnitude();
if ( fT >= fSqrLen ){
fT = 1.0f;
diff.sub(dir);
}else{
fT /= fSqrLen;
diff.sub(Fvector().mul(dir,fT));
}
}
return diff.square_magnitude();
}
void CBulletManager::Render ()
{
#ifdef DEBUG
//0-�������
//1-����������� ���� � ���������
//2-���������� ���������
if (g_bDrawBulletHit) {
extern FvectorVec g_hit[];
FvectorIt it;
u32 C[3] = { 0xffff0000,0xff00ff00,0xff0000ff };
//RCache.set_xform_world(Fidentity);
DRender->CacheSetXformWorld(Fidentity);
for (int i = 0; i<3; ++i)
for (it = g_hit[i].begin(); it != g_hit[i].end(); ++it) {
Level().debug_renderer().draw_aabb(*it, 0.01f, 0.01f, 0.01f, C[i]);
}
}
#endif
if(m_BulletsRendered.empty()) return;
u32 bullet_num = m_BulletsRendered.size();
UIRender->StartPrimitive((u32)bullet_num * 12, IUIRender::ptTriList, IUIRender::pttLIT);
for(BulletVecIt it = m_BulletsRendered.begin(); it!=m_BulletsRendered.end(); it++){
SBullet* bullet = &(*it);
if(!bullet->flags.allow_tracer) continue;
if (!bullet->flags.skipped_frame) continue;
float length = bullet->speed*float(m_dwStepTime)/1000.f;//dist.magnitude();
if(length<m_fTracerLengthMin) continue;
if(length>m_fTracerLengthMax)
length = m_fTracerLengthMax;
float width = m_fTracerWidth;
float dist2segSqr = SqrDistancePointToSegment(Device.vCameraPosition, bullet->pos, Fvector().mul(bullet->dir, length));
//---------------------------------------------
float MaxDistSqr = 1.0f;
float MinDistSqr = 0.09f;
if (dist2segSqr < MaxDistSqr)
{
if (dist2segSqr < MinDistSqr) dist2segSqr = MinDistSqr;
width *= XrMath::sqrt(dist2segSqr/MaxDistSqr);//*MaxDistWidth/0.08f;
}
if (Device.vCameraPosition.distance_to_sqr(bullet->pos)<(length*length))
{
length = Device.vCameraPosition.distance_to(bullet->pos) - 0.3f;
}
/*
//---------------------------------------------
Fvector vT, v0, v1;
vT.mad(Device.vCameraPosition, Device.vCameraDirection, XrMath::sqrt(dist2segSqr));
v0.mad(vT, Device.vCameraTop, width*.5f);
v1.mad(vT, Device.vCameraTop, -width*.5f);
Fvector v0r, v1r;
Device.mFullTransform.transform(v0r, v0);
Device.mFullTransform.transform(v1r, v1);
float ViewWidth = v1r.distance_to(v0r);
*/
// float dist = XrMath::sqrt(dist2segSqr);
// Msg("dist - [%f]; ViewWidth - %f, [%f]", dist, ViewWidth, ViewWidth*float(Device.dwHeight));
// Msg("dist - [%f]", dist);
//---------------------------------------------
bool bActor = false;
if (Level().CurrentViewEntity())
{
bActor = (bullet->parent_id == Level().CurrentViewEntity()->ID());
}
Fvector center;
center.mad (bullet->pos, bullet->dir, -length*.5f);
// tracers.Render (verts, bullet->pos, center, bullet->dir, length, width, bullet->m_u8ColorID);
tracers.Render(bullet->pos, center, bullet->dir, length, width, bullet->m_u8ColorID, bullet->speed, bActor);
}
UIRender->CacheSetCullMode(IUIRender::cmNONE);
UIRender->CacheSetXformWorld(Fidentity);
UIRender->SetShader(*tracers.sh_Tracer);
UIRender->FlushPrimitive();
UIRender->CacheSetCullMode(IUIRender::cmCCW);
}
void CBulletManager::CommitRenderSet () // @ the end of frame
{
m_BulletsRendered = m_Bullets ;
if (g_mt_config.test(mtBullets)) {
Device.seqParallel.push_back (XrFastDelegate<void>(this,&CBulletManager::UpdateWorkload));
} else {
UpdateWorkload ();
}
}
void CBulletManager::CommitEvents () // @ the start of frame
{
for (u32 _it=0; _it<m_Events.size(); _it++) {
_event& E = m_Events[_it];
switch (E.Type)
{
case EVENT_HIT:
{
if (E.dynamic) DynamicObjectHit (E);
else StaticObjectHit (E);
}break;
case EVENT_REMOVE:
{
if (E.bullet.flags.allow_sendhit && GameID() != GAME_SINGLE)
Game().m_WeaponUsageStatistic->OnBullet_Remove(&E.bullet);
m_Bullets[E.tgt_material] = m_Bullets.back();
m_Bullets.pop_back();
}break;
}
}
m_Events.clear_and_reserve () ;
}
void CBulletManager::RegisterEvent (EventType Type, BOOL _dynamic, SBullet* bullet, const Fvector& end_point, collide::rq_result& R, u16 tgt_material)
{
m_Events.push_back (_event()) ;
_event& E = m_Events.back() ;
E.Type = Type ;
E.bullet = *bullet ;
switch(Type)
{
case EVENT_HIT:
{
E.dynamic = _dynamic ;
E.result = ObjectHit (bullet,end_point,R,tgt_material,E.normal);
E.point = end_point ;
E.R = R ;
E.tgt_material = tgt_material ;
if (_dynamic)
{
// E.Repeated = (R.O->ID() == E.bullet.targetID);
// bullet->targetID = R.O->ID();
E.Repeated = (R.O->ID() == E.bullet.targetID);
if (GameID() == GAME_SINGLE)
{
bullet->targetID = R.O->ID();
}
else
{
if (bullet->targetID != R.O->ID())
{
CGameObject* pGO = smart_cast<CGameObject*>(R.O);
if (!pGO || !pGO->BonePassBullet(R.element))
bullet->targetID = R.O->ID();
}
}
};
}break;
case EVENT_REMOVE:
{
E.tgt_material = tgt_material ;
}break;
}
}
| [
"[email protected]"
] | |
8f12a9243eb2f1e6149b30ab8823cb75fa131caf | d43ca4dfa9c39707394e1831ffdb9978889a003b | /src/platform-windows.h | 0cb6f223eee238677fdbdc34ff7d81c72cb7fef5 | [
"MIT"
] | permissive | joshpeterson/fun-console | ecb70e5c7a63b4dd7bacbba9377e8b73742f65ef | 32f5d4573b6e05a0eda73716e45cde599199c35f | refs/heads/master | 2023-01-02T03:57:36.146757 | 2020-10-17T11:11:19 | 2020-10-17T11:11:19 | 272,185,010 | 1 | 0 | null | 2020-09-01T12:59:59 | 2020-06-14T11:06:34 | C++ | UTF-8 | C++ | false | false | 236 | h | #pragma once
#include "platform.h"
namespace fun
{
class PlatformWindows : public Platform
{
public:
PlatformWindows();
bool SupportsEmoji() const override;
bool SupportsControlCharacters() const override;
};
} // namespace fun
| [
"[email protected]"
] | |
6889342df692d3c2d43ea269fccafd2a19c658f2 | d044d94f3af1f057c118a583ce3c05c597a6253d | /src/luabind/src/class.cpp | de1086575350e9a58d5ab0882cee3f9dec8dbc4f | [
"MIT"
] | permissive | lonski/amarlon_dependencies | 3e4c08f40cea0cf8263f7d5ead593f981591cf17 | 1e07f90ffa3bf1aeba92ad9a9203aae4df6103e3 | refs/heads/master | 2021-01-10T08:17:16.101370 | 2016-03-28T21:29:39 | 2016-03-28T21:29:39 | 43,238,474 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,359 | cpp | // Copyright (c) 2004 Daniel Wallin and Arvid Norberg
// 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.
#define LUABIND_BUILDING
#include <luabind/class.hpp>
#include <luabind/config.hpp>
#include <luabind/nil.hpp>
#include <boost/foreach.hpp>
#include <luabind/lua_include.hpp>
#include <cstring>
#include <iostream>
namespace luabind
{
LUABIND_API detail::nil_type nil;
}
namespace luabind { namespace detail {
namespace
{
struct cast_entry
{
cast_entry(class_id src_, class_id target_, cast_function cast_)
: src(src_)
, target(target_)
, cast(cast_)
{}
class_id src;
class_id target;
cast_function cast;
};
} // namespace unnamed
struct class_registration : registration
{
class_registration(char const* name);
void register_(lua_State* L) const;
const char* m_name;
mutable std::map<const char*, int, detail::ltstr> m_static_constants;
mutable std::vector<type_id> m_bases;
type_id m_type;
class_id m_id;
class_id m_wrapper_id;
type_id m_wrapper_type;
std::vector<cast_entry> m_casts;
scope m_scope;
scope m_members;
scope m_default_members;
};
class_registration::class_registration(char const* name)
{
m_name = name;
}
void class_registration::register_(lua_State* L) const
{
LUABIND_CHECK_STACK(L);
assert(lua_type(L, -1) == LUA_TTABLE);
if (m_name != 0) {
lua_pushstring(L, m_name);
}
detail::class_rep* crep;
detail::class_registry* r = detail::class_registry::get_registry(L);
// create a class_rep structure for this class.
// allocate it within lua to let lua collect it on
// lua_close(). This is better than allocating it
// as a static, since it will then be destructed
// when the program exits instead.
// warning: we assume that lua will not
// move the userdata memory.
lua_newuserdata(L, sizeof(detail::class_rep));
crep = reinterpret_cast<detail::class_rep*>(lua_touserdata(L, -1));
new(crep) detail::class_rep(
m_type
, m_name
, L
);
// register this new type in the class registry
r->add_class(m_type, crep);
lua_rawgetp(L, LUA_REGISTRYINDEX, &class_map_tag);
class_map& classes = *static_cast<class_map*>(
lua_touserdata(L, -1));
lua_pop(L, 1);
classes.put(m_id, crep);
bool const has_wrapper = m_wrapper_id != registered_class<null_type>::id;
if (has_wrapper)
classes.put(m_wrapper_id, crep);
crep->m_static_constants.swap(m_static_constants);
detail::class_registry* registry = detail::class_registry::get_registry(L);
crep->get_default_table(L);
m_scope.register_(L);
m_default_members.register_(L);
lua_pop(L, 1);
crep->get_table(L);
m_members.register_(L);
lua_pop(L, 1);
lua_rawgetp(L, LUA_REGISTRYINDEX, &cast_graph_tag);
cast_graph* const casts = static_cast<cast_graph*>(
lua_touserdata(L, -1));
lua_pop(L, 1);
lua_rawgetp(L, LUA_REGISTRYINDEX, &classid_map_tag);
class_id_map* const class_ids = static_cast<class_id_map*>(
lua_touserdata(L, -1));
lua_pop(L, 1);
class_ids->put(m_id, m_type);
if (has_wrapper)
class_ids->put(m_wrapper_id, m_wrapper_type);
BOOST_FOREACH(cast_entry const& e, m_casts)
{
casts->insert(e.src, e.target, e.cast);
}
for (std::vector<type_id>::iterator i = m_bases.begin();
i != m_bases.end(); ++i)
{
LUABIND_CHECK_STACK(L);
// the baseclass' class_rep structure
detail::class_rep* bcrep = registry->find_class(*i);
crep->add_base_class(bcrep);
// copy base class table
crep->get_table(L);
bcrep->get_table(L);
lua_pushnil(L);
while (lua_next(L, -2))
{
lua_pushvalue(L, -2); // copy key
lua_gettable(L, -5);
if (!lua_isnil(L, -1))
{
lua_pop(L, 2);
continue;
}
lua_pop(L, 1);
lua_pushvalue(L, -2); // copy key
lua_insert(L, -2);
lua_settable(L, -5);
}
lua_pop(L, 2);
// copy base class detaults table
crep->get_default_table(L);
bcrep->get_default_table(L);
lua_pushnil(L);
while (lua_next(L, -2))
{
lua_pushvalue(L, -2); // copy key
lua_gettable(L, -5);
if (!lua_isnil(L, -1))
{
lua_pop(L, 2);
continue;
}
lua_pop(L, 1);
lua_pushvalue(L, -2); // copy key
lua_insert(L, -2);
lua_settable(L, -5);
}
lua_pop(L, 2);
}
if (m_name != 0) {
lua_settable(L, -3);
}
else {
lua_pop(L, 1);
}
}
// -- interface ---------------------------------------------------------
class_base::class_base(char const* name_)
: scope(std::unique_ptr<registration>(
m_registration = new class_registration(name_))
)
{
}
void class_base::init(
type_id const& type_id_, class_id id
, type_id const& wrapper_type, class_id wrapper_id)
{
m_registration->m_type = type_id_;
m_registration->m_id = id;
m_registration->m_wrapper_type = wrapper_type;
m_registration->m_wrapper_id = wrapper_id;
}
void class_base::add_base(type_id const& base)
{
m_registration->m_bases.push_back(base);
}
void class_base::add_member(registration* member)
{
std::unique_ptr<registration> ptr(member);
m_registration->m_members.operator,(scope(std::move(ptr)));
}
void class_base::add_default_member(registration* member)
{
std::unique_ptr<registration> ptr(member);
m_registration->m_default_members.operator,(scope(std::move(ptr)));
}
const char* class_base::name() const
{
return m_registration->m_name;
}
void class_base::add_static_constant(const char* name_, int val)
{
m_registration->m_static_constants[name_] = val;
}
void class_base::add_inner_scope(scope& s)
{
m_registration->m_scope.operator,(s);
}
void class_base::add_cast(
class_id src, class_id target, cast_function cast)
{
m_registration->m_casts.push_back(cast_entry(src, target, cast));
}
std::string get_class_name(lua_State* L, type_id const& i)
{
std::string ret;
assert(L);
class_registry* r = class_registry::get_registry(L);
class_rep* crep = r->find_class(i);
if (!crep || !crep->name())
{
ret = crep ? "unnamed [" : "custom [";
ret += i.name();
ret += ']';
}
else
{
/* TODO reimplement this?
if (i == crep->holder_type())
{
ret += "smart_ptr<";
ret += crep->name();
ret += ">";
}
else if (i == crep->const_holder_type())
{
ret += "smart_ptr<const ";
ret += crep->name();
ret += ">";
}
else*/
{
ret += crep->name();
}
}
return ret;
}
}} // namespace luabind::detail
| [
"[email protected]"
] | |
9e70175c9bee5976bbc46d1b17c72449ff8a4e48 | 1d28a48f1e02f81a8abf5a33c233d9c38e339213 | /SVEngine/src/file/SVParseAniTrigger.cpp | 4cd6fcf8fc7cb91ee712ac4c47b9a514bdeefc48 | [
"MIT"
] | permissive | SVEChina/SVEngine | 4972bed081b858c39e5871c43fd39e80c527c2b1 | 56174f479a3096e57165448142c1822e7db8c02f | refs/heads/master | 2021-07-09T10:07:46.350906 | 2020-05-24T04:10:57 | 2020-05-24T04:10:57 | 150,706,405 | 34 | 9 | null | null | null | null | UTF-8 | C++ | false | false | 457 | cpp | //
// SVParseAniTrigger.cpp
// SVEngine
// Copyright 2017-2020
// yizhou Fu,long Yin,longfei Lin,ziyu Xu,xiaofan Li,daming Li
//
#include "SVParseAniTrigger.h"
#include "../act/SVAniTrigger.h"
SVAniTriggerPtr SVParseAniTrigger::parseAniTrigger(SVInst *_app, RAPIDJSON_NAMESPACE::Value &item, s32 _resid, cptr8 _path) {
SVAniTriggerPtr trigger = MakeSharedPtr<SVAniTrigger>(_app);
trigger->init();
trigger->fromJson(item);
return trigger;
}
| [
"[email protected]"
] | |
ebe5fdc976abe467cc99784e444760b87ceace95 | 062e15bf0f33c9cde8027548f760a2b3c6839090 | /08/COMMON/DOTPRODC.CPP | 9297e67e5f44c994fae9a64b58e13c0a9eb23971 | [] | no_license | dumpinfo/DNNCudatest | 5098e994fff209c9cf95ac164fab025e9a829f6c | c1f3e1fb3a9e74870360143ee9b44d7a4d53cb66 | refs/heads/master | 2023-02-03T02:31:26.454713 | 2020-12-24T20:21:18 | 2020-12-24T20:21:18 | 324,229,439 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,991 | cpp | /******************************************************************************/
/* */
/* DOTPRODC - Compute dot product of two complex vectors */
/* */
/* Copyright (c) 1995 Timothy Masters. All rights reserved. */
/* Reproduction or translation of this work beyond that permitted in section */
/* 117 of the 1976 United States Copyright Act without the express written */
/* permission of the copyright owner is unlawful. Requests for further */
/* information should be addressed to the Permissions Department, John Wiley */
/* & Sons, Inc. The purchaser may make backup copies for his/her own use */
/* only and not for distribution or resale. */
/* Neither the author nor the publisher assumes responsibility for errors, */
/* omissions, or damages, caused by the use of these programs or from the */
/* use of the information contained herein. */
/* */
/******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <conio.h>
#include <ctype.h>
#include <stdlib.h>
#include "const.h" // System and limitation constants, typedefs, structs
#include "classes.h" // Includes all class headers
#include "funcdefs.h" // Function prototypes
void dotprodc (
int n , // Length of vectors
double *vec1 , // One of the vectors to be dotted
double *vec2 , // The other vector
double *re , // Real part of output
double *im ) // and imaginary
{
int k, m ;
*re = *im = 0.0 ; // Will cumulate dot product here
k = n / 4 ; // Divide vector into this many groups of 4
m = n % 4 ; // This is the remainder of that division
while (k--) { // Do each group of 4
*re += *(vec1 ) * *(vec2 ) - *(vec1+1) * *(vec2+1) ;
*re += *(vec1+2) * *(vec2+2) - *(vec1+3) * *(vec2+3) ;
*re += *(vec1+4) * *(vec2+4) - *(vec1+5) * *(vec2+5) ;
*re += *(vec1+6) * *(vec2+6) - *(vec1+7) * *(vec2+7) ;
*im += *(vec1 ) * *(vec2+1) + *(vec1+1) * *(vec2 ) ;
*im += *(vec1+2) * *(vec2+3) + *(vec1+3) * *(vec2+2) ;
*im += *(vec1+4) * *(vec2+5) + *(vec1+5) * *(vec2+4) ;
*im += *(vec1+6) * *(vec2+7) + *(vec1+7) * *(vec2+6) ;
vec1 += 8 ;
vec2 += 8 ;
}
while (m--) { // Do the remainder
*re += *vec1 * *vec2 - *(vec1+1) * *(vec2+1) ;
*im += *vec1 * *(vec2+1) + *(vec1+1) * *vec2 ;
vec1 += 2 ;
vec2 += 2 ;
}
}
/*
--------------------------------------------------------------------------------
DOTPRODCR - This version computes only the real part
--------------------------------------------------------------------------------
*/
double dotprodcr (
int n , // Length of vectors
double *vec1 , // One of the vectors to be dotted
double *vec2 ) // The other vector
{
int k, m ;
double sum ;
sum = 0.0 ; // Will cumulate dot product here
k = n / 4 ; // Divide vector into this many groups of 4
m = n % 4 ; // This is the remainder of that division
while (k--) { // Do each group of 4
sum += *(vec1 ) * *(vec2 ) - *(vec1+1) * *(vec2+1) ;
sum += *(vec1+2) * *(vec2+2) - *(vec1+3) * *(vec2+3) ;
sum += *(vec1+4) * *(vec2+4) - *(vec1+5) * *(vec2+5) ;
sum += *(vec1+6) * *(vec2+6) - *(vec1+7) * *(vec2+7) ;
vec1 += 8 ;
vec2 += 8 ;
}
while (m--) { // Do the remainder
sum += *vec1 * *vec2 - *(vec1+1) * *(vec2+1) ;
vec1 += 2 ;
vec2 += 2 ;
}
return sum ;
}
| [
"[email protected]"
] | |
1c27dfcf78627157a2d3727a177308b1adaa918e | 98ad7179c2bdecb7c428f1ab3aa34e430dbd2a50 | /Engine/Base/Resources/IResourceLoader.h | 36bb100d6ae257b5eb80edafde3d1e1fc596e03e | [
"BSD-3-Clause"
] | permissive | blizmax/GraphicsGenFramework | c7399efce254d5b5e6fa967a956c7adae8019cab | 89cb8cf95c105f12187ed3da999d16620a5b528a | refs/heads/master | 2021-09-24T03:39:26.403453 | 2018-10-02T20:02:03 | 2018-10-02T20:02:03 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,131 | h | // Copyright © 2014-2017 Zhirnov Andrey. All rights reserved.
#pragma once
#include "Resource.h"
namespace Engine
{
namespace Base
{
//
// Loader interface
//
class IResourceLoader : public BaseObject
{
// types
protected:
struct ResourceFileHeader : public CompileTime::PODStruct
{
typedef CompileTime::Signature<uint> Signature_t;
// variables
private:
Signature_t::value_t signature;
uint version;
// methods
public:
ResourceFileHeader (Signature_t::value_t signature, uint version) :
signature( signature ),
version( _engine_hidden_::BuildResourceVersion( ENGINE_VERSION, version ) )
{}
protected:
bool _Check (const ResourceFileHeader &right) const
{
return this->signature == right.signature and
this->version == right.version;
}
};
// interface
public:
explicit
IResourceLoader (const SubSystemsRef ss) : BaseObject( ss )
{}
virtual bool Load (OUT ResourcePtr &resource, PackFileID fileID, const RFilePtr &file) = 0;
virtual EResource::type GetType () const = 0;
};
SHARED_POINTER( IResourceLoader );
} // Base
} // Engine | [
"[email protected]"
] | |
fe672d2c45cfc06fb11eccbccd6718bde13ad4ff | e8b8c5d9510b267e41c496024f7f439d1aff1618 | /Platform/PlatformWindows.cpp | 4b2bfb23089cf8e5d78fb5eca5402248178820e8 | [] | no_license | Archetype/milkblocks | b80250cb5820188a16df73d528f80e3523d129b0 | 28ee5a44e5afc2440b77feec77202b310f395361 | refs/heads/master | 2021-01-19T21:29:05.453990 | 2011-07-12T02:44:59 | 2011-07-12T02:44:59 | 1,030,899 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,241 | cpp | #include "PlatformWindows.h"
#include <stdio.h>
#include <assert.h>
#include <GL/glew.h>
#include <GL/freeglut.h>
#ifndef __IPHONE_3_0
#include "mmgr.h"
#endif
static void display(void)
{
Platform::GetApplication()->Advance(glutGet( GLUT_ELAPSED_TIME ));
}
static void idle()
{
glutPostRedisplay();
}
bool wasCtrlPressed;
static void onMouseClick(int button, int state, int x, int y)
{
((PlatformWindows*)Platform::Get())->OnMouseClick(button,state,x,y);
}
static void onMouseDrag(int x, int y)
{
((PlatformWindows*)Platform::Get())->OnMouseMove(x,y);
}
static void onMouseMove(int x, int y)
{
}
void PlatformWindows::OnMouseClick( int button, int state, int x, int y)
{
if(button == 0)
{
m_LastX = x;
m_LastY = y;
if( state == 1 )
{
m_IsClicked = false;
OnManipulationEnded(0, x, y);
}
else
{
m_IsClicked = true;
OnManipulationStarted(0, x, y);
}
}
else if(button == 2)
{
if( state == 1 )
{
OnManipulationEnded(1, x, y);
}
else
{
OnManipulationStarted(1, x, y);
}
}
}
void PlatformWindows::OnMouseMove( int x, int y )
{
if(m_IsClicked)
{
OnManipulationDelta(0, x-m_LastX, y-m_LastY);
m_LastX = x;
m_LastY = y;
}
}
bool PlatformWindows::InitGL(char* windowName, int width, int height)
{
m_IsClicked = false;
m_LastX = 0;
m_LastY = 0;
glutInitWindowSize(width, height);
glutInitWindowPosition(40,40);
int argc = 0;
char** argv = NULL;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow(windowName);
GLenum err = glewInit();
if (GLEW_OK != err)
{
printf("Init Error: %s\n", glewGetErrorString(err));
}
if (!glewIsSupported("GL_VERSION_2_0"))
{
printf("OpenGL 2.0 not supported\n");
return false;
}
glutDisplayFunc(display);
glutIdleFunc(idle);
glutMouseFunc(onMouseClick);
glutMotionFunc(onMouseDrag);
glutPassiveMotionFunc(onMouseMove);
return true;
}
int PlatformWindows::GetElapsedMs()
{
return glutGet( GLUT_ELAPSED_TIME );
}
void PlatformWindows::StartRenderLoop(Application* app)
{
Platform::StartRenderLoop(app);
glutMainLoop();
} | [
"[email protected]"
] | |
b4877d4276a6cc282710540347c9083636d26178 | 1b09a3d48a767663ce79407c3560d18940a11f90 | /articles/index.re | 851897adc19f01593973b311e937755d9fb21705 | [
"MIT"
] | permissive | kubosho/review-boilerplate | ac800adfc43a2bb6eb5d5506105a419aa4365f4d | eb435c56bf65c3249a5d4601c832851ba6fdf3e8 | refs/heads/master | 2021-01-25T05:57:42.492335 | 2017-02-13T15:30:44 | 2017-02-13T15:30:44 | 29,169,196 | 5 | 0 | null | 2017-02-13T15:29:04 | 2015-01-13T02:40:48 | CSS | UTF-8 | C++ | false | false | 107 | re | = はじめに
ここにはなんでこの本を書くに至ったかなど熱い思いを書きます。
| [
"[email protected]"
] | |
c663cfe933b1389b9498eb1155af23edd9de349d | 14f1edb4aee8f7b79d351344f8a6bc50a9428c65 | /8.Template/caffeineBeverage.h | de9c03d6b9fef6038aa07fa6fbc76831933aa71a | [] | no_license | facku24/DesignPatters | eaf2ba3b2ae5c1aef015633556d26ac2abf3987d | 7f290daa3dcfc1592571bf6219f7c55fbad1d471 | refs/heads/master | 2020-04-08T20:09:03.828762 | 2019-02-18T14:23:06 | 2019-02-18T14:23:06 | 159,685,735 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 473 | h | #ifndef _CAFFEINEBEVERAGE_H_
#define _CAFFEINEBEVERAGE_H_
class CaffeineBeverage
{
public:
virtual void prepareRecipe() final;
virtual void brew() = 0;
virtual void addCondiments() = 0;
void boilWater();
void pourInCup();
};
class TeaBeverage : public CaffeineBeverage
{
public:
void brew();
void addCondiments();
};
class CoffeeBeverage : public CaffeineBeverage
{
void brew();
void addCondiments();
};
#endif // _CAFFEINEBEVERAGE_H_ | [
"[email protected]"
] | |
e6b9b8a9c91410d86242d77e7dae040857bea7e9 | 5d07b105147d5f20ad67f8c15f2670e98ed4430c | /MakerbotFEMSim/MakerbotFEMSim/LineSearch.cpp | 51c4bf1adab8e339cffdef343f61579c9686d065 | [] | no_license | arjunnar/MakerbotFEMSim | da5bd11288aeb5abffd4311a4a04a8fc9f1d4b51 | 3a34537ae2eea8a2e3a505049e6de3d8e809404b | refs/heads/master | 2021-01-19T11:43:11.514497 | 2014-05-15T16:59:56 | 2014-05-15T16:59:56 | 18,683,982 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,673 | cpp | #include "LineSearch.h"
void LineSearch::advanceMesh(ElementMesh * mesh, Eigen::VectorXf &deltaX)
{
Quadrature quadrature;
float stepSize = 0.1f;
while (true)
{
std::cout << "line search step size: " << stepSize << std::endl;
// try advancing mesh
addDeltaX(mesh, deltaX, stepSize);
// assess stability of system
bool stable = true;
for (int eleI = 0; eleI < mesh->elements.size(); ++eleI)
{
if (!stable)
{
break;
}
HexElement * element = (HexElement*) mesh->elements[eleI];
std::vector<Eigen::Vector3f> elemDeformedCoords;
for (int ii = 0; ii < element->vertices.size(); ++ii)
{
elemDeformedCoords.push_back(mesh->coords[element->vertices[ii]]);
}
for (int jj = 0; jj < NVERT; ++jj)
{
Eigen::Matrix3f defGradAtQuadPoint = element->defGradAtQuadPoint(elemDeformedCoords, quadrature.gaussCubePoints[jj]);
float J = defGradAtQuadPoint.determinant();
if (J < 0)
{
stable = false;
break;
}
}
}
// if the system is stable, then we're done
if (stable)
{
break;
}
// if the system is not stable then backtrack and reduce the step size
else
{
addDeltaX(mesh, deltaX, -1.0*stepSize);
stepSize /= 2.0;
}
}
}
void LineSearch::addDeltaX(ElementMesh * mesh, Eigen::VectorXf &deltaX, float stepSize)
{
// advance mesh
int countNonFixed = 0;
for (int sharedCoordI = 0; sharedCoordI < mesh->coords.size(); ++sharedCoordI)
{
if (mesh->fixedVertexIndexes.count(sharedCoordI) > 0)
{
// vertex is fixed
continue;
}
else
{
mesh->coords[sharedCoordI] += stepSize * deltaX.block(3*countNonFixed, 0, 3, 1);
++countNonFixed;
}
}
}
| [
"[email protected]"
] | |
295161fa00194e79012f8ebe500dd293b3480fe2 | 6f5a72debacfacab4adc1d26a11de06f9f898fda | /tvapp/Classes/PlayerStandingState.h | edc0172e55b7782f0356bdda75b395842bde34e0 | [
"MIT"
] | permissive | iacopocheccacci/cocos2dx-helloWorld-tvOS | 5c51b2aa098cc7997c54e53112e2d63477cdcaaf | ae08efb0b1a52e8b5fd0bbeea397f3c56c33f58e | refs/heads/master | 2021-01-09T06:59:17.063539 | 2015-10-20T17:03:16 | 2015-10-20T17:03:16 | 44,961,103 | 0 | 0 | null | 2015-10-26T10:20:38 | 2015-10-26T10:20:36 | null | UTF-8 | C++ | false | false | 1,032 | h | //
// PlayerStandingState.h
// SOP_Proto
//
// Created by Iacopo Checcacci on 16/12/14.
//
//
#ifndef __SOP_PLAYER_STANDING_STATE__
#define __SOP_PLAYER_STANDING_STATE__
#include "PlayerState.h"
class PlayerStandingState : public PlayerState
{
public:
PlayerStandingState(Player* player, bool fromJump);
virtual ~PlayerStandingState();
virtual PlayerState* handleInput(Player* player, eAction input);
virtual void update(Player* player);
private:
void setGraphics(Player* player);
void stopAnimation(Player* player);
PlayerState* handleMove(Player* player, eAction input);
PlayerState* handleJump(Player* player, eAction input);
PlayerState* handleFall(Player* player, eAction input);
PlayerState* handleDeath(Player* player, eAction input);
PlayerState* handleFly(Player* player, eAction input);
AnimationComponent* _animationIdle;
AnimationComponent* _animationPlayingIdle;
Action* _action;
bool _isFromJump;
};
#endif // __SOP_PLAYER_STANDING_STATE__
| [
"[email protected]"
] | |
37cb419e8a9c0e7abcca33154d15d6b1b863be12 | bbfef6b5537e5a37725b3bdd3d4e8bb8cae7cac1 | /src/modules/BacklightPrinter.hpp | 13ea056d1b1a11f7c64763a32256abe139ae3f9a | [
"MIT"
] | permissive | NobodyXu/swaystatus | 6cd80a6888776ece62ceccca31d6650cad71ee9e | 18d131631ac25a92a78630e033e89d751ebe3306 | refs/heads/main | 2023-07-30T08:57:11.177598 | 2021-09-12T04:38:21 | 2021-09-12T04:38:21 | 337,929,801 | 25 | 2 | MIT | 2021-06-15T05:34:04 | 2021-02-11T04:34:03 | C++ | UTF-8 | C++ | false | false | 245 | hpp | #ifndef __swaystatus_BacklightPrinter_H__
# define __swaystatus_BacklightPrinter_H__
# include "Base.hpp"
namespace swaystatus::modules {
std::unique_ptr<Base> makeBacklightPrinter(void *config);
} /* namespace swaystatus::modules */
#endif
| [
"[email protected]"
] | |
d04e0b63a15281a1813432f97046e56172bd6658 | 04fee3ff94cde55400ee67352d16234bb5e62712 | /11.12contest/source/Stu-56-STL/coal/coal.cpp | 63f9d7ced34b01440d6dddc6bc49fa0531e914a5 | [] | no_license | zsq001/oi-code | 0bc09c839c9a27c7329c38e490c14bff0177b96e | 56f4bfed78fb96ac5d4da50ccc2775489166e47a | refs/heads/master | 2023-08-31T06:14:49.709105 | 2021-09-14T02:28:28 | 2021-09-14T02:28:28 | 218,049,685 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 701 | cpp | #include<bits/stdc++.h>
using namespace std;
#define maxn 100010
#define ll long long
int n,type[maxn];
double k,c,w,a[maxn],dp[maxn];
int main(){
freopen("coal.in","r",stdin);
freopen("coal.out","w",stdout);
cin>>n>>k>>c>>w;
memset(dp,0,sizeof(dp));
k/=100;c/=100;
for(int i=1;i<=n;++i){
cin>>type[i]>>a[i];
}
double p=w;
for(int i=1;i<=n;++i){
if(p){
if(type[i]==1){//煤矿
// dp[i]=max(dp[i],dp[i-1])+p*a[i];
// p=p*(1-k);
}
else if(type[i]==2){//补给站
dp[i]=min(dp[i],dp[i-1])-p*a[i];
p=p*(1+c);
}
}
}
printf("%.2lf\n",dp[n]);
return 0;//保留两位小数
}
/*
5 50 50 10
1 10
1 20
2 10
2 20
1 30
*/
| [
"[email protected]"
] | |
2c2ad35f3f60e6a2e90b35f33a890a7384a8d055 | 641fa8341d8c436ad24945bcbf8e7d7d1dd7dbb2 | /chrome/browser/android/chrome_backup_agent.h | 790f297a609b6723041ae574e0713d0af8f8a0c4 | [
"BSD-3-Clause"
] | permissive | massnetwork/mass-browser | 7de0dfc541cbac00ffa7308541394bac1e945b76 | 67526da9358734698c067b7775be491423884339 | refs/heads/master | 2022-12-07T09:01:31.027715 | 2017-01-19T14:29:18 | 2017-01-19T14:29:18 | 73,799,690 | 4 | 4 | BSD-3-Clause | 2022-11-26T11:53:23 | 2016-11-15T09:49:29 | null | UTF-8 | C++ | false | false | 1,225 | h | // Copyright 2016 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 CHROME_BROWSER_ANDROID_CHROME_BACKUP_AGENT_H_
#define CHROME_BROWSER_ANDROID_CHROME_BACKUP_AGENT_H_
#include <jni.h>
#include <string>
#include <vector>
#include "base/android/jni_android.h"
namespace chrome {
namespace android {
std::vector<std::string> GetBackupPrefNames();
bool RegisterBackupAgent(JNIEnv* env);
// Test interface wrapping the static functions that are only called from Java.
base::android::ScopedJavaLocalRef<jobjectArray> GetBoolBackupNamesForTesting(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& jcaller);
base::android::ScopedJavaLocalRef<jbooleanArray> GetBoolBackupValuesForTesting(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& jcaller);
void SetBoolBackupPrefsForTesting(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& jcaller,
const base::android::JavaParamRef<jobjectArray>& names,
const base::android::JavaParamRef<jbooleanArray>& values);
} // namespace android
} // namespace chrome
#endif // CHROME_BROWSER_ANDROID_CHROME_BACKUP_AGENT_H_
| [
"[email protected]"
] | |
0f8cfc7c6a16fddef7b33a6dce59e4b54647cb6a | 23e3914567f5296107617f8c6b0129aa62326605 | /APIFramework/APIFramework/Include/Object/Stage.h | 7085e38f2645701934736ac9b883cebcc4bc4453 | [] | no_license | reverince/BCSD | 4e000edfb7680f6bb34f7512c27c9df2ae62468a | bf6d79481804504c4f780398f910e0e5cd5faf27 | refs/heads/master | 2020-04-24T15:29:51.420134 | 2019-09-19T13:42:39 | 2019-09-19T13:42:39 | 172,070,039 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 438 | h | #pragma once
#include "StaticObject.h"
class Stage : public StaticObject
{
friend class Scene;
friend class Object;
Stage();
Stage(const Stage & stage);
~Stage();
public:
virtual Stage * Clone();
virtual bool Init();
virtual void Input(float deltaTime);
virtual int Update(float deltaTime);
virtual int LateUpdate(float deltaTime);
virtual void Collision(float deltaTime);
virtual void Render(HDC hDC, float deltaTime);
};
| [
"[email protected]"
] | |
9824132ea63f401f8f094024a7ecf66733162877 | 84809f9778f2a9067b47d3009b7bd0819a114d49 | /android/pytorch_android/src/main/cpp/pytorch_jni.cpp | d9d180204848a3736748810bac03a8fecacda17f | [
"BSD-2-Clause",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"Apache-2.0"
] | permissive | funsilver76/pytorch | 3f3e8df3297a5e5a49c8c0cb1ffe015c97216e9a | d88edcc6cf554edd4abcf5041b57e36f18637bf9 | refs/heads/master | 2022-06-24T00:17:53.708231 | 2019-08-08T21:00:40 | 2019-08-08T21:28:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,050 | cpp | #include <pytorch_jni.h>
#include <cassert>
#include <iostream>
#include <memory>
#include <string.h>
#include <android/log.h>
#include <torch/script.h>
#define TAG "Pytorch_JNI"
#define __FILENAME__ \
(strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
#define LOG_PREFIX(s, ...) \
"%s:%d %s " s, __FILENAME__, __LINE__, __FUNCTION__, __VA_ARGS__
#define ALOGV(...) \
__android_log_print(ANDROID_LOG_VERBOSE, TAG, LOG_PREFIX(__VA_ARGS__))
#define ALOGD(...) \
__android_log_print(ANDROID_LOG_DEBUG, TAG, LOG_PREFIX(__VA_ARGS__))
#define ALOGE(...) \
__android_log_print(ANDROID_LOG_ERROR, TAG, LOG_PREFIX(__VA_ARGS__))
#define ALOGW(...) \
__android_log_print(ANDROID_LOG_WARN, TAG, LOG_PREFIX(__VA_ARGS__))
#define ALOGI(...) \
__android_log_print(ANDROID_LOG_INFO, TAG, LOG_PREFIX(__VA_ARGS__))
namespace pytorch_jni {
facebook::jni::local_ref<JTensor> JTensor::newJTensor(
facebook::jni::alias_ref<facebook::jni::JByteBuffer> jBuffer,
facebook::jni::alias_ref<jintArray> jDims, jint typeCode) {
static auto jMethodNewTensor =
JTensor::javaClassStatic()
->getStaticMethod<facebook::jni::local_ref<JTensor>(
facebook::jni::alias_ref<facebook::jni::JByteBuffer>,
facebook::jni::alias_ref<jintArray>, jint)>("nativeNewTensor");
return jMethodNewTensor(JTensor::javaClassStatic(), jBuffer, jDims, typeCode);
}
facebook::jni::local_ref<JTensor>
JTensor::newJTensorFromAtTensor(const at::Tensor &tensor) {
const auto scalarType = tensor.scalar_type();
int typeCode = 0;
if (at::kFloat == scalarType) {
typeCode = JTensor::kTensorTypeCodeFloat32;
} else if (at::kInt == scalarType) {
typeCode = JTensor::kTensorTypeCodeInt32;
} else if (at::kByte == scalarType) {
typeCode = JTensor::kTensorTypeCodeByte;
} else {
facebook::jni::throwNewJavaException(
PytorchJni::kJavaIllegalArgumentException,
"at::Tensor scalar type is not supported on java side");
}
const auto &tensorDims = tensor.sizes();
std::vector<int> tensorDimsVec;
for (const auto &dim : tensorDims) {
tensorDimsVec.push_back(dim);
}
facebook::jni::local_ref<jintArray> jTensorDims =
facebook::jni::make_int_array(tensorDimsVec.size());
jTensorDims->setRegion(0, tensorDimsVec.size(), tensorDimsVec.data());
facebook::jni::local_ref<facebook::jni::JByteBuffer> jTensorBuffer =
facebook::jni::JByteBuffer::allocateDirect(tensor.nbytes());
jTensorBuffer->order(facebook::jni::JByteOrder::nativeOrder());
std::memcpy(jTensorBuffer->getDirectBytes(), tensor.storage().data(),
tensor.nbytes());
return JTensor::newJTensor(jTensorBuffer, jTensorDims, typeCode);
}
void PytorchJni::registerNatives() {
registerHybrid({
makeNativeMethod("initHybrid", PytorchJni::initHybrid),
makeNativeMethod("run", PytorchJni::run),
});
}
at::Tensor PytorchJni::newAtTensor(
facebook::jni::alias_ref<facebook::jni::JBuffer> inputData,
facebook::jni::alias_ref<jintArray> inputDims, jint typeCode) {
const auto inputDimsRank = inputDims->size();
const auto inputDimsArr = inputDims->getRegion(0, inputDimsRank);
std::vector<int64_t> inputDimsVec;
auto inputNumel = 1;
for (auto i = 0; i < inputDimsRank; ++i) {
inputDimsVec.push_back(inputDimsArr[i]);
inputNumel *= inputDimsArr[i];
}
JNIEnv *jni = facebook::jni::Environment::current();
caffe2::TypeMeta inputTypeMeta{};
const auto directBufferCapacity =
jni->GetDirectBufferCapacity(inputData.get());
int inputDataElementSizeBytes = 0;
if (JTensor::kTensorTypeCodeFloat32 == typeCode) {
inputDataElementSizeBytes = 4;
inputTypeMeta = caffe2::TypeMeta::Make<float>();
} else if (JTensor::kTensorTypeCodeInt32 == typeCode) {
inputDataElementSizeBytes = 4;
inputTypeMeta = caffe2::TypeMeta::Make<int>();
} else if (JTensor::kTensorTypeCodeByte == typeCode) {
inputDataElementSizeBytes = 1;
inputTypeMeta = caffe2::TypeMeta::Make<uint8_t>();
} else {
facebook::jni::throwNewJavaException(
PytorchJni::kJavaIllegalArgumentException, "Unknown typeCode");
}
const auto inputDataCapacity =
directBufferCapacity * inputDataElementSizeBytes;
if (inputDataCapacity != (inputNumel * inputDataElementSizeBytes)) {
facebook::jni::throwNewJavaException(
PytorchJni::kJavaIllegalArgumentException,
"Tensor dimensions(elements number:%d, element byte size:%d, total "
"bytes:%d) inconsistent with buffer capacity(%d)",
inputNumel, inputDataElementSizeBytes,
inputNumel * inputDataElementSizeBytes, inputDataCapacity);
}
const auto &inputTensorDims = torch::IntArrayRef(inputDimsVec);
at::Tensor inputTensor = torch::empty(inputTensorDims);
inputTensor.unsafeGetTensorImpl()->ShareExternalPointer(
{jni->GetDirectBufferAddress(inputData.get()), at::DeviceType::CPU},
inputTypeMeta, inputDataCapacity);
return inputTensor;
}
facebook::jni::local_ref<PytorchJni::jhybriddata>
PytorchJni::initHybrid(facebook::jni::alias_ref<jclass>,
facebook::jni::alias_ref<jstring> modelPath) {
return makeCxxInstance(modelPath);
}
facebook::jni::local_ref<JTensor>
PytorchJni::run(facebook::jni::alias_ref<facebook::jni::JBuffer> inputData,
facebook::jni::alias_ref<jintArray> inputDims, jint typeCode) {
at::Tensor inputTensor =
PytorchJni::newAtTensor(inputData, inputDims, typeCode);
at::Tensor outputTensor =
module_.forward({std::move(inputTensor)}).toTensor();
return JTensor::newJTensorFromAtTensor(outputTensor);
}
} // namespace pytorch_jni
| [
"[email protected]"
] | |
0d5b4db854fc5caa37297e091b218b4fc9e8099e | de9dd76bd4c7d6b0c29ea871794628cb3967e90b | /due/Oscilloscope/Graphs/GraphRadar.cpp | 937e3bb482846acf1dfe6abb4aba1c44bfe10c3c | [
"MIT"
] | permissive | VictorTagayun/Arduino | c6bcaeb5fb6426b54fb4b69e2350bfe37c090169 | c66de663ae4ea9424d8281f2e23e03c30f50cacb | refs/heads/master | 2022-11-05T21:30:18.908354 | 2020-06-02T12:21:47 | 2020-06-02T12:21:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 284 | cpp | //
//
//
#include "GraphRadar.h"
#include "OsciCanvas.h"
void GraphRadar::init()
{
Canvas.init(-10, -10, 10, 10);
}
void GraphRadar::draw()
{
for (float t = 0; t < PI*2; t+= 0.01)
{
float x = 10 * cos(t);
float y = 10 * sin(t);
Canvas.line(0,0, x, y);
delay(5);
}
}
| [
"[email protected]"
] | |
daa9876e34b9d9c2a34f0e4c910dcbffc2cd8db2 | 7985054c887810f37345f6508f1a7d4fdc65b81b | /Development/Shared/Threading/sync.h | fd2997ca24df2fc8a1f0696df8d3c18d3e9a00e6 | [] | no_license | ghostuser846/venicelight | 95e625a8e9cb8dd3d357318c931ee9247420c28d | cdc5dfac8fbaa82d3d5eeb7d21a64c3e206b7ee2 | refs/heads/master | 2021-01-01T06:44:51.163612 | 2009-06-01T02:09:27 | 2009-06-01T02:09:27 | 37,787,439 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,521 | h | /*
* Copyright (C) 2005-2008 SREmu <http://www.sremu.org/>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _SREMU_THREADSYNC_H_
#define _SREMU_THREADSYNC_H_
#include "../Common.h"
class SREMU_SHARED Mutex
{
public:
Mutex();
~Mutex();
void lock(); // Acquire Ownership
void unlock(); // Release Ownership
bool trylock(); // Attempt to acquire Ownership. Return true if successful.
void Acquire(); // Acquire Ownership
void Release(); // Release Ownership
bool AttemptAcquire(); // Attempt to Acquire Ownership. Return true if successful.
private:
#if PLATFORM == PLATFORM_WIN32
RTL_CRITICAL_SECTION cs;
#else
static bool attr_initalized;
static pthread_mutexattr_t attr;
pthread_mutex_t mutex;
#endif
};
#define FastMutex Mutex
#endif // _SREMU_THREADSYNC_H_
| [
"dayanfernandez@c3741f72-2d1a-11de-9401-6341fb89ae7c"
] | dayanfernandez@c3741f72-2d1a-11de-9401-6341fb89ae7c |
f8cdf07b4c508309db09433e21bd7a6995348e6c | a0370090e044e2817842b90a9559be41282072c5 | /DevExpress VCL/ExpressSkins Library/Packages/dxSkinOffice2010BlackC15.cpp | 26d8ec12fadc124f810a19f888acc0f19a9c0298 | [] | no_license | bravesoftdz/MyVCL-7 | 600a1c1be2ea71b198859b39b6da53c6b65601b3 | 197c1e284f9ac0791c15376bcf12c243400e7bcd | refs/heads/master | 2022-01-11T17:18:00.430191 | 2018-12-20T08:23:02 | 2018-12-20T08:23:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 813 | cpp | //---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
USERES("dxSkinOffice2010Black.res");
USEPACKAGE("rtl.bpi");
USEPACKAGE("dxCoreC15.bpi");
USEPACKAGE("vcl.bpi");
USEPACKAGE("dxGDIPlusC15.bpi");
USEPACKAGE("cxLibraryC15.bpi");
USEPACKAGE("dxSkinsCoreC15.bpi");
USEUNIT("dxSkinOffice2010Black.pas");
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
// Package source.
//---------------------------------------------------------------------------
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*)
{
return 1;
}
//---------------------------------------------------------------------------
| [
"[email protected]"
] | |
55e2ec0bca0a989949ec8286a7433bfb8ad2520e | deaf796d44d4619f21a29b90ef6f8937f6328528 | /section1.4/ariprog.cpp | c4323db60ef6e9dfa96ff9c0272c448d8bd59f49 | [] | no_license | lyyyuna/usaco_y | 5c1895480969d55282f84d2280fa4dbee27171cb | 5a5f1fe326c26f3f78ba42bae1558a1e2b5409d9 | refs/heads/master | 2021-01-18T12:17:28.177512 | 2014-02-08T01:22:26 | 2014-02-08T01:22:26 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,379 | cpp | /*
ID: lyyyuna
PROG: ariprog
LANG: C++
*/
#include <fstream>
using namespace::std;
const int N = 250*250*2+1;
int main(void)
{
ifstream ifile("ariprog.in");
ofstream ofile("ariprog.out");
int n, m;
ifile >> n >> m;
int max;
max = 2*m*m;
// 把所有的双平方数标记出来
// 这个数组的总数应该是 250*250*2
bool allnumber[N]={false};
for (int i = 0; i <= m; ++i)
for (int j = 0; j <= i; ++j)
allnumber[i*i+j*j] = true;
// 这个数组用来存储所有的双平方数
int bisquares[N]={0};
int b_num(0);
for (int i = 0; i <= max; ++i)
if (allnumber[i])
bisquares[++b_num] = i;
// 先从b公差, 开始遍历，这样结果就不用再排序啦
bool flag(false);
for (int b = 1; b*(n-1) <= max; ++b)
// 一共b_num个数，第一个数不能超过b_num-n+1
// 还要保证第n个数不超过max
for (int i = 1; i <= b_num-n+1 && bisquares[i]+(n-1)*b<=max; ++i) {
int a = bisquares[i];
int j = n-1;
for (;j>=1; --j) {
if (!allnumber[a+j*b])
break;
}
if (!j) {
flag = true;
ofile << a << " " << b << endl;
}
}
if (!flag)
ofile << "NONE" << endl;
return 0;
} | [
"[email protected]"
] | |
e75d531b3b0098a4dc81ceff9a8afa88c4ee8116 | 39539987d11d1031f1c6ca56f85235a8355d8750 | /usr/bin/qtopia/demos/sub-attaq/textinformationitem.h | 75f4bdf3b791215ec385b3d57d58f70448a750ad | [] | no_license | sensarliar/zfcs_filesystem | dfe36b46c91eaa027940ec22f556dea6dabb08cf | fea119e8a5027cbef664414b7e44138a3bde7ce5 | refs/heads/master | 2021-01-25T10:29:28.515351 | 2014-08-29T13:27:46 | 2014-08-29T13:27:46 | 22,943,366 | 1 | 2 | null | 2018-02-23T15:05:27 | 2014-08-14T06:19:08 | C++ | UTF-8 | C++ | false | false | 1,981 | h | /****************************************************************************
**
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef TEXTINFORMATIONITEM_H
#define TEXTINFORMATIONITEM_H
//Qt
#include <QtGui/QGraphicsTextItem>
class TextInformationItem : public QGraphicsTextItem
{
public:
TextInformationItem(QGraphicsItem * parent = 0);
void setMessage(const QString& text);
};
#endif // TEXTINFORMATIONITEM_H
| [
"[email protected]"
] | |
c0bdcd242a684cf33d16e101669897278a27a825 | 422a0e7a01814d9b6843e08d1e3deb7f4ae24b23 | /MarketSimulation/marketindexwidget.cpp | 56227d87aa64a19500339c69a110e8b7dd7031e6 | [] | no_license | logworthy/marketsim | 876d4d15690f1447f5982a2a2309831d940f1dd8 | cbb84d5758e03ace21a58cde777db75ad6ada09e | refs/heads/master | 2020-04-05T23:46:49.624159 | 2013-09-03T11:01:30 | 2013-09-03T11:01:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,100 | cpp | #include "marketindexwidget.h"
#include "ui_marketindexwidget.h"
#include <QString>
MarketIndexWidget::MarketIndexWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::MarketIndexWidget)
{
ui->setupUi(this);
IndexChanged(100.0, 0.0);
}
MarketIndexWidget::~MarketIndexWidget()
{
delete ui;
}
void MarketIndexWidget::IndexChanged(double index, double indexChangePct)
{
ui->lblIndex->setText(QString::number(index, 'f', 1));
if (indexChangePct == 0)
{
ui->lblIndexChange->setText("");
ui->lblIndexImage->setPixmap(NULL);
}
else
{
ui->lblIndexChange->setText(QString::number(indexChangePct,'f',1) + QString("%"));
if (indexChangePct > 0)
{
ui->lblIndexImage->setPixmap(QPixmap(":/ui/arrow-up"));
ui->lblIndexChange->setStyleSheet("QLabel { color: green }");
}
else
{
ui->lblIndexImage->setPixmap(QPixmap(":/ui/arrow-down"));
ui->lblIndexChange->setStyleSheet("QLabel { color: red }");
}
}
}
| [
"[email protected]"
] | |
4aad6e8b5ed41e544422c50b12b2a3d9c53ff3cf | 9eee6f3d70570ecfdf470126aa9023a222f3877f | /lib-properties/include/propertiesbuilder.h | 29cb152b20a723327999682479dcf822e1900019 | [
"MIT"
] | permissive | rbarreiros/rpidmx512 | 2316b6c23b7db17d7ed35ddf622966267b623278 | 6e7eef3eaba35cc2eb7cdeb5bef906faea9366fd | refs/heads/master | 2023-05-07T06:52:36.652355 | 2021-04-26T16:50:29 | 2021-04-26T16:50:29 | 283,355,533 | 1 | 0 | null | 2020-07-29T00:10:21 | 2020-07-29T00:10:20 | null | UTF-8 | C++ | false | false | 4,113 | h | /**
* @file propertiesbuilder.h
*
*/
/* Copyright (C) 2019-2021 by Arjan van Vught mailto:[email protected]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef PROPERTIESBUILDER_H_
#define PROPERTIESBUILDER_H_
#include <stdint.h>
#include <stdio.h>
class PropertiesBuilder {
public:
PropertiesBuilder(const char *pFileName, char *pBuffer, uint32_t nLength);
bool Add(const char *pProperty, bool bValue) {
return Add(pProperty, bValue, bValue);
}
template<typename T>
bool Add(const char *pProperty, const T x, bool bIsSet, uint32_t nPrecision = 1) {
if (m_nSize >= m_nLength) {
return false;
}
auto *p = &m_pBuffer[m_nSize];
const auto nSize = m_nLength - m_nSize;
auto i = add_part(p, nSize, pProperty, x, bIsSet, nPrecision);
if (i > static_cast<int>(nSize)) {
return false;
}
m_nSize += static_cast<uint32_t>(i);
return true;
}
template<typename T> int inline add_part(char *p, uint32_t nSize, const char *pProperty, const T x, bool bIsSet, __attribute__((unused)) uint32_t nPrecision) {
if (bIsSet) {
return snprintf(p, nSize, "%s=%d\n", pProperty, static_cast<int>(x));
}
return snprintf(p, nSize, "#%s=%d\n", pProperty, static_cast<int>(x));
}
bool AddIpAddress(const char *pProperty, uint32_t nValue, bool bIsSet = true);
bool AddHex8(const char *pProperty, uint8_t nValue, bool bIsSet = true) {
return AddHex(pProperty, nValue, bIsSet, 2);
}
bool AddHex16(const char *pProperty, const uint16_t nValue16, bool bIsSet = true) {
return AddHex(pProperty, nValue16, bIsSet, 4);
}
bool AddHex16(const char *pProperty, const uint8_t nValue[2], bool bIsSet = true) {
const uint16_t v = (static_cast<uint16_t>(nValue[0]) << 8) | nValue[1];
return AddHex16(pProperty, v, bIsSet);
}
bool AddHex24(const char *pProperty, const uint32_t nValue32, bool bIsSet = true) {
return AddHex(pProperty, nValue32, bIsSet, 6);
}
bool AddComment(const char *pComment);
uint32_t GetSize() {
return m_nSize;
}
private:
bool AddHex(const char *pProperty, uint32_t nValue, const bool bIsSet, const uint32_t nWidth);
private:
char *m_pBuffer;
uint32_t m_nLength;
uint32_t m_nSize{0};
};
template<> int inline PropertiesBuilder::add_part<float>(char *p, uint32_t nSize, const char *pProperty, const float x, bool bIsSet, uint32_t nPrecision) {
if (bIsSet) {
return snprintf(p, nSize, "%s=%.*f\n", pProperty, nPrecision, x);
}
return snprintf(p, nSize, "#%s=%.*f\n", pProperty, nPrecision, x);
}
template<> int inline PropertiesBuilder::add_part<char*>(char *p, uint32_t nSize, const char *pProperty, char* x, bool bIsSet, __attribute__((unused)) uint32_t nPrecision) {
if (bIsSet) {
return snprintf(p, nSize, "%s=%s\n", pProperty, x);
}
return snprintf(p, nSize, "#%s=%s\n", pProperty, x);
}
template<> int inline PropertiesBuilder::add_part<const char*>(char *p, uint32_t nSize, const char *pProperty, const char* x, bool bIsSet, uint32_t nPrecision) {
return PropertiesBuilder::add_part(p, nSize, pProperty, const_cast<char *>(x), bIsSet, nPrecision);
}
#endif /* PROPERTIESBUILDER_H_ */
| [
"[email protected]"
] | |
ff8846e39ba108e4a481bab98fb059846f8c4deb | 18476e38d4f7b5183b02a489103188fc81ba27a3 | /readNas/readNas/MTriangle.h | e27b0abd1003c82516a59f69e0656bfa794817a6 | [] | no_license | chapman2014/ioNas | e1a0870aa66331f3bb14f335c05e229b29b26bb9 | 9fb0ee33c17debe6c7e863fdc2c1d456698ffa94 | refs/heads/master | 2020-12-14T13:25:00.912105 | 2015-08-29T03:54:17 | 2015-08-29T03:54:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 436 | h | #include "StdAfx.h"
#include "MVertex.h"
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
class MVertex;
class MTriangle
{
public:
int _num;
MVertex *_v0;
MVertex *_v1;
MVertex *_v2;
/*MTriangle(MVertex *v0, MVertex *v1, MVertex *v2)
{
_v0=v0;
_v1=v1;
_v2=v2;
}*/
MTriangle(const vector<MVertex*> &v,int num)
{
_v0=v[0];
_v1=v[1];
_v2=v[2];
_num= num;
}
~MTriangle(){}
}; | [
"[email protected]"
] | |
f8e3358b499ce2e1293eb4b1672aea4faf125911 | 10746961522a64d43c54acffad7df6c262631d56 | /components/wifi/wifi_service.cc | 2218ba0b0aeca9457d1dafd66fb621cfad580b6f | [
"BSD-3-Clause"
] | permissive | Nalic/chromium | bd004f13ce33e434b16509f5d1e3dcc3672ac188 | b2d69c8c268a9bf645d7ebda4ebab888c0e9d477 | refs/heads/master | 2021-01-18T02:38:04.715691 | 2013-12-06T07:56:24 | 2013-12-06T07:56:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,259 | cc | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/wifi/wifi_service.h"
#include "base/json/json_reader.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/stringprintf.h"
#include "components/onc/onc_constants.h"
namespace wifi {
WiFiService::NetworkProperties::NetworkProperties()
: connection_state(onc::connection_state::kNotConnected),
security(onc::wifi::kNone),
signal_strength(0),
auto_connect(false),
frequency(WiFiService::kFrequencyUnknown) {}
WiFiService::NetworkProperties::~NetworkProperties() {}
scoped_ptr<base::DictionaryValue> WiFiService::NetworkProperties::ToValue(
bool network_list) const {
scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
value->SetString(onc::network_config::kGUID, guid);
value->SetString(onc::network_config::kName, name);
value->SetString(onc::network_config::kConnectionState, connection_state);
value->SetString(onc::network_config::kType, type);
if (type == onc::network_type::kWiFi) {
scoped_ptr<base::DictionaryValue> wifi(new base::DictionaryValue());
wifi->SetString(onc::wifi::kSecurity, security);
wifi->SetInteger(onc::wifi::kSignalStrength, signal_strength);
// Network list expects subset of data.
if (!network_list) {
if (frequency != WiFiService::kFrequencyUnknown)
wifi->SetInteger(onc::wifi::kFrequency, frequency);
scoped_ptr<base::ListValue> frequency_list(new base::ListValue());
for (FrequencyList::const_iterator it = this->frequency_list.begin();
it != this->frequency_list.end();
++it) {
frequency_list->AppendInteger(*it);
}
if (!frequency_list->empty())
wifi->Set(onc::wifi::kFrequencyList, frequency_list.release());
if (!bssid.empty())
wifi->SetString(onc::wifi::kBSSID, bssid);
wifi->SetString(onc::wifi::kSSID, ssid);
}
value->Set(onc::network_type::kWiFi, wifi.release());
} else {
// Add properites from json extra if present.
if (!json_extra.empty()) {
Value* value_extra = base::JSONReader::Read(json_extra);
value->Set(type, value_extra);
}
}
return value.Pass();
}
bool WiFiService::NetworkProperties::UpdateFromValue(
const base::DictionaryValue& value) {
const base::DictionaryValue* wifi = NULL;
std::string network_type;
// Get network type and make sure that it is WiFi (if specified).
if (value.GetString(onc::network_config::kType, &network_type)) {
if (network_type != onc::network_type::kWiFi)
return false;
type = network_type;
}
if (value.GetDictionary(onc::network_type::kWiFi, &wifi)) {
std::string wifi_security;
if (wifi->GetString(onc::wifi::kSecurity, &wifi_security))
security = wifi_security;
std::string wifi_ssid;
if (wifi->GetString(onc::wifi::kSSID, &wifi_ssid))
ssid = wifi_ssid;
return true;
}
return false;
}
std::string WiFiService::NetworkProperties::MacAddressAsString(
const uint8 mac_as_int[6]) {
// mac_as_int is big-endian. Write in byte chunks.
// Format is XX:XX:XX:XX:XX:XX.
static const char* const kMacFormatString = "%02x:%02x:%02x:%02x:%02x:%02x";
return base::StringPrintf(kMacFormatString,
mac_as_int[0],
mac_as_int[1],
mac_as_int[2],
mac_as_int[3],
mac_as_int[4],
mac_as_int[5]);
}
bool WiFiService::NetworkProperties::OrderByType(const NetworkProperties& l,
const NetworkProperties& r) {
if (l.connection_state != r.connection_state)
return l.connection_state < r.connection_state;
// This sorting order is needed only for browser_tests, which expect this
// network type sort order: ethernet < wifi < vpn < cellular.
if (l.type == r.type)
return l.guid < r.guid;
if (l.type == onc::network_type::kEthernet)
return true;
if (r.type == onc::network_type::kEthernet)
return false;
return l.type > r.type;
}
} // namespace wifi
| [
"[email protected]@0039d316-1c4b-4281-b951-d872f2087c98"
] | [email protected]@0039d316-1c4b-4281-b951-d872f2087c98 |
ebcc9050eedbfd8f9abab06698f2624410f10cca | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14704/function14704_schedule_25/function14704_schedule_25.cpp | 2022f226b3f522694075cd276734254dc213dc2e | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 921 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function14704_schedule_25");
constant c0("c0", 64), c1("c1", 64), c2("c2", 64), c3("c3", 64);
var i0("i0", 0, c0), i1("i1", 0, c1), i2("i2", 0, c2), i3("i3", 0, c3), i01("i01"), i02("i02"), i03("i03"), i04("i04"), i05("i05"), i06("i06");
input input00("input00", {i1, i2, i3}, p_int32);
computation comp0("comp0", {i0, i1, i2, i3}, input00(i1, i2, i3));
comp0.tile(i1, i2, i3, 64, 64, 32, i01, i02, i03, i04, i05, i06);
comp0.parallelize(i0);
buffer buf00("buf00", {64, 64, 64}, p_int32, a_input);
buffer buf0("buf0", {64, 64, 64, 64}, p_int32, a_output);
input00.store_in(&buf00);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf0}, "../data/programs/function14704/function14704_schedule_25/function14704_schedule_25.o");
return 0;
} | [
"[email protected]"
] | |
a8d9c41ff5f3a232492abd267c9e69f087aa4d8c | 53895a22c17633b2fcdf11e14a2509a30c72de4c | /DestructibleTerrain/DestructibleTerrain/Bazooka.h | 58fd37321ba47f14bb6d581b8bcb69c6e8923089 | [
"MIT"
] | permissive | tEFFx/DestructibleTerrain | 63681d04ba4b296a84a1e4d13d4897eeded33bec | 4a6ff3f83a324fa0f549a06a4646d79056aee299 | refs/heads/master | 2021-01-16T01:02:06.650915 | 2014-05-30T14:01:15 | 2014-05-30T14:01:15 | 17,801,256 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 180 | h | #pragma once
#include "weapon.h"
class Bazooka :
public Weapon
{
public:
static Entity* newBazooka(sf::Vector2f pos);
private:
Bazooka(sf::Vector2f pos);
~Bazooka(void);
};
| [
"[email protected]"
] | |
3812ddc0a31a513d9fd2c1f7b6ed34a29afae3d2 | 917ddb1b4381ad59bb4c2899c2d17db2154be91f | /clientmock/client_mock_infohash.cpp | 55374539dfe39e8c5569e13cb1aa96362f0d4c2d | [] | no_license | phantom9999/torrent_suit | 490745f61f427ed15b29bdbdff15381feece0a17 | d2866c23e9fce9b99947d1d5a27676345bf00794 | refs/heads/master | 2021-06-26T10:22:17.938983 | 2020-10-08T11:22:52 | 2020-10-08T11:22:52 | 143,314,865 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 4,326 | cpp | #include <sys/socket.h>
#include <netinet/in.h>
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/protocol/TBinaryProtocol.h>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include "tracker-protocol/Announce.h"
#include "common/encode.h"
using std::string;
using std::vector;
using boost::shared_ptr;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;
using namespace apache::thrift;
using namespace bbts::tracker;
inline static bool HexcharToDigit(char c, uint8_t *digit) {
assert(digit);
if (c >= '0' && c <= '9') {
*digit = c - '0';
} else if (c >= 'a' && c <= 'f') {
*digit = c - 'a' + 10;
} else if (c >= 'A' && c <= 'F') {
*digit = c - 'A' + 10;
} else {
return false;
}
return true;
}
bool HexstrToBytes(const string &hex, string* bytes) {
assert(bytes);
string::size_type hex_len = hex.length();
if (hex_len % 2 != 0) {
return false;
}
bytes->clear();
for (string::size_type i = 0; i < hex_len; i += 2) {
uint8_t digit, byte;
if (!HexcharToDigit(hex[i], &digit)) {
return false;
}
byte = digit << 4;
if (!HexcharToDigit(hex[i + 1], &digit)) {
return false;
}
byte += digit;
bytes->append(1, byte);
}
return true;
}
inline static char DigitToHex(uint8_t digit) {
static const char hexchars[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
return hexchars[digit & 0x0f];
}
bool BytesToHex(const string &bytes, string* hex) {
assert(hex);
hex->clear();
string::size_type bytes_len = bytes.length();
for (string::size_type i = 0; i < bytes_len; ++i) {
uint8_t byte = bytes[i];
char c = DigitToHex((byte & 0xf0) >> 4);
hex->append(1, c);
c = DigitToHex(byte & 0x0f);
hex->append(1, c);
}
return true;
}
static void connect_server(string host, int port, string infohash, string peerid, int status,
bool is_seed) {
Peer peer;
peer.__set_ip("10.38.75.54");
peer.__set_idc("hz");
peer.__set_port(422);
peer.__set_peerid(peerid);
Stat stat;
stat.__set_downloaded(0);
stat.__set_left(100);
stat.__set_uploaded(0);
stat.__set_status(static_cast<Status::type>(status));
AnnounceRequest request;
request.__set_infohash(infohash);
request.__set_is_seed(is_seed);
request.__set_num_want(10);
request.__set_peer(peer);
request.__set_stat(stat);
AnnounceResponse response;
shared_ptr<TSocket> socket(new TSocket(host.c_str(), port));
socket->setConnTimeout(3000);
socket->setSendTimeout(3000);
socket->setRecvTimeout(5000);
shared_ptr<TTransport> transport(new TFramedTransport(socket));
shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(transport));
AnnounceClient client(protocol);
try {
transport->open();
client.announce(response, request);
transport->close();
printf("ret: %d, reason: %s\n", response.ret, response.failure_reason.c_str());
printf("min_interval: %d, have_seed: %d, peers_num: %ld\n", response.min_interval,
response.have_seed,
response.peers.size());
for (vector<Peer>::iterator it = response.peers.begin(); it != response.peers.end(); ++it) {
string peerid;
BytesToHex(it->peerid, &peerid);
printf("%s:%d %s\n", it->ip.c_str(), it->port, peerid.c_str());
}
} catch (TException &tx) {
printf("ERROR: %s\n", tx.what());
}
}
int main(int argc, char* argv[]) {
if (argc < 6) {
printf("usage: %s host port infohash peerid status [is_seed]\n", argv[0]);
return 0;
}
string host = argv[1];
int port = atoi(argv[2]);
std::string infohash = argv[3];
std::string peerid = argv[4];
int status = atoi(argv[5]);
bool is_seed = argc > 6 ? true : false;
printf("%s:%d %s %s is_seed:%d, status: %d\n", host.c_str(), port, infohash.c_str(),
peerid.c_str(),
is_seed,
status);
std::string bytes_infohash, bytes_peerid;
if (!HexstrToBytes(infohash, &bytes_infohash)) {
printf("decode hex infohash fail\n");
return -1;
}
if (!HexstrToBytes(peerid, &bytes_peerid)) {
printf("decode hex peerid fail\n");
return -1;
}
connect_server(host, port, bytes_infohash, bytes_peerid, status, is_seed);
return 0;
}
| [
"[email protected]"
] | |
e93e94ffe4f6f03a40f3d0083ecb508a966a9396 | 57e57ca90536f740de7cb72452e730872d0c8dd9 | /flashgg_scripts/THQLeptonicTagProducer.cc | a6b07f42d7ccba792e20943460bca1e6f49c3dee | [] | no_license | ashishadscft/tHqCMSAnalysis | 497bfac382edb9397c795fae967ca4b584abba82 | 809930411faff5b65a9a7901d39e983fb55ba6db | refs/heads/master | 2022-04-06T19:42:01.578102 | 2020-03-03T23:06:11 | 2020-03-03T23:06:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 84,341 | cc | #include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
#include "flashgg/DataFormats/interface/Jet.h"
#include "flashgg/DataFormats/interface/DiPhotonCandidate.h"
#include "flashgg/DataFormats/interface/THQLeptonicTag.h"
#include "flashgg/DataFormats/interface/Electron.h"
#include "flashgg/DataFormats/interface/Muon.h"
#include "flashgg/DataFormats/interface/Photon.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
//#include "DataFormats/PatCandidates/interface/MET.h"
#include "flashgg/DataFormats/interface/Met.h"
#include "DataFormats/TrackReco/interface/HitPattern.h"
#include "flashgg/Taggers/interface/LeptonSelection.h"
#include "DataFormats/Math/interface/deltaR.h"
//#include "flashgg/DataFormats/interface/TagTruthBase.h"
#include "flashgg/DataFormats/interface/THQLeptonicTagTruth.h"
#include "DataFormats/Common/interface/RefToPtr.h"
#include "flashgg/Taggers/interface/SemiLepTopQuark.h"
//#include "PhysicsTools/CandUtils/interface/EventShapeVariables.h"
#include "flashgg/Taggers/interface/FoxWolfram.hpp"
#include "flashgg/DataFormats/interface/PDFWeightObject.h"
#include "flashgg/Taggers/interface/THQLikelihoodComputer.h"
#include <vector>
#include <algorithm>
#include <string>
#include <utility>
#include "TLorentzVector.h"
#include "TMath.h"
#include "TMVA/Reader.h"
#include "SimDataFormats/GeneratorProducts/interface/LHEEventProduct.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "TCanvas.h"
#include <map>
#include <typeinfo>
using namespace std;
using namespace edm;
namespace flashgg {
class CTCVWeightedVariable {
public:
CTCVWeightedVariable( string name , string title , int nBins , double min , double max ) {
Name = name;
edm::Service<TFileService> fs;
Directory = fs->mkdir( name ) ;
for (uint i = 0 ; i < 70 ; i++) {
Histos.push_back( Directory.make< TH1D >( ("ctcv_"+to_string(i)).c_str() , (title + "," + to_string(i)).c_str() , nBins , min, max ) );
}
};
void Fill( double value , std::vector<double> weights) {
Histos[0]->Fill( value );
for( uint i = 0 ; i < weights.size() ; i++)
Histos[i+1]->Fill( value , weights[i] );
};
void Write() {
Directory.make< TCanvas >( ("Canvas_"+Name).c_str() );
for( auto h : Histos )
h->DrawNormalized();
}
TFileDirectory Directory;
vector< TH1* > Histos ;
string Name;
};
class THQLeptonicTagProducer : public EDProducer
{
public:
typedef math::XYZPoint Point;
map< string , CTCVWeightedVariable* > CTCVWeightedVariables;
THQLeptonicTagProducer( const ParameterSet & );
~THQLeptonicTagProducer();
private:
THQLikelihoodComputer* likelihood_tHq_;
std::string processId_;
edm::EDGetTokenT< LHEEventProduct > token_lhe;
// int chooseCategory( float, float);
int chooseCategory( float );
void produce( Event &, const EventSetup & ) override;
virtual void beginJob() override {
if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos) {
// CTCVWeightedVariables["photon1pt"] = new CTCVWeightedVariable("photon1pt" , "photon1pt" , 20 , 20 , 300 );
// CTCVWeightedVariables["photon2pt"] = new CTCVWeightedVariable("photon2pt" , "photon2pt" , 20 , 20 , 300 );
// CTCVWeightedVariables["diPhotonPt"] = new CTCVWeightedVariable("diPhotonPt" , "diPhotonPt" , 20 , 20 , 300 );
// CTCVWeightedVariables["diPhotonEta"] = new CTCVWeightedVariable("diPhotonEta" , "diPhotonEta" , 10 , 0 , 4 );
// CTCVWeightedVariables["diPhotonMVA"] = new CTCVWeightedVariable("diPhotonMVA" , "diPhotonMVA" , 20 , -1 , 1 );
// CTCVWeightedVariables["LeptonPt"] = new CTCVWeightedVariable("LeptonPt" , "LeptonPt" , 20 , 20 , 220 );
// CTCVWeightedVariables["LeptonEta"] = new CTCVWeightedVariable("LeptonPt" , "LeptonEta" , 5 , 0 , 2.5 );
// CTCVWeightedVariables["nJets"] = new CTCVWeightedVariable("nJets" , "nJets" , 5 , 0 , 5 );
// CTCVWeightedVariables["nbJets"] = new CTCVWeightedVariable("nbJets" , "nbJets" , 5 , 0 , 5 );
// CTCVWeightedVariables["MET"] = new CTCVWeightedVariable("MET" , "MET" , 10 , 30 , 230 );
// CTCVWeightedVariables["jPrimeEta"] = new CTCVWeightedVariable("jPrimeEta" , "jPrimeEta" , 5, 0 , 5 );
}
};
virtual void endJob() override {
// CTCVWeightedVariables["photon1pt"]->Write();
// CTCVWeightedVariables["photon2pt"]->Write();
// CTCVWeightedVariables["diPhotonPt"]->Write();
// CTCVWeightedVariables["diPhotonEta"]->Write();
// CTCVWeightedVariables["diPhotonMVA"]->Write();
// CTCVWeightedVariables["LeptonPt"]->Write();
// CTCVWeightedVariables["LeptonEta"]->Write();
// CTCVWeightedVariables["nJets"]->Write();
// CTCVWeightedVariables["nbJets"]->Write();
// CTCVWeightedVariables["MET"]->Write();
// CTCVWeightedVariables["jPrimeEta"]->Write();
};
std::vector<edm::EDGetTokenT<View<flashgg::Jet> > > tokenJets_;
EDGetTokenT<View<DiPhotonCandidate> > diPhotonToken_;
std::vector<edm::InputTag> inputTagJets_;
EDGetTokenT<View<Electron> > electronToken_;
EDGetTokenT<View<flashgg::Muon> > muonToken_;
EDGetTokenT<View<DiPhotonMVAResult> > mvaResultToken_;
EDGetTokenT<View<Photon> > photonToken_;
EDGetTokenT<View<reco::Vertex> > vertexToken_;
EDGetTokenT<View<flashgg::Met> > METToken_;
EDGetTokenT<View<reco::GenParticle> > genParticleToken_;
EDGetTokenT<View<reco::GenJet> > genJetToken_;
edm::EDGetTokenT<vector<flashgg::PDFWeightObject> > weightToken_;
EDGetTokenT<double> rhoTag_;
string systLabel_;
typedef std::vector<edm::Handle<edm::View<flashgg::Jet> > > JetCollectionVector;
//Thresholds
double muonPtThreshold_;
double muonEtaThreshold_;
vector<double> electronEtaThresholds_;
double electronPtThreshold_;
double leadPhoOverMassThreshold_;
double subleadPhoOverMassThreshold_;
double MVAThreshold_;
double deltaRLepPhoThreshold_;
double deltaRJetLepThreshold_;
double deltaRJetLeadPhoThreshold_;
double deltaRJetSubLeadPhoThreshold_;
double jetsNumberThreshold_;
double bjetsNumberThreshold_;
double jetPtThreshold_;
double jetEtaThreshold_;
vector<double> bDiscriminator_;
string bTag_;
double muPFIsoSumRelThreshold_;
double PhoMVAThreshold_;
double DeltaRTrkElec_;
double deltaRPhoElectronThreshold_;
double Zmass_;
double deltaMassElectronZThreshold_;
double DeltaRbjetfwdjet_;
double DeltaRtHchainfwdjet_;
double MVAThreshold_thq_;
double likelihoodThreshold_thq_;
bool hasGoodElec = false;
bool hasVetoElec = false;
bool hasGoodMuons = false;
unique_ptr<TMVA::Reader> thqLeptonicMva_;
FileInPath thqLeptonicMVAweightfile_;
FileInPath likelihood_input_;
string MVAMethod_;
vector<double> boundaries;
float thqLeptonicMvaResult_value_, topMass;
std::vector< TLorentzVector > particles_LorentzVector;
std::vector< math::RhoEtaPhiVector > particles_RhoEtaPhiVector;
TLorentzVector metL, metW_check, bL,fwdJL, G1, G2; //temp solution: make met, bjet & jprime global TLorentzVectors
//Variables for TMVA and Likelihood
edm::Ptr<flashgg::Jet> fwdJet1;
edm::Ptr<flashgg::Jet> bJet1;
edm::Ptr<flashgg::Muon> muon1;
edm::Ptr<flashgg::Electron> ele1;
float lepton_ch_;
float top_mt11_;
TLorentzVector l1, b1, l1b1, l1b1met, tHchain;
float dipho_pt_ ;
float n_jets_;
float n_bjets_;
float n_centraljets_;
float bJet1_pt_;
float dEta_leptonfwdjet_;
float fwdJet1_eta_;
float dRbjetfwdjet_ ;
float dRtHchainfwdjet_ ;
float dRleadphobjet_ ;
float dRsubleadphobjet_ ;
float dRleadphofwdjet_ ;
float dRsubleadphofwdjet_ ;
float dRleptonbjet_ ;
float dRleptonfwdjet_ ;
float bjet1_discr_;
float bjet2_discr_;
float bjet2_pt_;
float bjet1_eta_;
float bjet2_eta_;
float jet1_pt_;
float jet2_pt_;
float jet1_eta_;
float jet2_eta_;
struct GreaterByPt
{
public:
bool operator()( edm::Ptr<flashgg::Jet> lh, edm::Ptr<flashgg::Jet> rh ) const
{
return lh->pt() > rh->pt();
};
};
struct GreaterByEta
{
public:
bool operator()( edm::Ptr<flashgg::Jet> lh, edm::Ptr<flashgg::Jet> rh ) const
{
return fabs(lh->eta()) > fabs(rh->eta());
};
};
struct GreaterByBTagging
{
public:
GreaterByBTagging(std::string urName, std::string urName1):
urName( urName ), urName1(urName1)
{
}
bool operator()( edm::Ptr<flashgg::Jet> lh, edm::Ptr<flashgg::Jet> rh ) const
{
return (lh->bDiscriminator(urName.data()) + lh->bDiscriminator(urName1.data())) > (rh->bDiscriminator(urName.data()) + rh->bDiscriminator(urName1.data())) ;
};
private:
const std::string urName, urName1;
// const std::string urName1;
};
int LeptonType;
std::vector<edm::Ptr<flashgg::Jet> > SelJetVect;
std::vector<edm::Ptr<flashgg::Jet> > SelJetVect_EtaSorted;
std::vector<edm::Ptr<flashgg::Jet> > SelJetVect_PtSorted;
std::vector<edm::Ptr<flashgg::Jet> > SelJetVect_BSorted;
std::vector<edm::Ptr<flashgg::Jet> > MediumBJetVect, MediumBJetVect_PtSorted, MediumBJetVect_;
std::vector<edm::Ptr<flashgg::Jet> > LooseBJetVect, LooseBJetVect_PtSorted ;
std::vector<edm::Ptr<flashgg::Jet> > TightBJetVect, TightBJetVect_PtSorted;
std::vector<edm::Ptr<flashgg::Jet> > centraljet;
std::vector<edm::Ptr<flashgg::Jet> > forwardjet;
edm::Ptr<flashgg::Jet> fwdJet;
edm::Ptr<flashgg::Jet> bJet ;
void topReco( std::vector<edm::Ptr<flashgg::Jet> >* bjets ) {
topMass = -100.;
if ( bjets->size() < 1 || SelJetVect.size() < 2 || LeptonType == 0) {
return ;
}
fwdJet = SelJetVect_EtaSorted[0];
bJet = bjets->at(0);
if( fwdJet == bJet )
fwdJet = SelJetVect_EtaSorted[1] ;
bL.SetPtEtaPhiE( bJet->pt(), bJet->eta(), bJet->phi(), bJet->energy());
fwdJL.SetPtEtaPhiE( fwdJet->pt(),fwdJet->eta(), fwdJet->phi(), fwdJet->energy());
flashgg::SemiLepTopQuark singletop(bL, metL, lepton.LorentzVector(), fwdJL,fwdJL);
n_jets = SelJetVect.size();
metL = singletop.getMET() ;
jprime_eta = fabs( fwdJL.Eta() );
met_pt = metL.Pt();
metW_check = singletop.neutrino_W () ;
topMass = singletop.top().M() ;
};
//MVA INPUTS
float n_jets = 0;
float jprime_eta,met_pt;
struct particleinfo {
float pt, eta, phi , other , w , another; //other : for photon id, for diphoton mass, for jets btagging vals
unsigned short number;
bool isSet;
TLorentzVector lorentzVector_;
std::map<std::string,float> info;
particleinfo( double pt_=-999, double eta_=-999, double phi_=-999 , double other_= -999 , double W= 1.0 ) {
pt = pt_;
eta = eta_;
phi = phi_;
other = other_;
w = W;
number = 255;
isSet = false;
lorentzVector_.SetPtEtaPhiM(pt,eta,phi,other_);
};
void set(double pt_=-999, double eta_=-999, double phi_=-999 , double other_= -999 , double W= 1.0 , double Another= -999 ) {
pt = pt_;
eta = eta_;
phi = phi_;
other = other_;
w = W;
another = Another;
isSet = true;
lorentzVector_.SetPtEtaPhiM(pt,eta,phi,0.);
};
TLorentzVector LorentzVector() {
return lorentzVector_;
};
void SetLorentzVector(TLorentzVector lorentzVector) {
lorentzVector_.SetPxPyPzE(lorentzVector.Px(),lorentzVector.Py(),lorentzVector.Pz(),lorentzVector.Energy());
};
};
particleinfo lepton , eventshapes;
particleinfo foxwolf1 ; // foxwolf2 , foxwolf1Met, foxwolf2Met ;
};
THQLeptonicTagProducer::THQLeptonicTagProducer( const ParameterSet &iConfig ) :
processId_( iConfig.getParameter<string>("processId") ),
diPhotonToken_( consumes<View<flashgg::DiPhotonCandidate> >( iConfig.getParameter<InputTag> ( "DiPhotonTag" ) ) ),
inputTagJets_( iConfig.getParameter<std::vector<edm::InputTag> >( "inputTagJets" ) ),
electronToken_( consumes<View<flashgg::Electron> >( iConfig.getParameter<InputTag>( "ElectronTag" ) ) ),
muonToken_( consumes<View<flashgg::Muon> >( iConfig.getParameter<InputTag>( "MuonTag" ) ) ),
mvaResultToken_( consumes<View<flashgg::DiPhotonMVAResult> >( iConfig.getParameter<InputTag> ( "MVAResultTag" ) ) ),
vertexToken_( consumes<View<reco::Vertex> >( iConfig.getParameter<InputTag> ( "VertexTag" ) ) ),
METToken_( consumes<View<flashgg::Met> >( iConfig.getParameter<InputTag> ( "METTag" ) ) ),
genParticleToken_( consumes<View<reco::GenParticle> >( iConfig.getParameter<InputTag> ( "GenParticleTag" ) ) ),
genJetToken_ ( consumes<View<reco::GenJet> >( iConfig.getParameter<InputTag> ( "GenJetTag" ) ) ),
weightToken_( consumes<vector<flashgg::PDFWeightObject> >( iConfig.getUntrackedParameter<InputTag>( "WeightTag", InputTag( "flashggPDFWeightObject" ) ) ) ),
rhoTag_( consumes<double>( iConfig.getParameter<InputTag>( "rhoTag" ) ) ),
systLabel_( iConfig.getParameter<string> ( "SystLabel" ) ),
MVAMethod_ ( iConfig.getParameter<string> ( "MVAMethod" ) )
{
if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos) {
token_lhe = consumes<LHEEventProduct>( InputTag( "externalLHEProducer" ) );
}
double default_Zmass_ = 91.9;
double default_deltaMassElectronZThreshold_ = 5.;
vector<double> default_electronEtaCuts_;
muonEtaThreshold_ = iConfig.getParameter<double>( "muonEtaThreshold" );
muonPtThreshold_ = iConfig.getParameter<double>( "muonPtThreshold" );
electronEtaThresholds_ = iConfig.getParameter<vector<double > >( "electronEtaThresholds");
electronPtThreshold_ = iConfig.getParameter<double>( "electronPtThreshold" );
leadPhoOverMassThreshold_ = iConfig.getParameter<double>( "leadPhoOverMassThreshold" );
subleadPhoOverMassThreshold_ = iConfig.getParameter<double>( "subleadPhoOverMassThreshold" );
MVAThreshold_ = iConfig.getParameter<double>( "MVAThreshold" );
deltaRLepPhoThreshold_ = iConfig.getParameter<double>( "deltaRLepPhoThreshold" );
deltaRJetLepThreshold_ = iConfig.getParameter<double>( "deltaRJetLepThreshold" );
jetsNumberThreshold_ = iConfig.getParameter<double>( "jetsNumberThreshold" );
bjetsNumberThreshold_ = iConfig.getParameter<double>( "bjetsNumberThreshold" );
jetPtThreshold_ = iConfig.getParameter<double>( "jetPtThreshold" );
jetEtaThreshold_ = iConfig.getParameter<double>( "jetEtaThreshold" );
deltaRJetLeadPhoThreshold_ = iConfig.getParameter<double>( "deltaRJetLeadPhoThreshold" );
deltaRJetSubLeadPhoThreshold_ = iConfig.getParameter<double>( "deltaRJetSubLeadPhoThreshold" );
bDiscriminator_ = iConfig.getParameter<vector<double > >( "bDiscriminator" );
bTag_ = iConfig.getParameter<string>( "bTag" );
muPFIsoSumRelThreshold_ = iConfig.getParameter<double>( "muPFIsoSumRelThreshold" );
PhoMVAThreshold_ = iConfig.getParameter<double>( "PhoMVAThreshold" );
DeltaRTrkElec_ = iConfig.getParameter<double>( "DeltaRTrkElec" );
deltaRPhoElectronThreshold_ = iConfig.getParameter<double>( "deltaRPhoElectronThreshold" );
Zmass_ = iConfig.getUntrackedParameter<double>( "Zmass_", default_Zmass_ );
deltaMassElectronZThreshold_ = iConfig.getUntrackedParameter<double>( "deltaMassElectronZThreshold_", default_deltaMassElectronZThreshold_ );
DeltaRbjetfwdjet_ = iConfig.getParameter<double>( "DeltaRbjetfwdjet" );
DeltaRtHchainfwdjet_ = iConfig.getParameter<double>( "DeltaRtHchainfwdjet" );
MVAThreshold_thq_ = iConfig.getParameter<double>( "MVAThreshold_thq" );
likelihoodThreshold_thq_ = iConfig.getParameter<double>( "likelihoodThreshold_thq" );
thqLeptonicMVAweightfile_ = iConfig.getParameter<edm::FileInPath>( "thqleptonicMVAweightfile" );
likelihood_input_ = iConfig.getParameter<edm::FileInPath>( "likelihood_input" );
boundaries = iConfig.getParameter<vector<double > >( "Boundaries" );
thqLeptonicMva_.reset( new TMVA::Reader( "!Color:Silent" ) );
thqLeptonicMva_->AddVariable( "dipho_pt", &dipho_pt_);
thqLeptonicMva_->AddVariable( "n_jets" , &n_jets_);
thqLeptonicMva_->AddVariable( "n_bjets", &n_bjets_ );
thqLeptonicMva_->AddVariable( "n_centraljets", &n_centraljets_);
thqLeptonicMva_->AddVariable( "lepton_charge", &lepton_ch_);
thqLeptonicMva_->AddVariable( "bjet1_pt", &bJet1_pt_);
thqLeptonicMva_->AddVariable( "fwdjet1_eta", &fwdJet1_eta_ );
thqLeptonicMva_->AddVariable( "top_mt", &top_mt11_ );
thqLeptonicMva_->AddVariable( "dr_tHchainfwdjet", &dRtHchainfwdjet_ );
thqLeptonicMva_->AddVariable( "dr_leptonbjet", &dRleptonbjet_ );
thqLeptonicMva_->AddVariable( "dr_leptonfwdjet", &dRleptonfwdjet_ );
thqLeptonicMva_->AddVariable( "dr_bjetfwdjet", &dRbjetfwdjet_);
thqLeptonicMva_->AddVariable( "dr_leadphofwdjet", &dRleadphofwdjet_ );
thqLeptonicMva_->AddVariable( "dr_subleadphofwdjet" , &dRsubleadphofwdjet_);
thqLeptonicMva_->AddVariable( "bjet1_discr", &bjet1_discr_);
thqLeptonicMva_->AddVariable( "bjet2_discr", &bjet2_discr_);
thqLeptonicMva_->AddVariable( "bjet2_pt", &bjet2_pt_);
thqLeptonicMva_->AddVariable( "bjet1_eta", &bjet1_eta_);
thqLeptonicMva_->AddVariable( "bjet2_eta", &bjet2_eta_);
thqLeptonicMva_->AddVariable( "jet1_pt", &jet1_pt_);
thqLeptonicMva_->AddVariable( "jet2_pt", &jet2_pt_);
thqLeptonicMva_->AddVariable( "jet1_eta", &jet1_eta_);
thqLeptonicMva_->AddVariable( "jet2_eta", &jet2_eta_);
thqLeptonicMva_->BookMVA( MVAMethod_.c_str() , thqLeptonicMVAweightfile_.fullPath() );
for (unsigned i = 0 ; i < inputTagJets_.size() ; i++) {
auto token = consumes<View<flashgg::Jet> >(inputTagJets_[i]);
tokenJets_.push_back(token);
}
produces<vector<THQLeptonicTag> >();
produces<vector<THQLeptonicTagTruth> >();
std::string filename = likelihood_input_.fullPath();
likelihood_tHq_ = new THQLikelihoodComputer(filename.c_str());
}
THQLeptonicTagProducer::~THQLeptonicTagProducer() {
delete likelihood_tHq_;
}
int THQLeptonicTagProducer::chooseCategory( float mvavalue )
{
for(int n = 0 ; n < ( int )boundaries.size() ; n++ ) {
if( ( double )mvavalue > boundaries[boundaries.size() - n - 1] ) { return n; }
}
return -1;
}
/*int THQLeptonicTagProducer::chooseCategory( float mvavalue1, float mvavalue2 )
{
int n;
for( n = 0 ; n < ( int )boundaries.size() ; n++ ) {
if( ( double )mvavalue1 > boundaries[boundaries.size() - n - 1] && ( double )mvavalue2 > boundaries[boundaries.size() - n - 1] ) { return n; }
}
return -1;
}
*/
void THQLeptonicTagProducer::produce( Event &evt, const EventSetup & )
{
JetCollectionVector Jets( inputTagJets_.size() );
for( size_t j = 0; j < inputTagJets_.size(); ++j ) {
evt.getByToken( tokenJets_[j], Jets[j] );
}
edm::Handle<double> rho;
evt.getByToken(rhoTag_,rho);
float rho_ = *rho;
Handle<View<flashgg::DiPhotonCandidate> > diPhotons;
evt.getByToken( diPhotonToken_, diPhotons );
Handle<View<flashgg::Muon> > theMuons;
evt.getByToken( muonToken_, theMuons );
Handle<View<flashgg::Electron> > theElectrons;
evt.getByToken( electronToken_, theElectrons );
Handle<View<flashgg::DiPhotonMVAResult> > mvaResults;
evt.getByToken( mvaResultToken_, mvaResults );
std::unique_ptr<vector<THQLeptonicTag> > thqltags( new vector<THQLeptonicTag> );
Handle<View<reco::Vertex> > vertices;
evt.getByToken( vertexToken_, vertices );
Handle<View<flashgg::Met> > METs;
evt.getByToken( METToken_, METs );
Handle<View<reco::GenParticle> > genParticles;
Handle<View<reco::GenJet> > genJets;
std::unique_ptr<vector<THQLeptonicTagTruth> > truths( new vector<THQLeptonicTagTruth> );
Point higgsVtx;
edm::Handle<LHEEventProduct> product_lhe;
vector< double > CtCvWeights ;
// if( processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos ) {
// evt.getByToken(token_lhe, product_lhe);
// for (uint i = 446 ; i < product_lhe->weights().size() ; i++)
// CtCvWeights.push_back(product_lhe->weights()[i].wgt/product_lhe->originalXWGTUP () );
// }
edm::RefProd<vector<THQLeptonicTagTruth> > rTagTruth = evt.getRefBeforePut<vector<THQLeptonicTagTruth> >();
unsigned int idx = 0;
assert( diPhotons->size() == mvaResults->size() );
bool photonSelection = false;
double idmva1 = 0.;
double idmva2 = 0.;
for( unsigned int diphoIndex = 0; diphoIndex < diPhotons->size(); diphoIndex++ ) {
hasGoodElec = false;
hasVetoElec = false;
hasGoodMuons = false;
unsigned int jetCollectionIndex = diPhotons->ptrAt( diphoIndex )->jetCollectionIndex();
edm::Ptr<flashgg::DiPhotonCandidate> dipho = diPhotons->ptrAt( diphoIndex );
edm::Ptr<flashgg::DiPhotonMVAResult> mvares = mvaResults->ptrAt( diphoIndex );
flashgg::THQLeptonicTag thqltags_obj( dipho, mvares );
// if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos)
// CTCVWeightedVariables["photon1pt"]->Fill( dipho->leadingPhoton()->pt() , CtCvWeights );
if( dipho->leadingPhoton()->pt() < ( dipho->mass() )*leadPhoOverMassThreshold_ ) {
continue;
}
// if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos)
// CTCVWeightedVariables["photon2pt"]->Fill( dipho->subLeadingPhoton()->pt() , CtCvWeights );
if( dipho->subLeadingPhoton()->pt() < ( dipho->mass() )*subleadPhoOverMassThreshold_ ) {
continue;
}
idmva1 = dipho->leadingPhoton()->phoIdMvaDWrtVtx( dipho->vtx() );
idmva2 = dipho->subLeadingPhoton()->phoIdMvaDWrtVtx( dipho->vtx() );
if( idmva1 < PhoMVAThreshold_ || idmva2 < PhoMVAThreshold_ ) {
continue;
}
// if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos){
// CTCVWeightedVariables["diPhotonMVA"]->Fill( mvares->result , CtCvWeights );
// CTCVWeightedVariables["diPhotonPt"]->Fill( dipho->pt() , CtCvWeights );
// CTCVWeightedVariables["diPhotonEta"]->Fill( abs( dipho->eta() ) , CtCvWeights );
// }
if( mvares->result < MVAThreshold_ ) {
continue;
}
photonSelection = true;
G1.SetPtEtaPhiM( diPhotons->ptrAt( diphoIndex )->leadingPhoton()->pt(),
diPhotons->ptrAt( diphoIndex )->leadingPhoton()->eta(),
diPhotons->ptrAt( diphoIndex )->leadingPhoton()->phi() ,
0 );
particles_LorentzVector.push_back( G1 );
G2.SetPtEtaPhiM( diPhotons->ptrAt( diphoIndex )->subLeadingPhoton()->pt(),
diPhotons->ptrAt( diphoIndex )->subLeadingPhoton()->eta(),
diPhotons->ptrAt( diphoIndex )->subLeadingPhoton()->phi(),
0 );
particles_LorentzVector.push_back(G2);
particles_RhoEtaPhiVector.push_back( math::RhoEtaPhiVector(G1.Pt(), G1.Eta() , G1.Phi() ) );
particles_RhoEtaPhiVector.push_back( math::RhoEtaPhiVector(G2.Pt(), G2.Eta() , G2.Phi() ) );
if( METs->size() != 1 ) {
std::cout << "WARNING - #MET is not 1" << std::endl;
}
Ptr<flashgg::Met> theMET = METs->ptrAt( 0 );
thqltags_obj.setRECOMET(theMET);
// if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos)
// CTCVWeightedVariables["MET"]->Fill( theMET->getCorPt() , CtCvWeights );
//const pat::MET &met_ = METs->front();
metL.SetPtEtaPhiE( theMET->getCorPt(),
theMET->eta(),
theMET->getCorPhi(),
theMET->energy()
) ;
std::vector<edm::Ptr<flashgg::Muon> > LooseMu15 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.15 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_ );
std::vector<edm::Ptr<flashgg::Muon> > LooseMu25 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.25 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_ );
std::vector<edm::Ptr<flashgg::Muon> > LooseMu200 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
2. , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_);
std::vector<edm::Ptr<flashgg::Muon> > MediumMu15 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.15 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_ );
std::vector<edm::Ptr<flashgg::Muon> > MediumMu25 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.25 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_ );
std::vector<edm::Ptr<flashgg::Muon> > TightMuo15 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.15 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_);
std::vector<edm::Ptr<flashgg::Muon> > TightMuo25 = selectMuons( theMuons->ptrs(), dipho, vertices->ptrs(), muonEtaThreshold_ , muonPtThreshold_,
0.25 , deltaRLepPhoThreshold_, deltaRLepPhoThreshold_);
std::vector<edm::Ptr<flashgg::Muon> > goodMuons = muPFIsoSumRelThreshold_== 0.15 ? TightMuo15 : TightMuo25 ;
std::vector<int> looseMus_PassTight;
for(auto mu: LooseMu200)
looseMus_PassTight.push_back( std::find( goodMuons.begin() , goodMuons.end() , mu ) != goodMuons.end() );
std::vector<edm::Ptr<Electron> > vetoNonIsoElectrons = selectStdElectrons(theElectrons->ptrs(), dipho, vertices->ptrs(), electronPtThreshold_, electronEtaThresholds_ ,
0,4,
deltaRPhoElectronThreshold_,DeltaRTrkElec_,deltaMassElectronZThreshold_ , rho_, true ); //evt.isRealData()
std::vector<edm::Ptr<Electron> > looseElectrons = selectStdElectrons(theElectrons->ptrs(), dipho, vertices->ptrs(), electronPtThreshold_, electronEtaThresholds_ ,
0,3,
deltaRPhoElectronThreshold_,DeltaRTrkElec_,deltaMassElectronZThreshold_ , rho_, true ); //evt.isRealData()
std::vector<edm::Ptr<Electron> > vetoElectrons = selectStdElectrons(theElectrons->ptrs(), dipho, vertices->ptrs(), electronPtThreshold_, electronEtaThresholds_ ,
0,0,
deltaRPhoElectronThreshold_,DeltaRTrkElec_,deltaMassElectronZThreshold_ , rho_, true ); //evt.isRealData()
std::vector<edm::Ptr<Electron> > mediumElectrons = selectStdElectrons(theElectrons->ptrs(), dipho, vertices->ptrs(), electronPtThreshold_, electronEtaThresholds_ ,
0,2,
deltaRPhoElectronThreshold_,DeltaRTrkElec_,deltaMassElectronZThreshold_ , rho_, true ); //evt.isRealData()
std::vector<edm::Ptr<Electron> > goodElectrons = selectStdElectrons(theElectrons->ptrs(), dipho, vertices->ptrs(), electronPtThreshold_, electronEtaThresholds_ ,
0,1,
deltaRPhoElectronThreshold_,DeltaRTrkElec_,deltaMassElectronZThreshold_ , rho_, true);
std::vector<int> vetoNonIsoElectrons_PassTight;
std::vector<int> vetoNonIsoElectrons_PassVeto;
for(auto ele : vetoNonIsoElectrons ) {
vetoNonIsoElectrons_PassTight.push_back( std::find( goodElectrons.begin() , goodElectrons.end() , ele ) != goodElectrons.end() );
vetoNonIsoElectrons_PassVeto.push_back( std::find( vetoElectrons.begin() , vetoElectrons.end() , ele ) != vetoElectrons.end() );
}
//----------------------
if(goodMuons.size()>=2)
{
std::vector<edm::Ptr<flashgg::Muon>> Muons_0;
Muons_0 = goodMuons;
std::vector<int> badIndexes;
for(unsigned int i=0; i<Muons_0.size(); ++i)
{
for(unsigned int j=i+1; j<Muons_0.size(); ++j)
{
TLorentzVector l1, l2;
l1.SetPtEtaPhiE(Muons_0[i]->pt(), Muons_0[i]->eta(), Muons_0[i]->phi(), Muons_0[i]->energy());
l2.SetPtEtaPhiE(Muons_0[j]->pt(), Muons_0[j]->eta(), Muons_0[j]->phi(), Muons_0[j]->energy());
if(fabs((l1+l2).M() - Zmass_) < deltaMassElectronZThreshold_)
{
badIndexes.push_back(i);
badIndexes.push_back(j);
}
}
}
if(badIndexes.size()!=0)
{
goodMuons.clear();
for(unsigned int i=0; i<Muons_0.size(); ++i)
{
bool isBad = false;
for(unsigned int j=0; j<badIndexes.size(); ++j)
{
if(badIndexes[j]==(int)i)
isBad = true;
}
if(!isBad) goodMuons.push_back(Muons_0[i]);
}
}
}
if(goodElectrons.size()>=2)
{
std::vector<int> badIndexes;
std::vector<edm::Ptr<flashgg::Electron> > Electrons_0;
Electrons_0 = goodElectrons;
for(unsigned int i=0; i<Electrons_0.size(); ++i)
{
for(unsigned int j=i+1; j<Electrons_0.size(); ++j)
{
TLorentzVector l1, l2;
l1.SetPtEtaPhiE(Electrons_0[i]->pt(), Electrons_0[i]->eta(), Electrons_0[i]->phi(), Electrons_0[i]->energy());
l2.SetPtEtaPhiE(Electrons_0[j]->pt(), Electrons_0[j]->eta(), Electrons_0[j]->phi(), Electrons_0[j]->energy());
if(fabs((l1+l2).M() - Zmass_) < deltaMassElectronZThreshold_)
{
badIndexes.push_back(i);
badIndexes.push_back(j);
}
}
}
if(badIndexes.size()!=0)
{
goodElectrons.clear();
for(unsigned int i=0; i<Electrons_0.size(); ++i)
{
bool isBad = false;
for(unsigned int j=0; j<badIndexes.size(); ++j)
{
if(badIndexes[j]==(int)i)
isBad = true;
}
if(!isBad) goodElectrons.push_back(Electrons_0[i]);
}
}
}
//------------------------------------------
if((goodElectrons.size() + goodMuons.size()) < 1) {
continue;
}
hasGoodElec = ( goodElectrons.size() == 1 );
hasVetoElec = ( vetoElectrons.size() > 0 );
hasGoodMuons = ( goodMuons.size() == 1 );
LeptonType = 0; //1 : electron, 2:muon
if( hasGoodMuons && !hasVetoElec) {
LeptonType = 2;
}
for( unsigned int muonIndex = 0; muonIndex < goodMuons.size(); muonIndex++ ) {
Ptr<flashgg::Muon> muon = goodMuons[muonIndex];
thqltags_obj.includeWeights( *goodMuons[muonIndex] );
lepton.set( muon->pt(),
muon->eta() ,
muon->phi() ,
muon->energy(),
1. ,
muon->charge() );
particles_LorentzVector.push_back(lepton.LorentzVector());
particles_RhoEtaPhiVector.push_back( math::RhoEtaPhiVector( lepton.pt, lepton.eta, lepton.phi ) );
}//end of muons loop
if( hasGoodElec && !hasGoodMuons) {
LeptonType = 1;
}
for( unsigned int ElectronIndex = 0; ElectronIndex < goodElectrons.size(); ElectronIndex++ ) {
thqltags_obj.includeWeights( *goodElectrons[ElectronIndex] );
Ptr<Electron> Electron = goodElectrons[ElectronIndex];
lepton.set( Electron->pt(),
Electron->eta() ,
Electron->phi() ,
Electron->energy(),
1. ,
Electron->charge() );
particles_LorentzVector.push_back(lepton.LorentzVector());
particles_RhoEtaPhiVector.push_back( math::RhoEtaPhiVector( lepton.pt, lepton.eta, lepton.phi ) );
}//end of electron loop
// if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos){
// CTCVWeightedVariables["LeptonPt"]->Fill( lepton.pt , CtCvWeights );
// CTCVWeightedVariables["LeptonEta"]->Fill( abs(lepton.eta) , CtCvWeights );
// }
float ht=0;
float dRPhoLeadJet=0;
float dRPhoSubLeadJet=0;
double minDrLepton = 999.;
int njets_btagloose_ = 0;
int njets_btagmedium_ = 0;
int njets_btagtight_ = 0;
std::vector<float> bTag_value;
for( unsigned int candIndex_outer = 0; candIndex_outer < Jets[jetCollectionIndex]->size() ; candIndex_outer++ ) {
edm::Ptr<flashgg::Jet> thejet = Jets[jetCollectionIndex]->ptrAt( candIndex_outer );
std::vector <float> minDrLepton_ele;
std::vector <float> minDrLepton_muon;
if( !thejet->passesPuJetId( dipho ) ) {
continue;
}
if( fabs( thejet->eta() ) > jetEtaThreshold_ ) {
continue;
}
if( thejet->pt() < jetPtThreshold_ ) {
continue;
}
dRPhoLeadJet = deltaR( thejet->eta(), thejet->phi(), dipho->leadingPhoton()->superCluster()->eta(), dipho->leadingPhoton()->superCluster()->phi() ) ;
dRPhoSubLeadJet = deltaR( thejet->eta(), thejet->phi(), dipho->subLeadingPhoton()->superCluster()->eta(),dipho->subLeadingPhoton()->superCluster()->phi() );
if( dRPhoLeadJet < deltaRJetLeadPhoThreshold_ || dRPhoSubLeadJet < deltaRJetSubLeadPhoThreshold_ ) {
continue;
}
TLorentzVector jet_lorentzVector;
jet_lorentzVector.SetPtEtaPhiE( thejet->pt() , thejet->eta() , thejet->phi() , thejet->energy() );
particles_LorentzVector.push_back( jet_lorentzVector );
particles_RhoEtaPhiVector.push_back( math::RhoEtaPhiVector( thejet->pt(), thejet->eta(), thejet->phi() ) );
int goodElectrons_count = 0;
int goodMuons_count = 0;
int rejectJet_wrt_muon = 1;
int rejectJet_wrt_ele = 1;
//deltaR check with ele------------------------------------
for(auto ele : goodElectrons) {
float dRJetLepton_ele = deltaR( thejet->eta(), thejet->phi(), ele->eta() , ele->phi() );
minDrLepton_ele.push_back(dRJetLepton_ele);
goodElectrons_count++;
}
if(minDrLepton_ele.size() > 0) {
for(unsigned int minDrLepton_ele_index=0; minDrLepton_ele_index < minDrLepton_ele.size() ; minDrLepton_ele_index++ ) {
if( minDrLepton_ele.at(minDrLepton_ele_index) < deltaRJetLepThreshold_) {
rejectJet_wrt_ele = 0;
}
rejectJet_wrt_ele = rejectJet_wrt_ele * rejectJet_wrt_ele ;
}
}
if( rejectJet_wrt_ele == 0) {
continue;
}
minDrLepton_ele.clear();
//deltaR check with muon---------------------------
for(auto mu : goodMuons) {
float dRJetLepton_muon = deltaR( thejet->eta(), thejet->phi(), mu->eta() , mu->phi() );
minDrLepton_muon.push_back(dRJetLepton_muon);
goodMuons_count++;
}
if(minDrLepton_muon.size() > 0) {
for(unsigned int minDrLepton_muon_index=0; minDrLepton_muon_index < minDrLepton_muon.size() ; minDrLepton_muon_index++ ) {
if( minDrLepton_muon.at(minDrLepton_muon_index) < deltaRJetLepThreshold_) {
rejectJet_wrt_muon = 0;
}
rejectJet_wrt_muon = rejectJet_wrt_muon * rejectJet_wrt_muon ;
}
}
if( rejectJet_wrt_muon == 0) {
continue;
}
minDrLepton_muon.clear();
float bDiscriminatorValue; //= -2.;
if(bTag_ == "pfDeepCSV") bDiscriminatorValue = thejet->bDiscriminator("pfDeepCSVJetTags:probb") + thejet->bDiscriminator("pfDeepCSVJetTags:probbb");
else
bDiscriminatorValue = thejet->bDiscriminator( bTag_ );
if( bDiscriminatorValue > bDiscriminator_[0] ) {
LooseBJetVect_PtSorted.push_back( thejet );
LooseBJetVect.push_back( thejet );
njets_btagloose_++;
}
if( bDiscriminatorValue > bDiscriminator_[1] ) {
MediumBJetVect_.push_back( thejet );
MediumBJetVect_PtSorted.push_back( thejet );
njets_btagmedium_++;
}
if( bDiscriminatorValue > bDiscriminator_[2] ) {
TightBJetVect_PtSorted.push_back( thejet );
TightBJetVect.push_back( thejet );
njets_btagtight_++;
}
ht+=thejet->pt();
if( fabs( thejet->eta() ) < 1) {
centraljet.push_back( thejet );
}
if( fabs( thejet->eta() ) > 1) {
forwardjet.push_back( thejet );
}
SelJetVect.push_back( thejet );
SelJetVect_EtaSorted.push_back( thejet );
SelJetVect_PtSorted.push_back( thejet );
}//end of jets loop
//Calculate scalar sum of jets
std::sort(LooseBJetVect_PtSorted.begin(),LooseBJetVect_PtSorted.end(),GreaterByPt());
std::sort(MediumBJetVect_PtSorted.begin(),MediumBJetVect_PtSorted.end(),GreaterByPt());
std::sort(TightBJetVect_PtSorted.begin(),TightBJetVect_PtSorted.end(),GreaterByPt());
std::sort(SelJetVect_EtaSorted.begin(),SelJetVect_EtaSorted.end(),GreaterByEta());
std::sort(SelJetVect_PtSorted.begin(),SelJetVect_PtSorted.end(),GreaterByPt());
for(unsigned int bjetsindex = 0 ; bjetsindex < MediumBJetVect_.size(); bjetsindex++){
if(MediumBJetVect_[bjetsindex] != SelJetVect_EtaSorted[0] ){
MediumBJetVect.push_back( MediumBJetVect_[bjetsindex] );
bTag_value.push_back( MediumBJetVect_[bjetsindex]->bDiscriminator("pfDeepCSVJetTags:probb") + MediumBJetVect_[bjetsindex]->bDiscriminator("pfDeepCSVJetTags:probbb") );
}
}
MediumBJetVect_.clear();
std::sort(MediumBJetVect.begin(),MediumBJetVect.end(), GreaterByBTagging("pfDeepCSVJetTags:probb", "pfDeepCSVJetTags:probbb"));
std::sort(bTag_value.begin(), bTag_value.end(), std::greater<float>());
if(SelJetVect.size() < jetsNumberThreshold_ || MediumBJetVect.size() < bjetsNumberThreshold_){
SelJetVect.clear();
SelJetVect_EtaSorted.clear(); SelJetVect_PtSorted.clear(); SelJetVect_BSorted.clear();
LooseBJetVect.clear(); LooseBJetVect_PtSorted.clear();
MediumBJetVect.clear(); MediumBJetVect_PtSorted.clear(); MediumBJetVect_.clear();
TightBJetVect.clear(); TightBJetVect_PtSorted.clear();
centraljet.clear(); forwardjet.clear();
continue; }
//------------------------------------Likelihood and MVA-----------------------------------------
//---------------------------------------------------------------------------------------
// THQLikelihoodComputer *likelihood_tHq = new THQLikelihoodComputer();
std::vector<double> vec_lhood_calc;
fwdJet1 = SelJetVect_EtaSorted[0];
bJet1 = MediumBJetVect[0];
l1.SetPtEtaPhiE(0., 0., 0., 0.);
b1.SetPtEtaPhiE(0., 0., 0., 0.);
l1b1.SetPtEtaPhiE(0., 0., 0., 0.);
l1b1met.SetPtEtaPhiE(0., 0., 0., 0.);
double qdelR_leadphofwdjet1, qdelR_subleadphofwdjet1;
if(goodMuons.size() > 0){
muon1 = goodMuons[0];
l1.SetPtEtaPhiE(muon1->pt(), muon1->eta(), muon1->phi(), muon1->energy());
lepton_ch_ = muon1->charge();
}
else
{
ele1 = goodElectrons[0];
l1.SetPtEtaPhiE(ele1->pt(), ele1->eta(), ele1->phi(), ele1->energy());
lepton_ch_ = ele1->charge();
}
b1.SetPtEtaPhiE(bJet1->pt(), bJet1->eta(), bJet1->phi(), bJet1->energy());
l1b1 = l1 + b1;
l1b1met = l1b1 + metL;
top_mt11_ = sqrt((l1b1met.M() * l1b1met.M()) + (l1b1met.Pt() * l1b1met.Pt()));
tHchain=G1 + G2 + b1 + metL + l1;
qdelR_leadphofwdjet1 = deltaR( fwdJet1->eta(), fwdJet1->phi(), dipho->leadingPhoton()->eta(), dipho->leadingPhoton()->phi() ) ;
qdelR_subleadphofwdjet1 = deltaR( fwdJet1->eta(), fwdJet1->phi(), dipho->subLeadingPhoton()->eta(), dipho->subLeadingPhoton()->phi() ) ;
dipho_pt_ = dipho->pt();
n_jets_ = SelJetVect.size();
n_bjets_ = MediumBJetVect.size();
n_centraljets_ = centraljet.size();
bJet1_pt_ = bJet1->pt();
bjet1_eta_ = bJet1->eta();
dEta_leptonfwdjet_ = std::abs(l1.Eta()-fwdJet1->eta());
fwdJet1_eta_ = fwdJet1->eta();
bjet1_discr_ = bTag_value.at(0);
if(SelJetVect.size()==1){
jet1_pt_ = SelJetVect[0]->pt();
jet1_eta_ = SelJetVect[0]->eta();
jet2_pt_ = -999;
jet2_eta_ = -999;
}
else {
jet1_pt_ = SelJetVect[0]->pt();
jet1_eta_ = SelJetVect[0]->eta();
jet2_pt_ =SelJetVect[1]->pt();
jet2_eta_ =SelJetVect[1]->eta();
}
if(MediumBJetVect.size()==1){
bjet1_discr_ = bTag_value.at(0);
bjet2_discr_ = -999;
bjet2_pt_ = -999;
bjet2_eta_ = -999;
}
else {
bjet1_discr_ = bTag_value.at(0);
bjet2_discr_ = bTag_value.at(1);
bjet2_pt_ =SelJetVect[1]->pt();
bjet2_eta_ =SelJetVect[1]->eta();
}
dRbjetfwdjet_ = deltaR( b1.Eta() , b1.Phi() , fwdJet1->eta() , fwdJet1->phi() );
dRtHchainfwdjet_ = deltaR( tHchain.Eta() , tHchain.Phi() , fwdJL.Eta() , fwdJL.Phi() );
dRleadphobjet_ = deltaR( G1.Eta() , G1.Phi(), b1.Eta() , b1.Phi());
dRsubleadphobjet_ = deltaR( G2.Eta() , G2.Phi(), b1.Eta() , b1.Phi());
dRleadphofwdjet_ = deltaR( G1.Eta() , G1.Phi(), fwdJet1->eta() , fwdJet1->phi());
dRsubleadphofwdjet_ = deltaR( G2.Eta() , G2.Phi(), fwdJet1->eta() , fwdJet1->phi());
dRleptonbjet_ = deltaR( l1.Eta() , l1.Phi(), b1.Eta() , b1.Phi());
dRleptonfwdjet_ = deltaR( l1.Eta() , l1.Phi(), fwdJet1->eta() , fwdJet1->phi());
vec_lhood_calc.push_back( SelJetVect.size() );
vec_lhood_calc.push_back( centraljet.size() );
vec_lhood_calc.push_back( lepton_ch_ );
vec_lhood_calc.push_back( fwdJet1_eta_ );
vec_lhood_calc.push_back( dEta_leptonfwdjet_ );
vec_lhood_calc.push_back( qdelR_leadphofwdjet1 );
vec_lhood_calc.push_back( qdelR_subleadphofwdjet1 );
vec_lhood_calc.push_back( bJet1_pt_);
vec_lhood_calc.push_back( top_mt11_ );
vec_lhood_calc.push_back( dipho_pt_ );
vec_lhood_calc.push_back( n_bjets_ );
vec_lhood_calc.push_back( dRtHchainfwdjet_);
vec_lhood_calc.push_back( dRleptonbjet_ );
vec_lhood_calc.push_back( dRleptonfwdjet_ );
double lhood_value= likelihood_tHq_->evaluate_likelihood(vec_lhood_calc );
thqLeptonicMvaResult_value_ = thqLeptonicMva_->EvaluateMVA( MVAMethod_.c_str() );
thqltags_obj.setlikelihood ( lhood_value ) ;
thqltags_obj.setthq_mvaresult ( thqLeptonicMvaResult_value_ );
//Tagger with Likelihood
/* if(lhood_value < likelihoodThreshold_thq_){
SelJetVect.clear();
SelJetVect_EtaSorted.clear(); SelJetVect_PtSorted.clear(); SelJetVect_BSorted.clear();
LooseBJetVect.clear(); LooseBJetVect_PtSorted.clear();
MediumBJetVect.clear(); MediumBJetVect_PtSorted.clear();
TightBJetVect.clear(); TightBJetVect_PtSorted.clear();
centraljet.clear(); forwardjet.clear();
continue; }
*/
//Tagger with BDT
if( thqLeptonicMvaResult_value_ < MVAThreshold_thq_){
SelJetVect.clear();
SelJetVect_EtaSorted.clear(); SelJetVect_PtSorted.clear(); SelJetVect_BSorted.clear();
LooseBJetVect.clear(); LooseBJetVect_PtSorted.clear();
MediumBJetVect.clear(); MediumBJetVect_PtSorted.clear();
TightBJetVect.clear(); TightBJetVect_PtSorted.clear();
centraljet.clear(); forwardjet.clear();
continue; }
//int catnum = -1;
//catnum = chooseCategory( thqLeptonicMvaResult_value_ );
//catnum = chooseCategory( mvares->result );
//catnum = chooseCategory( idmva1, idmva2 );
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
thqltags_obj.setHT(ht);
// if( processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos ){
// CTCVWeightedVariables["nJets"]->Fill( SelJetVect_EtaSorted.size() , CtCvWeights );
// CTCVWeightedVariables["nbJets"]->Fill( MediumBJetVect.size() , CtCvWeights );
// if( SelJetVect_EtaSorted.size() > 0 )
// CTCVWeightedVariables["jPrimeEta"]->Fill( abs(SelJetVect_EtaSorted[0]->eta() ) , CtCvWeights );
// }
if( photonSelection ) {
FoxWolfram fwam( particles_LorentzVector );
std::vector< particleinfo*> allfoxwolfs = {&foxwolf1 };
for(uint ifw = 1 ; ifw < allfoxwolfs.size()+1 ; ifw++)
allfoxwolfs[ifw-1]->set( fwam.getMoment( FoxWolfram::SHAT , ifw ),
fwam.getMoment( FoxWolfram::PT , ifw ),
fwam.getMoment( FoxWolfram::ETA , ifw ),
fwam.getMoment( FoxWolfram::PSUM , ifw ),
fwam.getMoment( FoxWolfram::PZ , ifw ),
fwam.getMoment( FoxWolfram::ONE , ifw ) );
thqltags_obj.setrho(rho_);
thqltags_obj.setLeptonType(LeptonType);
thqltags_obj.includeWeights( *dipho );
thqltags_obj.photonWeights = dipho->leadingPhoton()->centralWeight()*dipho->subLeadingPhoton()->centralWeight() ;
thqltags_obj.setJets( SelJetVect_PtSorted , SelJetVect_EtaSorted);
thqltags_obj.setBJets( MediumBJetVect );
thqltags_obj.nCentralJets = centraljet.size();
thqltags_obj.nForwardJets = forwardjet.size();
thqltags_obj.setcentraljet( centraljet );
thqltags_obj.setforwardjet( forwardjet );
thqltags_obj.setdRtHchainfwdjet( dRtHchainfwdjet_ ) ;
thqltags_obj.setdRbjetfwdjet( dRbjetfwdjet_ ) ;
thqltags_obj.setdRleadphobjet( dRleadphobjet_ );
thqltags_obj.setdRsubleadphobjet( dRsubleadphobjet_ );
thqltags_obj.setdRleadphofwdjet( dRleadphofwdjet_ );
thqltags_obj.setdRsubleadphofwdjet( dRsubleadphofwdjet_ );
thqltags_obj.setdRleptonbjet (dRleptonbjet_);
thqltags_obj.setdRleptonfwdjet (dRleptonfwdjet_);
thqltags_obj.setdEtaleptonfwdjet(std::abs(l1.Eta()-fwdJet1->eta()));
thqltags_obj.settop_mt(top_mt11_);
thqltags_obj.settop_mass(topMass);
thqltags_obj.setlepton_ch(lepton_ch_);
thqltags_obj.setmvaresult ( mvares->result ) ; //diphoton mva
thqltags_obj.setthq_mvaresult ( thqLeptonicMvaResult_value_ );
thqltags_obj.setlikelihood ( lhood_value ) ;
thqltags_obj.setbDiscriminatorValue( bTag_value );
// thqltags_obj.setCategoryNumber( catnum );
thqltags_obj.bTagWeight = 1.0;
thqltags_obj.bTagWeightDown = 1.0;
thqltags_obj.bTagWeightUp = 1.0;
for( auto j : SelJetVect_PtSorted ) {
thqltags_obj.includeWeights( *j );
/* if( j->hasWeight("JetBTagCutWeightCentral") ){
thqltags_obj.bTagWeight *= j->weight( "JetBTagCutWeightCentral" );
thqltags_obj.bTagWeightDown *= j->weight( "JetBTagCutWeightDown01sigma" );
thqltags_obj.bTagWeightUp *= j->weight( "JetBTagCutWeightUp01sigma" );
}
else
cout << "BTag weight is not set in jet" << endl;
*/
}
thqltags_obj.setVertices( vertices->ptrs() );
std::vector <float> a;
std::vector <float> b;
std::vector <float> c;
std::vector <float> d;
for( unsigned int muonIndex = 0; muonIndex < LooseMu200.size(); muonIndex++ ) {
Ptr<flashgg::Muon> muon = LooseMu200[muonIndex];
int vtxInd = -1;
double dzmin = 9999;
for( size_t ivtx = 0 ; ivtx < vertices->ptrs().size(); ivtx++ ) {
Ptr<reco::Vertex> vtx = vertices->ptrs()[ivtx];
if( !muon->innerTrack() ) continue;
if( fabs( muon->innerTrack()->vz() - vtx->position().z() ) < dzmin ) {
dzmin = fabs( muon->innerTrack()->vz() - vtx->position().z() );
vtxInd = ivtx;
}
}
Ptr<reco::Vertex> best_vtx = vertices->ptrs()[vtxInd];
a.push_back(muon->muonBestTrack()->dxy(best_vtx->position()));
b.push_back(muon->muonBestTrack()->dz(best_vtx->position()));
c.push_back(muon->muonBestTrack()->dxy(dipho->vtx()->position()));
d.push_back(muon->muonBestTrack()->dz(dipho->vtx()->position()));
}//end of muons loop
thqltags_obj.setLeptonVertices( "muon", a, b, c, d) ;
thqltags_obj.setMuons( goodMuons , looseMus_PassTight , LooseMu25.size() , LooseMu15.size() , MediumMu25.size() , MediumMu15.size() , TightMuo25.size() , TightMuo15.size() );
a.clear();
b.clear();
c.clear();
d.clear();
/* for( unsigned int ElectronIndex = 0; ElectronIndex < vetoNonIsoElectrons.size(); ElectronIndex++ ) {
Ptr<flashgg::Electron> electron = vetoNonIsoElectrons[ElectronIndex];
int vtxInd = -1;
double dzmin = 9999;
for( size_t ivtx = 0 ; ivtx < vertices->ptrs().size(); ivtx++ ) {
Ptr<reco::Vertex> vtx = vertices->ptrs()[ivtx];
if( fabs( electron->gsfTrack()->dz(vtx->position()) ) < dzmin ) {
dzmin = fabs(electron->gsfTrack()->dz( vtx->position() ));
vtxInd = ivtx;
}
}
Ptr<reco::Vertex> best_vtx = vertices->ptrs()[vtxInd];
a.push_back(electron->gsfTrack()->dxy(best_vtx->position()));
b.push_back(electron->gsfTrack()->dz(best_vtx->position()));
c.push_back(electron->gsfTrack()->dxy(dipho->vtx()->position()));
d.push_back(electron->gsfTrack()->dz(dipho->vtx()->position()));
int elMissedHits = electron->gsfTrack()->hitPattern().numberOfAllHits( reco::HitPattern::MISSING_INNER_HITS);
thqltags_obj.setElectronMisHits(elMissedHits);
}//end of electrons loop
*/
thqltags_obj.setLeptonVertices( "electron", a, b, c, d) ;
thqltags_obj.setElectrons( goodElectrons , vetoNonIsoElectrons_PassTight , vetoNonIsoElectrons_PassVeto , looseElectrons.size() , vetoElectrons.size() , mediumElectrons.size() , goodElectrons.size() );
thqltags_obj.setDiPhotonIndex( diphoIndex );
thqltags_obj.setSystLabel( systLabel_ );
thqltags_obj.setFoxAndAplanarity( foxwolf1.another , eventshapes.pt );
thqltags_obj.setMETPtEtaPhiE( "SolvedMET", metW_check.Pt(), metW_check.Eta(), metW_check.Phi(), metW_check.E() );
topReco( &MediumBJetVect );
thqltags_obj.nMedium_bJets = MediumBJetVect.size();
thqltags_obj.nLoose_bJets = LooseBJetVect_PtSorted.size();
thqltags_obj.nTight_bJets = TightBJetVect_PtSorted.size();
if( ! evt.isRealData() ) {
if(processId_.find("thq") != std::string::npos or processId_.find("thw") != std::string::npos) {
// //8 QCD scale weights
// for( uint i = 1 ; i < 9 ; i ++ )
// thqltags_obj.setScale(i-1,product_lhe->weights()[i].wgt/product_lhe->originalXWGTUP () );
// //100 NNPDF30 LO weights
// for( uint i = 9 ; i < 109 ; i ++ )
// thqltags_obj.setPdf(i-9,product_lhe->weights()[i].wgt/product_lhe->originalXWGTUP () );
// //1 as down variation
// thqltags_obj.setAlphaDown(product_lhe->weights()[211].wgt/product_lhe->originalXWGTUP ());
// //1 NNDF30 NLO weight
// thqltags_obj.setPdfNLO(product_lhe->weights()[390].wgt/product_lhe->originalXWGTUP () );
// for (uint i = 446 ; i < product_lhe->weights().size() ; i++) {
// thqltags_obj.setCtCv(i-446,product_lhe->weights()[i].wgt/product_lhe->originalXWGTUP () );
// }
} else if (processId_.find("h_") != std::string::npos or processId_.find("vbf") != std::string::npos) {
//temporary solution till ctcv issue on PDFWeightObject is solved :(
Handle<vector<flashgg::PDFWeightObject> > WeightHandle;
evt.getByToken( weightToken_, WeightHandle );
for( unsigned int weight_index = 0; weight_index < (*WeightHandle).size(); weight_index++ ) {
vector<uint16_t> compressed_weights = (*WeightHandle)[weight_index].pdf_weight_container;
std::vector<float> uncompressed = (*WeightHandle)[weight_index].uncompress( compressed_weights );
vector<uint16_t> compressed_alpha = (*WeightHandle)[weight_index].alpha_s_container;
std::vector<float> uncompressed_alpha = (*WeightHandle)[weight_index].uncompress( compressed_alpha );
vector<uint16_t> compressed_scale = (*WeightHandle)[weight_index].qcd_scale_container;
std::vector<float> uncompressed_scale = (*WeightHandle)[weight_index].uncompress( compressed_scale );
vector<uint16_t> compressed_nloweights = (*WeightHandle)[weight_index].pdfnlo_weight_container;
std::vector<float> uncompressed_nloweights = (*WeightHandle)[weight_index].uncompress( compressed_nloweights );
// vector<uint16_t> compressed_ctcvweights = (*WeightHandle)[weight_index].ctcv_weight_container;
// std::vector<float> uncompressed_ctcvweights = (*WeightHandle)[weight_index].uncompress( compressed_ctcvweights );
// //std::cout << "size !! "<< uncompressed.size() << " "<< uncompressed_alpha.size() << " "<<uncompressed_scale.size()<<" " << uncompressed_nloweights.size() << " " <<uncompressed_ctcvweights.size() << std::endl;
float central_w = uncompressed_scale[0];
for( unsigned int j=0; j<(*WeightHandle)[weight_index].pdf_weight_container.size(); j++ ) {
thqltags_obj.setPdf(j,uncompressed[j]/ central_w );
}
// // for( unsigned int j=1; j<(*WeightHandle)[weight_index].ctcv_weight_container.size();j++ ) {
// // thqltags_obj.setCtCv(j,uncompressed_ctcvweights[j]/ central_w );
// // }
if (uncompressed_alpha.size()>1)
{
thqltags_obj.setAlphaUp(uncompressed_alpha[0]/central_w );
thqltags_obj.setAlphaDown(uncompressed_alpha[1]/ central_w );
}
else
thqltags_obj.setAlphaDown(uncompressed_alpha[0]/ central_w );
for( uint i = 1 ; i < 9 ; i ++ )
thqltags_obj.setScale(i-1,uncompressed_scale[i]/central_w );
if (uncompressed_nloweights.size()>0)
thqltags_obj.setPdfNLO(uncompressed_nloweights[0]/ central_w);
}
}//end of reading PDF weights from PDFWeightObject
evt.getByToken( genParticleToken_, genParticles );
evt.getByToken( genJetToken_, genJets );
THQLeptonicTagTruth truth_obj;
truth_obj.setDiPhoton ( dipho );
for( unsigned int genLoop = 0 ; genLoop < genParticles->size(); genLoop++ ) {
int pdgid = genParticles->ptrAt( genLoop )->pdgId();
if( pdgid == 25 || pdgid == 22 ) {
higgsVtx = genParticles->ptrAt( genLoop )->vertex();
break;
}
}
truth_obj.setGenPV( higgsVtx );
// --------
//gen met
TLorentzVector nu_lorentzVector, allnus_LorentzVector, promptnus_LorentzVector;
for( unsigned int genLoop = 0 ; genLoop < genParticles->size(); genLoop++ ) {
edm::Ptr<reco::GenParticle> part = genParticles->ptrAt( genLoop );
bool fid_cut = (abs(part->eta())<5.0 && part->status()==1) ? 1 : 0;
bool isNu = (abs(part->pdgId())==12 || abs(part->pdgId())==14 || abs(part->pdgId())==16) ? 1 : 0;
if (!fid_cut || !isNu) continue;
if( part->isPromptFinalState() || part->isDirectPromptTauDecayProductFinalState()) {
nu_lorentzVector.SetPtEtaPhiE( part->pt() , part->eta() , part->phi() , part->energy() );
promptnus_LorentzVector+=nu_lorentzVector;
}
else {
nu_lorentzVector.SetPtEtaPhiE( part->pt() , part->eta() , part->phi() , part->energy() );
allnus_LorentzVector+=nu_lorentzVector;
}
}
thqltags_obj.setMETPtEtaPhiE( "allPromptNus", promptnus_LorentzVector.Pt(), promptnus_LorentzVector.Eta(), promptnus_LorentzVector.Phi(), promptnus_LorentzVector.Energy() );
thqltags_obj.setMETPtEtaPhiE( "allNus", allnus_LorentzVector.Pt(), allnus_LorentzVector.Eta(), allnus_LorentzVector.Phi(), allnus_LorentzVector.Energy() );
thqltags_obj.setMETPtEtaPhiE( "genMetTrue", theMET->genMET()->pt(), theMET->genMET()->eta(), theMET->genMET()->phi(), theMET->genMET()->energy() );
if(SelJetVect_PtSorted.size() > 1) {
unsigned int index_leadq = std::numeric_limits<unsigned int>::max();
unsigned int index_subleadq = std::numeric_limits<unsigned int>::max();
unsigned int index_subsubleadq = std::numeric_limits<unsigned int>::max();
float pt_leadq = 0., pt_subleadq = 0., pt_subsubleadq = 0.;
// --------
//Partons
for( unsigned int genLoop = 0 ; genLoop < genParticles->size(); genLoop++ ) {
edm::Ptr<reco::GenParticle> part = genParticles->ptrAt( genLoop );
if( part->isHardProcess() ) {
if( abs( part->pdgId() ) <= 5 ) {
if( part->pt() > pt_leadq ) {
index_subleadq = index_leadq;
pt_subleadq = pt_leadq;
index_leadq = genLoop;
pt_leadq = part->pt();
} else if( part->pt() > pt_subleadq ) {
index_subsubleadq = index_subleadq;
pt_subsubleadq = pt_subleadq;
index_subleadq = genLoop;
pt_subleadq = part->pt();
} else if( part->pt() > pt_subsubleadq ) {
index_subsubleadq = genLoop;
pt_subleadq = part->pt();
}
}
}
}
if( index_leadq < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setLeadingParton( genParticles->ptrAt( index_leadq ) );
}
if( index_subleadq < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setSubLeadingParton( genParticles->ptrAt( index_subleadq ) );
}
if( index_subsubleadq < std::numeric_limits<unsigned int>::max()) {
truth_obj.setSubSubLeadingParton( genParticles->ptrAt( index_subsubleadq ));
}
unsigned int index_gp_leadjet = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_subleadjet = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_leadphoton = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_subleadphoton = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_leadmuon = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_subleadmuon = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_leadelectron = std::numeric_limits<unsigned int>::max();
unsigned int index_gp_subleadelectron = std::numeric_limits<unsigned int>::max();
float dr_gp_leadjet = 999.;
float dr_gp_subleadjet = 999.;
float dr_gp_leadphoton = 999.;
float dr_gp_subleadphoton = 999.;
float dr_gp_leadmuon = 999.;
float dr_gp_subleadmuon = 999.;
float dr_gp_leadelectron = 999.;
float dr_gp_subleadelectron = 999.;
if (SelJetVect_PtSorted.size()>0)truth_obj.setLeadingJet( SelJetVect_PtSorted[0] );
if (SelJetVect_PtSorted.size()>1)truth_obj.setSubLeadingJet( SelJetVect_PtSorted[1] );
if (SelJetVect_PtSorted.size()>2)truth_obj.setSubSubLeadingJet( SelJetVect_PtSorted[2] );
if (SelJetVect_PtSorted.size()>0)truth_obj.setLeadingJet( SelJetVect_PtSorted[0] );
if (SelJetVect_PtSorted.size()>1)truth_obj.setSubLeadingJet( SelJetVect_PtSorted[1] );
if (thqltags_obj.muons().size()>0)truth_obj.setLeadingMuon( thqltags_obj.muons()[0] );
if (thqltags_obj.muons().size()>1)truth_obj.setSubLeadingMuon( thqltags_obj.muons()[1] );
if (thqltags_obj.electrons().size()>0)truth_obj.setLeadingElectron( thqltags_obj.electrons()[0] );
if (thqltags_obj.electrons().size()>1)truth_obj.setSubLeadingElectron( thqltags_obj.electrons()[1] );
// --------
//GEN-RECO Level Matching
for( unsigned int genLoop = 0 ; genLoop < genParticles->size(); genLoop++ )
{
edm::Ptr<reco::GenParticle> part = genParticles->ptrAt( genLoop );
if( part->isHardProcess())
{
float dr;
if (truth_obj.hasLeadingJet()) {
dr = deltaR( truth_obj.leadingJet()->eta(), truth_obj.leadingJet()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_leadjet )
{
dr_gp_leadjet = dr;
index_gp_leadjet = genLoop;
}
}
if (truth_obj.hasSubLeadingJet()) {
dr = deltaR( truth_obj.subLeadingJet()->eta(), truth_obj.subLeadingJet()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_subleadjet )
{
dr_gp_subleadjet = dr;
index_gp_subleadjet = genLoop;
}
}
if (truth_obj.hasDiPhoton()) {
dr = deltaR( truth_obj.diPhoton()->leadingPhoton()->eta(), truth_obj.diPhoton()->leadingPhoton()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_leadphoton )
{
dr_gp_leadphoton = dr;
index_gp_leadphoton = genLoop;
}
dr = deltaR( truth_obj.diPhoton()->subLeadingPhoton()->eta(), truth_obj.diPhoton()->subLeadingPhoton()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_subleadphoton )
{
dr_gp_subleadphoton = dr;
index_gp_subleadphoton = genLoop;
}
}
if (truth_obj.hasLeadingMuon()) {
dr = deltaR( truth_obj.leadingMuon()->eta(), truth_obj.leadingMuon()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_leadmuon )
{
dr_gp_leadmuon = dr;
index_gp_leadmuon = genLoop;
}
}
if (truth_obj.hasSubLeadingMuon()) {
dr = deltaR( truth_obj.subLeadingMuon()->eta(), truth_obj.subLeadingMuon()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_subleadmuon )
{
dr_gp_subleadmuon = dr;
index_gp_subleadmuon = genLoop;
}
}
if (truth_obj.hasLeadingElectron()) {
dr = deltaR( truth_obj.leadingElectron()->eta(), truth_obj.leadingElectron()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_leadelectron )
{
dr_gp_leadelectron = dr;
index_gp_leadelectron = genLoop;
}
}
if (truth_obj.hasSubLeadingElectron()) {
dr = deltaR( truth_obj.subLeadingElectron()->eta(), truth_obj.subLeadingElectron()->phi(), part->eta(), part->phi() );
if( dr < dr_gp_subleadelectron )
{
dr_gp_subleadelectron = dr;
index_gp_subleadelectron = genLoop;
}
}
}
}
if( index_gp_leadjet < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestParticleToLeadingJet( genParticles->ptrAt( index_gp_leadjet ) );
}
if( index_gp_subleadjet < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestParticleToSubLeadingJet( genParticles->ptrAt( index_gp_subleadjet ) );
}
if( index_gp_leadphoton < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestParticleToLeadingPhoton( genParticles->ptrAt( index_gp_leadphoton ) );
}
if( index_gp_subleadphoton < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestParticleToSubLeadingPhoton( genParticles->ptrAt( index_gp_subleadphoton ) );
}
if( index_gp_leadmuon < std::numeric_limits<unsigned int>::max() )
{
truth_obj.setClosestParticleToLeadingMuon( genParticles->ptrAt( index_gp_leadmuon ) );
const reco::GenParticle *mcMom;
mcMom = static_cast<const reco::GenParticle *>(genParticles->ptrAt( index_gp_leadmuon )->mother());
if (mcMom) {
if( abs(genParticles->ptrAt( index_gp_leadmuon )->pdgId())==13
&& genParticles->ptrAt( index_gp_leadmuon )->status()==1
&& abs( mcMom->pdgId())==24 )
{ truth_obj.setClosestPromptParticleToLeadingMuon( genParticles->ptrAt( index_gp_leadmuon ) );
}
}
}
if( index_gp_subleadmuon < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestParticleToSubLeadingMuon( genParticles->ptrAt( index_gp_subleadmuon ) );
const reco::GenParticle *mcMom;
mcMom = static_cast<const reco::GenParticle *>(genParticles->ptrAt( index_gp_subleadmuon )->mother());
if (mcMom) {
if( abs(genParticles->ptrAt( index_gp_subleadmuon )->pdgId())==13
&& genParticles->ptrAt( index_gp_subleadmuon )->status()==1
&& abs( mcMom->pdgId())==24 )
{
truth_obj.setClosestPromptParticleToSubLeadingMuon( genParticles->ptrAt( index_gp_subleadmuon ) );
}
}
}
if( index_gp_leadelectron < std::numeric_limits<unsigned int>::max() )
{
truth_obj.setClosestParticleToLeadingElectron( genParticles->ptrAt( index_gp_leadelectron ) );
if(truth_obj.hasClosestParticleToLeadingElectron()) {
}
const reco::GenParticle *mcMom;
mcMom = static_cast<const reco::GenParticle *>(genParticles->ptrAt( index_gp_leadelectron )->mother());
if (mcMom) {
if( abs(genParticles->ptrAt( index_gp_leadelectron )->pdgId())==11
&& genParticles->ptrAt( index_gp_leadelectron )->status()==1
&& abs( mcMom->pdgId())==24 )
{
truth_obj.setClosestPromptParticleToLeadingElectron( genParticles->ptrAt( index_gp_leadelectron ) );
}
if(truth_obj.hasClosestPromptParticleToLeadingElectron()) {
}
truth_obj.pt_genPromptParticleMatchingToLeadingElectron();
}
}
// truth_obj.testfunction();
if( index_gp_subleadelectron < std::numeric_limits<unsigned int>::max() ) {
const reco::GenParticle *mcMom;
truth_obj.setClosestParticleToSubLeadingElectron( genParticles->ptrAt( index_gp_subleadelectron ) );
mcMom = static_cast<const reco::GenParticle *>(genParticles->ptrAt( index_gp_subleadelectron )->mother());
if (mcMom) {
if( abs(genParticles->ptrAt( index_gp_subleadelectron )->pdgId())==11
&& genParticles->ptrAt( index_gp_subleadelectron )->status()==1
&& abs( mcMom->pdgId())==24 )
{
truth_obj.setClosestPromptParticleToSubLeadingElectron( genParticles->ptrAt( index_gp_subleadelectron ) );
}
}
}
unsigned int index_gj_leadjet = std::numeric_limits<unsigned int>::max();
unsigned int index_gj_subleadjet = std::numeric_limits<unsigned int>::max();
unsigned int index_gj_subsubleadjet = std::numeric_limits<unsigned int>::max();
float dr_gj_leadjet = 999.;
float dr_gj_subleadjet = 999.;
float dr_gj_subsubleadjet = 999.;
// --------
//GEN Jet-RECO Jet Matching
for( unsigned int gjLoop = 0 ; gjLoop < genJets->size() ; gjLoop++ )
{
edm::Ptr <reco::GenJet> gj = genJets->ptrAt( gjLoop );
float dr = deltaR( SelJetVect_PtSorted[0]->eta(), SelJetVect_PtSorted[0]->phi(), gj->eta(), gj->phi() );
if( dr < dr_gj_leadjet )
{
dr_gj_leadjet = dr;
index_gj_leadjet = gjLoop;
}
//if( > 1 ){
dr = deltaR( SelJetVect_PtSorted[1]->eta(), SelJetVect_PtSorted[1]->phi(), gj->eta(), gj->phi() );
if( dr < dr_gj_subleadjet )
{
dr_gj_subleadjet = dr;
index_gj_subleadjet = gjLoop;
}
//}
if (truth_obj.hasSubSubLeadingJet())
{
dr = deltaR( SelJetVect_PtSorted[2]->eta(), SelJetVect_PtSorted[2]->phi(), gj->eta(), gj->phi() );
if( dr < dr_gj_subsubleadjet )
{
dr_gj_subsubleadjet = dr;
index_gj_subsubleadjet = gjLoop;
}
}
}
if( index_gj_leadjet < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestGenJetToLeadingJet( genJets->ptrAt( index_gj_leadjet ) );
}
if( index_gj_subleadjet < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestGenJetToSubLeadingJet( genJets->ptrAt( index_gj_subleadjet ) );
}
if( index_gj_subsubleadjet < std::numeric_limits<unsigned int>::max() ) {
truth_obj.setClosestGenJetToSubSubLeadingJet( genJets->ptrAt( index_gj_subsubleadjet ) );
}
// --------
//Parton-Jet Matching
std::vector<edm::Ptr<reco::GenParticle>> ptOrderedPartons;
for (unsigned int genLoop(0); genLoop < genParticles->size(); genLoop++)
{
edm::Ptr<reco::GenParticle> gp = genParticles->ptrAt(genLoop);
bool isQuark = abs( gp->pdgId() ) < 7 && gp->numberOfMothers() == 0;
bool isGluon = gp->pdgId() == 21 && gp->numberOfMothers() == 0;
if (isGluon || isQuark) {
unsigned int insertionIndex(0);
for (unsigned int parLoop(0); parLoop<ptOrderedPartons.size(); parLoop++) {
if (gp->pt() < ptOrderedPartons[parLoop]->pt()) {
insertionIndex = parLoop + 1;
}
}
ptOrderedPartons.insert( ptOrderedPartons.begin() + insertionIndex, gp);
}
}
//Lead
if ( ptOrderedPartons.size() > 0 && truth_obj.hasLeadingJet())
{
float dr(999.0);
unsigned pIndex(0);
for (unsigned partLoop(0); partLoop<ptOrderedPartons.size(); partLoop++) {
float deltaR_temp = deltaR(SelJetVect_PtSorted[0]->eta(),SelJetVect_PtSorted[0]->phi(),
ptOrderedPartons[partLoop]->eta(),ptOrderedPartons[partLoop]->phi());
if (deltaR_temp < dr) {
dr = deltaR_temp;
pIndex = partLoop;
}
}
truth_obj.setClosestPartonToLeadingJet( ptOrderedPartons[pIndex] );
}
//Sublead
if (ptOrderedPartons.size() > 0 && truth_obj.hasSubLeadingJet())
{
float dr(999.0);
unsigned pIndex(0);
for (unsigned partLoop(0); partLoop<ptOrderedPartons.size(); partLoop++) {
float deltaR_temp = deltaR(SelJetVect_PtSorted[1]->eta(),SelJetVect_PtSorted[1]->phi(),
ptOrderedPartons[partLoop]->eta(),ptOrderedPartons[partLoop]->phi());
if (deltaR_temp < dr) {
dr = deltaR_temp;
pIndex = partLoop;
}
}
truth_obj.setClosestPartonToSubLeadingJet( ptOrderedPartons[pIndex] );
}
//Subsublead
if (ptOrderedPartons.size() > 0 && truth_obj.hasSubSubLeadingJet())
{
float dr(999.0);
unsigned pIndex(0);
for (unsigned partLoop(0); partLoop<ptOrderedPartons.size(); partLoop++) {
float deltaR_temp = deltaR(SelJetVect_PtSorted[2]->eta(),SelJetVect_PtSorted[2]->phi(),
ptOrderedPartons[partLoop]->eta(),ptOrderedPartons[partLoop]->phi());
if (deltaR_temp < dr) {
dr = deltaR_temp;
pIndex = partLoop;
}
}
truth_obj.setClosestPartonToSubSubLeadingJet( ptOrderedPartons[pIndex] );
}
}
thqltags->push_back( thqltags_obj );
truths->push_back( truth_obj );
thqltags->back().setTagTruth( edm::refToPtr( edm::Ref<vector<THQLeptonicTagTruth> >( rTagTruth, idx++ ) ) );
}// ! evt.isRealData() loop end !
if (evt.isRealData()) thqltags->push_back( thqltags_obj ); //FIXME at next iteration!!
}//thq tag
else {
if(false)
std::cout << " THQLeptonicTagProducer NO TAG " << std::endl;
}
n_jets = 0;
particles_LorentzVector.clear();
particles_RhoEtaPhiVector.clear();
SelJetVect.clear();
SelJetVect_EtaSorted.clear();
SelJetVect_PtSorted.clear();
SelJetVect_BSorted.clear();
LooseBJetVect.clear();
LooseBJetVect_PtSorted.clear();
MediumBJetVect.clear();
MediumBJetVect_.clear();
MediumBJetVect_PtSorted.clear();
TightBJetVect.clear();
TightBJetVect_PtSorted.clear();
centraljet.clear();
forwardjet.clear();
}//diPho loop end !
evt.put( std::move( thqltags ) );
evt.put( std::move( truths ) );
}
}
typedef flashgg::THQLeptonicTagProducer FlashggTHQLeptonicTagProducer;
DEFINE_FWK_MODULE( FlashggTHQLeptonicTagProducer );
// Local Variables:
// mode:c++
// indent-tabs-mode:nil
// tab-width:4
// c-basic-offset:4
// End:
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
| [
"[email protected]"
] | |
067144f91bd466430d370184bb6267965973c590 | 124903acc416f5ea1d4451b2a9feef69d22cd8d8 | /HomeWork.16.02.21/ex.1.cpp | b48b9ed9ab2f0b535e6e0386b63adf7f4483feb5 | [] | no_license | sanyonk/Algorithms-and-data-structures | c8507dcc8632c34692163ebd52a6d995b4266ec0 | e5b40ad04e5c5377b88d6247a996416897490d3e | refs/heads/main | 2023-07-04T23:41:28.331091 | 2021-09-03T21:23:55 | 2021-09-03T21:23:55 | 340,674,883 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 473 | cpp | #include <iostream>
#include <ctime>
using namespace std;
int f_1(int* arr, int size, int* summ)
{
for (int i = 0; i < size; i++)
{
*summ += *(arr + i);
}
return *summ;
}
int main()
{
srand(time(NULL));
const int size = 5;
int arr[size];
int summ = 0;
int* summ_1 = &summ;
for(int i = 0; i < size; i++)
{
arr[i] = rand() % 10;
}
int* a = &arr[0];
cout << f_1(a, size, summ_1);
return 0;
} | [
"[email protected]"
] | |
3fc0868b4d4282bb6a2cfc221ad43cc1cda0d7b5 | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /components/history/core/browser/history_match.cc | 6e252b9c4d25d60286516689dcf9c23b3e6ac1a4 | [
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 1,114 | cc | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/history/core/browser/history_match.h"
#include "base/logging.h"
namespace history {
HistoryMatch::HistoryMatch()
: url_info(),
input_location(base::string16::npos),
match_in_scheme(false),
innermost_match(true) {
}
HistoryMatch::HistoryMatch(const URLRow& url_info,
size_t input_location,
bool match_in_scheme,
bool innermost_match)
: url_info(url_info),
input_location(input_location),
match_in_scheme(match_in_scheme),
innermost_match(innermost_match) {
}
bool HistoryMatch::EqualsGURL(const HistoryMatch& h, const GURL& url) {
return h.url_info.url() == url;
}
bool HistoryMatch::IsHostOnly() const {
const GURL& gurl = url_info.url();
DCHECK(gurl.is_valid());
return (!gurl.has_path() || (gurl.path() == "/")) && !gurl.has_query() &&
!gurl.has_ref();
}
} // namespace history
| [
"[email protected]"
] | |
d698340bb394f82178bdd7cb42fb21461d13b68c | 102375c73e7e2587cd08b2e595c0d5dab2066e7a | /UnitTest1/chap2unittest.cpp | 51dde391d521e473911fff5541e20572c6fb3f64 | [] | no_license | RodChen/CrackCodeInterview | 504e9c06c1302d01850282797db561932bea2e0e | d284a1f0986dca5b9c8127186c336cb918381b87 | refs/heads/master | 2021-01-10T16:14:12.701109 | 2016-03-16T06:44:50 | 2016-03-16T06:44:50 | 52,148,689 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,046 | cpp | #include "stdafx.h"
#include "CppUnitTest.h"
#include "..\CrackCodeInterviewDll\CrackCodeInterviewDll.h"
#include "..\CrackCodeInterviewDll\LinkedList.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace Chap2UnitTest
{
TEST_CLASS(Chap2)
{
public:
LinkedList emptyList, list1, list2, list3, list4, list5;
Chap2()
{
// Prepare test data
emptyList = LinkedList();
list1 = LinkedList();
list1.add_node_to_tail(10);
list1.add_node_to_tail(20);
list1.add_node_to_tail(30);
list1.add_node_to_tail(20);
list2 = LinkedList();
list2.add_node_to_tail(100);
list2.add_node_to_tail(20);
list2.add_node_to_tail(30);
list2.add_node_to_tail(50);
list3 = LinkedList();
list3.add_node_to_tail(1);
list3.add_node_to_tail(1);
list3.add_node_to_tail(1);
list4 = LinkedList();
list4.add_node_to_tail(1);
list4.add_node_to_tail(5);
list4.add_node_to_tail(3);
list4.add_node_to_tail(2);
list4.add_node_to_tail(4);
list5 = LinkedList();
list5.add_node_to_tail(1);
list5.add_node_to_tail(5);
list5.add_node_to_tail(3);
list5.add_node_to_tail(5);
list5.add_node_to_tail(1);
}
CCrackCodeInterviewDll library;
TEST_METHOD(Chap2_1)
{
library.removeDuplicate(emptyList);
Assert::IsTrue(emptyList.is_empty());
library.removeDuplicate(list1);
Assert::IsFalse(list1.has_duplicate_element());
library.removeDuplicate(list2);
Assert::IsFalse(list2.has_duplicate_element());
library.removeDuplicate(list3);
Assert::IsFalse(list3.has_duplicate_element());
}
TEST_METHOD(Chap2_2)
{
Node* result1 = library.getKthLast(emptyList, 1);
Assert::IsNull(result1);
Node* result2 = library.getKthLast(list1, 1);
Assert::AreEqual(20, result2->value);
result2 = library.getKthLast(list1, 2);
Assert::AreEqual(30, result2->value);
result2 = library.getKthLast(list1, 3);
Assert::AreEqual(20, result2->value);
result2 = library.getKthLast(list1, 4);
Assert::AreEqual(10, result2->value);
Node* result3 = library.getKthLast(list2, 1);
Assert::AreEqual(50, result3->value);
result3 = library.getKthLast(list2, 2);
Assert::AreEqual(30, result3->value);
result3 = library.getKthLast(list2, 3);
Assert::AreEqual(20, result3->value);
result3 = library.getKthLast(list2, 4);
Assert::AreEqual(100, result3->value);
Node* result4 = library.getKthLast(list3, 1);
Assert::AreEqual(1, result4->value);
result4 = library.getKthLast(list3, 2);
Assert::AreEqual(1, result4->value);
result4 = library.getKthLast(list3, 3);
Assert::AreEqual(1, result4->value);
}
TEST_METHOD(Chap2_3)
{
library.deleteMiddle(list4, list4.get_index_at(3));
Node* result = list4.get_index_at(3);
Assert::AreEqual(2, result->value);
}
TEST_METHOD(Chap2_4)
{
library.partitionValue(list4, 4);
Node* result1 = list4.get_index_at(1);
Assert::AreEqual(1, result1->value);
result1 = list4.get_index_at(2);
Assert::AreEqual(3, result1->value);
result1 = list4.get_index_at(3);
Assert::AreEqual(2, result1->value);
result1 = list4.get_index_at(4);
Assert::AreEqual(5, result1->value);
result1 = list4.get_index_at(5);
Assert::AreEqual(4, result1->value);
}
TEST_METHOD(Chap2_5)
{
//111 + 42351 = 42462 => 2->6->4->2->4
LinkedList resultList1 = library.sum(list4, list3);
Node* result1 = resultList1.get_index_at(1);
Assert::AreEqual(2, result1->value);
result1 = resultList1.get_index_at(2);
Assert::AreEqual(6, result1->value);
result1 = resultList1.get_index_at(3);
Assert::AreEqual(4, result1->value);
result1 = resultList1.get_index_at(4);
Assert::AreEqual(2, result1->value);
result1 = resultList1.get_index_at(5);
Assert::AreEqual(4, result1->value);
}
TEST_METHOD(Chap2_7)
{
Assert::IsTrue(library.isPalindrome(emptyList));
Assert::IsTrue(library.isPalindrome(list3));
Assert::IsTrue(library.isPalindrome(list5));
Assert::IsFalse(library.isPalindrome(list1));
}
};
} | [
"[email protected]"
] | |
4ca4f4b216dd8a6a6c217c78203038a9c304209a | 0ab01bbedb1dc7f2554e59cd5451c8e806e994b8 | /dev/3rdParty/expat/expat_external.h | 0e57d57d0cf8a226330a1aa67229eee934515aae | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | jafetmorales/iremote | 98ff2c287c00afc827ad99e0e7a9861795c33361 | d6c8a858757f93bbccd9969c2f75a2a4901a95dd | refs/heads/master | 2020-05-19T03:58:56.594993 | 2019-05-06T19:14:16 | 2019-05-06T19:14:16 | 184,813,981 | 0 | 0 | null | 2019-05-03T20:04:32 | 2019-05-03T20:04:32 | null | UTF-8 | C++ | false | false | 3,367 | h | /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
See the file COPYING for copying permission.
*/
#ifndef Expat_External_INCLUDED
#define Expat_External_INCLUDED 1
/* External API definitions */
#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
// #define XML_USE_MSC_EXTENSIONS 1
#endif
/* Expat tries very hard to make the API boundary very specifically
defined. There are two macros defined to control this boundary;
each of these can be defined before including this header to
achieve some different behavior, but doing so it not recommended or
tested frequently.
XMLCALL - The calling convention to use for all calls across the
"library boundary." This will default to cdecl, and
try really hard to tell the compiler that's what we
want.
XMLIMPORT - Whatever magic is needed to note that a function is
to be imported from a dynamically loaded library
(.dll, .so, or .sl, depending on your platform).
The XMLCALL macro was added in Expat 1.95.7. The only one which is
expected to be directly useful in client code is XMLCALL.
Note that on at least some Unix versions, the Expat library must be
compiled with the cdecl calling convention as the default since
system headers may assume the cdecl convention.
*/
#ifndef XMLCALL
#if defined(_MSC_VER)
#define XMLCALL __cdecl
#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
#define XMLCALL __attribute__((cdecl))
#else
/* For any platform which uses this definition and supports more than
one calling convention, we need to extend this definition to
declare the convention used on that platform, if it's possible to
do so.
If this is the case for your platform, please file a bug report
with information on how to identify your platform via the C
pre-processor and how to specify the same calling convention as the
platform's malloc() implementation.
*/
#define XMLCALL
#endif
#endif /* not defined XMLCALL */
#if !defined(XML_STATIC) && !defined(XMLIMPORT)
#ifndef XML_BUILDING_EXPAT
/* using Expat from an application */
#ifdef XML_USE_MSC_EXTENSIONS
#define XMLIMPORT __declspec(dllimport)
#endif
#endif
#endif /* not defined XML_STATIC */
/* If we didn't define it above, define it away: */
#ifndef XMLIMPORT
#define XMLIMPORT
#endif
#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
#ifdef __cplusplus
extern "C" {
#endif
#ifdef XML_UNICODE_WCHAR_T
#define XML_UNICODE
#endif
#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
#ifdef XML_UNICODE_WCHAR_T
typedef wchar_t XML_Char;
typedef wchar_t XML_LChar;
#else
typedef unsigned short XML_Char;
typedef char XML_LChar;
#endif /* XML_UNICODE_WCHAR_T */
#else /* Information is UTF-8 encoded. */
typedef char XML_Char;
typedef char XML_LChar;
#endif /* XML_UNICODE */
#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
typedef __int64 XML_Index;
typedef unsigned __int64 XML_Size;
#else
typedef long long XML_Index;
typedef unsigned long long XML_Size;
#endif
#else
typedef long XML_Index;
typedef unsigned long XML_Size;
#endif /* XML_LARGE_SIZE */
#ifdef __cplusplus
}
#endif
#endif /* not Expat_External_INCLUDED */
| [
"[email protected]"
] | |
5d5c67c216ca431d03660cc341fed360499d0a55 | f944116a3b877d968a701d53c745c07877279977 | /VS2005/ArABB.OPC.DA.NET.Server/OPC.DA.Server.Wrapped/ArABB.OPC.DA.Common/OpcXmlType.cpp | 7fd1361f4b455655a866ba6aa97fba38d1f3eba3 | [] | no_license | simple555a/niko78csharp | c5d9b421fbbb2a288318a3b1d66e39e01ca86977 | 0ae5714664cbd957ba82d27d5568569b9fc26655 | refs/heads/master | 2021-05-29T07:08:41.989881 | 2012-06-12T15:35:54 | 2012-06-12T15:35:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 24,097 | cpp | //==============================================================================
// TITLE: OpcXmlType.cpp
//
// CONTENTS:
//
// Declarations for common XML constants, types and free functions.
//
// (c) Copyright 2002-2003 The OPC Foundation
// ALL RIGHTS RESERVED.
//
// DISCLAIMER:
// This code is provided by the OPC Foundation solely to assist in
// understanding and use of the appropriate OPC Specification(s) and may be
// used as set forth in the License Grant section of the OPC Specification.
// This code is provided as-is and without warranty or support of any sort
// and is subject to the Warranty and Liability Disclaimers which appear
// in the printed OPC Specification.
//
// MODIFICATION LOG:
//
// Date By Notes
// ---------- --- -----
// 2002/09/03 RSA First release.
//
#include "StdAfx.h"
#include <float.h>
#include <limits.h>
#include "OpcXmlType.h"
#include "COpcTextReader.h"
using namespace OpcXml;
//==============================================================================
// Local Delcarations
#define MAX_VALUE_BUF_SIZE 1024
// numeric upper/lower bounds.
#define MIN_SBYTE _I8_MIN
#define MAX_SBYTE _I8_MAX
#define MAX_BYTE _UI8_MAX
#define MIN_SHORT _I16_MIN
#define MAX_SHORT _I16_MAX
#define MAX_USHORT _UI16_MAX
#define MIN_INT _I32_MIN
#define MAX_INT _I32_MAX
#define MAX_UINT _UI32_MAX
#define MIN_LONG _I64_MIN
#define MAX_LONG _I64_MAX
#define MAX_ULONG _UI64_MAX
#define MIN_FLOAT FLT_MIN
#define MAX_FLOAT FLT_MAX
#define MIN_DOUBLE DBL_MIN
#define MAX_DOUBLE DBL_MAX
#define MIN_DECIMAL (_I64_MIN/10000)
#define MAX_DECIMAL (_I64_MAX/10000)
#define MAX_DEC_FRACTION 9999
#define MIN_YEAR 1601
#define MAX_YEAR 9999
#define MIN_MONTH 1
#define MAX_MONTH 12
#define MIN_DAY 1
#define MAX_DAY 31
#define MIN_HOUR 0
#define MAX_HOUR 23
#define MIN_MINUTE 0
#define MAX_MINUTE 59
#define MIN_SECOND 0
#define MAX_SECOND 59
#define MIN_SEC_FRACTION 0
#define MAX_SEC_FRACTION 999
//==============================================================================
// Local Functions
// CharToValue
static UINT CharToValue(TCHAR tzChar, UINT uBase)
{
static const LPCTSTR g_tsDigits = _T("0123456789ABCDEF");
TCHAR tzDigit = (_istlower(tzChar))?_toupper(tzChar):tzChar;
for (UINT ii = 0; ii < uBase; ii++)
{
if (tzDigit == g_tsDigits[ii])
{
return ii;
}
}
return -1;
}
// ToUnsigned
static bool ToUnsigned(
const COpcString& cString,
ULong& nValue,
ULong nMax,
ULong nMin,
UINT uBase
)
{
bool bResult = true;
TRY
{
COpcText cText;
COpcTextReader cReader(cString);
// extract non-whitespace.
cText.SetType(COpcText::NonWhitespace);
cText.SetEofDelim();
if (!cReader.GetNext(cText))
{
THROW_(bResult, false);
}
COpcString cValue = cText;
nValue = 0;
for (UINT ii = 0; ii < cValue.GetLength(); ii++)
{
UINT uDigit = CharToValue(cValue[ii], uBase);
// invalid digit found.
if (uDigit == -1)
{
bResult = false;
break;
}
// detect overflow
if (nValue > nMax/uBase) THROW_(bResult, false);
// shift result up by base.
nValue *= uBase;
// detect overflow
if (nValue > nMax - uDigit) THROW_(bResult, false);
// add digit.
nValue += uDigit;
}
// detect underflow
if (nMin > nValue) THROW_(bResult, false);
}
CATCH
{
nValue = 0;
}
return bResult;
}
// ToUnsigned
static bool ToUnsigned(
const COpcString& cString,
ULong& nValue,
ULong nMax,
ULong nMin
)
{
// extract base
COpcText cText;
COpcTextReader cReader(cString);
UINT uBase = 10;
cText.SetType(COpcText::Literal);
cText.SetText(L"0x");
cText.SetIgnoreCase();
if (cReader.GetNext(cText))
{
uBase = 16;
}
// read unsigned value.
return ToUnsigned(cReader.GetBuf(), nValue, nMax, nMin, uBase);
}
// ToSigned
static bool ToSigned(
const COpcString& cString,
Long& nValue,
Long nMax,
Long nMin
)
{
nValue = 0;
// extract plus sign
bool bSign = true;
COpcText cText;
COpcTextReader cReader(cString);
cText.SetType(COpcText::Literal);
cText.SetText(L"+");
if (!cReader.GetNext(cText))
{
// extract minus sign
cText.SetType(COpcText::Literal);
cText.SetText(L"-");
bSign = !cReader.GetNext(cText);
}
// read unsigned value.
ULong uValue = 0;
if (!ToUnsigned(cReader.GetBuf(), uValue, (bSign)?nMax:-nMin, 0, 10))
{
return false;
}
nValue = (Long)uValue;
// apply sign.
if (!bSign)
{
nValue = -nValue;
}
return true;
}
// ToReal
static bool ToReal(
const COpcString& cString,
Double& nValue,
Double nMax,
Double nMin
)
{
bool bResult = true;
TRY
{
// extract non-whitespace token.
COpcText cText;
COpcTextReader cReader(cString);
cText.SetType(COpcText::NonWhitespace);
cText.SetSkipLeading();
if (!cReader.GetNext(cText))
{
THROW_(bResult, false);
}
// parse double with C runtime function.
WCHAR* pzEnd = NULL;
nValue = (Double)wcstod((LPCWSTR)(COpcString&)cText, &pzEnd);
// check for error - all text must have been parsed.
if (pzEnd == NULL || wcslen(pzEnd) != 0)
{
THROW_(bResult, false);
}
// check limits.
if (nValue > nMax && nValue < nMin) THROW_(bResult, false);
}
CATCH
{
nValue = 0;
}
return bResult;
}
// ToDate
static bool ToDate(
const COpcString& cString,
WORD& wYear,
WORD& wMonth,
WORD& wDay
)
{
bool bResult = true;
TRY
{
COpcText cText;
COpcTextReader cReader(cString);
ULong uValue = 0;
// parse year field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L"-");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_YEAR, MIN_YEAR, 10)) THROW_(bResult, false);
wYear = (WORD)uValue;
// parse month field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L"-");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_MONTH, MIN_MONTH, 10)) THROW_(bResult, false);
wMonth = (WORD)uValue;
// parse day field.
cText.SetType(COpcText::Delimited);
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_DAY, MIN_DAY, 10)) THROW_(bResult, false);
wDay = (WORD)uValue;
}
CATCH
{
wYear = 0;
wMonth = 0;
wDay = 0;
}
return bResult;
}
// ToTime
static bool ToTime(
const COpcString& cString,
WORD& wHour,
WORD& wMinute,
WORD& wSeconds,
WORD& wFraction
)
{
bool bResult = true;
TRY
{
COpcText cText;
COpcTextReader cReader(cString);
ULong uValue = 0;
// parse hour field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L":");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_HOUR, MIN_HOUR, 10)) THROW_(bResult, false);
wHour = (WORD)uValue;
// parse month field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L":");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_MINUTE, MIN_MINUTE, 10)) THROW_(bResult, false);
wMinute = (WORD)uValue;
// parse seconds field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L".");
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_SECOND, MIN_SECOND, 10)) THROW_(bResult, false);
wSeconds = (WORD)uValue;
// parse seconds fraction field.
wFraction = 0;
if (cText.GetDelimChar() == L'.')
{
cText.SetType(COpcText::Delimited);
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
// preprocess text.
COpcString cFraction = cText;
// add trailing zeros.
while (cFraction.GetLength() < 3) cFraction += _T("0");
// truncate extra digits.
if (cFraction.GetLength() > 3) cFraction = cFraction.SubStr(0,3);
if (!ToUnsigned(cFraction, uValue, MAX_ULONG, 0, 10))
{
THROW_(bResult, false);
}
// result is in milliseconds.
wFraction = (WORD)uValue;
}
}
CATCH
{
wHour = 0;
wMinute = 0;
wSeconds = 0;
wFraction = 0;
}
return bResult;
}
// ToOffset
static bool ToOffset(
const COpcString& cString,
bool bNegative,
SHORT& sMinutes
)
{
bool bResult = true;
TRY
{
COpcText cText;
COpcTextReader cReader(cString);
ULong uValue = 0;
// parse hour field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L":");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_HOUR, MIN_HOUR, 10)) THROW_(bResult, false);
sMinutes = (SHORT)uValue*60;
// parse minute field.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L".");
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToUnsigned(cText, uValue, MAX_MINUTE, MIN_MINUTE, 10)) THROW_(bResult, false);
sMinutes += (SHORT)uValue;
// add sign.
if (bNegative)
{
sMinutes = -sMinutes;
}
}
CATCH
{
sMinutes = 0;
}
return bResult;
}
//==============================================================================
// FUNCTION: Read<TYPE>
// PURPOSE Explicit template implementations for common data types.
// Read
template<> bool OpcXml::Read(const COpcString& cText, SByte& cValue)
{
Long lValue = 0;
if (!ToSigned(cText, lValue, MAX_SBYTE, MIN_SBYTE))
{
cValue = 0;
return false;
}
cValue = (SByte)lValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Byte& cValue)
{
ULong ulValue = 0;
if (!ToUnsigned(cString, ulValue, MAX_BYTE, 0))
{
cValue = 0;
return false;
}
cValue = (Byte)ulValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Short& cValue)
{
Long lValue = 0;
if (!ToSigned(cString, lValue, MAX_SHORT, MIN_SHORT))
{
cValue = 0;
return false;
}
cValue = (Short)lValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, UShort& cValue)
{
ULong ulValue = 0;
if (!ToUnsigned(cString, ulValue, MAX_USHORT, 0))
{
cValue = 0;
return false;
}
cValue = (UShort)ulValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Int& cValue)
{
Long lValue = 0;
if (!ToSigned(cString, lValue, MAX_INT, MIN_INT))
{
cValue = 0;
return false;
}
cValue = (Int)lValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, UInt& cValue)
{
ULong ulValue = 0;
if (!ToUnsigned(cString, ulValue, MAX_UINT, 0))
{
cValue = 0;
return false;
}
cValue = (UInt)ulValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, long& cValue)
{
Long lValue = 0;
if (!ToSigned(cString, lValue, MAX_INT, MIN_INT))
{
cValue = 0;
return false;
}
cValue = (Int)lValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, unsigned long& cValue)
{
ULong ulValue = 0;
if (!ToUnsigned(cString, ulValue, MAX_UINT, 0))
{
cValue = 0;
return false;
}
cValue = (UInt)ulValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Long& cValue)
{
return ToSigned(cString, cValue, MAX_LONG, MIN_LONG);
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, ULong& cValue)
{
return ToUnsigned(cString, cValue, MAX_ULONG, 0);
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Float& cValue)
{
Double dblValue = 0;
if (!ToReal(cString, dblValue, MAX_FLOAT, MIN_FLOAT))
{
cValue = 0;
return false;
}
cValue = (Float)dblValue;
return true;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Double& cValue)
{
return ToReal(cString, cValue, MAX_DOUBLE, MIN_DOUBLE);
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Decimal& cValue)
{
bool bResult = true;
TRY
{
COpcText cText;
COpcTextReader cReader(cString);
// parse whole integer portion.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L".");
cText.SetEofDelim();
if (!cReader.GetNext(cText))
{
THROW_(bResult, false);
}
// convert to signed integer.
Long nValue = 0;
if (!ToSigned(cText, nValue, MAX_DECIMAL, MIN_DECIMAL))
{
THROW_(bResult, false);
}
cValue.int64 = nValue*10000;
if (cText.GetDelimChar() == L'.')
{
// parse decimal portion.
cText.SetType(COpcText::Delimited);
cText.SetEofDelim();
if (!cReader.GetNext(cText))
{
THROW_(bResult, false);
}
// convert to unsigned integer.
ULong uValue = 0;
if (!ToUnsigned(cText, uValue, MAX_DEC_FRACTION, 0, 10))
{
THROW_(bResult, false);
}
cValue.int64 += (Long)uValue;
}
}
CATCH
{
cValue.int64 = 0;
}
return bResult;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, DateTime& cValue)
{
bool bResult = true;
FILETIME cFileTime;
// check for invalid date.
if (cString.IsEmpty())
{
cValue = OpcMinDate();
return true;
}
TRY
{
SYSTEMTIME cSystemTime; ZeroMemory(&cSystemTime, sizeof(cSystemTime));
COpcText cText;
COpcTextReader cReader(cString);
// parse date fields.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L"T");
if (!cReader.GetNext(cText)) THROW_(bResult, false);
if (!ToDate(cText, cSystemTime.wYear, cSystemTime.wMonth, cSystemTime.wDay))
{
THROW_(bResult, false);
}
// parse time fields.
cText.SetType(COpcText::Delimited);
cText.SetDelims(L"Z-+");
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
bResult = ToTime(
cText,
cSystemTime.wHour,
cSystemTime.wMinute,
cSystemTime.wSecond,
cSystemTime.wMilliseconds);
if (!bResult)
{
THROW_(bResult, false);
}
// convert to a UTC file time.
if (!SystemTimeToFileTime(&cSystemTime, &cFileTime))
{
THROW_(bResult, false);
}
if (cText.GetDelimChar() != _T('Z'))
{
// convert local system time to UTC file time.
if (cText.GetEof())
{
FILETIME ftUtcTime;
if (!OpcLocalTimeToUtcTime(cFileTime, ftUtcTime))
{
THROW_(bResult, false);
}
cFileTime = ftUtcTime;
}
// apply offset specified in the datetime string.
else
{
bool bNegative = (cText.GetDelimChar() == _T('-'));
// parse time fields.
cText.SetType(COpcText::Delimited);
cText.SetEofDelim();
if (!cReader.GetNext(cText)) THROW_(bResult, false);
SHORT sMinutes = 0;
bResult = ToOffset(
cText,
bNegative,
sMinutes);
if (!bResult)
{
THROW_(bResult, false);
}
// apply timezone offset.
LONGLONG llTime = OpcToInt64(cFileTime);
llTime -= ((LONGLONG)sMinutes)*60*10000000;
cFileTime = OpcToFILETIME(llTime);
}
}
cValue = cFileTime;
}
CATCH
{
ZeroMemory(&cFileTime, sizeof(cFileTime));
cValue = cFileTime;
}
return bResult;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, Boolean& cValue)
{
// check for an integer representation (any non-zero value is true).
Long nValue = 0;
if (Read(cString, nValue))
{
cValue = (nValue != 0);
return true;
}
// check for alphabetic representation.
COpcString cBoolean(cString);
cBoolean = cBoolean.ToLower();
// test for true value.
if (cBoolean == _T("true"))
{
cValue = true;
return true;
}
// test for false value.
if (cBoolean == _T("false"))
{
cValue = false;
return true;
}
return false;
}
// Read
template<> bool OpcXml::Read(const COpcString& cString, String& cValue)
{
cValue = OpcStrDup((LPCWSTR)cString);
return true;
}
//==============================================================================
// FUNCTION: Write<TYPE>
// PURPOSE Explicit template implementations for common data types.
// Write
template<> bool OpcXml::Write(const SByte& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%d", (Int)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Byte& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%u", (UInt)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Short& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%d", (Int)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const UShort& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%u", (UInt)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Int& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%d", (Int)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const UInt& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%u", (UInt)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const long& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%d", (Int)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const unsigned long& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%u", (UInt)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Long& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%I64d", cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const ULong& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%I64u", cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Float& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%0.8g", (Double)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Double& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%0.16g", (Double)cValue);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Decimal& cValue, COpcString& cString)
{
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(szBuf, L"%0I64d.%0I64u", (cValue.int64/10000), (cValue.int64%10000));
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const DateTime& cValue, COpcString& cString)
{
// check for invalid date.
if (cValue == OpcMinDate())
{
cString.Empty();
return true;
}
// convert to xml dateTime representation.
SYSTEMTIME cSystemTime;
if (!FileTimeToSystemTime(&((FILETIME)cValue), &cSystemTime))
{
return false;
}
WCHAR szBuf[MAX_VALUE_BUF_SIZE];
swprintf(
szBuf,
L"%04hu-%02hu-%02huT%02hu:%02hu:%02hu.%03hu",
cSystemTime.wYear,
cSystemTime.wMonth,
cSystemTime.wDay,
cSystemTime.wHour,
cSystemTime.wMinute,
cSystemTime.wSecond,
cSystemTime.wMilliseconds);
cString = szBuf;
return true;
}
// Write
template<> bool OpcXml::Write(const Boolean& cValue, COpcString& cString)
{
cString = (cValue)?_T("True"):_T("False");
return true;
}
// Write
template<> bool OpcXml::Write(const String& cValue, COpcString& cString)
{
// TBD - add any escape sequences.
cString = cValue;
return true;
}
//==============================================================================
// XXX<COpcString>
// Init
template<> void OpcXml::Init(COpcString& cValue)
{
cValue.Empty();
}
// Clear
template<> void OpcXml::Clear(COpcString& cValue)
{
cValue.Empty();
}
// Read
template<> bool OpcXml::Read(const COpcString& cText, COpcString& cValue)
{
cValue = cText;
return true;
}
// Write
template<> bool OpcXml::Write(const COpcString& cValue, COpcString& cText)
{
cText = cValue;
return true;
}
//==============================================================================
// XXX<GUID>
// Init
template<> void OpcXml::Init(GUID& cValue)
{
cValue = GUID_NULL;
}
// Clear
template<> void OpcXml::Clear(GUID& cValue)
{
cValue = GUID_NULL;
}
// Read
template<> bool OpcXml::Read(const COpcString& cText, GUID& cValue)
{
return cText.ToGuid(cValue);
}
// Write
template<> bool OpcXml::Write(const GUID& cValue, COpcString& cText)
{
cText.FromGuid(cValue);
return true;
} | [
"niko78@ab31eaa2-35d0-11de-8e0c-53a27eea117e"
] | niko78@ab31eaa2-35d0-11de-8e0c-53a27eea117e |
e8ff06ed3f1335dfea3a4317a073eeeadde2ff58 | 191c8a31295021505a01242a461efa78c8e5d712 | /chipyard.TestHarness.RocketConfig/chipyard.TestHarness.RocketConfig/VTestHarness__2__Slow.cpp | 9ad80443a58eab1349998245c0330d0c23a87018 | [
"BSD-3-Clause"
] | permissive | vargandhi/ime-congs | 4f485c6551ba725e2a11d57888341be65f841c01 | 963be79b7b319d8e74edae09df7bdf3330371401 | refs/heads/main | 2023-03-21T13:10:21.477493 | 2021-03-13T22:04:02 | 2021-03-13T22:04:02 | 334,827,027 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 386,791 | cpp | // Verilated -*- C++ -*-
// DESCRIPTION: Verilator output: Design implementation internals
// See VTestHarness.h for the primary calling header
#include "VTestHarness.h"
#include "VTestHarness__Syms.h"
#include "verilated_dpi.h"
void VTestHarness::_settle__TOP__117(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__117\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txm__DOT___T_5
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txm__DOT__prescaler))
& (0U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txm__DOT__counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__head_pop_head_data
= ((0x27U >= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__head
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put]
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT__head_pop_head_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT__head
[(1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put))];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__excSign
= (1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
& (~ (IData)((7U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___T_605
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__d_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__logic_out_lo_lo_lo
= ((0x80U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>> ((2U & ((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 7U)) << 1U))
| (1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 7U)))))
<< 7U)) | ((0x40U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 6U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 6U)))))
<< 6U)) |
((0x20U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>> ((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 5U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 5U)))))
<< 5U))
| ((0x10U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 4U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 4U)))))
<< 4U))
| ((8U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>> (
(2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 3U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 3U)))))
<< 3U))
| ((4U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 2U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 2U)))))
<< 2U))
| ((2U &
(((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>>
((2U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data
>> 1U))
<< 1U))
| (1U
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data
>> 1U)))))
<< 1U))
| (1U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_lut)
>>
((2U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_a_0_bits_data)
<< 1U))
| (1U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_d_0_data))))))))))));
}
void VTestHarness::_settle__TOP__121(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__121\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*639:0*/ __Vtemp184[20];
// Body
VL_SHIFTR_WWI(640,640,11, __Vtemp184, vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT__inflight_opcodes,
((IData)(vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__r_source)
<< 2U));
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0U]
= __Vtemp184[0U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[1U]
= __Vtemp184[1U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[2U]
= __Vtemp184[2U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[3U]
= __Vtemp184[3U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[4U]
= __Vtemp184[4U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[5U]
= __Vtemp184[5U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[6U]
= __Vtemp184[6U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[7U]
= __Vtemp184[7U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[8U]
= __Vtemp184[8U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[9U]
= __Vtemp184[9U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xaU]
= __Vtemp184[0xaU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xbU]
= __Vtemp184[0xbU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xcU]
= __Vtemp184[0xcU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xdU]
= __Vtemp184[0xdU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xeU]
= __Vtemp184[0xeU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0xfU]
= __Vtemp184[0xfU];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0x10U]
= __Vtemp184[0x10U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0x11U]
= __Vtemp184[0x11U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0x12U]
= __Vtemp184[0x12U];
vlTOPp->TestHarness__DOT__ram__DOT__srams__DOT__monitor__DOT___a_opcode_lookup_T_1[0x13U]
= __Vtemp184[0x13U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txm_io_in_ready
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txen)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txm__DOT__counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__amoalu__DOT___less_T_12
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_data)
< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__pstore1_data));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__narrow__DOT__invalidExc
= (((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)) | ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU))))
& (~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxq__DOT__deq_ptr_value));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_sink_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_sink
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_corrupt_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_corrupt
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore_io_sourceD_rdat_data
= (((((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regsel_sourceD))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regout_r
: VL_ULL(0)) | ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regsel_sourceD))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regout_r_1
: VL_ULL(0))) | ((4U
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regsel_sourceD))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regout_r_2
: VL_ULL(0)))
| ((8U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regsel_sourceD))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bankedStore__DOT__regout_r_3
: VL_ULL(0)));
}
void VTestHarness::_settle__TOP__122(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__122\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__classify_out_isInf_1
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__classify_out_isNormal_1
= (((1U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(2U <= (0x3ffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U)))))
| (2U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__classify_out_isSubnormal_1
= ((1U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)))) |
((1U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(2U > (0x3ffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_address_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_address
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_sink_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_sink
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_corrupt_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_corrupt
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__narrower__DOT__roundAnyRawFNToRecFN_io_in_isInf
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x1dU)));
}
void VTestHarness::_settle__TOP__123(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__123\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp187[3];
WData/*95:0*/ __Vtemp191[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_sink_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_sink
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_corrupt_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_corrupt
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__txq__DOT__deq_ptr_value));
VL_EXTEND_WQ(65,64, __Vtemp187, (VL_ULL(0x80000000)
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__flushInAddress));
VL_EXTEND_WQ(65,64, __Vtemp191, (VL_ULL(0x10000000)
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__flushInAddress));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__flushSelect
= ((0U == (((0xf0000000U & __Vtemp187[0U])
| __Vtemp187[1U]) | (1U & __Vtemp187[2U])))
| (0U == (((0xfffff000U & __Vtemp191[0U])
| __Vtemp191[1U]) | (1U & __Vtemp191[2U]))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_opcode)));
}
void VTestHarness::_settle__TOP__124(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__124\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__bothInfs
= (((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))) & ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 2U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1eU))))
& (~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__bothZeros
= ((0U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)))) &
(0U == (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_denied_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_denied
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_denied
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_b_isNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_a_sig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_b_sig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_b_isInf
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU)));
}
void VTestHarness::_settle__TOP__125(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__125\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__narrower__DOT__roundAnyRawFNToRecFN_io_invalidExc
= (((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x1dU)) & (~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x13U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__narrower__DOT__roundAnyRawFNToRecFN__DOT__roundMagUp
= (((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_rm))
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U])
| ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_rm))
& (~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U])));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__store_unrecoded_rawIn___05FisInf
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__store_unrecoded_rawIn___05Fsig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__queue__DOT__deq_ptr_value));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_b_bits_echo_tl_state_size
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xbU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U
: (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_size
[0U]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_size
[0U]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_size
[0U]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_size
[0U]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_size
[0U]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_size
[0U]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_size
[0U]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_size
[0U]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_size
[0U]
:
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_size
[0U])))))))))))))));
}
void VTestHarness::_settle__TOP__126(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__126\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_r_bits_echo_tl_state_size
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xbU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U
: (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_size
[0U]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_size
[0U]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_size
[0U]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_size
[0U]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_size
[0U]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_size
[0U]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_size
[0U]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_size
[0U]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_size
[0U]
:
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_size
[0U])))))))))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__rawA___05FisNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU));
}
void VTestHarness::_settle__TOP__127(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__127\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__rawB___05FisNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_oindex
= ((8U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_index
[0U] >> 0xfU)) | ((4U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_index
[0U] >> 8U))
| ((2U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_index
[0U]
>> 8U))
| (1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_index
[0U]
>> 4U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_a_isInf
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(~ (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__s2_error
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__s2_valid_vec)
& VL_REDXOR_64(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___05Fio_a_isNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT___classify_out_T
= (((QData)((IData)((1U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U])))
<< 0x20U) | (QData)((IData)(((0xff800000U
& ((((0U
==
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))
| (6U
<=
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)))))
? ((0x1c0U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 9U)
| (0x1c0U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x17U))))
| (0x3fU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))))
: ((IData)(0x100U)
+
((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))))
<< 0x17U))
| (0x7fffffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U]
>> 0x1dU)))))));
}
void VTestHarness::_settle__TOP__128(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__128\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__rawIn___05FisNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__isNaNOut
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_invalidExc_b)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_isNaN));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__rawA___05Fsig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__rawB___05Fsig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__dcmp__DOT__eqExps
= ((0xfffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))) == (0xfffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x14U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___GEN_24
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__r_first)
? (3U == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_resp_reg))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__r_denied_r));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__store_prevRecoded
= (((QData)((IData)((1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U]
>> 0x1fU)))) << 0x20U)
| (QData)((IData)(((0x80000000U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
<< 0xbU))
| (0x7fffffffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U])))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT___io_pb_pop_ready_T
= (VL_ULL(0xffffffffff) & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__valid
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT___io_rel_pop_ready_T
= ((1U >= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put))
? (3U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT__valid)
>> (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s2_req_put)))
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__narrow__DOT__magJustBelowOne
= ((~ (1U & ((0x1ffffeU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U)) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU))))
& (0x7ffU == (0x7ffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U)))));
}
void VTestHarness::_settle__TOP__129(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__129\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_address_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_address
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr_io_singleStep
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_dcsr_step)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__csr__DOT__reg_debug)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT___mux_data_T_2
= (((1U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__inPipe_bits_typeTagIn))
? VL_ULL(0) : VL_ULL(0xffffffff00000000))
| vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__ifpu__DOT__inPipe_bits_in1);
vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pagesMasked_4
= ((0x10U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pageValid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_4
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pagesMasked_5
= ((0x20U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pageValid))
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_5
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT___doPeek_T
= (((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_27))
<< 0x1bU) | (((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_26))
<< 0x1aU) | (((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_25))
<< 0x19U) |
(((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_24))
<< 0x18U)
| (((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_23))
<< 0x17U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_22))
<< 0x16U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_21))
<< 0x15U)
| ((((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_20))
<< 0x14U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_19))
<< 0x13U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_18))
<< 0x12U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_17))
<< 0x11U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_16))
<< 0x10U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_15))
<< 0xfU)
| ((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_14))
<< 0xeU)))))))
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_13))
<< 0xdU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_12))
<< 0xcU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_11))
<< 0xbU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_10))
<< 0xaU)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_9))
<< 9U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_8))
<< 8U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_7))
<< 7U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_6))
<< 6U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_5))
<< 5U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_4))
<< 4U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_3))
<< 3U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_2))
<< 2U)
| (((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_1))
<< 1U)
| (3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_0)))))))))))))))))))))));
}
void VTestHarness::_settle__TOP__130(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__130\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___final_meta_writeback_dirty_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_dirty)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_io_b
= (((QData)((IData)((1U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U])))
<< 0x20U) | (QData)((IData)(((0xff800000U
& ((((0U
==
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU))))
| (6U
<=
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x1dU)))))
? ((0x1c0U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 9U)
| (0x1c0U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x17U))))
| (0x3fU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x14U))))
: ((IData)(0x100U)
+
((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
>> 0x14U))))
<< 0x17U))
| (0x7fffffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[1U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in2[0U]
>> 0x1dU)))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT___roundIncr_T
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_roundingMode_b))
| (4U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_roundingMode_b)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT__roundMagUp
= (((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_roundingMode_b))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sign))
| ((3U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_roundingMode_b))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sign))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_source)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_source)))));
}
void VTestHarness::_settle__TOP__131(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__131\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_source)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_source)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_source)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_source)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___final_meta_writeback_clients_T_7
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_clients)
& (~ ((((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_param))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_param)))
| (5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_param)))
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_source)))));
vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1));
}
void VTestHarness::_settle__TOP__132(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__132\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT___freeOH_T_3
= (0xffffU & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT__used))
| (0xfffeU & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__putbuffer__DOT__used))
<< 1U))));
vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div_io_resp_valid
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div__DOT__state))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div__DOT__state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT___isBranch_T
= (((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_27))
<< 0x1bU) | (((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_26))
<< 0x1aU) | (((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_25))
<< 0x19U) |
(((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_24))
<< 0x18U)
| (((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_23))
<< 0x17U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_22))
<< 0x16U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_21))
<< 0x15U)
| ((((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_20))
<< 0x14U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_19))
<< 0x13U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_18))
<< 0x12U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_17))
<< 0x11U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_16))
<< 0x10U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_15))
<< 0xfU)
| ((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_14))
<< 0xeU)))))))
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_13))
<< 0xdU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_12))
<< 0xcU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_11))
<< 0xbU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_10))
<< 0xaU)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_9))
<< 9U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_8))
<< 8U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_7))
<< 7U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_6))
<< 6U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_5))
<< 5U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_4))
<< 4U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_3))
<< 3U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_2))
<< 2U)
| (((0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_1))
<< 1U)
| (0U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__cfiType_0)))))))))))))))))))))));
}
void VTestHarness::_settle__TOP__133(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__133\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__magJustBelowOne
= ((~ (1U & ((0x1ffffeU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U)) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU))))
& (0x7ffU == (0x7ffU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___final_meta_writeback_state_T_3
= (((3U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_param))
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state)))
? 3U : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state));
}
void VTestHarness::_settle__TOP__134(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__134\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp194[3];
WData/*95:0*/ __Vtemp195[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT___taken_T
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__s2_valid)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__s2_btb_resp_valid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__coupler_from_port_named_serial_tl_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_io_a
= (((QData)((IData)((1U & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U])))
<< 0x20U) | (QData)((IData)(((0xff800000U
& ((((0U
==
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU))))
| (6U
<=
(7U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1dU)))))
? ((0x1c0U
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 9U)
| (0x1c0U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x17U))))
| (0x3fU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))))
: ((IData)(0x100U)
+
((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))))
<< 0x17U))
| (0x7fffffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
<< 3U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U]
>> 0x1dU)))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1];
VL_EXTEND_WQ(84,53, __Vtemp194, (((QData)((IData)(
(1U
& ((0x1ffffeU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U))
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU)))))
<< 0x34U) | (VL_ULL(0xfffffffffffff)
& (((QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]))
<< 0x20U)
| (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U]))))));
VL_SHIFTL_WWI(84,84,5, __Vtemp195, __Vtemp194,
((1U & ((0x1ffffeU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U)) | (
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU)))
? (0x1fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U)))
: 0U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__narrow__DOT__shiftedSig[0U]
= __Vtemp195[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__narrow__DOT__shiftedSig[1U]
= __Vtemp195[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__narrow__DOT__shiftedSig[2U]
= (0xfffffU & __Vtemp195[2U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__narrower__DOT__roundAnyRawFNToRecFN_io_in_sig
= (((QData)((IData)((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U]
<< 3U) |
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x1dU))))))
<< 0x34U) | (VL_ULL(0xfffffffffffff) &
(((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]))
<< 0x20U) | (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[0U])))));
}
void VTestHarness::_settle__TOP__135(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__135\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*127:0*/ __Vtemp198[4];
WData/*127:0*/ __Vtemp199[4];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___final_meta_writeback_clients_T_9
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_clients)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__probes_toN)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT___GEN_83
= ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? 4U : ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? ((2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_param))
? 4U : 5U) : ((5U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? 2U : ((4U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? 1U
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? 1U
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
? 1U
: 0U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_b_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_b_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_b_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
VL_EXTEND_WQ(116,53, __Vtemp198, (((QData)((IData)(
(1U
& ((0x1ffffeU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U))
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU)))))
<< 0x34U) |
(VL_ULL(0xfffffffffffff)
& (((QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]))
<< 0x20U)
| (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[0U]))))));
VL_SHIFTL_WWI(116,116,6, __Vtemp199, __Vtemp198,
((1U & ((0x1ffffeU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 1U)) | (
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x1fU)))
? (0x3fU & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U)))
: 0U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__shiftedSig[0U]
= __Vtemp199[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__shiftedSig[1U]
= __Vtemp199[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__shiftedSig[2U]
= __Vtemp199[2U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__conv__DOT__shiftedSig[3U]
= (0xfffffU & __Vtemp199[3U]);
}
void VTestHarness::_settle__TOP__136(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__136\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp202[3];
WData/*95:0*/ __Vtemp203[3];
WData/*95:0*/ __Vtemp206[3];
WData/*95:0*/ __Vtemp207[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1];
vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT___bundleIn_0_a_ready_T_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__doneAW)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__queue_arw_deq__DOT__maybe_full))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___req_needT_T_8
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_opcode)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1];
__Vtemp202[0U] = 0U;
__Vtemp202[1U] = 0U;
__Vtemp202[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp203, __Vtemp202,
(0x3fU & (~ (0x3fffU & VL_EXTENDS_II(14,13,
(0xfffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x14U))))))));
__Vtemp206[0U] = 0U;
__Vtemp206[1U] = 0U;
__Vtemp206[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp207, __Vtemp206,
(0x3fU & (~ (0x3fffU & VL_EXTENDS_II(14,13,
(0xfffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[2U]
<< 0xcU)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__inPipe_bits_in1[1U]
>> 0x14U))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpmu__DOT__narrower__DOT__roundAnyRawFNToRecFN__DOT___roundMask_T_12
= ((0xffU & ((0x4000U & (__Vtemp203[2U] << 0xeU))
| (__Vtemp203[1U] >> 0x12U)))
| (0xff00U & ((0x40000000U & (__Vtemp207[2U]
<< 0x1eU))
| (0x3fffff00U & (__Vtemp207[1U]
>> 2U)))));
}
void VTestHarness::_settle__TOP__137(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__137\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*95:0*/ __Vtemp210[3];
WData/*95:0*/ __Vtemp211[3];
WData/*95:0*/ __Vtemp214[3];
WData/*95:0*/ __Vtemp215[3];
WData/*95:0*/ __Vtemp218[3];
WData/*95:0*/ __Vtemp219[3];
WData/*95:0*/ __Vtemp222[3];
WData/*95:0*/ __Vtemp223[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_c_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT___freeOH_T_3
= (VL_ULL(0xffffffffff) & ((~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__used)
| (VL_ULL(0xfffffffffe)
& ((~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkA__DOT__putbuffer__DOT__used)
<< 1U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__setQuash
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__write__DOT__maybe_full)
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__write__DOT__ram_set
[0U] == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__directory__DOT__set)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT___freeOH_T_3
= (VL_ULL(0x1ffffffff) & ((~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__used)
| ((QData)((IData)(
(~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__requests__DOT__used))))
<< 1U)));
__Vtemp210[0U] = 0U;
__Vtemp210[1U] = 0U;
__Vtemp210[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp211, __Vtemp210,
(0x3fU & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sExp))));
__Vtemp214[0U] = 0U;
__Vtemp214[1U] = 0U;
__Vtemp214[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp215, __Vtemp214,
(0x3fU & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sExp))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT___roundMask_T_62
= ((0xffU & ((0x800U & (__Vtemp211[2U] << 0xbU))
| (__Vtemp211[1U] >> 0x15U)))
| (0xff00U & ((0x8000000U & (__Vtemp215[2U]
<< 0x1bU))
| (0x7ffff00U & (__Vtemp215[1U]
>> 5U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value_1));
__Vtemp218[0U] = 0U;
__Vtemp218[1U] = 0U;
__Vtemp218[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp219, __Vtemp218,
(0x3fU & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sExp))));
__Vtemp222[0U] = 0U;
__Vtemp222[1U] = 0U;
__Vtemp222[2U] = 1U;
VL_SHIFTRS_WWI(65,65,6, __Vtemp223, __Vtemp222,
(0x3fU & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN_io_in_b_sExp))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__roundRawFNToRecFN__DOT__roundAnyRawFNToRecFN__DOT___roundMask_T_12
= ((0xffffU & ((__Vtemp219[1U] << 3U) | (__Vtemp219[0U]
>> 0x1dU)))
| (0xffff0000U & (__Vtemp223[0U] << 3U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_e_q__DOT__value_1));
}
void VTestHarness::_settle__TOP__138(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__138\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_b_bits_echo_tl_state_source
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U : ((0xbU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U
: (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
? 0U
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_19__DOT__ram_tl_state_source
[0U]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_18__DOT__ram_tl_state_source
[0U]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_17__DOT__ram_tl_state_source
[0U]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_16__DOT__ram_tl_state_source
[0U]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_15__DOT__ram_tl_state_source
[0U]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_14__DOT__ram_tl_state_source
[0U]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_13__DOT__ram_tl_state_source
[0U]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_12__DOT__ram_tl_state_source
[0U]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fb_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_11__DOT__ram_tl_state_source
[0U]
:
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_10__DOT__ram_tl_state_source
[0U])))))))))))))));
}
void VTestHarness::_settle__TOP__139(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__139\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank_auto_in_r_bits_echo_tl_state_source
= ((0xfU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xeU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xdU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xcU == (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U : ((0xbU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U
: (
(0xaU
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
? 0U
:
((9U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_9__DOT__ram_tl_state_source
[0U]
:
((8U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_8__DOT__ram_tl_state_source
[0U]
:
((7U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_7__DOT__ram_tl_state_source
[0U]
:
((6U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_6__DOT__ram_tl_state_source
[0U]
:
((5U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_5__DOT__ram_tl_state_source
[0U]
:
((4U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_4__DOT__ram_tl_state_source
[0U]
:
((3U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_3__DOT__ram_tl_state_source
[0U]
:
((2U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_2__DOT__ram_tl_state_source
[0U]
:
((1U
== (IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_id_reg))
?
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility_1__DOT__ram_tl_state_source
[0U]
:
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__axi4yank__DOT__QueueCompatibility__DOT__ram_tl_state_source
[0U])))))))))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
}
void VTestHarness::_settle__TOP__140(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__140\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer_1__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__wrapped_error_device__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceC__DOT__queue__DOT__deq_ptr_value));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q_1__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q_1__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q_1__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_address_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_address
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__r_wins
= ((IData)(vlTOPp->TestHarness__DOT__simdram__DOT_____05Fr_valid_reg)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__r_holds_d));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkC__DOT__c__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___s2_read_T_4
= (((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd))
| (6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT___s2_write_T_21
= (((((4U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd))
| (9U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (0xaU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (0xbU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (((((8U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd))
| (0xcU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (0xdU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (0xeU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd)))
| (0xfU == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd))));
}
void VTestHarness::_settle__TOP__141(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__141\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_fbus__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__buffer_1__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4_io_schedule_bits_a_valid
= (((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__s_acquire))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__s_pprobe));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__w_rprobeackfirst));
}
void VTestHarness::_settle__TOP__142(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__142\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4_io_schedule_bits_c_valid
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___io_schedule_bits_c_valid_T_1
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__s_release))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__w_rprobeackfirst));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceE__DOT__io_e_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceE__DOT__io_e_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceE__DOT__io_e_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceA__DOT__io_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter1_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter_1)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_1
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter1_2
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter_2)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_2
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__d_first_counter_2)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter)));
}
void VTestHarness::_settle__TOP__143(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__143\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter1_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter_1)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_1
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter1_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter_1)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_1
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter1_2
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter_2)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_2
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__bar__DOT__monitor__DOT__d_first_counter_2)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter1_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter_1)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_1
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter1_2
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter_2)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_2
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiBypass__DOT__error__DOT__monitor__DOT__d_first_counter_2)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter1_1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter_1)
- (IData)(1U)));
}
void VTestHarness::_settle__TOP__144(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__144\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_1
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter1_2
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter_2)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_2
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__d_first_counter_2)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT___GEN_0
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__dmiReqValidReg)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__busyReg));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT___T_527
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__dtm__DOT__dmiReqValidReg)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmiXbar__DOT__monitor__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__empty
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full)));
vlTOPp->TestHarness__DOT__uart_sim_0__DOT___T_8
= (0U == (IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txState));
vlTOPp->TestHarness__DOT__uart_sim_0__DOT___T_9
= (1U == (IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txState));
vlTOPp->TestHarness__DOT__uart_sim_0__DOT___T_10
= (2U == (IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txState));
vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txfifo__DOT___value_T_3
= (0x7fU & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txfifo__DOT__deq_ptr_value)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__ram_denied
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sinkD__DOT__d__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT___haveResetBitRegs_T_2
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__haveResetBitRegs)
& (0U != (0x3ffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmactive_synced_dmInner_io_innerCtrl_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg)
>> 4U)))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmInner__DOT__dmInner__DOT__hartIsInResetSync_0_debug_hartReset_0__DOT__output_chain__DOT__sync_0));
vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__monitor__DOT___T_1026
= ((((7U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
? 1U : 4U) == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__monitor__DOT__opcode))
| (IData)(vlTOPp->reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT__r_superpage_repl_addr_valids
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT__superpage_entries_3_valid_0)
<< 3U) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT__superpage_entries_2_valid_0)
<< 2U) | (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT__superpage_entries_1_valid_0)
<< 1U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT__superpage_entries_0_valid_0))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT___a_opcode_lookup_T_1
= ((0x13U >= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_source)
<< 2U)) ? (0xfffffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT__inflight_opcodes
>> ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_source)
<< 2U)))
: 0U);
vlTOPp->TestHarness__DOT__ram__DOT__buffer_1__DOT__monitor__DOT___GEN_30
= ((5U == ((7U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
? 1U : 4U)) ? 2U : ((4U == ((7U
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
? 1U
: 4U))
? 1U : ((3U
==
((7U
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
? 1U
: 4U))
? 1U
:
((2U
==
((7U
== (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
? 1U
: 4U))
? 1U
: 0U))));
}
void VTestHarness::_settle__TOP__145(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__145\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT___do_enq_T
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_valid_d));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___T_24
= ((6U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fin_valid_reg));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___T_20
= ((5U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fout_ready_reg));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___T_3
= ((1U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fin_valid_reg));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___T_6
= ((2U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fin_valid_reg));
vlTOPp->TestHarness__DOT__ram__DOT__adapter_auto_out_d_ready
= ((8U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
| (4U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor__DOT___d_first_T
= ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_valid_d));
vlTOPp->TestHarness__DOT__ram__DOT__adapter_auto_out_a_valid
= ((7U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
| (3U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state)));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___T_1
= ((0U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__state))
& (IData)(vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fin_valid_reg));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q_io_deq_bits_denied
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__ram_denied
[0U] : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_bad));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD_io_d_bits_param
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_prio_0)
& ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_opcode))))
? ((0U != (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_param))
? 0U : 1U) : 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q_io_deq_bits_sink
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__ram_sink
[0U] : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_sink));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q_io_deq_bits_size
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__ram_size
[0U] : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_size));
}
void VTestHarness::_settle__TOP__146(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__146\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT___s3_ready_T_2
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_valid_d))
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full))));
vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txfifo__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txfifo__DOT__enq_ptr_value)
== (IData)(vlTOPp->TestHarness__DOT__uart_sim_0__DOT__txfifo__DOT__deq_ptr_value));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext_RW0_rdata[0U]
= (IData)((((QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram_RW_0_r_addr_pipe_0]))
<< 0x16U) | (QData)((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram_RW_0_r_addr_pipe_0]))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext_RW0_rdata[1U]
= ((0xfffff000U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram_RW_0_r_addr_pipe_0]
<< 0xcU)) | (IData)(((((QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_1__DOT__ram_RW_0_r_addr_pipe_0]))
<< 0x16U)
| (QData)((IData)(
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_0__DOT__ram_RW_0_r_addr_pipe_0])))
>> 0x20U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext_RW0_rdata[2U]
= ((0xfffffffcU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_3__DOT__ram_RW_0_r_addr_pipe_0]
<< 2U)) | (0xfffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tag_array__DOT__tag_array_ext__DOT__mem_0_2__DOT__ram_RW_0_r_addr_pipe_0]
>> 0x14U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__ram__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q_io_deq_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_valid_d)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q_io_deq_bits_source
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__maybe_full)
? vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__InclusiveCache_inner_TLBuffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] : (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__sourceD__DOT__s3_req_source));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__buffer__DOT__bundleIn_0_d_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__d_first_counter1
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__d_first
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__dmOuter__DOT__monitor__DOT__d_first_counter)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_704
= (1U & (((~ (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x21U))) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_803
= (((7U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x28U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__opcode_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_807
= (((3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x26U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__param_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__147(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__147\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_811
= (((3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x24U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__size_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_815
= (((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x23U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_819
= (((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x22U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__sink))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_823
= (((1U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x21U))) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__denied))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_877
= (((3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x24U))) == (7U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__inflight_sizes)
>>
(4U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x23U))
<< 2U)))
>> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___T_949
= (((3U & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x24U))) == (7U & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__inflight_sizes_1)
>>
(4U
& ((IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x23U))
<< 2U)))
>> 1U)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT___a_opcode_lookup_T_1
= (0xfU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__monitor__DOT__inflight_opcodes)
>> (4U & ((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__debug_1__DOT__dmOuter__DOT__asource__DOT__bundleIn_0_d_sink__DOT__io_deq_bits_deq_bits_reg__DOT__cdc_reg
>> 0x23U)) << 2U))));
}
void VTestHarness::_settle__TOP__148(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__148\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__int_rtc_tick_wrap_wrap
= (0x63U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__int_rtc_tick_value));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT___int_rtc_tick_wrap_value_T_1
= (0x7fU & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__int_rtc_tick_value)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_device_named_uart_0__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT___value_T_3
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_clint__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_debug__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT___acknum_T_1
= (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_bootrom__DOT__fragmenter__DOT__acknum)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT__empty
= (1U & (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_mbus__DOT__coupler_to_memory_controller_port_named_axi4__DOT__tl2axi4__DOT__deq__DOT__maybe_full)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_first
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_first_counter));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_first_counter1
= (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_first_counter)
- (IData)(1U)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT__rawA___05FisNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[1U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[0U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[0U]
>> 0x1dU));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT__rawA___05Fsig
= (((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[1U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[0U]
>> 0x1dU)))) << 0x17U)
| (0x7fffffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[0U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT__rawB___05FisNaN
= ((3U == (3U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[1U]
<< 2U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[0U]
>> 0x1eU)))) &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[0U]
>> 0x1dU));
}
void VTestHarness::_settle__TOP__149(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__149\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT__rawB___05Fsig
= (((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[1U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[0U]
>> 0x1dU)))) << 0x17U)
| (0x7fffffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[0U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__pulse
= (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__prescaler));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample_mid
= (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample_count));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___idx_T_1
= (1U & ((IData)(1U) + (IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__idx)));
vlTOPp->TestHarness__DOT__ram__DOT__fragmenter__DOT__dFirst
= (0U == (IData)(vlTOPp->TestHarness__DOT__ram__DOT__fragmenter__DOT__acknum));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___T_457
= (((((4U == (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] >> 4U))) | (0U ==
(7U &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U]
>> 4U))))
| (1U == (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] >> 4U)))) | (2U ==
(7U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U]
>> 4U))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT___T_457
= (((((4U == (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] >> 4U))) | (0U ==
(7U &
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U]
>> 4U))))
| (1U == (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] >> 4U)))) | (2U ==
(7U
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U]
>> 4U))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__150(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__150\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_hit));
}
void VTestHarness::_settle__TOP__151(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__151\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*1023:0*/ __Vtemp227[32];
WData/*1023:0*/ __Vtemp228[32];
WData/*1023:0*/ __Vtemp230[32];
WData/*1023:0*/ __Vtemp231[32];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_170
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_valid)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_174
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_valid)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_176
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_valid)
& (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_180
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__bad_grant)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_hit));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul__DOT__CDom_sign
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_signProd)
^ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_doSubMags));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul__DOT__notNaN_isInfProd
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_isInfA)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_isInfB));
__Vtemp227[0U] = 1U;
__Vtemp227[1U] = 0U;
__Vtemp227[2U] = 0U;
__Vtemp227[3U] = 0U;
__Vtemp227[4U] = 0U;
__Vtemp227[5U] = 0U;
__Vtemp227[6U] = 0U;
__Vtemp227[7U] = 0U;
__Vtemp227[8U] = 0U;
__Vtemp227[9U] = 0U;
__Vtemp227[0xaU] = 0U;
__Vtemp227[0xbU] = 0U;
__Vtemp227[0xcU] = 0U;
__Vtemp227[0xdU] = 0U;
__Vtemp227[0xeU] = 0U;
__Vtemp227[0xfU] = 0U;
__Vtemp227[0x10U] = 0U;
__Vtemp227[0x11U] = 0U;
__Vtemp227[0x12U] = 0U;
__Vtemp227[0x13U] = 0U;
__Vtemp227[0x14U] = 0U;
__Vtemp227[0x15U] = 0U;
__Vtemp227[0x16U] = 0U;
__Vtemp227[0x17U] = 0U;
__Vtemp227[0x18U] = 0U;
__Vtemp227[0x19U] = 0U;
__Vtemp227[0x1aU] = 0U;
__Vtemp227[0x1bU] = 0U;
__Vtemp227[0x1cU] = 0U;
__Vtemp227[0x1dU] = 0U;
__Vtemp227[0x1eU] = 0U;
__Vtemp227[0x1fU] = 0U;
VL_SHIFTL_WWI(1024,1024,10, __Vtemp228, __Vtemp227,
(0x3ffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_req_addr));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0U]
| __Vtemp228[0U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[1U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[1U]
| __Vtemp228[1U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[2U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[2U]
| __Vtemp228[2U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[3U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[3U]
| __Vtemp228[3U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[4U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[4U]
| __Vtemp228[4U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[5U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[5U]
| __Vtemp228[5U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[6U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[6U]
| __Vtemp228[6U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[7U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[7U]
| __Vtemp228[7U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[8U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[8U]
| __Vtemp228[8U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[9U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[9U]
| __Vtemp228[9U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xaU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xaU]
| __Vtemp228[0xaU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xbU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xbU]
| __Vtemp228[0xbU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xcU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xcU]
| __Vtemp228[0xcU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xdU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xdU]
| __Vtemp228[0xdU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xeU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xeU]
| __Vtemp228[0xeU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0xfU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xfU]
| __Vtemp228[0xfU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x10U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x10U]
| __Vtemp228[0x10U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x11U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x11U]
| __Vtemp228[0x11U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x12U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x12U]
| __Vtemp228[0x12U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x13U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x13U]
| __Vtemp228[0x13U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x14U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x14U]
| __Vtemp228[0x14U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x15U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x15U]
| __Vtemp228[0x15U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x16U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x16U]
| __Vtemp228[0x16U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x17U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x17U]
| __Vtemp228[0x17U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x18U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x18U]
| __Vtemp228[0x18U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x19U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x19U]
| __Vtemp228[0x19U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1aU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1aU]
| __Vtemp228[0x1aU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1bU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1bU]
| __Vtemp228[0x1bU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1cU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1cU]
| __Vtemp228[0x1cU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1dU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1dU]
| __Vtemp228[0x1dU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1eU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1eU]
| __Vtemp228[0x1eU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_105[0x1fU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1fU]
| __Vtemp228[0x1fU]);
__Vtemp230[0U] = 1U;
__Vtemp230[1U] = 0U;
__Vtemp230[2U] = 0U;
__Vtemp230[3U] = 0U;
__Vtemp230[4U] = 0U;
__Vtemp230[5U] = 0U;
__Vtemp230[6U] = 0U;
__Vtemp230[7U] = 0U;
__Vtemp230[8U] = 0U;
__Vtemp230[9U] = 0U;
__Vtemp230[0xaU] = 0U;
__Vtemp230[0xbU] = 0U;
__Vtemp230[0xcU] = 0U;
__Vtemp230[0xdU] = 0U;
__Vtemp230[0xeU] = 0U;
__Vtemp230[0xfU] = 0U;
__Vtemp230[0x10U] = 0U;
__Vtemp230[0x11U] = 0U;
__Vtemp230[0x12U] = 0U;
__Vtemp230[0x13U] = 0U;
__Vtemp230[0x14U] = 0U;
__Vtemp230[0x15U] = 0U;
__Vtemp230[0x16U] = 0U;
__Vtemp230[0x17U] = 0U;
__Vtemp230[0x18U] = 0U;
__Vtemp230[0x19U] = 0U;
__Vtemp230[0x1aU] = 0U;
__Vtemp230[0x1bU] = 0U;
__Vtemp230[0x1cU] = 0U;
__Vtemp230[0x1dU] = 0U;
__Vtemp230[0x1eU] = 0U;
__Vtemp230[0x1fU] = 0U;
VL_SHIFTL_WWI(1024,1024,10, __Vtemp231, __Vtemp230,
(0x3ffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_req_addr));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0U]
| __Vtemp231[0U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[1U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[1U]
| __Vtemp231[1U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[2U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[2U]
| __Vtemp231[2U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[3U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[3U]
| __Vtemp231[3U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[4U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[4U]
| __Vtemp231[4U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[5U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[5U]
| __Vtemp231[5U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[6U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[6U]
| __Vtemp231[6U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[7U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[7U]
| __Vtemp231[7U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[8U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[8U]
| __Vtemp231[8U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[9U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[9U]
| __Vtemp231[9U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xaU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xaU]
| __Vtemp231[0xaU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xbU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xbU]
| __Vtemp231[0xbU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xcU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xcU]
| __Vtemp231[0xcU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xdU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xdU]
| __Vtemp231[0xdU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xeU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xeU]
| __Vtemp231[0xeU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0xfU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xfU]
| __Vtemp231[0xfU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x10U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x10U]
| __Vtemp231[0x10U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x11U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x11U]
| __Vtemp231[0x11U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x12U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x12U]
| __Vtemp231[0x12U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x13U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x13U]
| __Vtemp231[0x13U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x14U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x14U]
| __Vtemp231[0x14U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x15U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x15U]
| __Vtemp231[0x15U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x16U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x16U]
| __Vtemp231[0x16U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x17U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x17U]
| __Vtemp231[0x17U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x18U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x18U]
| __Vtemp231[0x18U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x19U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x19U]
| __Vtemp231[0x19U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1aU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1aU]
| __Vtemp231[0x1aU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1bU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1bU]
| __Vtemp231[0x1bU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1cU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1cU]
| __Vtemp231[0x1cU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1dU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1dU]
| __Vtemp231[0x1dU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1eU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1eU]
| __Vtemp231[0x1eU]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_106[0x1fU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1fU]
| __Vtemp231[0x1fU]);
}
void VTestHarness::_settle__TOP__152(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__152\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*1023:0*/ __Vtemp233[32];
WData/*1023:0*/ __Vtemp234[32];
WData/*95:0*/ __Vtemp238[3];
// Body
__Vtemp233[0U] = 1U;
__Vtemp233[1U] = 0U;
__Vtemp233[2U] = 0U;
__Vtemp233[3U] = 0U;
__Vtemp233[4U] = 0U;
__Vtemp233[5U] = 0U;
__Vtemp233[6U] = 0U;
__Vtemp233[7U] = 0U;
__Vtemp233[8U] = 0U;
__Vtemp233[9U] = 0U;
__Vtemp233[0xaU] = 0U;
__Vtemp233[0xbU] = 0U;
__Vtemp233[0xcU] = 0U;
__Vtemp233[0xdU] = 0U;
__Vtemp233[0xeU] = 0U;
__Vtemp233[0xfU] = 0U;
__Vtemp233[0x10U] = 0U;
__Vtemp233[0x11U] = 0U;
__Vtemp233[0x12U] = 0U;
__Vtemp233[0x13U] = 0U;
__Vtemp233[0x14U] = 0U;
__Vtemp233[0x15U] = 0U;
__Vtemp233[0x16U] = 0U;
__Vtemp233[0x17U] = 0U;
__Vtemp233[0x18U] = 0U;
__Vtemp233[0x19U] = 0U;
__Vtemp233[0x1aU] = 0U;
__Vtemp233[0x1bU] = 0U;
__Vtemp233[0x1cU] = 0U;
__Vtemp233[0x1dU] = 0U;
__Vtemp233[0x1eU] = 0U;
__Vtemp233[0x1fU] = 0U;
VL_SHIFTL_WWI(1024,1024,10, __Vtemp234, __Vtemp233,
(0x3ffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_req_addr));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0U]
& (~ __Vtemp234[0U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[1U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[1U]
& (~ __Vtemp234[1U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[2U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[2U]
& (~ __Vtemp234[2U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[3U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[3U]
& (~ __Vtemp234[3U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[4U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[4U]
& (~ __Vtemp234[4U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[5U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[5U]
& (~ __Vtemp234[5U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[6U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[6U]
& (~ __Vtemp234[6U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[7U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[7U]
& (~ __Vtemp234[7U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[8U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[8U]
& (~ __Vtemp234[8U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[9U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[9U]
& (~ __Vtemp234[9U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xaU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xaU]
& (~ __Vtemp234[0xaU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xbU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xbU]
& (~ __Vtemp234[0xbU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xcU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xcU]
& (~ __Vtemp234[0xcU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xdU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xdU]
& (~ __Vtemp234[0xdU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xeU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xeU]
& (~ __Vtemp234[0xeU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0xfU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xfU]
& (~ __Vtemp234[0xfU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x10U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x10U]
& (~ __Vtemp234[0x10U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x11U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x11U]
& (~ __Vtemp234[0x11U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x12U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x12U]
& (~ __Vtemp234[0x12U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x13U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x13U]
& (~ __Vtemp234[0x13U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x14U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x14U]
& (~ __Vtemp234[0x14U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x15U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x15U]
& (~ __Vtemp234[0x15U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x16U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x16U]
& (~ __Vtemp234[0x16U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x17U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x17U]
& (~ __Vtemp234[0x17U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x18U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x18U]
& (~ __Vtemp234[0x18U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x19U]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x19U]
& (~ __Vtemp234[0x19U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1aU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1aU]
& (~ __Vtemp234[0x1aU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1bU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1bU]
& (~ __Vtemp234[0x1bU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1cU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1cU]
& (~ __Vtemp234[0x1cU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1dU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1dU]
& (~ __Vtemp234[0x1dU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1eU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1eU]
& (~ __Vtemp234[0x1eU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_108[0x1fU]
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1fU]
& (~ __Vtemp234[0x1fU]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT___io_imem_btb_update_bits_br_pc_T_2
= (VL_ULL(0xffffffffff) & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__mem_reg_pc
+ (QData)((IData)(
((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__mem_reg_rvc)
? 0U
: 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT___countdown_T
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__data_count)
<< 4U) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample_count));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___T_582
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
VL_SHIFTR_WWI(80,80,7, __Vtemp238, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__inflight_1,
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___T_708
= (1U & (__Vtemp238[0U] | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT___acknum_T_1
= (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__acknum)
- (1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_opcode
[0U] | (1U & (((IData)(1U)
<< vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[0U]) >> 3U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___T_636
= (((7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] >> 4U)) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___T_762
= (1U & ((0x1fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_1)
>> (7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] >> 4U))))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT___acknum_T_1
= (7U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__acknum)
- (1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_read
[0U] | (1U & (((IData)(1U)
<< vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_size
[0U]) >> 3U))))));
}
void VTestHarness::_settle__TOP__153(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__153\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT___T_636
= (((7U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] >> 4U)) == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_113
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_rd)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_rd));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_114
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_typeTag)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_typeTag));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_116
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_pipeid)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_0_pipeid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_117
= ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_2_rd)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_rd));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_118
= ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_2_typeTag)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_typeTag));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___GEN_120
= ((4U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wen))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_2_pipeid)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__wbInfo_1_pipeid));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul__DOT__notNaN_addZeros
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_isZeroA)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_isZeroB))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__dfma__DOT__fma__DOT__mulAddRecFNToRaw_postMul_io_fromPreMul_b_isZeroC));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[1U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[1U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[1U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[2U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[2U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[2U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[3U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[3U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[3U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[4U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[4U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[4U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[5U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[5U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[5U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[6U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[6U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[6U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[7U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[7U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[7U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[8U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[8U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[8U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[9U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[9U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[9U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xaU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xaU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xaU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xbU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xbU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xbU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xcU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xcU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xcU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xdU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xdU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xdU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xeU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xeU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xeU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0xfU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0xfU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0xfU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x10U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x10U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x10U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x11U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x11U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x11U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x12U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x12U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x12U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x13U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x13U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x13U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x14U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x14U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x14U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x15U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x15U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x15U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x16U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x16U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x16U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x17U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x17U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x17U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x18U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x18U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x18U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x19U]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x19U]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x19U])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1aU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1aU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1aU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1bU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1bU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1bU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1cU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1cU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1cU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1dU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1dU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1dU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1eU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1eU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1eU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT___T_115[0x1fU]
= ((2U & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__wb_reg_mem_size))
? (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__valid_1_0[0x1fU]
& vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__g_0[0x1fU])
: 0U);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___T_582
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT__source_1))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__gateways_gateway__DOT___GEN_0
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__intsource__DOT__reg___DOT__reg_)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__pending_0)))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__gateways_gateway__DOT__inFlight));
}
void VTestHarness::_settle__TOP__154(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__154\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*319:0*/ __Vtemp246[10];
WData/*319:0*/ __Vtemp249[10];
WData/*319:0*/ __Vtemp250[10];
WData/*319:0*/ __Vtemp253[10];
WData/*319:0*/ __Vtemp256[10];
WData/*319:0*/ __Vtemp257[10];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT___GEN_14
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__data_count))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__shifter)
: ((0x80U & ((((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample)
<< 7U) & (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample)
<< 6U) | ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample)
<< 5U)))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample)
<< 6U) & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__sample)
<< 5U)))) |
(0x7fU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__uartClockDomainWrapper__DOT__uart_0__DOT__rxm__DOT__shifter)
>> 1U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__domain_1__DOT__resetCtrl__DOT__monitor__DOT___T_80
= (1U & ((~ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_corrupt
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1])
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_pbus_0_reset_catcher_io_sync_reset)));
VL_SHIFTR_WWI(320,320,10, __Vtemp246, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes,
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] << 2U));
__Vtemp249[0U] = (7U & (__Vtemp246[0U] >> 1U));
__Vtemp249[1U] = 0U;
__Vtemp249[2U] = 0U;
__Vtemp249[3U] = 0U;
__Vtemp249[4U] = 0U;
__Vtemp249[5U] = 0U;
__Vtemp249[6U] = 0U;
__Vtemp249[7U] = 0U;
__Vtemp249[8U] = 0U;
__Vtemp249[9U] = 0U;
VL_EXTEND_WW(320,319, __Vtemp250, __Vtemp249);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___T_644
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[0U] == (0xfU & __Vtemp250[0U])) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
VL_SHIFTR_WWI(320,320,10, __Vtemp253, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__inflight_sizes_1,
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] << 2U));
__Vtemp256[0U] = (7U & (__Vtemp253[0U] >> 1U));
__Vtemp256[1U] = 0U;
__Vtemp256[2U] = 0U;
__Vtemp256[3U] = 0U;
__Vtemp256[4U] = 0U;
__Vtemp256[5U] = 0U;
__Vtemp256[6U] = 0U;
__Vtemp256[7U] = 0U;
__Vtemp256[8U] = 0U;
__Vtemp256[9U] = 0U;
VL_EXTEND_WW(320,319, __Vtemp257, __Vtemp256);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___T_716
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_size
[0U] == (0xfU & __Vtemp257[0U])) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
}
void VTestHarness::_settle__TOP__155(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__155\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*319:0*/ __Vtemp260[10];
WData/*319:0*/ __Vtemp263[10];
WData/*319:0*/ __Vtemp264[10];
WData/*319:0*/ __Vtemp265[10];
// Body
VL_SHIFTR_WWI(320,320,10, __Vtemp260, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT__inflight_sizes,
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] << 2U));
__Vtemp263[0U] = (7U & (__Vtemp260[0U] >> 1U));
__Vtemp263[1U] = 0U;
__Vtemp263[2U] = 0U;
__Vtemp263[3U] = 0U;
__Vtemp263[4U] = 0U;
__Vtemp263[5U] = 0U;
__Vtemp263[6U] = 0U;
__Vtemp263[7U] = 0U;
__Vtemp263[8U] = 0U;
__Vtemp263[9U] = 0U;
VL_EXTEND_WW(320,319, __Vtemp264, __Vtemp263);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___T_644
= ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_size
[0U] == (0xfU & __Vtemp264[0U])) | (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__dividerOnlyClockGenerator_3__DOT__bundleOut_0_member_allClocks_subsystem_cbus_0_reset_catcher_io_sync_reset));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__lo_9
= (((QData)((IData)((0x1ffffU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_req_addr
>> 0xaU))))
<< 0x1aU) | (QData)((IData)(((0x3ffffc0U
& ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_ppn)
<< 6U))
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_d)
<< 5U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_a)
<< 4U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_u)
<< 3U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_x)
<< 2U)
| (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_w)
<< 1U)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__ptw__DOT__r_pte_r))))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_param_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_param
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___T_605
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT__d_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_wen
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_reg_valid)
& (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_fma)
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_fastpipe))
| (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_fromint)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor_1__DOT___T_594
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__monitor_1__DOT__a_first_counter_1)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_mask_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_mask
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__monitor_io_in_d_bits_sink
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__d_first_counter))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__pool__DOT__select)
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__cork__DOT__bundleIn_0_d_bits_sink_r));
VL_SHIFTR_WWI(320,320,10, __Vtemp265, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT__inflight_opcodes,
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] << 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[0U]
= __Vtemp265[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[1U]
= __Vtemp265[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[2U]
= __Vtemp265[2U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[3U]
= __Vtemp265[3U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[4U]
= __Vtemp265[4U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[5U]
= __Vtemp265[5U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[6U]
= __Vtemp265[6U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[7U]
= __Vtemp265[7U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[8U]
= __Vtemp265[8U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__monitor__DOT___a_opcode_lookup_T_1[9U]
= __Vtemp265[9U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT___a_opcode_lookup_T_1
= ((0x13U >= (0x1cU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U] >> 2U))) ? (0xfffffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__monitor__DOT__inflight_opcodes
>>
(0x1cU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleIn_0_d_q__DOT__ram_source
[0U]
>> 2U))))
: 0U);
}
void VTestHarness::_settle__TOP__156(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__156\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Variables
// Begin mtask footprint all:
WData/*319:0*/ __Vtemp266[10];
WData/*95:0*/ __Vtemp268[3];
WData/*95:0*/ __Vtemp269[3];
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT___a_opcode_lookup_T_1
= ((0x13U >= (0x1cU & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] >> 2U))) ? (0xfffffU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__monitor__DOT__inflight_opcodes
>>
(0x1cU
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U]
>> 2U))))
: 0U);
VL_SHIFTR_WWI(320,320,10, __Vtemp266, vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT__inflight_opcodes,
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__ram_extra_tlrr_extra_source
[0U] << 2U));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[0U]
= __Vtemp266[0U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[1U]
= __Vtemp266[1U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[2U]
= __Vtemp266[2U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[3U]
= __Vtemp266[3U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[4U]
= __Vtemp266[4U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[5U]
= __Vtemp266[5U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[6U]
= __Vtemp266[6U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[7U]
= __Vtemp266[7U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[8U]
= __Vtemp266[8U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__monitor__DOT___a_opcode_lookup_T_1[9U]
= __Vtemp266[9U];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT__rawC___05Fsig
= (((0U != (7U & ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in3[1U]
<< 3U) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in3[0U]
>> 0x1dU)))) << 0x17U)
| (0x7fffffU & vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in3[0U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_vaddr
= (((QData)((IData)((0xfffffffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_vaddr_r
>> 0xcU)))))
<< 0xcU) | (QData)((IData)((0xfffU & (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_victim_or_hit_way
= (0xfU & ((0U < (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_hit_state_state))
? (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_hit_way)
: ((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_victim_way_r))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT___out_wifireMux_T_2
= (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__maybe_full)
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__out_back__DOT__maybe_full)))
& (4U != vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_opcode
[0U]));
VL_EXTEND_WI(95,32, __Vtemp268, vlTOPp->TestHarness__DOT__success_sim__DOT_____05Fin_bits_reg);
VL_SHIFTL_WWI(95,95,6, __Vtemp269, __Vtemp268,
((IData)(vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT__idx)
<< 5U));
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___addr_T_1[0U]
= __Vtemp269[0U];
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___addr_T_1[1U]
= __Vtemp269[1U];
vlTOPp->TestHarness__DOT__ram__DOT__adapter__DOT___addr_T_1[2U]
= (0x7fffffffU & __Vtemp269[2U]);
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___memLatencyMask_T_3
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_fma)
& (0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_typeTagOut)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT___memLatencyMask_T_6
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_fma)
& (1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_typeTagOut)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_opcode)
>> 2U)))));
}
void VTestHarness::_settle__TOP__157(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__157\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT___signProd_T
= (1U & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[1U]
^ vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[1U]));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__tlb__DOT___misaligned_T_3
= (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s1_tlb_req_vaddr
& (QData)((IData)((0xfU & (((IData)(1U)
<< (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s1_tlb_req_size))
- (IData)(1U))))));
}
void VTestHarness::_settle__TOP__158(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__158\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_sc_fail
= ((7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_cmd))
& (~ ((3U < (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__lrscCount))
& (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__lrscAddr
== (VL_ULL(0x3ffffffff) & (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 6U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_source
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__div_io_req_valid
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ex_reg_valid)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__core__DOT__ex_ctrl_div));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__fma__DOT__mulAddRecFNToRaw_preMul__DOT___sExpAlignedProd_T
= (0x7ffU & (VL_EXTENDS_II(11,10, (0x1ffU &
((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[1U]
<< 9U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in1[0U]
>> 0x17U))))
+ VL_EXTENDS_II(11,10, (0x1ffU
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[1U]
<< 9U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__sfma__DOT__in_in2[0U]
>> 0x17U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__updatePageHit
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pageValid)
& (((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_5
== (0x1ffffffU & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))
<< 5U) | (((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_4
== (0x1ffffffU & (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))
<< 4U) | (((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_3
== (0x1ffffffU
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))
<< 3U) | (((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_2
==
(0x1ffffffU
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))
<< 2U)
| (((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_1
==
(0x1ffffffU
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))
<< 1U)
| (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__pages_0
==
(0x1ffffffU
& (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__frontend__DOT__btb__DOT__r_btb_updatePipe_bits_pc
>> 0xeU))))))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_eq_2
= (1U & ((~ (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))) & (~ (IData)(
(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 1U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_eq_3
= (1U & ((~ (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))) & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 1U))));
}
void VTestHarness::_settle__TOP__159(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__159\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_eq_4
= (1U & ((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U)) & (~ (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 1U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_eq_5
= (1U & ((IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U)) & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 1U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__divSqrt_1__DOT__divSqrtRecFNToRaw__DOT__divSqrtRawFN___DOT__oddSqrt_S
= (0xfffU & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__mem_ctrl_sqrt)
& ((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[2U]
<< 0xcU) | (vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__fpuOpt__DOT__fpiu__DOT__in_in1[1U]
>> 0x14U))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_acc
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_size))
| (1U & ((((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_size))
>> 2U) & (~ (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U)))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__get_a_mask_acc_1
= (1U & ((3U <= (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_size))
| (1U & ((((IData)(1U) << (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_size))
>> 2U) & (IData)((vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__s2_req_addr
>> 2U))))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_30
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_control)
? ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_hit))
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_dirty))
: (((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_hit)
& (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__meta_dirty))
| (~ ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_opcode)
>> 2U)))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_size
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
}
void VTestHarness::_settle__TOP__160(VTestHarness__Syms* __restrict vlSymsp) {
VL_DEBUG_IF(VL_DBG_MSGF("+ VTestHarness::_settle__TOP__160\n"); );
VTestHarness* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
// Body
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__repeater_io_enq_ready
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__maybe_full))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_l2_ctrl__DOT__fragmenter__DOT__repeater__DOT__full))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__repeater_io_enq_ready
= (1U & ((~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__plicDomainWrapper__DOT__plic__DOT__out_back__DOT__maybe_full))
& (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__coupler_to_plic__DOT__fragmenter__DOT__repeater__DOT__full))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_0__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_1__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_2__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_3__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__abc_mshrs_4__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__bc_mshr__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT___GEN_38
= (1U & ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_prio_2)
| (~ (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_l2_wrapper__DOT__l2__DOT__mods_0__DOT__c_mshr__DOT__request_control))));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_address_io_deq_bits_MPORT_data
= vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ram_address
[vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1];
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__inWriteback
= ((1U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__release_state))
| (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__release_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__metaArb_io_in_4_valid
= ((6U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__release_state))
| (7U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__tile_prci_domain__DOT__tile_reset_domain__DOT__tile__DOT__dcache__DOT__release_state)));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__muxStateEarly_0
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__beatsLeft))
? (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__cam_s_0_state))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__atomics__DOT__state_0));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__ptr_match
= ((IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value)
== (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_pbus__DOT__coupler_to_slave_named_tileresetctrl__DOT__buffer__DOT__bundleOut_0_a_q__DOT__value_1));
vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__muxStateEarly_0
= ((0U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__beatsLeft))
? (2U == (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__cam_s_0_state))
: (IData)(vlTOPp->TestHarness__DOT__chiptop__DOT__system__DOT__subsystem_cbus__DOT__atomics__DOT__state_0));
}
| [
"[email protected]"
] | |
8cfe9f7a6129450125146a3cacb069a178f1891b | f774cfee5cab777a6d30b6cca2caedb9de224c2c | /Homework2Q5/Homework2Q5/Homework2Q5/Set.cpp | 80321332b05cfb4751269308423fd3967a17a956 | [] | no_license | charliet2020/CS32HW2 | 7cc2a3144d27f7c999d1d2c12c756c72503bb9df | c64cd752ff60b4fd237afc255af9d8221d25fcff | refs/heads/master | 2022-11-20T00:44:17.045259 | 2020-07-20T20:34:48 | 2020-07-20T20:34:48 | 281,215,212 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,401 | cpp | // Set.cpp
#include "Set.h"
#include <cassert>
#include <iostream>
using namespace std;
Set::Set()
{
createEmpty();
}
bool Set::insert(const ItemType& value)
{
// Fail if value already present
Node* p = findFirstAtLeast(value);
if (p != m_head && p->m_value == value)
return false;
// Insert new Node preserving ascending order and incrementing m_size
insertBefore(p, value);
return true;
}
bool Set::erase(const ItemType& value)
{
// Find the Node with the value, failing if there is none.
Node* p = findFirstAtLeast(value);
if (p == m_head || p->m_value != value)
return false;
// Erase the Node, decrementing m_size
doErase(p);
return true;
}
bool Set::get(int i, ItemType& value) const
{
if (i < 0 || i >= m_size)
return false;
// Return the value at position i. Since the values are stored in
// ascending, the value at position i will be greater than exactly i
// items in the set, meeting get's specification.
// If i is closer to the head of the list, go forward to reach that
// position; otherwise, start from tail and go backward.
Node* p;
if (i < m_size / 2) // closer to head
{
p = m_head->m_next;
for (int k = 0; k != i; k++)
p = p->m_next;
}
else // closer to tail
{
p = m_head->m_prev;
for (int k = m_size - 1; k != i; k--)
p = p->m_prev;
}
value = p->m_value;
return true;
}
int Set::size() const
{
return m_size;
}
bool Set::empty() const
{
return size() == 0;
}
bool Set::contains(const ItemType& value) const
{
//cerr << "contains called" << endl;
Node* p = findFirstAtLeast(value);
return p != m_head && p->m_value == value;
}
void Set::swap(Set& other)
{
// Swap head pointers
Node* p = other.m_head;
other.m_head = m_head;
m_head = p;
// Swap sizes
int s = other.m_size;
other.m_size = m_size;
m_size = s;
}
Set::~Set()
{
// Delete all Nodes from first non-dummy up to but not including
// the dummy
while (m_head->m_next != m_head)
doErase(m_head->m_next);
// delete the dummy
delete m_head;
}
Set::Set(const Set& other)
{
createEmpty();
// Copy all non-dummy other Nodes. (This will set m_size.)
// Inserting each new node before the dummy node that m_head points to
// puts the new node at the end of the list.
for (Node* p = other.m_head->m_next; p != other.m_head; p = p->m_next)
insertBefore(m_head, p->m_value);
}
Set& Set::operator=(const Set& rhs)
{
if (this != &rhs)
{
// Copy and swap idiom
Set temp(rhs);
swap(temp);
}
return *this;
}
void Set::createEmpty()
{
m_size = 0;
// Create dummy node
m_head = new Node;
m_head->m_next = m_head;
m_head->m_prev = m_head;
}
void Set::insertBefore(Node* p, const ItemType& value)
{
// Create a new node
Node* newp = new Node;
newp->m_value = value;
// Insert new item before p
newp->m_prev = p->m_prev;
newp->m_next = p;
newp->m_prev->m_next = newp;
newp->m_next->m_prev = newp;
m_size++;
}
void Set::doErase(Node* p)
{
// Unlink p from the list and destroy it
p->m_prev->m_next = p->m_next;
p->m_next->m_prev = p->m_prev;
delete p;
m_size--;
}
Set::Node* Set::findFirstAtLeast(const ItemType& value) const
{
// Walk through the list looking for a match
Node* p = m_head->m_next;
for (; p != m_head && p->m_value < value; p = p->m_next)
;
return p;
}
void unite(const Set& s1, const Set& s2, Set& result)
{
// Check for aliasing to get correct behavior or better performance:
// If result is s1 and s2, result already is the union.
// If result is s1, insert s2's elements into result.
// If result is s2, insert s1's elements into result.
// If result is a distinct set, assign it s1's contents, then
// insert s2's elements in result, unless s2 is s1, in which
// case result now already is the union.
const Set* sp = &s2;
if (&result == &s1)
{
if (&result == &s2)
return;
}
else if (&result == &s2)
sp = &s1;
else
{
result = s1;
if (&s1 == &s2)
return;
}
for (int k = 0; k < sp->size(); k++)
{
ItemType v;
sp->get(k, v);
result.insert(v);
}
}
void subtract(const Set& s1, const Set& s2, Set& result)
{
// Guard against the case that result is an alias for s2 by copying
// s2 to a local variable. This implementation needs no precaution
// against result being an alias for s1.
Set s2copy(s2);
result = s1;
for (int k = 0; k < s2copy.size(); k++)
{
ItemType v;
s2copy.get(k, v);
result.erase(v);
}
} | [
"[email protected]"
] | |
44d58647b652f517a6553a5b412e5a82459faac7 | dac93b4dbc3f8b6d50e31659a4bc7ce8faec7a84 | /SFMLBase/Collision.hpp | cb812d62b0e2277b1cbc8097c4ea417f5817e7c6 | [] | no_license | miguelfmlopes91/SFML-Flappy-bird | 186a9031a557cb608a3b0801d0c64a3c38c51685 | 0cc3211e8673268602d8e0bd7b00f53741430c02 | refs/heads/master | 2020-03-25T16:26:12.307090 | 2018-08-27T21:24:45 | 2018-08-27T21:24:45 | 143,930,519 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 295 | hpp | #pragma once
#include <SFML/Graphics.hpp>
namespace Bardo
{
class Collision
{
public:
Collision();
~Collision();
bool CheckSpriteCollision(sf::Sprite sprite1, sf::Sprite sprite2);
bool CheckSpriteCollision(sf::Sprite sprite1, float scale1, sf::Sprite sprite2, float scale2);
};
} | [
"[email protected]"
] | |
91515ba580d474e880a7f580a501756441969b34 | 5544ab772b5220e1f5b9a1145eec1d001ba9a39f | /openssl_client/Maps.h | e2b8e471a524ad99402779b2137055d049ebd745 | [] | no_license | kapes316/tlsprofiler | a8d1ab7a37449cbc738f9c76c4ab64b9ff747d30 | 2cd2e0b533b6a9f5251761aec4be828b6d8c3918 | refs/heads/master | 2020-04-24T21:42:34.608029 | 2019-02-24T03:07:39 | 2019-02-24T03:07:39 | 172,287,888 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,849 | h | #ifndef _MAPS_H_
#define _MAPS_H_
/* Cipher suites */
static const std::map<uint32_t,std::string> ssl_ciphers_tbl =
{
{0x0000, "TLS_NULL_WITH_NULL_NULL"},
{0x0001, "TLS_RSA_WITH_NULL_MD5"},
{0x0002, "TLS_RSA_WITH_NULL_SHA"},
{0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"},
{0x0004, "TLS_RSA_WITH_RC4_128_MD5"},
{0x0005, "TLS_RSA_WITH_RC4_128_SHA"},
{0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"},
{0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"},
{0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"},
{0x0009, "TLS_RSA_WITH_DES_CBC_SHA"},
{0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
{0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"},
{0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"},
{0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"},
{0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"},
{0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"},
{0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"},
{0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"},
{0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"},
{0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"},
{0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"},
{0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"},
{0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"},
{0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"},
{0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"},
{0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"},
{0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"},
{0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"},
{0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"},
{0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"},
{0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"},
{0x0020, "TLS_KRB5_WITH_RC4_128_SHA"},
{0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"},
{0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"},
{0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"},
{0x0024, "TLS_KRB5_WITH_RC4_128_MD5"},
{0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"},
{0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"},
{0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"},
{0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"},
{0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"},
{0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"},
{0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"},
{0x002C, "TLS_PSK_WITH_NULL_SHA"},
{0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"},
{0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"},
{0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"},
{0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"},
{0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"},
{0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"},
{0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
{0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"},
{0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"},
{0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"},
{0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"},
{0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"},
{0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
{0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"},
{0x003B, "TLS_RSA_WITH_NULL_SHA256"},
{0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"},
{0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"},
{0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"},
{0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"},
{0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"},
{0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"},
{0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"},
{0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"},
{0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"},
{0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"},
{0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"},
{0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
{0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"},
{0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"},
{0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"},
{0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
{0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"},
{0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"},
{0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"},
{0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"},
{0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"},
{0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"},
{0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"},
{0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"},
{0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"},
{0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"},
{0x008A, "TLS_PSK_WITH_RC4_128_SHA"},
{0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"},
{0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"},
{0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"},
{0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"},
{0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"},
{0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"},
{0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"},
{0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"},
{0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"},
{0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"},
{0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"},
{0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"},
{0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"},
{0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"},
{0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"},
{0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"},
{0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"},
{0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"},
{0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"},
{0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"},
{0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"},
{0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"},
{0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"},
{0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"},
{0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"},
{0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"},
{0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"},
{0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"},
{0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"},
{0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"},
{0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"},
{0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"},
{0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"},
{0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"},
{0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"},
{0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"},
{0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"},
{0x00B0, "TLS_PSK_WITH_NULL_SHA256"},
{0x00B1, "TLS_PSK_WITH_NULL_SHA384"},
{0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"},
{0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"},
{0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"},
{0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"},
{0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"},
{0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"},
{0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"},
{0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"},
{0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"},
{0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"},
{0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"},
{0x5600, "TLS_FALLBACK_SCSV"},
{0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"},
{0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"},
{0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"},
{0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"},
{0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"},
{0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"},
{0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"},
{0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
{0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"},
{0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"},
{0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"},
{0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"},
{0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"},
{0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"},
{0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"},
{0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"},
{0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"},
{0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
{0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"},
{0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"},
{0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"},
{0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"},
{0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"},
{0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"},
{0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"},
{0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"},
{0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"},
{0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"},
{0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"},
{0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"},
{0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"},
{0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"},
{0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"},
{0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"},
{0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
{0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
{0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"},
{0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"},
{0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
{0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
{0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"},
{0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"},
{0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"},
{0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"},
{0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"},
{0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"},
{0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"},
{0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"},
{0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"},
{0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"},
{0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"},
{0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"},
{0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"},
{0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"},
{0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"},
{0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"},
{0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"},
{0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"},
{0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"},
{0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"},
{0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"},
{0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"},
{0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"},
{0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"},
{0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"},
{0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"},
{0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"},
{0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"},
{0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"},
{0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"},
{0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"},
{0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"},
{0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"},
{0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"},
{0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"},
{0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"},
{0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"},
{0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"},
{0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"},
{0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"},
{0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"},
{0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"},
{0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"},
{0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"},
{0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"},
{0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"},
{0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"},
{0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"},
{0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"},
{0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"},
{0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"},
{0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"},
{0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"},
{0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"},
{0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"},
{0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"},
{0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"},
{0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"},
{0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"},
{0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"},
{0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"},
{0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"},
{0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"},
{0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"},
{0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"},
{0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"},
{0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"},
{0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"},
{0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"},
{0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"},
{0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"},
{0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"},
{0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"},
{0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
{0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
{0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
{0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
{0xC09C, "TLS_RSA_WITH_AES_128_CCM"},
{0xC09D, "TLS_RSA_WITH_AES_256_CCM"},
{0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"},
{0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"},
{0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"},
{0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"},
{0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"},
{0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"},
{0xC0A4, "TLS_PSK_WITH_AES_128_CCM"},
{0xC0A5, "TLS_PSK_WITH_AES_256_CCM"},
{0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"},
{0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"},
{0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"},
{0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"},
{0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"},
{0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"},
{0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"},
{0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"},
{0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"},
{0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"},
{0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
{0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"},
{0x1301, "TLS_AES_128_GCM_SHA256"},
{0x1302, "TLS_AES_256_GCM_SHA384"},
{0x1303, "TLS_CHACHA20_POLY1305_SHA256"},
{0x1304, "TLS_AES_128_CCM_SHA256"},
{0x1305, "TLS_AES_128_CCM_8_SHA256"},
{0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"},
{0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"},
{0xFF85, "GOST2012-GOST8912-GOST8912"},
{0xFF87, "GOST2012-NULL-GOST12"}
};
/* Version number */
static const std::map<uint32_t,std::string> ssl_version_tbl =
{
{768, "SSL 3.0"},
{769, "TLS 1.0"},
{770, "TLS 1.1"},
{771, "TLS 1.2"},
{772, "TLS 1.3"}
// {DTLS1_VERSION, "DTLS 1.0"},
// {DTLS1_2_VERSION, "DTLS 1.2"},
// {DTLS1_BAD_VER, "DTLS 1.0 (bad)"}
};
/* Extensions sorted by ascending id */
static const std::map<uint32_t,std::string> ssl_exts_tbl =
{
{TLSEXT_TYPE_server_name, "server_name"},
{TLSEXT_TYPE_max_fragment_length, "max_fragment_length"},
{TLSEXT_TYPE_client_certificate_url, "client_certificate_url"},
{TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"},
{TLSEXT_TYPE_truncated_hmac, "truncated_hmac"},
{TLSEXT_TYPE_status_request, "status_request"},
{TLSEXT_TYPE_user_mapping, "user_mapping"},
{TLSEXT_TYPE_client_authz, "client_authz"},
{TLSEXT_TYPE_server_authz, "server_authz"},
{TLSEXT_TYPE_cert_type, "cert_type"},
{TLSEXT_TYPE_supported_groups, "supported_groups"},
{TLSEXT_TYPE_ec_point_formats, "ec_point_formats"},
{TLSEXT_TYPE_srp, "srp"},
{TLSEXT_TYPE_signature_algorithms, "signature_algorithms"},
{TLSEXT_TYPE_use_srtp, "use_srtp"},
{TLSEXT_TYPE_heartbeat, "tls_heartbeat"},
{TLSEXT_TYPE_application_layer_protocol_negotiation, "application_layer_protocol_negotiation"},
{TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"},
{TLSEXT_TYPE_padding, "padding"},
{TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"},
{TLSEXT_TYPE_extended_master_secret, "extended_master_secret"},
{TLSEXT_TYPE_session_ticket, "session_ticket"},
{TLSEXT_TYPE_psk, "psk"},
{TLSEXT_TYPE_early_data, "early_data"},
{TLSEXT_TYPE_supported_versions, "supported_versions"},
{TLSEXT_TYPE_cookie, "cookie_ext"},
{TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"},
{TLSEXT_TYPE_certificate_authorities, "certificate_authorities"},
{TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"},
{TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"},
{TLSEXT_TYPE_key_share, "key_share"},
{TLSEXT_TYPE_renegotiate, "renegotiate"},
{TLSEXT_TYPE_next_proto_neg, "next_proto_neg"},
};
#endif
| [
"[email protected]"
] | |
3f61bc7aa26a9f45dccd228ca904e449c9e53151 | a47a4401527abaffdc67afd8f774cdffc30a47cd | /RecommenderStandalone/DataModel.h | d3c8ecc0176e0ceb9c28882a8aad66fd4fe9c4bd | [] | no_license | Exlsunshine/RecommenderStandalone | 556b148909b6e171b76465dd103b5faefeee8386 | 37032ee31ad7f3371c89bb1fed82e1811bd97969 | refs/heads/master | 2021-01-13T01:44:40.309736 | 2015-02-28T07:11:59 | 2015-02-28T07:11:59 | 31,312,346 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,505 | h | #ifndef DATAMODEL_H
#define DATAMODEL_H
#include <vector>
#include "PreferenceArray.h"
namespace RS
{
/**
Implementations represent a repository of information about users and their associated {@link Preference}s
for items.
*/
class DataModel
{
private:
float maxPreference;
float minPreference;
public:
DataModel();
virtual ~DataModel();
/**
* @return all user IDs in the model, in order
*/
virtual std::vector<long> getUserIDs();
/**
@param
ID of user to get prefs for
@return user's preferences, ordered by item ID
*/
virtual PreferenceArray getPreferencesFromUser(long userID);
/**
* @param userID
* ID of user to get prefs for
* @return IDs of items user expresses a preference for
*/
virtual std::vector<long> getItemIDsFromUser(long userID);
/**
* @return a {@link LongPrimitiveIterator} of all item IDs in the model, in order
*/
virtual std::vector<long> getItemIDs();
/**
* @param itemID
* item ID
* @return all existing {@link Preference}s expressed for that item, ordered by user ID, as an array
*/
virtual PreferenceArray getPreferencesForItem(long itemID);
/**
* Retrieves the preference value for a single user and item.
*
* @param userID
* user ID to get pref value from
* @param itemID
* item ID to get pref value for
* @return preference value from the given user for the given item or null if none exists
*/
virtual float getPreferenceValue(long userID, long itemID);
/**
* Retrieves the time at which a preference value from a user and item was set, if known.
* Time is expressed in the usual way, as a number of milliseconds since the epoch.
*
* @param userID user ID for preference in question
* @param itemID item ID for preference in question
* @return time at which preference was set or null if no preference exists or its time is not known
*/
virtual long getPreferenceTime(long userID, long itemID);
/**
* @return total number of items known to the model. This is generally the union of all items preferred by
* at least one user but could include more.
*/
virtual int getNumItems();
/**
* @return total number of users known to the model.
*/
virtual int getNumUsers();
/**
* @param itemID item ID to check for
* @return the number of users who have expressed a preference for the item
*/
virtual int getNumUsersWithPreferenceFor(long itemID);
/**
* @param itemID1 first item ID to check for
* @param itemID2 second item ID to check for
* @return the number of users who have expressed a preference for the items
*/
virtual int getNumUsersWithPreferenceFor(long itemID1, long itemID2);
/**
* <p>
* Sets a particular preference (item plus rating) for a user.
* </p>
*
* @param userID
* user to set preference for
* @param itemID
* item to set preference for
* @param value
* preference value
*/
virtual void setPreference(long userID, long itemID, float value);
/**
* <p>
* Removes a particular preference for a user.
* </p>
*
* @param userID
* user from which to remove preference
* @param itemID
* item to remove preference for
*/
virtual void removePreference(long userID, long itemID);
/**
* @return true if this implementation actually stores and returns distinct preference values;
* that is, if it is not a 'boolean' DataModel
*/
virtual bool hasPreferenceValues();
/**
* @return the maximum preference value that is possible in the current problem domain being evaluated. For
* example, if the domain is movie ratings on a scale of 1 to 5, this should be 5. While a
* {@link org.apache.mahout.cf.taste.recommender.Recommender} may estimate a preference value above 5.0, it
* isn't "fair" to consider that the system is actually suggesting an impossible rating of, say, 5.4 stars.
* In practice the application would cap this estimate to 5.0. Since evaluators evaluate
* the difference between estimated and actual value, this at least prevents this effect from unfairly
* penalizing a {@link org.apache.mahout.cf.taste.recommender.Recommender}
*/
virtual float getMaxPreference();
/**
* @see #getMaxPreference()
*/
virtual float getMinPreference();
virtual void setMaxPreference(float maxPreferenceValue);
virtual void setMinPreference(float minPreferenceValue);
virtual std::string toString();
};
}
#endif | [
"[email protected]"
] | |
4985692ddaf7106f3a555af1d7f3ed29acb28d13 | 17a7b5893b986a9332bc6fa4188ce7bc553aa361 | /include/example/example.h | e8847b50a59b591b0258b2dd5cf145512422fc0b | [
"MIT"
] | permissive | rivergold/CMake-Demo | 3bd31629cebafae4d7228ce6ca9fe2fee19853c4 | 2acd20a682d45790da465f88d0e4a8bc7d376594 | refs/heads/master | 2022-11-25T10:07:09.292407 | 2020-08-04T13:03:04 | 2020-08-04T13:03:04 | 283,968,537 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 109 | h | #include <torch/script.h>
class Example {
public:
void run();
private:
torch::jit::Module model_;
};
| [
"[email protected]"
] | |
b5e44bbef91314eead5d5792fbcaa35bd6a4ec38 | f406d9f94de326a287a0c1c2108c911a03345170 | /include/common/algine/core/InputLayout.h | 8c5d8a701e497ca1eb8b7ff84c90d4cb2f41af31 | [
"MIT"
] | permissive | congard/algine | 0b50aee47cf7f3b3074b8fa68a17d75111ec5018 | 2e69b6b21c282ddb8c6aa75e2d1273f8c2eabddf | refs/heads/master | 2023-08-29T07:26:03.362871 | 2023-08-27T22:30:00 | 2023-08-27T22:30:00 | 182,413,604 | 17 | 4 | MIT | 2020-05-13T09:37:54 | 2019-04-20T14:07:52 | C++ | UTF-8 | C++ | false | false | 704 | h | #ifndef ALGINE_INPUTLAYOUT_H
#define ALGINE_INPUTLAYOUT_H
#include <algine/core/buffers/ArrayBuffer.h>
#include <algine/core/buffers/IndexBuffer.h>
#include <algine/core/InputAttributeDescription.h>
#include <algine/core/context/ContextObject.h>
namespace algine {
AL_CONTEXT_OBJECT(InputLayout) {
AL_CONTEXT_OBJECT_IMPL(InputLayout)
public:
explicit InputLayout(Object *parent = defaultParent());
~InputLayout() override;
void bind() const;
void unbind() const;
void addAttribute(const InputAttributeDescription &inputAttribDescription, const ArrayBuffer *arrayBuffer) const;
void setIndexBuffer(const IndexBuffer *indexBuffer) const;
};
}
#endif //ALGINE_INPUTLAYOUT_H
| [
"[email protected]"
] | |
eab1c75e1c5fecfeff4f36051007970abc1c43c7 | cc334e8369c0bee75db9873fe472fc930dec3e2f | /communication_node/src/send_robot_state.cpp | 2cd650198e12326923af9ec6c09bc6de81c562f4 | [] | no_license | JDR-neu/lab_car | 94f1fb58f829578c1a2e1030dc2872feb9ccb5a6 | 5793d3cce481f5ea801572ce7d97d6d65261764b | refs/heads/master | 2022-12-20T09:19:10.268646 | 2020-10-07T07:33:38 | 2020-10-07T07:33:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 937 | cpp | #include "zmq_test.h"
#include "iostream"
#include <vector>
#include "ros/ros.h"
#include "std_msgs/String.h"
#include "jsoncpp/json/json.h"
std::string state{"stand by"};
void DecisionSub(const std_msgs::StringConstPtr &msg){
state = msg->data;
}
int main(int argc,char **argv)
{
ros::init(argc,argv,"send_robot_state");
ros::NodeHandle nh;
std::string ip_address;
int car_id;
nh.getParam("car_id",car_id);
nh.getParam("my_ip_address",ip_address);
ros::Subscriber state_subs;
state_subs = nh.subscribe("decision_state",10,&DecisionSub);
ZMQ_TEST *zmq_test;
zmq_test = new ZMQ_TEST();
zmq_test->zmq_init(0,1,6666,ip_address);
ros::Rate loop(1);
Json::Value json1;
json1["state"] = state;
cout << json1.toStyledString();
while(ros::ok())
{
zmq_test->send_data(json1.toStyledString());
ros::spinOnce();
loop.sleep();
}
return 0;
} | [
"[email protected]"
] | |
912cc69dccfd232952256e2c793b072f0fecd067 | 5999c514e121e79d2291846da97cb586db93cf62 | /include/cgeom/utility.h | 7da4e0dc6e3e9b89c26d583808be5c5523a13d92 | [] | no_license | euyuil/algorithm-libraries | c96374faa0481b8bb29b6ac4d068f2f37deb680f | e8ee4658158597460a45a8233e6c3035d4544c1d | refs/heads/master | 2016-09-06T12:30:18.783819 | 2013-04-07T13:07:44 | 2013-04-07T13:07:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,091 | h | #ifndef _CGEOM_UTILITY_H_
#define _CGEOM_UTILITY_H_
/**
* @brief Returns the cross product of two vectors.
* @param a One vector.
* @param b The other vector.
* @return The cross product of a and b.
* @date 2011-08-09
*/
inline double cross(const point &a, const point &b) {
return a.x * b.y - b.x * a.y;
}
/**
* @brief Returns the dot product of two vectors.
* @param a One vector.
* @param b The other vector.
* @return The dot product of a and b.
* @date 2011-08-09
*/
inline double dot(const point &a, const point &b) {
return a.x * b.x + a.y * b.y;
}
/**
* @brief For Each Segment of POlygon.
* @param s Output segment.
* @param i Iterator of the first end-point of the segment.
* @param b The begin iterator of the polygon.
* @param e The end iterator of the polygon.
* @return True if succeeded.
*/
template <typename I> bool fespo(line &s, I &i, I b, I e)
{
if (i == e) return false;
I j = i; ++j;
if (j == e) s = line(*i, *b);
else s = line(*i, *j);
i = j; return true;
}
#endif /* _CGEOM_UTILITY_H_ */
| [
"[email protected]"
] | |
fe1f51423f58c62e42595d2f04938d570bd8c90a | c49a7992e5e2e94f073690e1188e40fe271e395a | /uploads/Integer.cpp | 5e2bb735f8ade34aadb3f146b088aedb9a773d14 | [] | no_license | ipkCoder/sandbox | 735e2c93864fe1e19141fd4b5b301951df80b1d3 | 007e1f2a8533d6369dbc5219aae1dc158c15baac | refs/heads/master | 2020-05-17T17:59:54.235000 | 2014-05-31T19:24:51 | 2014-05-31T19:24:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,215 | cpp |
#include <iostream>
#include <string>
#include <cstdlib>
#include <cctype> // isdigit
using namespace std;
bool is_number(const string &sNumber)
{
int i;
for (i = 0; i < sNumber.length(); i++) {
if (!isdigit(sNumber[i])) {
return false;
}
}
return true;
}
class Integer
{
friend ostream& operator<<(ostream &cout, const Integer &n);
friend int operator+(const Integer &n1, const Integer &n2);
protected:
int number;
public:
Integer();
Integer(int n);
Integer(const char &sNum);
int getNumber();
void print() const;
};
Integer::Integer()
{
number = 0;
}
Integer::Integer(int n)
{
number = n;
}
int Integer::getNumber()
{
return number;
}
void Integer::print() const
{
cout << number;
}
ostream& operator<<(ostream &cout, const Integer &n)
{
cout << n.getNumber();
return cout;
}
int operator+(const Integer &n1, const Integer &n2)
{
return n1.getNumber)() + n2.getNumber();
}
/*
bool is_number(const sting &sNumber)
{
int i;
for (i = 0; i < sNumber.length; i++) {
if (!isdigit(sNumber[i])) {
return false;
}
}
return true;
}
*/
int main()
{
Integer i;
Integer i2(2);
Integer i3;
i3 = i + i2;
cout << i << i2 << i3 << endl;
} | [
"[email protected]"
] | |
997b7ac934b4259dcc13f5d7cb7fde049c9bf078 | 0f2ae9e7a6d542e2cc8b7b2b97ff97e467c7ce22 | /Helló, Mandelbrot!/Forward engineering UML osztálydiagram/c++/LZWBinFa.h | dea0ce7dec287443e2d025b855d18a1d0057e36b | [] | no_license | grestemayster/prog2 | 7d242ca2ae5fe5baf61215f27bac1468e164ca82 | 27099c3b927ac8e7ab1a6db1cf3fa396a8e5bbfd | refs/heads/master | 2023-01-24T16:51:29.017686 | 2020-12-06T16:52:01 | 2020-12-06T16:52:01 | 297,918,817 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 464 | h | #ifndef LZWBINFA_H
#define LZWBINFA_H
class LZWBinFa {
protected:
Csomopont _gyoker;
private:
int _melyseg;
int _atlagosszeg;
int _atlagdb;
double _szorasosszeg;
protected:
int _maxMelyseg;
double _atlag;
double _szoras;
public:
void _LZWBinFa();
void getMelyseg();
void getAtlag();
void getSzoras();
LZWBinFa();
void kiir();
private:
void _();
void szabadit();
protected:
void rmelyseg();
void ratlag();
void rszoras();
};
#endif
| [
"[email protected]"
] | |
728d8bb90cedeb75930d22150a277ac0c06bd217 | 302f4bda84739593ab952f01c9e38d512b0a7d73 | /ext/Celero-2.0.7/experiments/ExperimentCompressBools/ExperimentCompressBools.cpp | 1af2297faccd11d4498234d8e9e9eca284411b01 | [
"Apache-2.0",
"ICU",
"BSD-3-Clause",
"BSL-1.0",
"X11",
"Beerware"
] | permissive | thomaskrause/graphANNIS | 649ae23dd74b57bcd8a699c1e309e74096be9db2 | 66d12bcfb0e0b9bfcdc2df8ffaa5ae8c84cc569c | refs/heads/develop | 2020-04-11T01:28:47.589724 | 2018-03-15T18:16:50 | 2018-03-15T18:16:50 | 40,169,698 | 9 | 3 | Apache-2.0 | 2018-07-28T20:18:41 | 2015-08-04T07:24:49 | C++ | UTF-8 | C++ | false | false | 13,801 | cpp | // Original code at: https://github.com/fenbf/benchmarkLibsTest
#pragma warning(push)
#pragma warning(disable : 4251) // warning C4251: celero::Result::pimpl': class 'celero::Pimpl<celero::Result::Impl>' needs to have dll-interface to
// be used by clients of class 'celero::Result'
#include <celero\Celero.h>
#pragma warning(pop)
#include <emmintrin.h>
#include <omp.h>
#include <bitset>
#include <iostream>
#include <random>
CELERO_MAIN;
static const int SamplesCount = 30;
static const int IterationsCount = 5;
static const int ThresholdValue = 127;
static const int MaximumDistribution = 255;
void Checker(bool val, bool reference, uint64_t i)
{
if(val != reference)
{
std::cout << "Mismatch at index: " << i << "\n";
}
}
bool GetBoolAt(int64_t pos, uint8_t* outputValues)
{
const auto bytePos = pos / 8;
const auto bitPos = pos % 8;
return ((*(outputValues + bytePos)) & (1 << bitPos)) > 0;
}
class CompressBoolsFixture : public celero::TestFixture
{
public:
virtual std::vector<std::pair<int64_t, uint64_t>> getExperimentValues() const override
{
std::vector<std::pair<int64_t, uint64_t>> problemSpace;
const auto stepCount = MaxArrayLength / BenchmarkSteps;
for(int64_t i = 0; i < BenchmarkSteps; i++)
{
// ExperimentValues is part of the base class and allows us to specify
// some values to control various test runs to end up building a nice graph.
problemSpace.push_back(std::make_pair(stepCount + i * stepCount, uint64_t(i + 1)));
}
return problemSpace;
}
/// Before each run, build a vector of random integers.
virtual void setUp(int64_t experimentValue) override
{
this->arrayLength = static_cast<size_t>(experimentValue);
this->inputValues.reset(new int[arrayLength]);
this->referenceValues.reset(new bool[arrayLength]);
std::mt19937 gen(0); // Standard mersenne_twister_engine seeded with 0, constant
std::uniform_int_distribution<> dist(0, MaximumDistribution);
// set every byte, copute reference values
for(int64_t i = 0; i < experimentValue; ++i)
{
this->inputValues[i] = dist(gen);
this->referenceValues[i] = this->inputValues[i] > ThresholdValue;
}
}
#ifdef _DEBUG
static const int64_t MaxArrayLength{100};
static const int64_t BenchmarkSteps{1};
#else
static const int64_t MaxArrayLength{5000000};
static const int64_t BenchmarkSteps{5};
#endif
size_t arrayLength{0};
std::unique_ptr<int[]> inputValues;
std::unique_ptr<bool[]> referenceValues;
};
class NoPackingFixture : public CompressBoolsFixture
{
public:
virtual void setUp(int64_t experimentValue) override
{
CompressBoolsFixture::setUp(experimentValue);
this->outputValues.reset(new bool[static_cast<unsigned int>(arrayLength)]);
}
virtual void tearDown() override
{
for(size_t i = 0; i < arrayLength; ++i)
{
Checker(outputValues[i], referenceValues[i], i);
}
}
std::unique_ptr<bool[]> outputValues;
};
BASELINE_F(CompressBoolsTest, NoPackingVersion, NoPackingFixture, SamplesCount, IterationsCount)
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
this->outputValues[i] = this->inputValues[i] > ThresholdValue;
}
}
class StdBitsetFixture : public CompressBoolsFixture
{
public:
virtual void tearDown() override
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
Checker(this->outputBitset[i], this->referenceValues[i], i);
}
}
std::bitset<MaxArrayLength> outputBitset;
};
// Run an automatic baseline.
// Celero will help make sure enough samples are taken to get a reasonable measurement
BENCHMARK_F(CompressBoolsTest, StdBitset, StdBitsetFixture, SamplesCount, IterationsCount)
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
this->outputBitset.set(i, this->inputValues[i] > ThresholdValue);
}
}
class StdVectorFixture : public CompressBoolsFixture
{
public:
virtual void setUp(int64_t experimentValue) override
{
CompressBoolsFixture::setUp(experimentValue);
this->outputVector.resize(static_cast<unsigned int>(experimentValue));
}
virtual void tearDown() override
{
for(size_t i = 0; i < arrayLength; ++i)
{
Checker(this->outputVector[i], this->referenceValues[i], i);
}
}
std::vector<bool> outputVector;
};
BENCHMARK_F(CompressBoolsTest, StdVector, StdVectorFixture, SamplesCount, IterationsCount)
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
this->outputVector[i] = this->inputValues[i] > ThresholdValue;
}
}
class ManualVersionFixture : public CompressBoolsFixture
{
public:
ManualVersionFixture() : numBytes(0), numFullBytes(0)
{
}
virtual void setUp(int64_t experimentValue) override
{
CompressBoolsFixture::setUp(experimentValue);
this->numBytes = static_cast<unsigned int>((experimentValue + 7) / 8);
this->numFullBytes = static_cast<unsigned int>((experimentValue) / 8);
this->outputValues.reset(new uint8_t[this->numBytes]);
}
virtual void tearDown() override
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
Checker(GetBoolAt(i, outputValues.get()), referenceValues[i], i);
}
}
unsigned int numBytes;
unsigned int numFullBytes;
std::unique_ptr<uint8_t[]> outputValues;
};
BENCHMARK_F(CompressBoolsTest, SingleVarVersion, ManualVersionFixture, SamplesCount, IterationsCount)
{
uint8_t OutByte = 0;
int shiftCounter = 0;
auto pInputData = inputValues.get();
auto pOutputByte = outputValues.get();
for(size_t i = 0; i < this->arrayLength; ++i)
{
if(*pInputData > ThresholdValue)
{
OutByte |= (1 << shiftCounter);
}
pInputData++;
shiftCounter++;
if(shiftCounter > 7)
{
*pOutputByte++ = OutByte;
OutByte = 0;
shiftCounter = 0;
}
}
// our byte might be incomplete, so we need to handle this:
if(this->arrayLength & 7)
{
*pOutputByte++ = OutByte;
}
}
BENCHMARK_F(CompressBoolsTest, NotDepentendVersion, ManualVersionFixture, SamplesCount, IterationsCount)
{
uint8_t Bits[8] = {0};
const int64_t lenDivBy8 = (this->arrayLength / 8) * 8;
auto pInputData = inputValues.get();
auto pOutputByte = outputValues.get();
for(int64_t j = 0; j < lenDivBy8; j += 8)
{
Bits[0] = pInputData[0] > ThresholdValue ? 0x01 : 0;
Bits[1] = pInputData[1] > ThresholdValue ? 0x02 : 0;
Bits[2] = pInputData[2] > ThresholdValue ? 0x04 : 0;
Bits[3] = pInputData[3] > ThresholdValue ? 0x08 : 0;
Bits[4] = pInputData[4] > ThresholdValue ? 0x10 : 0;
Bits[5] = pInputData[5] > ThresholdValue ? 0x20 : 0;
Bits[6] = pInputData[6] > ThresholdValue ? 0x40 : 0;
Bits[7] = pInputData[7] > ThresholdValue ? 0x80 : 0;
*pOutputByte++ = Bits[0] | Bits[1] | Bits[2] | Bits[3] | Bits[4] | Bits[5] | Bits[6] | Bits[7];
pInputData += 8;
}
if(arrayLength & 7)
{
// note that we'll use max 7 elements, so max is Bits[6]... (otherwise we would get another full byte)
auto RestW = arrayLength & 7;
memset(Bits, 0, 8);
for(unsigned long long i = 0; i < RestW; ++i)
{
Bits[i] = *pInputData > ThresholdValue ? 1 << i : 0;
pInputData++;
}
*pOutputByte++ = Bits[0] | Bits[1] | Bits[2] | Bits[3] | Bits[4] | Bits[5] | Bits[6];
}
}
struct bool8
{
bool8() : val0(0), val1(0), val2(0), val3(0), val4(0), val5(0), val6(0), val7(0)
{
}
bool8(bool v0, bool v1, bool v2, bool v3, bool v4, bool v5, bool v6, bool v7)
: val0(v0), val1(v1), val2(v2), val3(v3), val4(v4), val5(v5), val6(v6), val7(v7)
{
}
uint8_t val0 : 1;
uint8_t val1 : 1;
uint8_t val2 : 1;
uint8_t val3 : 1;
uint8_t val4 : 1;
uint8_t val5 : 1;
uint8_t val6 : 1;
uint8_t val7 : 1;
};
class PackedStructFixture : public CompressBoolsFixture
{
public:
virtual void setUp(int64_t experimentValue) override
{
CompressBoolsFixture::setUp(experimentValue);
this->numBytes = static_cast<unsigned int>((experimentValue + 7) / 8);
this->numFullBytes = static_cast<unsigned int>((experimentValue) / 8);
this->outputValues.reset(new bool8[numBytes]);
}
virtual void tearDown() override
{
for(size_t i = 0; i < arrayLength; ++i)
{
Checker(getBoolAt(i), referenceValues[i], i);
}
}
bool getBoolAt(int64_t pos)
{
const auto bytePos = pos / 8;
const auto bitPos = pos % 8;
switch(bitPos)
{
case 0:
return (*(outputValues.get() + bytePos)).val0;
case 1:
return (*(outputValues.get() + bytePos)).val1;
case 2:
return (*(outputValues.get() + bytePos)).val2;
case 3:
return (*(outputValues.get() + bytePos)).val3;
case 4:
return (*(outputValues.get() + bytePos)).val4;
case 5:
return (*(outputValues.get() + bytePos)).val5;
case 6:
return (*(outputValues.get() + bytePos)).val6;
case 7:
return (*(outputValues.get() + bytePos)).val7;
}
return (*(outputValues.get() + bytePos)).val7;
}
unsigned int numBytes;
unsigned int numFullBytes;
std::unique_ptr<bool8[]> outputValues;
};
BENCHMARK_F(CompressBoolsTest, PackedStructVersion, PackedStructFixture, SamplesCount, IterationsCount)
{
const int64_t lenDivBy8 = (arrayLength / 8) * 8;
auto pInputData = inputValues.get();
auto pOutputByte = outputValues.get();
bool8 out;
for(int64_t j = 0; j < lenDivBy8; j += 8)
{
out.val0 = pInputData[0] > ThresholdValue;
out.val1 = pInputData[1] > ThresholdValue;
out.val2 = pInputData[2] > ThresholdValue;
out.val3 = pInputData[3] > ThresholdValue;
out.val4 = pInputData[4] > ThresholdValue;
out.val5 = pInputData[5] > ThresholdValue;
out.val6 = pInputData[6] > ThresholdValue;
out.val7 = pInputData[7] > ThresholdValue;
*pOutputByte++ = out;
pInputData += 8;
}
if(arrayLength & 7)
{
auto RestW = arrayLength & 7;
out = {false, false, false, false, false, false, false, false};
if(RestW > 6)
{
out.val6 = pInputData[6] > ThresholdValue;
}
if(RestW > 5)
{
out.val5 = pInputData[5] > ThresholdValue;
}
if(RestW > 4)
{
out.val4 = pInputData[4] > ThresholdValue;
}
if(RestW > 3)
{
out.val3 = pInputData[3] > ThresholdValue;
}
if(RestW > 2)
{
out.val2 = pInputData[2] > ThresholdValue;
}
if(RestW > 1)
{
out.val1 = pInputData[1] > ThresholdValue;
}
if(RestW > 0)
{
out.val0 = pInputData[0] > ThresholdValue;
}
*pOutputByte++ = out;
}
}
BENCHMARK_F(CompressBoolsTest, WithOpenMP, ManualVersionFixture, SamplesCount, IterationsCount)
{
uint8_t Bits[8];
#pragma omp parallel for private(Bits)
for(unsigned int i = 0; i < numFullBytes; ++i)
{
auto pInputData = inputValues.get() + i * 8;
Bits[0] = pInputData[0] > ThresholdValue ? 0x01 : 0;
Bits[1] = pInputData[1] > ThresholdValue ? 0x02 : 0;
Bits[2] = pInputData[2] > ThresholdValue ? 0x04 : 0;
Bits[3] = pInputData[3] > ThresholdValue ? 0x08 : 0;
Bits[4] = pInputData[4] > ThresholdValue ? 0x10 : 0;
Bits[5] = pInputData[5] > ThresholdValue ? 0x20 : 0;
Bits[6] = pInputData[6] > ThresholdValue ? 0x40 : 0;
Bits[7] = pInputData[7] > ThresholdValue ? 0x80 : 0;
this->outputValues.get()[i] = Bits[0] | Bits[1] | Bits[2] | Bits[3] | Bits[4] | Bits[5] | Bits[6] | Bits[7];
}
if(numFullBytes < numBytes)
{
uint8_t Bits2[8] = {0};
auto RestW = arrayLength & 7;
auto pInputData = inputValues.get() + numFullBytes * 8;
for(unsigned long long i = 0; i < RestW; ++i)
{
Bits2[i] = *pInputData > ThresholdValue ? 1 << i : 0;
pInputData++;
}
this->outputValues.get()[numFullBytes] = Bits2[0] | Bits2[1] | Bits2[2] | Bits2[3] | Bits2[4] | Bits2[5] | Bits2[6];
}
}
class SimdVersionFixture : public CompressBoolsFixture
{
public:
virtual void setUp(int64_t experimentValue) override
{
CompressBoolsFixture::setUp(experimentValue);
this->numBytes = static_cast<unsigned int>((experimentValue + 7) / 8);
this->numFullBytes = static_cast<unsigned int>((experimentValue) / 8);
this->alignedOutputValues = (uint8_t*)_aligned_malloc(numBytes, 16);
this->signedInputValues.reset(new int8_t[arrayLength]);
for(size_t i = 0; i < this->arrayLength; ++i)
{
this->signedInputValues[i] = static_cast<int8_t>(this->inputValues[i] - 128);
}
}
virtual void tearDown() override
{
for(size_t i = 0; i < this->arrayLength; ++i)
{
Checker(GetBoolAt(i, this->alignedOutputValues), this->referenceValues[i], i);
}
if(this->alignedOutputValues)
{
_aligned_free(this->alignedOutputValues);
this->alignedOutputValues = nullptr;
}
}
unsigned int numBytes;
unsigned int numFullBytes;
uint8_t* alignedOutputValues{nullptr};
std::unique_ptr<int8_t[]> signedInputValues;
};
BENCHMARK_F(CompressBoolsTest, SimdVersion, SimdVersionFixture, SamplesCount, IterationsCount)
{
uint16_t Bits[16] = {0};
const size_t lenDiv16y16 = (arrayLength / 16) * 16; // full packs of 16 values...
const __m128i sse127 = _mm_set1_epi8(127);
const int8_t ConvertedThreshold = ThresholdValue - 128;
const __m128i sseThresholds = _mm_set1_epi8(ConvertedThreshold);
auto pInputData = signedInputValues.get();
auto pOutputByte = alignedOutputValues;
for(size_t j = 0; j < lenDiv16y16; j += 16)
{
const auto in16Values =
_mm_set_epi8(pInputData[15], pInputData[14], pInputData[13], pInputData[12], pInputData[11], pInputData[10], pInputData[9], pInputData[8],
pInputData[7], pInputData[6], pInputData[5], pInputData[4], pInputData[3], pInputData[2], pInputData[1], pInputData[0]);
const auto cmpRes = _mm_cmpgt_epi8(in16Values, sseThresholds);
const auto packed = _mm_movemask_epi8(cmpRes);
*((uint16_t*)pOutputByte) = static_cast<uint16_t>(packed);
pOutputByte += 2;
pInputData += 16;
}
if(arrayLength & 15)
{
auto RestW = arrayLength & 15;
memset(Bits, 0, 16 * sizeof(uint16_t));
for(size_t i = 0; i < RestW; ++i)
{
Bits[i] = *pInputData > ConvertedThreshold ? 1 << i : 0;
pInputData++;
}
*pOutputByte++ = static_cast<uint8_t>(Bits[0] | Bits[1] | Bits[2] | Bits[3] | Bits[4] | Bits[5] | Bits[6] | Bits[7]);
if(RestW > 8)
{
*pOutputByte++ = (Bits[8] | Bits[9] | Bits[10] | Bits[11] | Bits[12] | Bits[13] | Bits[14] | Bits[15]) >> 8;
}
}
} | [
"[email protected]"
] | |
4f214d30bf68b990cad0585ebb11dce13174c57a | 32c6645f0110c5a650c7212d1f6050330d165a26 | /os/android/iahwc2.h | bd8c971c3717ff953194b1b446a58db692fc8557 | [] | no_license | XiaosongWei/IA-Hardware-Composer | de6c9f7fd2c6101f55ef41c462345a066764f3c8 | 8b5ec048013b78b45294d3ea336154b637a939ce | refs/heads/master | 2021-09-03T21:49:27.654679 | 2017-09-12T12:23:04 | 2017-09-12T12:33:13 | 103,377,960 | 0 | 0 | null | 2017-09-13T09:04:50 | 2017-09-13T09:04:50 | null | UTF-8 | C++ | false | false | 10,601 | h | /*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OS_ANDROID_IAHWC2_H_
#define OS_ANDROID_IAHWC2_H_
#include <hardware/hwcomposer2.h>
#include <gpudevice.h>
#include <hwclayer.h>
#include <platformdefines.h>
#include <map>
#include <utility>
#include "hwcservice.h"
namespace hwcomposer {
class GpuDevice;
class NativeDisplay;
}
namespace android {
class HwcService;
class IAHWC2 : public hwc2_device_t {
public:
static int HookDevOpen(const struct hw_module_t *module, const char *name,
struct hw_device_t **dev);
IAHWC2();
HWC2::Error Init();
hwcomposer::NativeDisplay *GetPrimaryDisplay();
hwcomposer::NativeDisplay *GetExtendedDisplay(uint32_t);
private:
class Hwc2Layer {
public:
HWC2::Composition sf_type() const {
return sf_type_;
}
HWC2::Composition validated_type() const {
return validated_type_;
}
void accept_type_change() {
sf_type_ = validated_type_;
}
void set_validated_type(HWC2::Composition type) {
validated_type_ = type;
}
bool type_changed() const {
return sf_type_ != validated_type_;
}
uint32_t z_order() const {
return hwc_layer_.GetZorder();
}
void set_buffer(buffer_handle_t buffer) {
native_handle_.handle_ = buffer;
hwc_layer_.SetNativeHandle(&native_handle_);
}
void set_acquire_fence(int acquire_fence) {
if (acquire_fence > 0)
hwc_layer_.SetAcquireFence(dup(acquire_fence));
}
hwcomposer::HwcLayer *GetLayer() {
return &hwc_layer_;
}
bool IsCursorLayer() const {
return is_cursor_layer_;
}
// Layer hooks
HWC2::Error SetCursorPosition(int32_t x, int32_t y);
HWC2::Error SetLayerBlendMode(int32_t mode);
HWC2::Error SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence);
HWC2::Error SetLayerColor(hwc_color_t color);
HWC2::Error SetLayerCompositionType(int32_t type);
HWC2::Error SetLayerDataspace(int32_t dataspace);
HWC2::Error SetLayerDisplayFrame(hwc_rect_t frame);
HWC2::Error SetLayerPlaneAlpha(float alpha);
HWC2::Error SetLayerSidebandStream(const native_handle_t *stream);
HWC2::Error SetLayerSourceCrop(hwc_frect_t crop);
HWC2::Error SetLayerSurfaceDamage(hwc_region_t damage);
HWC2::Error SetLayerTransform(int32_t transform);
HWC2::Error SetLayerVisibleRegion(hwc_region_t visible);
HWC2::Error SetLayerZOrder(uint32_t z);
private:
// sf_type_ stores the initial type given to us by surfaceflinger,
// validated_type_ stores the type after running ValidateDisplay
HWC2::Composition sf_type_ = HWC2::Composition::Invalid;
HWC2::Composition validated_type_ = HWC2::Composition::Invalid;
bool is_cursor_layer_ = false;
android_dataspace_t dataspace_ = HAL_DATASPACE_UNKNOWN;
hwcomposer::HwcLayer hwc_layer_;
struct gralloc_handle native_handle_;
};
class HwcDisplay {
public:
HwcDisplay();
HwcDisplay(const HwcDisplay &) = delete;
HWC2::Error Init(hwcomposer::NativeDisplay *display, int display_index,
bool disable_explicit_sync);
HWC2::Error InitVirtualDisplay(hwcomposer::NativeDisplay *display,
uint32_t width, uint32_t height,
bool disable_explicit_sync);
HWC2::Error RegisterVsyncCallback(hwc2_callback_data_t data,
hwc2_function_pointer_t func);
HWC2::Error RegisterRefreshCallback(hwc2_callback_data_t data,
hwc2_function_pointer_t func);
HWC2::Error RegisterHotPlugCallback(hwc2_callback_data_t data,
hwc2_function_pointer_t func);
// HWC Hooks
HWC2::Error AcceptDisplayChanges();
HWC2::Error CreateLayer(hwc2_layer_t *layer);
HWC2::Error DestroyLayer(hwc2_layer_t layer);
HWC2::Error GetActiveConfig(hwc2_config_t *config);
HWC2::Error GetChangedCompositionTypes(uint32_t *num_elements,
hwc2_layer_t *layers,
int32_t *types);
HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height,
int32_t format, int32_t dataspace);
HWC2::Error GetColorModes(uint32_t *num_modes, int32_t *modes);
HWC2::Error GetDisplayAttribute(hwc2_config_t config, int32_t attribute,
int32_t *value);
HWC2::Error GetDisplayConfigs(uint32_t *num_configs,
hwc2_config_t *configs);
HWC2::Error GetDisplayName(uint32_t *size, char *name);
HWC2::Error GetDisplayRequests(int32_t *display_requests,
uint32_t *num_elements, hwc2_layer_t *layers,
int32_t *layer_requests);
HWC2::Error GetDisplayType(int32_t *type);
HWC2::Error GetDozeSupport(int32_t *support);
HWC2::Error GetHdrCapabilities(uint32_t *num_types, int32_t *types,
float *max_luminance,
float *max_average_luminance,
float *min_luminance);
HWC2::Error GetReleaseFences(uint32_t *num_elements, hwc2_layer_t *layers,
int32_t *fences);
HWC2::Error PresentDisplay(int32_t *retire_fence);
HWC2::Error SetActiveConfig(hwc2_config_t config);
HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
int32_t dataspace, hwc_region_t damage);
HWC2::Error SetColorMode(int32_t mode);
HWC2::Error SetColorTransform(const float *matrix, int32_t hint);
HWC2::Error SetOutputBuffer(buffer_handle_t buffer, int32_t release_fence);
HWC2::Error SetPowerMode(int32_t mode);
HWC2::Error SetVsyncEnabled(int32_t enabled);
HWC2::Error ValidateDisplay(uint32_t *num_types, uint32_t *num_requests);
Hwc2Layer &get_layer(hwc2_layer_t layer) {
return layers_.at(layer);
}
hwcomposer::NativeDisplay *GetDisplay();
private:
hwcomposer::NativeDisplay *display_ = NULL;
hwc2_display_t handle_;
HWC2::DisplayType type_;
int layer_idx_ = 0;
std::map<hwc2_layer_t, Hwc2Layer> layers_;
Hwc2Layer client_layer_;
int32_t color_mode_;
uint32_t frame_no_ = 0;
// True after validateDisplay
bool checkValidateDisplay = false;
bool disable_explicit_sync_ = false;
};
static IAHWC2 *toIAHWC2(hwc2_device_t *dev) {
return static_cast<IAHWC2 *>(dev);
}
template <typename PFN, typename T>
static hwc2_function_pointer_t ToHook(T function) {
static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer");
return reinterpret_cast<hwc2_function_pointer_t>(function);
}
template <typename T, typename HookType, HookType func, typename... Args>
static T DeviceHook(hwc2_device_t *dev, Args... args) {
IAHWC2 *hwc = toIAHWC2(dev);
return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...));
}
template <typename HookType, HookType func, typename... Args>
static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
Args... args) {
IAHWC2 *hwc = toIAHWC2(dev);
if (display_handle == HWC_DISPLAY_PRIMARY) {
HwcDisplay &display = hwc->primary_display_;
return static_cast<int32_t>((display.*func)(std::forward<Args>(args)...));
}
if (display_handle == HWC_DISPLAY_VIRTUAL) {
return static_cast<int32_t>(
(hwc->virtual_display_.*func)(std::forward<Args>(args)...));
}
// TODO(kalyank): How do we map extended display id in case of more than
// one external display.
HwcDisplay *display = hwc->extended_displays_.at(0).get();
return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...));
}
template <typename HookType, HookType func, typename... Args>
static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle,
hwc2_layer_t layer_handle, Args... args) {
IAHWC2 *hwc = toIAHWC2(dev);
if (display_handle == HWC_DISPLAY_PRIMARY) {
HwcDisplay &display = hwc->primary_display_;
Hwc2Layer &layer = display.get_layer(layer_handle);
return static_cast<int32_t>((layer.*func)(std::forward<Args>(args)...));
}
if (display_handle == HWC_DISPLAY_VIRTUAL) {
Hwc2Layer &layer = hwc->virtual_display_.get_layer(layer_handle);
return static_cast<int32_t>((layer.*func)(std::forward<Args>(args)...));
}
// TODO(kalyank): How do we map extended display id in case of more than
// one external display.
HwcDisplay *display = hwc->extended_displays_.at(0).get();
Hwc2Layer &layer = display->get_layer(layer_handle);
return static_cast<int32_t>((layer.*func)(std::forward<Args>(args)...));
}
// hwc2_device_t hooks
static int HookDevClose(hw_device_t *dev);
static void HookDevGetCapabilities(hwc2_device_t *dev, uint32_t *out_count,
int32_t *out_capabilities);
static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device *device,
int32_t descriptor);
// Device functions
HWC2::Error CreateVirtualDisplay(uint32_t width, uint32_t height,
int32_t *format, hwc2_display_t *display);
HWC2::Error DestroyVirtualDisplay(hwc2_display_t display);
void Dump(uint32_t *size, char *buffer);
uint32_t GetMaxVirtualDisplayCount();
HWC2::Error RegisterCallback(int32_t descriptor, hwc2_callback_data_t data,
hwc2_function_pointer_t function);
hwcomposer::GpuDevice device_;
std::vector<std::unique_ptr<HwcDisplay>> extended_displays_;
HwcDisplay primary_display_;
HwcDisplay virtual_display_;
bool disable_explicit_sync_ = false;
android::HwcService hwcService_;
};
} // namespace android
#endif // OS_ANDROID_IAHWC2_H_
| [
"[email protected]"
] | |
41924ea29aae6c73682c9c4ed9cd09e555cc12c2 | 58cc7a560ad992154edc61d1f290d0eaafe0c262 | /AODVsecond/AODVsecond.ino/tableRouting.ino | dc51687dfc84b27596d69c71c75a9b2a8136826f | [] | no_license | wahyuLittleSamurai/AODV-Arduino-With-NRF | 059ee9779179a991c925acb26d037bb3ab40ff9e | d3294ad099f00f560b279870b4cc91c07e91adbe | refs/heads/master | 2020-03-31T07:40:45.864642 | 2018-10-08T08:24:17 | 2018-10-08T08:24:17 | 152,030,592 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,318 | ino | void tableRouting()
{
int idNode = valSplitNode[banyakNodeYgDiLalui].toInt(); //dari id node X
int panjangString = valSplit[4].length(); //panjang Route Sekarang
int panjangRouteBefore = hasilRouting[idNode][0].length();//panjang Route Sebelumnya
if(panjangString < panjangRouteBefore || panjangRouteBefore == 0)//cari jalur terpendek dari sebelumnya
{
hasilRouting[idNode][0] = valSplit[4];
//Serial.println(hasilRouting[idNode][0]);
}
else
{
//Serial.println("Lebih Jauh");
}
}
void showTblRouting()
{
Serial.println("########## Table Routing #######");
for(int node = 2; node <= nodeClient; node++)
{
Serial.print("Node Ke ");
Serial.print(node);
Serial.print(" ");
Serial.println(hasilRouting[node][0]);
}
Serial.println("########## ------------- #######");
}
void showFromNodeData()
{
Serial.println("########## Data AODV #######");
Serial.print("Data RAW: ");
Serial.println(data);
Serial.print("From :");
Serial.println(valSplitNode[banyakNodeYgDiLalui]);
Serial.print("Route :");
Serial.println(valSplit[4]);
Serial.print("Message :");
Serial.println(valSplit[3]);
Serial.println("########### END ################");
int nodeActive = valSplitNode[banyakNodeYgDiLalui].toInt();
active[nodeActive] = true;
}
| [
"[email protected]"
] | |
6f6bffba2664de554d9ea7f7c8d5b5c2363029ac | fb95534e8519acb3670ee9743ddb15bf09232e70 | /src/xtd.core/include/xtd/async_callback.h | 5729cdd7d59cfa8c551815139a73fc3c2698e462 | [
"MIT"
] | permissive | niansa/xtd | a5050e27fda1f092cea85db264820d6518994893 | 4d412ab046f51da2e5baf782f9f2f5bb23c49840 | refs/heads/master | 2023-09-01T01:13:25.592979 | 2021-10-28T14:30:05 | 2021-10-28T14:30:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 652 | h | /// @file
/// @brief Contains xtd::action delegate.
/// @copyright Copyright (c) 2021 Gammasoft. All rights reserved.
#pragma once
#include "delegate.h"
#include "iasync_result.h"
/// @brief The xtd namespace contains all fundamental classes to access Hardware, Os, System, and more.
namespace xtd {
/// @brief References a method to be called when a corresponding asynchronous operation completes.
/// @param ar The result of the asynchronous operation.
/// @par Namespace
/// xtd
/// @par Library
/// xtd.core
/// @ingroup xtd_core
using async_callback = delegate<void(std::shared_ptr<xtd::iasync_result> ar)>;
}
| [
"[email protected]"
] | |
228d8feed40a81a52b8451b2dfd9191348e7b796 | 2277375bd4a554d23da334dddd091a36138f5cae | /ThirdParty/Havok/Source/Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h | 0d0c93b37f303513f0e28df9b6f46ed2adb08dc9 | [] | no_license | kevinmore/Project-Nebula | 9a0553ccf8bdc1b4bb5e2588fc94516d9e3532bc | f6d284d4879ae1ea1bd30c5775ef8733cfafa71d | refs/heads/master | 2022-10-22T03:55:42.596618 | 2020-06-19T09:07:07 | 2020-06-19T09:07:07 | 25,372,691 | 6 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 4,876 | h | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2013 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#ifndef HK_COLLIDE2_CAPSULE_SHAPE_H
#define HK_COLLIDE2_CAPSULE_SHAPE_H
#include <Physics2012/Collide/Shape/Convex/hkpConvexShape.h>
extern const hkClass hkpCapsuleShapeClass;
/// A capsule defined by two points and a radius.
/// The points are stored internally as hkSpheres, each point being the center of one of the
/// end spheres of the capsule.
class hkpCapsuleShape : public hkpConvexShape
{
public:
HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_SHAPE);
HK_DECLARE_REFLECTION();
HKCD_DECLARE_SHAPE_TYPE(hkcdShapeType::CAPSULE);
HK_DECLARE_GET_SIZE_FOR_SPU(hkpCapsuleShape);
public:
/// For raycasting, the part of the shape hit.
enum RayHitType
{
HIT_CAP0,
HIT_CAP1,
HIT_BODY,
};
public:
/// Empty constructor, to be called by the shape vtable util on SPU
HK_FORCE_INLINE hkpCapsuleShape()
{}
/// Creates a new hkpCapsuleShape using the specified points and radius
hkpCapsuleShape( const hkVector4& vertexA,const hkVector4& vertexB, hkReal radius );
/// Allocates a new capsule shape at the given memory location
static HK_FORCE_INLINE hkpCapsuleShape* HK_CALL createInPlace(hkUint8*& memPtr, const hkVector4& vertexA,const hkVector4& vertexB, hkReal radius);
public:
// hkpShapeBase interface implementation.
virtual HK_FORCE_INLINE void getSupportingVertex(hkVector4Parameter direction, hkcdVertex& supportingVertexOut) const;
// hkpShapeBase interface implementation.
virtual HK_FORCE_INLINE void convertVertexIdsToVertices(const hkpVertexId* ids, int numIds, hkcdVertex* verticesOut) const;
// hkpShapeBase interface implementation.
virtual HK_FORCE_INLINE void getCentre(hkVector4& centreOut) const;
// hkpShapeBase interface implementation.
virtual HK_FORCE_INLINE int getNumCollisionSpheres() const;
// hkpShapeBase interface implementation.
virtual const hkSphere* getCollisionSpheres(hkSphere* sphereBuffer) const;
// hkpShapeBase interface implementation.
virtual void getAabb(const hkTransform& localToWorld, hkReal tolerance, hkAabb& out) const;
// hkpShapeBase interface implementation.
virtual hkBool castRay(const hkpShapeRayCastInput& input, hkpShapeRayCastOutput& results) const;
public:
/// Gets the pointer to the first vertex. This casts the corresponding hkSphere (m_vertexA) to a hkVector4*.
/// You can then index by 0 or 1, to get the first or second vertex respectively.
inline const hkVector4* getVertices() const;
/// Gets a vertex given an index "i". "i" can be 0 or 1. This casts the corresponding hkSphere to a hkVector4.
HK_FORCE_INLINE const hkVector4& getVertex(int i) const;
template <int I> HK_FORCE_INLINE const hkVector4& getVertex() const;
/// Sets a vertex given an index "i". "i" can be 0 or 1.
HK_FORCE_INLINE void setVertex(int i, const hkVector4& position );
template <int I> HK_FORCE_INLINE void setVertex(hkVector4Parameter position );
#ifndef HK_PLATFORM_SPU
/// Serialization constructor
hkpCapsuleShape( hkFinishLoadedObjectFlag flag );
// hkpConvexShape interface implementation.
virtual void getFirstVertex(hkVector4& v) const;
#endif //HK_PLATFORM_SPU
public:
static void HK_CALL closestPointLineSeg( const hkVector4& A, const hkVector4& B, const hkVector4& B2, hkVector4& pt );
static void HK_CALL closestInfLineSegInfLineSeg( const hkVector4& A, const hkVector4& dA, const hkVector4& B, const hkVector4& dB, hkReal& distSquared, hkReal& t, hkReal &u, hkVector4& p, hkVector4& q );
protected:
// The line's first point.
hkVector4 m_vertexA;
// The line's second point.
hkVector4 m_vertexB;
};
#include <Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.inl>
#endif // HK_COLLIDE2_CAPSULE_SHAPE_H
/*
* Havok SDK - Base file, BUILD(#20130912)
*
* Confidential Information of Havok. (C) Copyright 1999-2013
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available from [email protected].
*
*/
| [
"[email protected]"
] | |
bfdcf320b8b080bb69dc9c33a470d4e26914135d | 3236ab814706b0b21e8c70224eabc593ccb4e79d | /kody aplikacji/ri.h | 53d6273396f6044559ad5d8c5ad3762046c7b2ee | [] | no_license | krenciok12/repo-praca-magisterska | 88e94eafc28d0d9177a4539eab2d47d39cefb705 | eda553b1491f918334e4795c1adf6dd59d6cd0a9 | refs/heads/main | 2023-07-01T00:32:25.536547 | 2021-08-05T13:11:36 | 2021-08-05T13:11:36 | 393,044,408 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 632 | h | #ifndef RI_H
#define RI_H
#include <vector>
#include <iostream>
#include <map>
#include "graph.h"
#include <set>
#include <utility>
struct Rank{
Rank(int m, int i, int vis, int neig, int unv, int m_degree);
int m;
int i;
int vis;
int neig;
int unv;
int m_degree;
void clear();
int check(int sm, int si, int svis, int sneig, int sunv, int sm_degree);
};
std::pair<std::vector<std::vector<int>>, std::vector<int>> gtf(Graph * g1);
bool feasibility(Graph * g1, Graph *g2, std::map<int,int> m, std::vector<int> m1, std::vector<int> m2, int k1, int k2);
std::map<int,int> ri_gi(Graph * g1, Graph *g2);
#endif
| [
"[email protected]"
] | |
ef1c9eae8448c2645e7f532c7c1312a0390d2d8a | 4b02a9cb6d43492c8eaee1f79156a372e61ba2cc | /src/util.cpp | 6e9c3be3bad5b0efc7e1049689501b2885742917 | [
"MIT"
] | permissive | SamaritanProject/SamaritanCoin | 7073278e2602129424a1b625d239ddf9eb7535dd | 8abdf1784a8601593e56b3eb6c377731a2dac85e | refs/heads/master | 2021-05-07T08:53:27.420646 | 2017-11-10T17:14:54 | 2017-11-10T17:14:54 | 109,426,010 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37,971 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "util.h"
#include "sync.h"
#include "strlcpy.h"
#include "version.h"
#include "ui_interface.h"
#include <boost/algorithm/string/join.hpp>
// Work around clang compilation problem in Boost 1.46:
// /usr/include/boost/program_options/detail/config_file.hpp:163:17: error: call to function 'to_internal' that is neither visible in the template definition nor found by argument-dependent lookup
// See also: http://stackoverflow.com/questions/10020179/compilation-fail-in-boost-librairies-program-options
// http://clang.debian.net/status.php?version=3.0&key=CANNOT_FIND_FUNCTION
namespace boost {
namespace program_options {
std::string to_internal(const std::string&);
}
}
#include <boost/program_options/detail/config_file.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/foreach.hpp>
#include <boost/thread.hpp>
#include <openssl/crypto.h>
#include <openssl/rand.h>
#include <stdarg.h>
#ifdef WIN32
#ifdef _MSC_VER
#pragma warning(disable:4786)
#pragma warning(disable:4804)
#pragma warning(disable:4805)
#pragma warning(disable:4717)
#endif
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <io.h> /* for _commit */
#include "shlobj.h"
#elif defined(__linux__)
# include <sys/prctl.h>
#endif
using namespace std;
map<string, string> mapArgs;
map<string, vector<string> > mapMultiArgs;
bool fDebug = false;
bool fDebugNet = false;
bool fPrintToConsole = false;
bool fPrintToDebugger = false;
bool fRequestShutdown = false;
bool fShutdown = false;
bool fDaemon = false;
bool fServer = false;
bool fCommandLine = false;
string strMiscWarning;
bool fTestNet = false;
bool fNoListen = false;
bool fLogTimestamps = false;
CMedianFilter<int64_t> vTimeOffsets(200,0);
bool fReopenDebugLog = false;
// Init OpenSSL library multithreading support
static CCriticalSection** ppmutexOpenSSL;
void locking_callback(int mode, int i, const char* file, int line)
{
if (mode & CRYPTO_LOCK) {
ENTER_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
} else {
LEAVE_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
}
}
LockedPageManager LockedPageManager::instance;
// Init
class CInit
{
public:
CInit()
{
// Init OpenSSL library multithreading support
ppmutexOpenSSL = (CCriticalSection**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(CCriticalSection*));
for (int i = 0; i < CRYPTO_num_locks(); i++)
ppmutexOpenSSL[i] = new CCriticalSection();
CRYPTO_set_locking_callback(locking_callback);
#ifdef WIN32
// Seed random number generator with screen scrape and other hardware sources
RAND_screen();
#endif
// Seed random number generator with performance counter
RandAddSeed();
}
~CInit()
{
// Shutdown OpenSSL library multithreading support
CRYPTO_set_locking_callback(NULL);
for (int i = 0; i < CRYPTO_num_locks(); i++)
delete ppmutexOpenSSL[i];
OPENSSL_free(ppmutexOpenSSL);
}
}
instance_of_cinit;
void RandAddSeed()
{
// Seed with CPU performance counter
int64_t nCounter = GetPerformanceCounter();
RAND_add(&nCounter, sizeof(nCounter), 1.5);
memset(&nCounter, 0, sizeof(nCounter));
}
void RandAddSeedPerfmon()
{
RandAddSeed();
// This can take up to 2 seconds, so only do it every 10 minutes
static int64_t nLastPerfmon;
if (GetTime() < nLastPerfmon + 10 * 60)
return;
nLastPerfmon = GetTime();
#ifdef WIN32
// Don't need this on Linux, OpenSSL automatically uses /dev/urandom
// Seed with the entire set of perfmon data
unsigned char pdata[250000];
memset(pdata, 0, sizeof(pdata));
unsigned long nSize = sizeof(pdata);
long ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, pdata, &nSize);
RegCloseKey(HKEY_PERFORMANCE_DATA);
if (ret == ERROR_SUCCESS)
{
RAND_add(pdata, nSize, nSize/100.0);
memset(pdata, 0, nSize);
printf("RandAddSeed() %lu bytes\n", nSize);
}
#endif
}
uint64_t GetRand(uint64_t nMax)
{
if (nMax == 0)
return 0;
// The range of the random source must be a multiple of the modulus
// to give every possible output value an equal possibility
uint64_t nRange = (std::numeric_limits<uint64_t>::max() / nMax) * nMax;
uint64_t nRand = 0;
do
RAND_bytes((unsigned char*)&nRand, sizeof(nRand));
while (nRand >= nRange);
return (nRand % nMax);
}
int GetRandInt(int nMax)
{
return GetRand(nMax);
}
uint256 GetRandHash()
{
uint256 hash;
RAND_bytes((unsigned char*)&hash, sizeof(hash));
return hash;
}
inline int OutputDebugStringF(const char* pszFormat, ...)
{
int ret = 0;
if (fPrintToConsole)
{
// print to console
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret = vprintf(pszFormat, arg_ptr);
va_end(arg_ptr);
}
else if (!fPrintToDebugger)
{
// print to debug.log
static FILE* fileout = NULL;
if (!fileout)
{
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
fileout = fopen(pathDebug.string().c_str(), "a");
if (fileout) setbuf(fileout, NULL); // unbuffered
}
if (fileout)
{
static bool fStartedNewLine = true;
// This routine may be called by global destructors during shutdown.
// Since the order of destruction of static/global objects is undefined,
// allocate mutexDebugLog on the heap the first time this routine
// is called to avoid crashes during shutdown.
static boost::mutex* mutexDebugLog = NULL;
if (mutexDebugLog == NULL) mutexDebugLog = new boost::mutex();
boost::mutex::scoped_lock scoped_lock(*mutexDebugLog);
// reopen the log file, if requested
if (fReopenDebugLog) {
fReopenDebugLog = false;
boost::filesystem::path pathDebug = GetDataDir() / "debug.log";
if (freopen(pathDebug.string().c_str(),"a",fileout) != NULL)
setbuf(fileout, NULL); // unbuffered
}
// Debug print useful for profiling
if (fLogTimestamps && fStartedNewLine)
fprintf(fileout, "%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
if (pszFormat[strlen(pszFormat) - 1] == '\n')
fStartedNewLine = true;
else
fStartedNewLine = false;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret = vfprintf(fileout, pszFormat, arg_ptr);
va_end(arg_ptr);
}
}
#ifdef WIN32
if (fPrintToDebugger)
{
static CCriticalSection cs_OutputDebugStringF;
// accumulate and output a line at a time
{
LOCK(cs_OutputDebugStringF);
static std::string buffer;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
buffer += vstrprintf(pszFormat, arg_ptr);
va_end(arg_ptr);
int line_start = 0, line_end;
while((line_end = buffer.find('\n', line_start)) != -1)
{
OutputDebugStringA(buffer.substr(line_start, line_end - line_start).c_str());
line_start = line_end + 1;
}
buffer.erase(0, line_start);
}
}
#endif
return ret;
}
string vstrprintf(const char *format, va_list ap)
{
char buffer[50000];
char* p = buffer;
int limit = sizeof(buffer);
int ret;
while (true)
{
va_list arg_ptr;
va_copy(arg_ptr, ap);
#ifdef WIN32
ret = _vsnprintf(p, limit, format, arg_ptr);
#else
ret = vsnprintf(p, limit, format, arg_ptr);
#endif
va_end(arg_ptr);
if (ret >= 0 && ret < limit)
break;
if (p != buffer)
delete[] p;
limit *= 2;
p = new char[limit];
if (p == NULL)
throw std::bad_alloc();
}
string str(p, p+ret);
if (p != buffer)
delete[] p;
return str;
}
string real_strprintf(const char *format, int dummy, ...)
{
va_list arg_ptr;
va_start(arg_ptr, dummy);
string str = vstrprintf(format, arg_ptr);
va_end(arg_ptr);
return str;
}
string real_strprintf(const std::string &format, int dummy, ...)
{
va_list arg_ptr;
va_start(arg_ptr, dummy);
string str = vstrprintf(format.c_str(), arg_ptr);
va_end(arg_ptr);
return str;
}
bool error(const char *format, ...)
{
va_list arg_ptr;
va_start(arg_ptr, format);
std::string str = vstrprintf(format, arg_ptr);
va_end(arg_ptr);
printf("ERROR: %s\n", str.c_str());
return false;
}
void ParseString(const string& str, char c, vector<string>& v)
{
if (str.empty())
return;
string::size_type i1 = 0;
string::size_type i2;
while (true)
{
i2 = str.find(c, i1);
if (i2 == str.npos)
{
v.push_back(str.substr(i1));
return;
}
v.push_back(str.substr(i1, i2-i1));
i1 = i2+1;
}
}
string FormatMoney(int64_t n, bool fPlus)
{
// Note: not using straight sprintf here because we do NOT want
// localized number formatting.
int64_t n_abs = (n > 0 ? n : -n);
int64_t quotient = n_abs/COIN;
int64_t remainder = n_abs%COIN;
string str = strprintf("%" PRId64 ".%08" PRId64 , quotient, remainder);
// Right-trim excess zeros before the decimal point:
int nTrim = 0;
for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i)
++nTrim;
if (nTrim)
str.erase(str.size()-nTrim, nTrim);
if (n < 0)
str.insert((unsigned int)0, 1, '-');
else if (fPlus && n > 0)
str.insert((unsigned int)0, 1, '+');
return str;
}
bool ParseMoney(const string& str, int64_t& nRet)
{
return ParseMoney(str.c_str(), nRet);
}
bool ParseMoney(const char* pszIn, int64_t& nRet)
{
string strWhole;
int64_t nUnits = 0;
const char* p = pszIn;
while (isspace(*p))
p++;
for (; *p; p++)
{
if (*p == '.')
{
p++;
int64_t nMult = CENT*10;
while (isdigit(*p) && (nMult > 0))
{
nUnits += nMult * (*p++ - '0');
nMult /= 10;
}
break;
}
if (isspace(*p))
break;
if (!isdigit(*p))
return false;
strWhole.insert(strWhole.end(), *p);
}
for (; *p; p++)
if (!isspace(*p))
return false;
if (strWhole.size() > 10) // guard against 63 bit overflow
return false;
if (nUnits < 0 || nUnits > COIN)
return false;
int64_t nWhole = atoi64(strWhole);
int64_t nValue = nWhole*COIN + nUnits;
nRet = nValue;
return true;
}
static const signed char phexdigit[256] =
{ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
bool IsHex(const string& str)
{
BOOST_FOREACH(unsigned char c, str)
{
if (phexdigit[c] < 0)
return false;
}
return (str.size() > 0) && (str.size()%2 == 0);
}
vector<unsigned char> ParseHex(const char* psz)
{
// convert hex dump to vector
vector<unsigned char> vch;
while (true)
{
while (isspace(*psz))
psz++;
signed char c = phexdigit[(unsigned char)*psz++];
if (c == (signed char)-1)
break;
unsigned char n = (c << 4);
c = phexdigit[(unsigned char)*psz++];
if (c == (signed char)-1)
break;
n |= c;
vch.push_back(n);
}
return vch;
}
vector<unsigned char> ParseHex(const string& str)
{
return ParseHex(str.c_str());
}
static void InterpretNegativeSetting(string name, map<string, string>& mapSettingsRet)
{
// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
if (name.find("-no") == 0)
{
std::string positive("-");
positive.append(name.begin()+3, name.end());
if (mapSettingsRet.count(positive) == 0)
{
bool value = !GetBoolArg(name);
mapSettingsRet[positive] = (value ? "1" : "0");
}
}
}
void ParseParameters(int argc, const char* const argv[])
{
mapArgs.clear();
mapMultiArgs.clear();
for (int i = 1; i < argc; i++)
{
char psz[10000];
strlcpy(psz, argv[i], sizeof(psz));
char* pszValue = (char*)"";
if (strchr(psz, '='))
{
pszValue = strchr(psz, '=');
*pszValue++ = '\0';
}
#ifdef WIN32
_strlwr(psz);
if (psz[0] == '/')
psz[0] = '-';
#endif
if (psz[0] != '-')
break;
mapArgs[psz] = pszValue;
mapMultiArgs[psz].push_back(pszValue);
}
// New 0.6 features:
BOOST_FOREACH(const PAIRTYPE(string,string)& entry, mapArgs)
{
string name = entry.first;
// interpret --foo as -foo (as long as both are not set)
if (name.find("--") == 0)
{
std::string singleDash(name.begin()+1, name.end());
if (mapArgs.count(singleDash) == 0)
mapArgs[singleDash] = entry.second;
name = singleDash;
}
// interpret -nofoo as -foo=0 (and -nofoo=0 as -foo=1) as long as -foo not set
InterpretNegativeSetting(name, mapArgs);
}
}
std::string GetArg(const std::string& strArg, const std::string& strDefault)
{
if (mapArgs.count(strArg))
return mapArgs[strArg];
return strDefault;
}
int64_t GetArg(const std::string& strArg, int64_t nDefault)
{
if (mapArgs.count(strArg))
return atoi64(mapArgs[strArg]);
return nDefault;
}
bool GetBoolArg(const std::string& strArg, bool fDefault)
{
if (mapArgs.count(strArg))
{
if (mapArgs[strArg].empty())
return true;
return (atoi(mapArgs[strArg]) != 0);
}
return fDefault;
}
bool SoftSetArg(const std::string& strArg, const std::string& strValue)
{
if (mapArgs.count(strArg))
return false;
mapArgs[strArg] = strValue;
return true;
}
bool SoftSetBoolArg(const std::string& strArg, bool fValue)
{
if (fValue)
return SoftSetArg(strArg, std::string("1"));
else
return SoftSetArg(strArg, std::string("0"));
}
string EncodeBase64(const unsigned char* pch, size_t len)
{
static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
string strRet="";
strRet.reserve((len+2)/3*4);
int mode=0, left=0;
const unsigned char *pchEnd = pch+len;
while (pch<pchEnd)
{
int enc = *(pch++);
switch (mode)
{
case 0: // we have no bits
strRet += pbase64[enc >> 2];
left = (enc & 3) << 4;
mode = 1;
break;
case 1: // we have two bits
strRet += pbase64[left | (enc >> 4)];
left = (enc & 15) << 2;
mode = 2;
break;
case 2: // we have four bits
strRet += pbase64[left | (enc >> 6)];
strRet += pbase64[enc & 63];
mode = 0;
break;
}
}
if (mode)
{
strRet += pbase64[left];
strRet += '=';
if (mode == 1)
strRet += '=';
}
return strRet;
}
string EncodeBase64(const string& str)
{
return EncodeBase64((const unsigned char*)str.c_str(), str.size());
}
vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
{
static const int decode64_table[256] =
{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
if (pfInvalid)
*pfInvalid = false;
vector<unsigned char> vchRet;
vchRet.reserve(strlen(p)*3/4);
int mode = 0;
int left = 0;
while (1)
{
int dec = decode64_table[(unsigned char)*p];
if (dec == -1) break;
p++;
switch (mode)
{
case 0: // we have no bits and get 6
left = dec;
mode = 1;
break;
case 1: // we have 6 bits and keep 4
vchRet.push_back((left<<2) | (dec>>4));
left = dec & 15;
mode = 2;
break;
case 2: // we have 4 bits and get 6, we keep 2
vchRet.push_back((left<<4) | (dec>>2));
left = dec & 3;
mode = 3;
break;
case 3: // we have 2 bits and get 6
vchRet.push_back((left<<6) | dec);
mode = 0;
break;
}
}
if (pfInvalid)
switch (mode)
{
case 0: // 4n base64 characters processed: ok
break;
case 1: // 4n+1 base64 character processed: impossible
*pfInvalid = true;
break;
case 2: // 4n+2 base64 characters processed: require '=='
if (left || p[0] != '=' || p[1] != '=' || decode64_table[(unsigned char)p[2]] != -1)
*pfInvalid = true;
break;
case 3: // 4n+3 base64 characters processed: require '='
if (left || p[0] != '=' || decode64_table[(unsigned char)p[1]] != -1)
*pfInvalid = true;
break;
}
return vchRet;
}
string DecodeBase64(const string& str)
{
vector<unsigned char> vchRet = DecodeBase64(str.c_str());
return string((const char*)&vchRet[0], vchRet.size());
}
string EncodeBase32(const unsigned char* pch, size_t len)
{
static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
string strRet="";
strRet.reserve((len+4)/5*8);
int mode=0, left=0;
const unsigned char *pchEnd = pch+len;
while (pch<pchEnd)
{
int enc = *(pch++);
switch (mode)
{
case 0: // we have no bits
strRet += pbase32[enc >> 3];
left = (enc & 7) << 2;
mode = 1;
break;
case 1: // we have three bits
strRet += pbase32[left | (enc >> 6)];
strRet += pbase32[(enc >> 1) & 31];
left = (enc & 1) << 4;
mode = 2;
break;
case 2: // we have one bit
strRet += pbase32[left | (enc >> 4)];
left = (enc & 15) << 1;
mode = 3;
break;
case 3: // we have four bits
strRet += pbase32[left | (enc >> 7)];
strRet += pbase32[(enc >> 2) & 31];
left = (enc & 3) << 3;
mode = 4;
break;
case 4: // we have two bits
strRet += pbase32[left | (enc >> 5)];
strRet += pbase32[enc & 31];
mode = 0;
}
}
static const int nPadding[5] = {0, 6, 4, 3, 1};
if (mode)
{
strRet += pbase32[left];
for (int n=0; n<nPadding[mode]; n++)
strRet += '=';
}
return strRet;
}
string EncodeBase32(const string& str)
{
return EncodeBase32((const unsigned char*)str.c_str(), str.size());
}
vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
{
static const int decode32_table[256] =
{
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
if (pfInvalid)
*pfInvalid = false;
vector<unsigned char> vchRet;
vchRet.reserve((strlen(p))*5/8);
int mode = 0;
int left = 0;
while (1)
{
int dec = decode32_table[(unsigned char)*p];
if (dec == -1) break;
p++;
switch (mode)
{
case 0: // we have no bits and get 5
left = dec;
mode = 1;
break;
case 1: // we have 5 bits and keep 2
vchRet.push_back((left<<3) | (dec>>2));
left = dec & 3;
mode = 2;
break;
case 2: // we have 2 bits and keep 7
left = left << 5 | dec;
mode = 3;
break;
case 3: // we have 7 bits and keep 4
vchRet.push_back((left<<1) | (dec>>4));
left = dec & 15;
mode = 4;
break;
case 4: // we have 4 bits, and keep 1
vchRet.push_back((left<<4) | (dec>>1));
left = dec & 1;
mode = 5;
break;
case 5: // we have 1 bit, and keep 6
left = left << 5 | dec;
mode = 6;
break;
case 6: // we have 6 bits, and keep 3
vchRet.push_back((left<<2) | (dec>>3));
left = dec & 7;
mode = 7;
break;
case 7: // we have 3 bits, and keep 0
vchRet.push_back((left<<5) | dec);
mode = 0;
break;
}
}
if (pfInvalid)
switch (mode)
{
case 0: // 8n base32 characters processed: ok
break;
case 1: // 8n+1 base32 characters processed: impossible
case 3: // +3
case 6: // +6
*pfInvalid = true;
break;
case 2: // 8n+2 base32 characters processed: require '======'
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || p[4] != '=' || p[5] != '=' || decode32_table[(unsigned char)p[6]] != -1)
*pfInvalid = true;
break;
case 4: // 8n+4 base32 characters processed: require '===='
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || p[3] != '=' || decode32_table[(unsigned char)p[4]] != -1)
*pfInvalid = true;
break;
case 5: // 8n+5 base32 characters processed: require '==='
if (left || p[0] != '=' || p[1] != '=' || p[2] != '=' || decode32_table[(unsigned char)p[3]] != -1)
*pfInvalid = true;
break;
case 7: // 8n+7 base32 characters processed: require '='
if (left || p[0] != '=' || decode32_table[(unsigned char)p[1]] != -1)
*pfInvalid = true;
break;
}
return vchRet;
}
string DecodeBase32(const string& str)
{
vector<unsigned char> vchRet = DecodeBase32(str.c_str());
return string((const char*)&vchRet[0], vchRet.size());
}
bool WildcardMatch(const char* psz, const char* mask)
{
while (true)
{
switch (*mask)
{
case '\0':
return (*psz == '\0');
case '*':
return WildcardMatch(psz, mask+1) || (*psz && WildcardMatch(psz+1, mask));
case '?':
if (*psz == '\0')
return false;
break;
default:
if (*psz != *mask)
return false;
break;
}
psz++;
mask++;
}
}
bool WildcardMatch(const string& str, const string& mask)
{
return WildcardMatch(str.c_str(), mask.c_str());
}
static std::string FormatException(std::exception* pex, const char* pszThread)
{
#ifdef WIN32
char pszModule[MAX_PATH] = "";
GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));
#else
const char* pszModule = "samaritan";
#endif
if (pex)
return strprintf(
"EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);
else
return strprintf(
"UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);
}
void PrintException(std::exception* pex, const char* pszThread)
{
std::string message = FormatException(pex, pszThread);
printf("\n\n************************\n%s\n", message.c_str());
fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
strMiscWarning = message;
throw;
}
void PrintExceptionContinue(std::exception* pex, const char* pszThread)
{
std::string message = FormatException(pex, pszThread);
printf("\n\n************************\n%s\n", message.c_str());
fprintf(stderr, "\n\n************************\n%s\n", message.c_str());
strMiscWarning = message;
}
boost::filesystem::path GetDefaultDataDir()
{
namespace fs = boost::filesystem;
// Windows < Vista: C:\Documents and Settings\Username\Application Data\samaritan
// Windows >= Vista: C:\Users\Username\AppData\Roaming\samaritan
// Mac: ~/Library/Application Support/samaritan
// Unix: ~/.samaritan
#ifdef WIN32
// Windows
return GetSpecialFolderPath(CSIDL_APPDATA) / "samaritan";
#else
fs::path pathRet;
char* pszHome = getenv("HOME");
if (pszHome == NULL || strlen(pszHome) == 0)
pathRet = fs::path("/");
else
pathRet = fs::path(pszHome);
#ifdef MAC_OSX
// Mac
pathRet /= "Library/Application Support";
fs::create_directory(pathRet);
return pathRet / "samaritan";
#else
// Unix
return pathRet / ".samaritan";
#endif
#endif
}
const boost::filesystem::path &GetDataDir(bool fNetSpecific)
{
namespace fs = boost::filesystem;
static fs::path pathCached[2];
static CCriticalSection csPathCached;
static bool cachedPath[2] = {false, false};
fs::path &path = pathCached[fNetSpecific];
// This can be called during exceptions by printf, so we cache the
// value so we don't have to do memory allocations after that.
if (cachedPath[fNetSpecific])
return path;
LOCK(csPathCached);
if (mapArgs.count("-datadir")) {
path = fs::system_complete(mapArgs["-datadir"]);
if (!fs::is_directory(path)) {
path = "";
return path;
}
} else {
path = GetDefaultDataDir();
}
if (fNetSpecific && GetBoolArg("-testnet", false))
path /= "testnet";
fs::create_directory(path);
cachedPath[fNetSpecific]=true;
return path;
}
boost::filesystem::path GetConfigFile()
{
boost::filesystem::path pathConfigFile(GetArg("-conf", "samaritan.conf"));
if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir(false) / pathConfigFile;
return pathConfigFile;
}
void ReadConfigFile(map<string, string>& mapSettingsRet,
map<string, vector<string> >& mapMultiSettingsRet)
{
boost::filesystem::ifstream streamConfig(GetConfigFile());
if (!streamConfig.good())
return; // No bitcoin.conf file is OK
set<string> setOptions;
setOptions.insert("*");
for (boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
{
// Don't overwrite existing settings so command line settings override bitcoin.conf
string strKey = string("-") + it->string_key;
if (mapSettingsRet.count(strKey) == 0)
{
mapSettingsRet[strKey] = it->value[0];
// interpret nofoo=1 as foo=0 (and nofoo=0 as foo=1) as long as foo not set)
InterpretNegativeSetting(strKey, mapSettingsRet);
}
mapMultiSettingsRet[strKey].push_back(it->value[0]);
}
}
boost::filesystem::path GetPidFile()
{
boost::filesystem::path pathPidFile(GetArg("-pid", "samaritand.pid"));
if (!pathPidFile.is_complete()) pathPidFile = GetDataDir() / pathPidFile;
return pathPidFile;
}
#ifndef WIN32
void CreatePidFile(const boost::filesystem::path &path, pid_t pid)
{
FILE* file = fopen(path.string().c_str(), "w");
if (file)
{
fprintf(file, "%d\n", pid);
fclose(file);
}
}
#endif
bool RenameOver(boost::filesystem::path src, boost::filesystem::path dest)
{
#ifdef WIN32
return MoveFileExA(src.string().c_str(), dest.string().c_str(),
MOVEFILE_REPLACE_EXISTING);
#else
int rc = std::rename(src.string().c_str(), dest.string().c_str());
return (rc == 0);
#endif /* WIN32 */
}
void FileCommit(FILE *fileout)
{
fflush(fileout); // harmless if redundantly called
#ifdef WIN32
_commit(_fileno(fileout));
#else
fsync(fileno(fileout));
#endif
}
void ShrinkDebugFile()
{
// Scroll debug.log if it's getting too big
boost::filesystem::path pathLog = GetDataDir() / "debug.log";
FILE* file = fopen(pathLog.string().c_str(), "r");
if (file && boost::filesystem::file_size(pathLog) > 10 * 1000000)
{
// Restart the file with some of the end
char pch[200000];
fseek(file, -sizeof(pch), SEEK_END);
int nBytes = fread(pch, 1, sizeof(pch), file);
fclose(file);
file = fopen(pathLog.string().c_str(), "w");
if (file)
{
fwrite(pch, 1, nBytes, file);
fclose(file);
}
}
}
//
// "Never go to sea with two chronometers; take one or three."
// Our three time sources are:
// - System clock
// - Median of other nodes clocks
// - The user (asking the user to fix the system clock if the first two disagree)
//
static int64_t nMockTime = 0; // For unit testing
int64_t GetTime()
{
if (nMockTime) return nMockTime;
return time(NULL);
}
void SetMockTime(int64_t nMockTimeIn)
{
nMockTime = nMockTimeIn;
}
static int64_t nTimeOffset = 0;
int64_t GetTimeOffset()
{
return nTimeOffset;
}
int64_t GetAdjustedTime()
{
return GetTime() + GetTimeOffset();
}
void AddTimeData(const CNetAddr& ip, int64_t nTime)
{
int64_t nOffsetSample = nTime - GetTime();
// Ignore duplicates
static set<CNetAddr> setKnown;
if (!setKnown.insert(ip).second)
return;
// Add data
vTimeOffsets.input(nOffsetSample);
printf("Added time data, samples %d, offset %+" PRId64 " (%+" PRId64 " minutes)\n", vTimeOffsets.size(), nOffsetSample, nOffsetSample/60);
if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
{
int64_t nMedian = vTimeOffsets.median();
std::vector<int64_t> vSorted = vTimeOffsets.sorted();
// Only let other nodes change our time by so much
if (abs64(nMedian) < 70 * 60)
{
nTimeOffset = nMedian;
}
else
{
nTimeOffset = 0;
static bool fDone;
if (!fDone)
{
// If nobody has a time different than ours but within 5 minutes of ours, give a warning
bool fMatch = false;
BOOST_FOREACH(int64_t nOffset, vSorted)
if (nOffset != 0 && abs64(nOffset) < 5 * 60)
fMatch = true;
if (!fMatch)
{
fDone = true;
string strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong samaritan will not work properly.");
strMiscWarning = strMessage;
printf("*** %s\n", strMessage.c_str());
uiInterface.ThreadSafeMessageBox(strMessage+" ", string("samaritan"), CClientUIInterface::OK | CClientUIInterface::ICON_EXCLAMATION);
}
}
}
if (fDebug) {
BOOST_FOREACH(int64_t n, vSorted)
printf("%+" PRId64 " ", n);
printf("| ");
}
printf("nTimeOffset = %+" PRId64 " (%+" PRId64 " minutes)\n", nTimeOffset, nTimeOffset/60);
}
}
uint32_t insecure_rand_Rz = 11;
uint32_t insecure_rand_Rw = 11;
void seed_insecure_rand(bool fDeterministic)
{
//The seed values have some unlikely fixed points which we avoid.
if(fDeterministic)
{
insecure_rand_Rz = insecure_rand_Rw = 11;
} else {
uint32_t tmp;
do{
RAND_bytes((unsigned char*)&tmp,4);
}while(tmp==0 || tmp==0x9068ffffU);
insecure_rand_Rz=tmp;
do{
RAND_bytes((unsigned char*)&tmp,4);
}while(tmp==0 || tmp==0x464fffffU);
insecure_rand_Rw=tmp;
}
}
string FormatVersion(int nVersion)
{
if (nVersion%100 == 0)
return strprintf("%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100);
else
return strprintf("%d.%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100, nVersion%100);
}
string FormatFullVersion()
{
return CLIENT_BUILD;
}
// Format the subversion field according to BIP 14 spec (https://en.bitcoin.it/wiki/BIP_0014)
std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments)
{
std::ostringstream ss;
ss << "/";
ss << name << ":" << FormatVersion(nClientVersion);
if (!comments.empty())
ss << "(" << boost::algorithm::join(comments, "; ") << ")";
ss << "/";
return ss.str();
}
#ifdef WIN32
boost::filesystem::path GetSpecialFolderPath(int nFolder, bool fCreate)
{
namespace fs = boost::filesystem;
char pszPath[MAX_PATH] = "";
if(SHGetSpecialFolderPathA(NULL, pszPath, nFolder, fCreate))
{
return fs::path(pszPath);
}
printf("SHGetSpecialFolderPathA() failed, could not obtain requested path.\n");
return fs::path("");
}
#endif
void runCommand(std::string strCommand)
{
int nErr = ::system(strCommand.c_str());
if (nErr)
printf("runCommand error: system(%s) returned %d\n", strCommand.c_str(), nErr);
}
void RenameThread(const char* name)
{
#if defined(PR_SET_NAME)
// Only the first 15 characters are used (16 - NUL terminator)
::prctl(PR_SET_NAME, name, 0, 0, 0);
#elif 0 && (defined(__FreeBSD__) || defined(__OpenBSD__))
// TODO: This is currently disabled because it needs to be verified to work
// on FreeBSD or OpenBSD first. When verified the '0 &&' part can be
// removed.
pthread_set_name_np(pthread_self(), name);
// This is XCode 10.6-and-later; bring back if we drop 10.5 support:
// #elif defined(MAC_OSX)
// pthread_setname_np(name);
#else
// Prevent warnings for unused parameters...
(void)name;
#endif
}
bool NewThread(void(*pfn)(void*), void* parg)
{
try
{
boost::thread(pfn, parg); // thread detaches when out of scope
} catch(boost::thread_resource_error &e) {
printf("Error creating thread: %s\n", e.what());
return false;
}
return true;
}
| [
"[email protected]"
] | |
c4036201a1baa74f8dc180aeb91761b71ca900b5 | 5b926bf12340e03deced7495e818958b8866ada5 | /Users/Eric/IbeoSDK2.0.2/src/ibeosdk/datablocks/LogMessageBase.cpp | 159436d4573f38793e8285304541b115a3232e7f | [] | no_license | jpearkes/snowbots | 6514b19e24f246ee1d4291b18090135e2f4998e6 | 52bacd9f58524090e0ab421a47714629249ca273 | refs/heads/master | 2021-05-27T02:02:15.119679 | 2014-05-23T01:19:24 | 2014-05-23T01:19:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,045 | cpp | //======================================================================
/*! \file LogMessageBase.cpp
*
* \copydoc Copyright
* \author Jan Christian Dittmer (jcd)
* \date Sep 30, 2013
*///-------------------------------------------------------------------
#include <ibeosdk/datablocks/LogMessageBase.hpp>
#include <ibeosdk/io.hpp>
//======================================================================
namespace ibeo {
//======================================================================
LogMessageBase::LogMessageBase(const TraceLevel traceLevel, const std::string msg)
: m_traceLevel(traceLevel), m_message(msg)
{}
//======================================================================
bool LogMessageBase::deserialize(std::istream& is, const IbeoDataHeader& dh)
{
const std::istream::pos_type startPos = is.tellg();
uint8_t tl;
ibeo::readBE(is, tl);
m_traceLevel = TraceLevel(tl);
if (dh.getMessageSize()==1) {
m_message.clear();
if ((is.tellg() - startPos) != this->getSerializedSize())
return false;
}
else {
std::vector<char> buf(dh.getMessageSize()-1);
is.read(buf.data(), dh.getMessageSize()-1);
if ((is.tellg() - startPos) != dh.getMessageSize())
return false;
while (!buf.empty() && (buf.back() == std::string::value_type(0) || buf.back() == std::string::value_type('\n'))) {
buf.pop_back();
}
m_message = toASCII(buf);
}
return !is.fail();
// return !is.fail() && ((is.tellg() - startPos) == this->getSerializedSize());
}
//======================================================================
bool LogMessageBase::serialize(std::ostream& os) const
{
const std::istream::pos_type startPos = os.tellp();
const uint8_t tl = uint8_t(m_traceLevel);
ibeo::writeBE(os, tl);
os.write(m_message.c_str(), m_message.size());
return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
//======================================================================
}// namespace ibeo
//======================================================================
| [
"[email protected]"
] | |
161a9ae7e4b2ed1b028ae81b357c23477e6d045e | 8e9e8d1273438e38271b4b55e87be7b91a657c5f | /src/server/scripts/Spells/spell_warlock.cpp | ac07cf7e0662b791dde15550126d0b10713680db | [] | no_license | kmN666/Leroy | 43df8105252851e4e756cf36e02e0ffd674cce15 | 189c990d7227d0aa4ad21f20c319d49ccaeb262e | refs/heads/master | 2020-12-24T15:23:25.403594 | 2012-08-01T08:42:58 | 2012-08-01T08:42:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 26,153 | cpp | /*
* Copyright (C) 2012 DeadCore <https://bitbucket.org/jacobcore/deadcore>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Scripts for spells with SPELLFAMILY_WARLOCK and SPELLFAMILY_GENERIC spells used by warlock players.
* Ordered alphabetically using scriptname.
* Scriptnames of files in this file should be prefixed with "spell_warl_".
*/
#include "ScriptMgr.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
enum WarlockSpells
{
WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS = 54435,
WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER = 54443,
WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD = 54508,
WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER = 54509,
WARLOCK_DEMONIC_EMPOWERMENT_IMP = 54444,
WARLOCK_IMPROVED_HEALTHSTONE_R1 = 18692,
WARLOCK_IMPROVED_HEALTHSTONE_R2 = 18693,
WARLOCK_DEMONIC_CIRCLE_SUMMON = 48018,
WARLOCK_DEMONIC_CIRCLE_TELEPORT = 48020,
WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST = 62388,
WARLOCK_HAUNT = 48181,
WARLOCK_HAUNT_HEAL = 48210,
WARLOCK_UNSTABLE_AFFLICTION_DISPEL = 31117,
};
class spell_warl_banish : public SpellScriptLoader
{
public:
spell_warl_banish() : SpellScriptLoader("spell_warl_banish") { }
class spell_warl_banish_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_banish_SpellScript);
bool Load()
{
_removed = false;
return true;
}
void HandleBanish()
{
if (Unit* target = GetHitUnit())
{
if (target->GetAuraEffect(SPELL_AURA_SCHOOL_IMMUNITY, SPELLFAMILY_WARLOCK, 0, 0x08000000, 0))
{
//No need to remove old aura since its removed due to not stack by current Banish aura
PreventHitDefaultEffect(EFFECT_0);
PreventHitDefaultEffect(EFFECT_1);
PreventHitDefaultEffect(EFFECT_2);
_removed = true;
}
}
}
void RemoveAura()
{
if (_removed)
PreventHitAura();
}
void Register()
{
BeforeHit += SpellHitFn(spell_warl_banish_SpellScript::HandleBanish);
AfterHit += SpellHitFn(spell_warl_banish_SpellScript::RemoveAura);
}
bool _removed;
};
SpellScript* GetSpellScript() const
{
return new spell_warl_banish_SpellScript();
}
};
// 47193 Demonic Empowerment
class spell_warl_demonic_empowerment : public SpellScriptLoader
{
public:
spell_warl_demonic_empowerment() : SpellScriptLoader("spell_warl_demonic_empowerment") { }
class spell_warl_demonic_empowerment_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_demonic_empowerment_SpellScript);
bool Validate(SpellInfo const* /*spellEntry*/)
{
if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_IMP))
return false;
return true;
}
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
{
if (Creature* targetCreature = GetHitCreature())
{
if (targetCreature->isPet())
{
CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(targetCreature->GetEntry());
switch (ci->family)
{
case CREATURE_FAMILY_SUCCUBUS:
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS, true);
break;
case CREATURE_FAMILY_VOIDWALKER:
{
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER);
int32 hp = int32(targetCreature->CountPctFromMaxHealth(GetCaster()->CalculateSpellDamage(targetCreature, spellInfo, 0)));
targetCreature->CastCustomSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER, &hp, NULL, NULL, true);
//unitTarget->CastSpell(unitTarget, 54441, true);
break;
}
case CREATURE_FAMILY_FELGUARD:
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD, true);
break;
case CREATURE_FAMILY_FELHUNTER:
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER, true);
break;
case CREATURE_FAMILY_IMP:
targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_IMP, true);
break;
}
}
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_warl_demonic_empowerment_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_demonic_empowerment_SpellScript();
}
};
// 6201 Create Healthstone (and ranks)
class spell_warl_create_healthstone : public SpellScriptLoader
{
public:
spell_warl_create_healthstone() : SpellScriptLoader("spell_warl_create_healthstone") { }
class spell_warl_create_healthstone_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_create_healthstone_SpellScript);
static uint32 const iTypes[8][3];
bool Validate(SpellInfo const* /*spellEntry*/)
{
if (!sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R1) || !sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R2))
return false;
return true;
}
SpellCastResult CheckCast()
{
if (Player* caster = GetCaster()->ToPlayer())
{
uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
ItemPosCountVec dest;
InventoryResult msg = caster->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, iTypes[spellRank - 1][0], 1, NULL);
if (msg != EQUIP_ERR_OK)
return SPELL_FAILED_TOO_MANY_OF_ITEM;
}
return SPELL_CAST_OK;
}
void HandleScriptEffect(SpellEffIndex effIndex)
{
if (Unit* unitTarget = GetHitUnit())
{
uint32 rank = 0;
// Improved Healthstone
if (AuraEffect const* aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 284, 0))
{
switch (aurEff->GetId())
{
case WARLOCK_IMPROVED_HEALTHSTONE_R1: rank = 1; break;
case WARLOCK_IMPROVED_HEALTHSTONE_R2: rank = 2; break;
default:
sLog->outError("Unknown rank of Improved Healthstone id: %d", aurEff->GetId());
break;
}
}
uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
if (spellRank > 0 && spellRank <= 8)
CreateItem(effIndex, iTypes[spellRank - 1][rank]);
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_warl_create_healthstone_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
OnCheckCast += SpellCheckCastFn(spell_warl_create_healthstone_SpellScript::CheckCast);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_create_healthstone_SpellScript();
}
};
uint32 const spell_warl_create_healthstone::spell_warl_create_healthstone_SpellScript::iTypes[8][3] = {
{ 5512, 19004, 19005}, // Minor Healthstone
{ 5511, 19006, 19007}, // Lesser Healthstone
{ 5509, 19008, 19009}, // Healthstone
{ 5510, 19010, 19011}, // Greater Healthstone
{ 9421, 19012, 19013}, // Major Healthstone
{22103, 22104, 22105}, // Master Healthstone
{36889, 36890, 36891}, // Demonic Healthstone
{36892, 36893, 36894} // Fel Healthstone
};
// 47422 Everlasting Affliction
class spell_warl_everlasting_affliction : public SpellScriptLoader
{
public:
spell_warl_everlasting_affliction() : SpellScriptLoader("spell_warl_everlasting_affliction") { }
class spell_warl_everlasting_affliction_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_everlasting_affliction_SpellScript);
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
{
if (Unit* unitTarget = GetHitUnit())
// Refresh corruption on target
if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, 0x2, 0, 0, GetCaster()->GetGUID()))
aur->GetBase()->RefreshDuration();
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_warl_everlasting_affliction_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_everlasting_affliction_SpellScript();
}
};
// 18541 Ritual of Doom Effect
class spell_warl_ritual_of_doom_effect : public SpellScriptLoader
{
public:
spell_warl_ritual_of_doom_effect() : SpellScriptLoader("spell_warl_ritual_of_doom_effect") { }
class spell_warl_ritual_of_doom_effect_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_ritual_of_doom_effect_SpellScript);
void HandleDummy(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
caster->CastSpell(caster, GetEffectValue(), true);
}
void Register()
{
OnEffectHit += SpellEffectFn(spell_warl_ritual_of_doom_effect_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_ritual_of_doom_effect_SpellScript();
}
};
class spell_warl_seed_of_corruption : public SpellScriptLoader
{
public:
spell_warl_seed_of_corruption() : SpellScriptLoader("spell_warl_seed_of_corruption") { }
class spell_warl_seed_of_corruption_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_seed_of_corruption_SpellScript);
void FilterTargets(std::list<WorldObject*>& targets)
{
if (GetExplTargetUnit())
targets.remove(GetExplTargetUnit());
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warl_seed_of_corruption_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_seed_of_corruption_SpellScript();
}
};
enum Soulshatter
{
SPELL_SOULSHATTER = 32835,
};
class spell_warl_soulshatter : public SpellScriptLoader
{
public:
spell_warl_soulshatter() : SpellScriptLoader("spell_warl_soulshatter") { }
class spell_warl_soulshatter_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_soulshatter_SpellScript);
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_SOULSHATTER))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
if (Unit* target = GetHitUnit())
{
if (target->CanHaveThreatList() && target->getThreatManager().getThreat(caster) > 0.0f)
caster->CastSpell(target, SPELL_SOULSHATTER, true);
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_warl_soulshatter_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_soulshatter_SpellScript();
}
};
enum LifeTap
{
SPELL_LIFE_TAP_ENERGIZE = 31818,
SPELL_LIFE_TAP_ENERGIZE_2 = 32553,
ICON_ID_IMPROVED_LIFE_TAP = 208,
ICON_ID_MANA_FEED = 1982,
};
class spell_warl_life_tap : public SpellScriptLoader
{
public:
spell_warl_life_tap() : SpellScriptLoader("spell_warl_life_tap") { }
class spell_warl_life_tap_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_life_tap_SpellScript);
bool Load()
{
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
}
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE) || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE_2))
return false;
return true;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
Player* caster = GetCaster()->ToPlayer();
if (Unit* target = GetHitUnit())
{
int32 damage = GetEffectValue();
int32 mana = int32(damage + (caster->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+SPELL_SCHOOL_SHADOW) * 0.5f));
// Shouldn't Appear in Combat Log
target->ModifyHealth(-damage);
// Improved Life Tap mod
if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, ICON_ID_IMPROVED_LIFE_TAP, 0))
AddPctN(mana, aurEff->GetAmount());
caster->CastCustomSpell(target, SPELL_LIFE_TAP_ENERGIZE, &mana, NULL, NULL, false);
// Mana Feed
int32 manaFeedVal = 0;
if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_WARLOCK, ICON_ID_MANA_FEED, 0))
manaFeedVal = aurEff->GetAmount();
if (manaFeedVal > 0)
{
ApplyPctN(manaFeedVal, mana);
caster->CastCustomSpell(caster, SPELL_LIFE_TAP_ENERGIZE_2, &manaFeedVal, NULL, NULL, true, NULL);
}
}
}
SpellCastResult CheckCast()
{
if ((int32(GetCaster()->GetHealth()) > int32(GetSpellInfo()->Effects[EFFECT_0].CalcValue() + (6.3875 * GetSpellInfo()->BaseLevel))))
return SPELL_CAST_OK;
return SPELL_FAILED_FIZZLE;
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_warl_life_tap_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
OnCheckCast += SpellCheckCastFn(spell_warl_life_tap_SpellScript::CheckCast);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_life_tap_SpellScript();
}
};
class spell_warl_demonic_circle_summon : public SpellScriptLoader
{
public:
spell_warl_demonic_circle_summon() : SpellScriptLoader("spell_warl_demonic_circle_summon") { }
class spell_warl_demonic_circle_summon_AuraScript : public AuraScript
{
PrepareAuraScript(spell_warl_demonic_circle_summon_AuraScript);
void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes mode)
{
// If effect is removed by expire remove the summoned demonic circle too.
if (!(mode & AURA_EFFECT_HANDLE_REAPPLY))
GetTarget()->RemoveGameObject(GetId(), true);
GetTarget()->RemoveAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST);
}
void HandleDummyTick(AuraEffect const* /*aurEff*/)
{
if (GameObject* circle = GetTarget()->GetGameObject(GetId()))
{
// Here we check if player is in demonic circle teleport range, if so add
// WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST; allowing him to cast the WARLOCK_DEMONIC_CIRCLE_TELEPORT.
// If not in range remove the WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST.
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_CIRCLE_TELEPORT);
if (GetTarget()->IsWithinDist(circle, spellInfo->GetMaxRange(true)))
{
if (!GetTarget()->HasAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST))
GetTarget()->CastSpell(GetTarget(), WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST, true);
}
else
GetTarget()->RemoveAura(WARLOCK_DEMONIC_CIRCLE_ALLOW_CAST);
}
}
void Register()
{
OnEffectRemove += AuraEffectApplyFn(spell_warl_demonic_circle_summon_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_warl_demonic_circle_summon_AuraScript::HandleDummyTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
class spell_warl_demonic_circle_summon_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_demonic_circle_summon_SpellScript)
SpellCastResult CheckIfInvalidPosition()
{
Unit* caster = GetCaster();
switch (caster->GetMapId())
{
case 617: // Dalaran Sewers
// casting on starting pipes
if (caster->GetPositionZ() > 13.0f)
return SPELL_FAILED_NOT_HERE;
break;
case 618: // Ring of Valor
if(caster->GetDistance2d(763.632385f, -306.162384f) < 1.5f || // casting over a small pilar
caster->GetDistance2d(763.611145f, -261.856750f) < 1.5f ||
caster->GetDistance2d(723.644287f, -284.493256f) < 4.0f || // casting over a big pilar
caster->GetDistance2d(802.211609f, -284.493256f) < 4.0f ||
caster->GetPositionZ() < 28.0f) // casting on the elevator
return SPELL_FAILED_NOT_HERE;
break;
}
return SPELL_CAST_OK;
}
void Register()
{
OnCheckCast += SpellCheckCastFn(spell_warl_demonic_circle_summon_SpellScript::CheckIfInvalidPosition);
}
};
AuraScript* GetAuraScript() const
{
return new spell_warl_demonic_circle_summon_AuraScript();
}
SpellScript* GetSpellScript() const
{
return new spell_warl_demonic_circle_summon_SpellScript();
}
};
class spell_warl_demonic_circle_teleport : public SpellScriptLoader
{
public:
spell_warl_demonic_circle_teleport() : SpellScriptLoader("spell_warl_demonic_circle_teleport") { }
class spell_warl_demonic_circle_teleport_AuraScript : public AuraScript
{
PrepareAuraScript(spell_warl_demonic_circle_teleport_AuraScript);
void HandleTeleport(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
if (Player* player = GetTarget()->ToPlayer())
{
if (GameObject* circle = player->GetGameObject(WARLOCK_DEMONIC_CIRCLE_SUMMON))
{
player->NearTeleportTo(circle->GetPositionX(), circle->GetPositionY(), circle->GetPositionZ(), circle->GetOrientation());
player->RemoveMovementImpairingAuras();
}
}
}
void Register()
{
OnEffectApply += AuraEffectApplyFn(spell_warl_demonic_circle_teleport_AuraScript::HandleTeleport, EFFECT_0, SPELL_AURA_MECHANIC_IMMUNITY, AURA_EFFECT_HANDLE_REAL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_warl_demonic_circle_teleport_AuraScript();
}
};
class spell_warl_haunt : public SpellScriptLoader
{
public:
spell_warl_haunt() : SpellScriptLoader("spell_warl_haunt") { }
class spell_warl_haunt_SpellScript : public SpellScript
{
PrepareSpellScript(spell_warl_haunt_SpellScript);
void HandleOnHit()
{
if (Aura* aura = GetHitAura())
if (AuraEffect* aurEff = aura->GetEffect(EFFECT_1))
aurEff->SetAmount(CalculatePctN(aurEff->GetAmount(), GetHitDamage()));
}
void Register()
{
OnHit += SpellHitFn(spell_warl_haunt_SpellScript::HandleOnHit);
}
};
class spell_warl_haunt_AuraScript : public AuraScript
{
PrepareAuraScript(spell_warl_haunt_AuraScript);
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(WARLOCK_HAUNT_HEAL))
return false;
return true;
}
void HandleRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
{
if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_ENEMY_SPELL && GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_EXPIRE)
return;
if (Unit* caster = GetCaster())
{
int32 amount = aurEff->GetAmount();
GetTarget()->CastCustomSpell(caster, WARLOCK_HAUNT_HEAL, &amount, NULL, NULL, true, NULL, aurEff, GetCasterGUID());
}
}
void Register()
{
OnEffectRemove += AuraEffectApplyFn(spell_warl_haunt_AuraScript::HandleRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
}
};
SpellScript* GetSpellScript() const
{
return new spell_warl_haunt_SpellScript();
}
AuraScript* GetAuraScript() const
{
return new spell_warl_haunt_AuraScript();
}
};
class spell_warl_unstable_affliction : public SpellScriptLoader
{
public:
spell_warl_unstable_affliction() : SpellScriptLoader("spell_warl_unstable_affliction") { }
class spell_warl_unstable_affliction_AuraScript : public AuraScript
{
PrepareAuraScript(spell_warl_unstable_affliction_AuraScript);
bool Validate(SpellInfo const* /*spell*/)
{
if (!sSpellMgr->GetSpellInfo(WARLOCK_UNSTABLE_AFFLICTION_DISPEL))
return false;
return true;
}
void HandleDispel(DispelInfo* dispelInfo)
{
if (Unit* caster = GetCaster())
if (AuraEffect const* aurEff = GetEffect(EFFECT_0))
{
int32 damage = aurEff->GetAmount() * 9;
// backfire damage and silence
caster->CastCustomSpell(dispelInfo->GetDispeller(), WARLOCK_UNSTABLE_AFFLICTION_DISPEL, &damage, NULL, NULL, true, NULL, aurEff);
}
}
void Register()
{
AfterDispel += AuraDispelFn(spell_warl_unstable_affliction_AuraScript::HandleDispel);
}
};
AuraScript* GetAuraScript() const
{
return new spell_warl_unstable_affliction_AuraScript();
}
};
void AddSC_warlock_spell_scripts()
{
new spell_warl_banish();
new spell_warl_demonic_empowerment();
new spell_warl_create_healthstone();
new spell_warl_everlasting_affliction();
new spell_warl_ritual_of_doom_effect();
new spell_warl_seed_of_corruption();
new spell_warl_soulshatter();
new spell_warl_life_tap();
new spell_warl_demonic_circle_summon();
new spell_warl_demonic_circle_teleport();
new spell_warl_haunt();
new spell_warl_unstable_affliction();
}
| [
"[email protected]"
] | |
d78fb2511c839533a946687984a2572fbb0148fe | 00f930eacba4521fc249b00d96cb8a8b5db97764 | /day04/ex03/ICharacter.h | 8ec633b4ad5f1f501cb6b88f978ad8308d04c7a9 | [] | no_license | rmalkevy/Pool_CPP | c2c1e0734ac18b8b76b2d164616bab5fd64d96fb | f780ee32fa410a071cc747e8be144eb55a7200fd | refs/heads/master | 2020-12-02T19:22:25.165018 | 2017-07-12T16:34:22 | 2017-07-12T16:34:22 | 96,331,696 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 375 | h | //
// Created by Roman Malkevych on 7/12/17.
//
#ifndef ICHARACTER_H
#define ICHARACTER_H
#include <iostream>
#include "AMateria.h"
class ICharacter
{
public:
virtual ~ICharacter() {}
virtual std::string const & getName() const = 0;
virtual void equip(AMateria* m) = 0;
virtual void unequip(int idx) = 0;
virtual void use(int idx, ICharacter& target) = 0;
};
#endif
| [
"[email protected]"
] | |
2979d3c306103ad63b259d0741c4bccd0242cb59 | 53f3b9bfd50839a14118113749200ab769500817 | /Binary Tree/BST/dll_to_bst.cpp | 931658f8b3a4f27f23c558f976e58906d21bd263 | [] | no_license | ankitoscar/dsa-practice | cde0458ea1073b5843245b54dc13f0823315e1ae | 34ebd74a841ff210ef5b6b31a84e105a485bbcaf | refs/heads/main | 2023-08-11T03:58:54.988782 | 2021-10-16T14:53:00 | 2021-10-16T14:53:00 | 410,044,687 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,471 | cpp | #include<iostream>
using namespace std;
class DLL{
public:
int data;
DLL* left;
DLL* right;
DLL(int x){
data = x;
left = right = NULL;
}
};
int size(DLL* head, DLL* end){
if(head == NULL)
return 0;
DLL* temp = head;
int s = 0;
while(temp != end){
temp = temp->right;
s++;
}
return s;
}
DLL* middle(DLL* head, int size){
if(head == NULL || size <= 0)
return NULL;
DLL* temp = head;
int mid = size/2;
while(mid--)
temp = temp->right;
return temp;
}
DLL* toBST(DLL* head, DLL* end){
if(head == NULL || head == end)
return NULL;
int n = size(head, end);
DLL* root = middle(head, n);
root->left = toBST(head, root->left);
root->right = toBST(root->right, end);
return root;
}
void printDLL(DLL* head){
if(head == NULL)
return;
DLL* temp = head;
while(temp != NULL){
cout<<temp->data<<' ';
temp = temp->right;
}
cout<<'\n';
}
void printInorder(DLL* root){
if(root == NULL)
return;
printInorder(root->left);
cout<<root->data<<' ';
printInorder(root->right);
cout<<'\n';
}
int main(){
DLL* head = new DLL(2);
head->right = new DLL(3);
head->right->left = head;
head->right->right = new DLL(4);
head->right->right->left = head->right;
head->right->right->right = new DLL(5);
head->right->right->right->left = head->right->right;
printDLL(head);
DLL* root = toBST(head, NULL);
printInorder(root);
return 0;
}
| [
"[email protected]"
] | |
cd47fd21486fb390153354a087b45d346ba3ca8a | 1e0f12cd4c682f5f50e34e827bbe2cded0c725d5 | /4922.cpp | 68080a92ea4e5c5e16adeec4e052d4b88522c537 | [] | no_license | kyun2024/ProgramSolve | 4f11d5ff67c799e867b6462c4da35edcca9a9d9d | ba2f8fdbe8342dd99de49cd00fd538075849dc53 | refs/heads/master | 2023-08-21T18:11:27.161772 | 2023-08-09T11:23:43 | 2023-08-09T11:23:43 | 209,213,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 293 | cpp | #include <iostream>
using namespace std;
int memo[1000];
int main(){
int n,i;
memo[0]=1;
for(i=1;i<1000;i++){
memo[i] = memo[i-1] + (i<<1);
}
while(1){
cin >> n;
if(!n)break;
cout << n << " => " << memo[n-1] << endl;
}
return 0;
} | [
"[email protected]"
] | |
0d4aef6712d2011cfda4e0eb9e00c860b5253fda | b1fdeb29c93e4ef35bbb840fe192251855d3746c | /runtime/core/EASTL.cc | 7d75b71e70aad5f58f2a205c9ab3fe76a89b8914 | [] | no_license | WooZoo86/xEngine | b80e7fc2b64a30ed3d631fdd340c63a45f6e6566 | 0d9f7c262d04f53402d339bd815db0c50eaa9d24 | refs/heads/master | 2021-05-14T13:25:00.430222 | 2017-10-11T11:21:50 | 2017-10-11T11:21:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 674 | cc | #include <EASTL/allocator.h>
#include <cstdlib>
void *operator new[](size_t size,
const char * /*name*/,
int /*flags*/,
unsigned /*debugFlags*/,
const char * /*file*/,
int /*line*/) {
return malloc(size);
}
void *operator new[](size_t size,
size_t /*alignment*/,
size_t /*alignmentOffset*/,
const char * /*name*/,
int /*flags*/,
unsigned /*debugFlags*/,
const char * /*file*/,
int /*line*/) {
return malloc(size);
} | [
"[email protected]"
] | |
3ab2bba580c8704cef077a8533eeaf8c98cdfef3 | 484ec4d1331b94fe9c19fd282009d6618e9a1eef | /Real-Time Corruptor/BizHawk_RTC/waterbox/ngp/mem.h | c467354d2c02bf00eb919126fbe3d3b144e1f939 | [
"GPL-1.0-or-later",
"MIT"
] | permissive | mguid65/RTC3 | a565303fdfd1807a2516be5752c7b30a8be3d909 | 4082eb302f8e6e20ba621ec70308dab94985fe7f | refs/heads/master | 2020-04-13T16:57:31.933643 | 2018-12-31T16:03:39 | 2018-12-31T16:03:39 | 161,684,492 | 0 | 0 | MIT | 2018-12-13T19:19:17 | 2018-12-13T19:19:17 | null | UTF-8 | C++ | false | false | 1,774 | h | //---------------------------------------------------------------------------
// NEOPOP : Emulator as in Dreamland
//
// Copyright (c) 2001-2002 by neopop_uk
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version. See also the license.txt file for
// additional informations.
//---------------------------------------------------------------------------
#ifndef __NEOPOP_MEM__
#define __NEOPOP_MEM__
//=============================================================================
namespace MDFN_IEN_NGP
{
#define ROM_START 0x200000
#define ROM_END 0x3FFFFF
#define HIROM_START 0x800000
#define HIROM_END 0x9FFFFF
#define BIOS_START 0xFF0000
#define BIOS_END 0xFFFFFF
void reset_memory(void);
void dump_memory(uint32 start, uint32 length);
extern bool debug_abort_memory;
extern bool debug_mask_memory_error_messages;
extern bool memory_unlock_flash_write;
extern bool memory_flash_error;
extern bool memory_flash_command;
extern bool FlashStatusEnable;
extern uint8 COMMStatus;
//=============================================================================
uint8 loadB(uint32 address);
uint16 loadW(uint32 address);
uint32 loadL(uint32 address);
void storeB(uint32 address, uint8 data);
void storeW(uint32 address, uint16 data);
void storeL(uint32 address, uint32 data);
void SetFRM(void);
void RecacheFRM(void);
}
//=============================================================================
#endif
| [
"[email protected]"
] | |
fa35a94b4363fd0d732dda51b7adce5b085bc3bc | 6226d6aed3629aa4069c46971ffe764bb6c743f6 | /MRenderPlugin/MWSSAO.cpp | 1d37faaa0d97cb6552fcaeec00bd0ba46680ce3d | [] | no_license | Myway3D/Myway3D | 83c30258f1e3eae90e619269406acd0ddeac7887 | 39cf569993f62fc648cbba49ebf74b3f8a64e46a | refs/heads/master | 2020-04-22T20:24:15.817427 | 2014-03-09T14:25:23 | 2014-03-09T14:25:23 | 170,640,096 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,100 | cpp | #include "MWSSAO.h"
#include "Engine.h"
#include "MWEnvironment.h"
namespace Myway {
SSAO::SSAO()
{
_init();
}
SSAO::~SSAO()
{
}
void SSAO::_init()
{
mRT_Ao = NULL;
mTex_Ao = NULL;
mRT_Quad = NULL;
mTex_Quad = NULL;
RenderScheme * scheme = Engine::Instance()->GetRenderScheme();
int width = scheme->GetColorTexture()->GetWidth();
int height = scheme->GetColorTexture()->GetHeight();
VideoBufferManager * video = VideoBufferManager::Instance();
mRT_Quad = video->CreateRenderTarget("Env_SSAO_RT_Quad", width / 2, height / 2, FMT_R16F, MSAA_NONE);
mTex_Quad = video->CreateTextureRT("Env_SSAO_Tex_Quad0", width / 2, height / 2, FMT_R16F);
mTex_Ao = video->CreateTextureRT("Env_SSAO_Tex", width, height, FMT_R16F);
mRT_Ao = video->CreateRenderTarget(mTex_Ao);
mTech_Ao = Environment::Instance()->GetShaderLib()->GetTechnique("SSAO");
mTech_DownSample = Environment::Instance()->GetShaderLib()->GetTechnique("DownScale2x");
mTech_BlurH = Environment::Instance()->GetShaderLib()->GetTechnique("BlurH");
mTech_BlurV = Environment::Instance()->GetShaderLib()->GetTechnique("BlurV");
mTech_Blend = Environment::Instance()->GetShaderLib()->GetTechnique("SSAOBlend");
d_assert (mTech_Ao && mTech_Blend && mTech_BlurH && mTech_BlurV && mTech_DownSample);
mTex_Random = video->Load2DTexture("random2.png", "Shaders\\random.png");
}
void SSAO::Resize(int w, int h)
{
_init();
}
void SSAO::Render(Texture * depthTex, Texture * normalTex)
{
RenderSystem * render = RenderSystem::Instance();
RenderTarget * oldRt = render->GetRenderTarget(0);
_renderAo(depthTex, normalTex);
_downSample();
_blur();
render->SetRenderTarget(0, oldRt);
_blend();
}
void SSAO::_renderAo(Texture * depthTex, Texture * normalTex)
{
RenderSystem * render = RenderSystem::Instance();
render->SetRenderTarget(0, mRT_Ao.c_ptr());
render->ClearBuffer(NULL, true, false, false, Color::White);
Camera * cam = World::Instance()->MainCamera();
const Vec3 * corner = cam->GetCorner();
Vec3 cornerLeftTop = corner[4];
Vec3 cornerRightDir = corner[5] - corner[4];
Vec3 cornerDownDir = corner[6] - corner[4];
float width = float(mRT_Ao->GetWidth());
float height = float(mRT_Ao->GetHeight());
ShaderParam * uCornerLeftTop = mTech_Ao->GetPixelShaderParamTable()->GetParam("gCornerLeftTop");
ShaderParam * uCornerRightDir = mTech_Ao->GetPixelShaderParamTable()->GetParam("gCornerRightDir");
ShaderParam * uCornerDownDir = mTech_Ao->GetPixelShaderParamTable()->GetParam("gCornerDownDir");
ShaderParam * uFar = mTech_Ao->GetPixelShaderParamTable()->GetParam("far");
ShaderParam * uMatProj = mTech_Ao->GetPixelShaderParamTable()->GetParam("ptMat");
uCornerLeftTop->SetUnifom(cornerLeftTop.x, cornerLeftTop.y, cornerLeftTop.z, 0);
uCornerRightDir->SetUnifom(cornerRightDir.x, cornerRightDir.y, cornerRightDir.z, 0);
uCornerDownDir->SetUnifom(cornerDownDir.x, cornerDownDir.y, cornerDownDir.z, 0);
//uFar->SetUnifom(cam->GetFarClip(), 0, 0, 0);
uMatProj->SetMatrix(cam->GetProjMatrix());
SamplerState state;
state.Address = TEXA_CLAMP;
state.Filter = TEXF_POINT;
RenderSystem::Instance()->SetTexture(0, state, depthTex);
RenderSystem::Instance()->SetTexture(1, state, normalTex);
state.Address = TEXA_WRAP;
state.Filter = TEXF_DEFAULT;
RenderSystem::Instance()->SetTexture(2, state, mTex_Random.c_ptr());
RenderHelper::Instance()->DrawScreenQuad(BM_OPATICY, mTech_Ao);
}
void SSAO::_downSample()
{
RenderSystem * render = RenderSystem::Instance();
render->SetRenderTarget(0, mRT_Quad.c_ptr());
float invWidth = 1.0f / mRT_Quad->GetWidth();
float invHeight = 1.0f / mRT_Quad->GetHeight();
Vec4 uvOffs[4] = {
Vec4(0, 0, 0, 0), Vec4(invWidth, 0, 0, 0),
Vec4(0, invHeight, 0, 0), Vec4(invWidth, invHeight, 0, 0),
};
ShaderParam * uUVOffs = mTech_DownSample->GetPixelShaderParamTable()->GetParam("gUVOffsets");
uUVOffs->SetVector(uvOffs, 4);
SamplerState state;
render->SetTexture(0, state, mTex_Ao.c_ptr());
RenderHelper::Instance()->DrawScreenQuad(BM_OPATICY, mTech_DownSample);
mRT_Quad->Stretch(mTex_Quad.c_ptr());
}
void SSAO::_blur()
{
RenderSystem * render = RenderSystem::Instance();
render->SetRenderTarget(0, mRT_Quad.c_ptr());
SamplerState state;
state.Address = TEXA_CLAMP;
RenderSystem::Instance()->SetTexture(0, state, mTex_Quad.c_ptr());
RenderHelper::Instance()->DrawScreenQuad(BM_OPATICY, mTech_BlurH);
mRT_Quad->Stretch(mTex_Quad.c_ptr());
RenderSystem::Instance()->SetTexture(0, state, mTex_Quad.c_ptr());
RenderHelper::Instance()->DrawScreenQuad(BM_OPATICY, mTech_BlurV);
mRT_Quad->Stretch(mTex_Quad.c_ptr());
}
void SSAO::_blend()
{
SamplerState state;
state.Address = TEXA_CLAMP;
RenderSystem::Instance()->SetTexture(0, state, mTex_Quad.c_ptr());
RenderHelper::Instance()->DrawScreenQuad(BM_MULTIPLY, mTech_Blend);
}
} | [
"[email protected]@ff49bfeb-f889-bd78-9ae6-4dc862721fa0"
] | [email protected]@ff49bfeb-f889-bd78-9ae6-4dc862721fa0 |
4fd0193ba9f8d57c1da3f0eec6807814799eba04 | ff5b427352226fc308b8f10ebce3f563c51cf9bd | /Data Structures/Linked Lists/Delete a Node.cpp | 95bff6aee5f9d8488c4d21903e467b4586852be8 | [] | no_license | davidffa/HackerRank-Cpp | 622520cab05764abde301ce44e2a8730aa28e83c | 9bcbbcea8a66811d182915eedfb6965d7907ea01 | refs/heads/master | 2022-11-05T11:00:42.827861 | 2020-06-21T20:45:42 | 2020-06-21T20:45:42 | 272,500,629 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,434 | cpp | #include <bits/stdc++.h>
using namespace std;
class SinglyLinkedListNode {
public:
int data;
SinglyLinkedListNode *next;
SinglyLinkedListNode(int node_data) {
this->data = node_data;
this->next = nullptr;
}
};
class SinglyLinkedList {
public:
SinglyLinkedListNode *head;
SinglyLinkedListNode *tail;
SinglyLinkedList() {
this->head = nullptr;
this->tail = nullptr;
}
void insert_node(int node_data) {
SinglyLinkedListNode* node = new SinglyLinkedListNode(node_data);
if (!this->head) {
this->head = node;
} else {
this->tail->next = node;
}
this->tail = node;
}
};
void print_singly_linked_list(SinglyLinkedListNode* node, string sep, ofstream& fout) {
while (node) {
fout << node->data;
node = node->next;
if (node) {
fout << sep;
}
}
}
void free_singly_linked_list(SinglyLinkedListNode* node) {
while (node) {
SinglyLinkedListNode* temp = node;
node = node->next;
free(temp);
}
}
// Complete the deleteNode function below.
/*
* For your reference:
*
* SinglyLinkedListNode {
* int data;
* SinglyLinkedListNode* next;
* };
*
*/
SinglyLinkedListNode* deleteNode(SinglyLinkedListNode* head, int position) {
SinglyLinkedListNode* curr = head;
if (position == 0)
return head->next;
while (--position && curr->next != nullptr) {
curr = curr->next;
}
SinglyLinkedListNode* temp = curr->next->next;
delete curr->next;
curr->next = temp;
return head;
}
int main()
{
ofstream fout(getenv("OUTPUT_PATH"));
SinglyLinkedList* llist = new SinglyLinkedList();
int llist_count;
cin >> llist_count;
cin.ignore(numeric_limits<streamsize>::max(), '\n');
for (int i = 0; i < llist_count; i++) {
int llist_item;
cin >> llist_item;
cin.ignore(numeric_limits<streamsize>::max(), '\n');
llist->insert_node(llist_item);
}
int position;
cin >> position;
cin.ignore(numeric_limits<streamsize>::max(), '\n');
SinglyLinkedListNode* llist1 = deleteNode(llist->head, position);
print_singly_linked_list(llist1, " ", fout);
fout << "\n";
free_singly_linked_list(llist1);
fout.close();
return 0;
}
| [
"[email protected]"
] | |
c1b0dc1f96a736b2dadc71a8e70d13896ce58cb4 | 9aee810d0d9d72d3dca7920447872216a3af49fe | /AtCoder/ABC/ABC301/abc301_e.cpp | 6f05af2e4dfbd595b9efdfd0a5820f0a6e1bbbb0 | [] | no_license | pulcherriman/Programming_Contest | 37d014a414d473607a11c2edcb25764040edd686 | 715308628fc19843b8231526ad95dbe0064597a8 | refs/heads/master | 2023-08-04T00:36:36.540090 | 2023-07-30T18:31:32 | 2023-07-30T18:31:32 | 163,375,122 | 3 | 0 | null | 2023-01-24T11:02:11 | 2018-12-28T06:33:16 | C++ | UTF-8 | C++ | false | false | 14,847 | cpp | #ifdef _DEBUG
// #define _GLIBCXX_DEBUG 1
#else
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("inline")
#endif
/*
* Include Headers
*/
#if defined(EVAL) || defined(ONLINE_JUDGE) || defined(_DEBUG)
// #include <atcoder/all>
// using namespace atcoder;
#endif
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
/*
* Additional Type Definition
*/
using ll=long long;
using ld=long double;
using ull=unsigned long long;
using vb=vector<bool>;
using vvb=vector<vb>;
using vd=vector<ld>;
using vvd=vector<vd>;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vp=vector<pll>;
using tl2=tuple<ll,ll>;
using tl3=tuple<ll,ll,ll>;
using vs=vector<string>;
template<class K> using IndexedSet=__gnu_pbds::tree<K,__gnu_pbds::null_type,less<K>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<class K> using HashSet=__gnu_pbds::gp_hash_table<K,__gnu_pbds::null_type,hash<K>>;
template<class K,class V> using IndexedMap=__gnu_pbds::tree<K,V,less<K>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
template<class K,class V> using HashMap=__gnu_pbds::gp_hash_table<K,V,hash<K>>;
template<class V> using minpq = priority_queue<V, vector<V>, greater<V>>;
#define all(a) begin(a),end(a)
#define rall(a) rbegin(a),rend(a)
#define __LOOPSWITCH(_1, _2, _3, __LOOPSWITCH, ...) __LOOPSWITCH
#define rep(...) __LOOPSWITCH(__VA_ARGS__, __RANGE, __REP, __LOOP) (__VA_ARGS__)
#define rrep(...) __LOOPSWITCH(__VA_ARGS__, __RRANGE, __RREP, __LOOP) (__VA_ARGS__)
#define __LOOP(q) __LOOP2(q, __LINE__)
#define __LOOP2(q,l) __LOOP3(q,l)
#define __LOOP3(q,l) __REP(_lp ## l,q)
#define __REP(i,n) __RANGE(i,0,n)
#define __RANGE(i,a,n) for(ll i=((ll)a);i<((ll)n);++i)
#define __RREP(i,n) __RRANGE(i,0,n)
#define __RRANGE(i,a,n) for(ll i=((ll)(n)-1);i>=((ll)a);--i)
#define sz(a) ((ll)(a).size())
#define pb push_back
#define eb emplace_back
/*
* Constants
*/
constexpr ll LINF=1ll<<60;
constexpr int INF=1<<30;
constexpr double EPS=(1e-14);
constexpr ll MOD=998244353ll;
constexpr long double PI=3.14159265358979323846;
/*
* Utilities
*/
template<class T,class...Args>auto vec(T x,int arg,Args...args){
if constexpr(sizeof...(args)==0) return vector(arg,x);
else return vector(arg,vec(x,args...));
}
template<class T>constexpr bool chmax(T&a,T b){return a<b?a=b,1:0;}
template<class T>constexpr bool chmin(T&a,T b){return a>b?a=b,1:0;}
template<class S>S sum(vector<S>&a){return accumulate(all(a),S());}
template<class S>S max(vector<S>&a){return *max_element(all(a));}
template<class S>S min(vector<S>&a){return *min_element(all(a));}
ll sumAtoB(ll a,ll b){return (a+b)*(b-a+1)/2;}
namespace IO {
// container detection
template<typename T, typename _=void> struct is_container : false_type {};
template<> struct is_container<string> : false_type {};
template<class T> struct is_container<valarray<T>> : true_type {};
template<typename...Ts> struct is_container_helper {};
template<typename T> struct is_container<T, conditional_t<
true, void, is_container_helper<
typename T::value_type, typename T::size_type, typename T::iterator,
decltype(declval<T>().size()),
decltype(declval<T>().begin()),
decltype(declval<T>().end()) >>> : public true_type {};
template<typename T,
typename enable_if<is_container<T>{}, nullptr_t>::type = nullptr,
char Separator = is_container<typename T::value_type>{} ? '\n' : ' ' >
constexpr ostream&operator<<(ostream&os, T t){
if(auto b=begin(t), e=end(t) ; t.size()) for(os<<(*b++);b!=e;os<<Separator<<(*b++)) ;
return os;
}
// output
template<class T, class...Ts> constexpr ostream& pargs(ostream&os, T&&t, Ts&&...args); // support clang
template<class S,class T>constexpr ostream&operator<<(ostream&os,pair<S,T>p){ return os<<'['<<p.first<<", "<<p.second<<']'; };
template<class...Ts>constexpr ostream&operator<<(ostream&os,tuple<Ts...>t){
return apply([&os](auto&&t,auto&&...args)->ostream&{return pargs(os, t, args...);}, t);
};
template<class T, class...Ts> constexpr ostream& pargs(ostream&os, T&&t, Ts&&...args) {
return ((os<<t)<<...<<(os<<' ', args));
}
template<class...Ts> constexpr ostream& out(Ts...args) { return pargs(cout, args...)<<'\n'; }
template<class...Ts> constexpr ostream& debug_f(Ts...args) { return pargs(cerr, args...)<<'\n'; }
#ifdef _DEBUG
template<class...Ts> constexpr ostream& debug(Ts...args) { return pargs(cerr, args...)<<'\n'; }
#else
#define debug(...) if(false)debug_f(__VA_ARGS__)
#endif
void Yn(bool f) { out(f?"Yes":"No"); }
// input
template<class T, class...Ts> constexpr istream& gargs(istream&is, T&&t, Ts&&...args) {
return ((is>>t)>>...>>args);
}
template<class S,class T>auto&operator>>(istream&is,pair<S,T>&p){return is>>p.first>>p.second;}
template<class...Ts>constexpr istream&operator>>(istream&is,tuple<Ts...>&t){
return apply([&is](auto&&t,auto&&...args)->istream&{return gargs(is, t, args...);}, t);
};
template<typename...S>auto&in(S&...s){return gargs(cin, s...);}
#define def(t,...) t __VA_ARGS__; in(__VA_ARGS__)
template<typename T, typename enable_if<is_container<T>{}, nullptr_t>::type = nullptr>
auto&operator>>(istream&is,T&t){for(auto&a:t)is>>a; return is;}
}
using namespace IO;
class Random {
public:
typedef uint_fast32_t result_type;
constexpr result_type operator()(){return operator()((ll)min(),(ll)max());}
static constexpr result_type max(){return numeric_limits<result_type>::max();}
static constexpr result_type min(){return 0;}
constexpr Random(const bool&isDeterministic):y(isDeterministic?2463534242:chrono::system_clock::now().time_since_epoch().count()){}
constexpr int operator()(int a,int b){return next()%(b-a)+a;}
constexpr ll operator()(ll a,ll b){return (((ull)next())<<32|next())%(b-a)+a;}
constexpr double operator()(double a,double b){return (b-a)*next()/4294967296.0+a;}
private:
result_type y;
constexpr result_type next(){return y^=(y^=(y^=y<<13)>>17)<<5;}
} Random(0);
class Timer {
#ifdef _DEBUG
static constexpr uint64_t ClocksPerMsec = 3587000;
#else
static constexpr uint64_t ClocksPerMsec = 2987000;
#endif
const uint64_t start,limit;
uint64_t getClocks() const{
unsigned int lo,hi;
__asm__ volatile ("rdtsc" : "=a" (lo), "=d" (hi));
return((uint64_t)hi<<32)|lo;
}
public:
Timer(uint64_t _limit=1970): start(getClocks()),limit(start+_limit*ClocksPerMsec) {}
uint64_t get() const{return (getClocks()-start)/ClocksPerMsec;}
operator bool()const{return getClocks()<limit;}
};
void wait(const int&msec){Timer tm(msec); while(tm);}
struct Mgr {
static const int TLE = 2000;
static inline Timer timer = Timer(TLE-20);
Mgr() {
ios_base::sync_with_stdio(0); cin.tie(0);
cout<<fixed<<setprecision(11);
cerr<<fixed<<setprecision(3);
}
~Mgr(){
cout<<flush;
debug_f(timer.get(), "ms")<<flush;
}
} _manager;
namespace std {
template<class T>
struct hash_base {
const static inline size_t hash_value = 0x9e3779b9;
static inline size_t hash_rnd = Random(0, numeric_limits<size_t>::max());
template<class V, class P=remove_const_t<remove_reference_t<V>>> static size_t& do_hash(size_t&seed, V&v) {
return seed ^= hash<P>{}(v) + hash_value + (seed<<6) + (seed>>2);
}
virtual size_t operator()(T p) const = 0;
};
template<class S, class T>
struct hash<pair<S,T>> : public hash_base<pair<S,T>> {
size_t operator()(pair<S,T> p) const {
size_t seed = 0;
this->do_hash(seed, p.first);
this->do_hash(seed, p.second);
return this->do_hash(seed, this->hash_value);
}
};
template<class...Ts>
struct hash<tuple<Ts...>> : public hash_base<tuple<Ts...>> {
size_t operator()(tuple<Ts...> t) const {
return apply([&](auto&&...args)->size_t{
size_t seed = 0;
for(auto&&v : {args...}) this->do_hash(seed, v);
return this->do_hash(seed, this->hash_value);
}, t);
}
};
}
template<class T>struct Graph;
template<class T>struct DFSResult{
vb connected;
vector<T> distance;
vi preorder, postorder, eulertour, subtreeNodeCount;
vl subtreePathLengthSum;
DFSResult(Graph<T>&g):
connected(g.size,false),
distance(g.size,g.INF_VAL),
preorder(g.size,-1),
postorder(g.size,-1),
subtreeNodeCount(g.size,1),
subtreePathLengthSum(g.size,0){
eulertour.reserve(g.size*2);
}
};
template<class T=ll>struct Graph{
int size;
T INF_VAL;
vector<vector<tuple<ll,T>>>edge;
Graph(int n=1,T inf=LINF):size(n),INF_VAL(inf){edge.resize(size);}
constexpr void add(ll from, ll to, T cost, bool directed=false){
edge[from].emplace_back(to,cost);
if(!directed) edge[to].emplace_back(from,cost);
}
constexpr friend ostream &operator<<(ostream &os, const Graph<T> &g) {
rep(i,g.size)for(auto[from,val]:g.edge[i])pargs(os, i,"=>",from,", cost :",val)<<'\n';
return os;
}
constexpr static pair<int,Graph<T>> input(bool weighted=false, bool directed=false){
def(int,n,m);
Graph<T> g(n);
g.inputEdge(m,weighted,directed);
return {n,g};
}
// s始点で深さ優先探索して情報を返す。木以外で使うのか？
// この関数は変更しない
constexpr DFSResult<T> dfs(int s){
int pre=0,post=0;
DFSResult<T> ret(*this);
ret.distance[s]=0;
const function<void(int)> dfsrec=[this, &ret ,&pre, &post, &dfsrec](int p){
ret.connected[p]=true;
ret.preorder[p]=pre++;
ret.eulertour.emplace_back(p);
for(auto[to,cost]:edge[p])if(!ret.connected[to]){
ret.distance[to]=ret.distance[p]+cost;
dfsrec(to);
ret.subtreePathLengthSum[p]+=ret.subtreePathLengthSum[to] + ret.subtreeNodeCount[to] * cost;
ret.subtreeNodeCount[p]+=ret.subtreeNodeCount[to];
}
ret.postorder[p]=post++;
ret.eulertour.emplace_back(p);
};
dfsrec(s);
return ret;
};
// BFSする。この関数は変更しない
constexpr vector<T> bfs(int s){
vector<T> ret(size,INF_VAL);
deque<int> q;
ret[q.emplace_back(s)]=0;
while(!q.empty()){
int p=q.front(); q.pop_front();
for(auto[to,cost]:edge[p])if(chmin(ret[to],ret[p]+cost)){
if(cost==0)q.emplace_front(to); else q.emplace_back(to);
}
}
return ret;
}
// BFSしてパスを復元する。
// 余分にO(N)掛けてるので、距離だけほしい場合はbfs(s)[t]を見るとよい
constexpr pair<T,vi> bfs(int s, int t){
auto dist=bfs(s);
vi path(1,t);
while(path.back()!=s)for(auto[to,_]:edge[path.back()])if(dist[to]==dist[path.back()]-1){path.emplace_back(to);break;}
reverse(all(path));
return {dist[t], path};
}
constexpr void inputEdge(int edgeCount, bool weighted, bool directed){
int a,b; T c=1;
rep(i,edgeCount){
cin>>a>>b; if(weighted)cin>>c;
add(a-1,b-1,c,directed);
}
}
// ノードを追加
int addNode(){
edge.emplace_back();
return size++;
}
// 入次数を返す
vi inDegree(){
vi in(size,0);
for(auto&e:edge)for(auto&[to,_]:e)in[to]++;
return in;
}
// トポロジカルソート
pair<bool,vi> topologicalSort(){
queue<int> st;
vi ans, in=inDegree();
rep(i,size)if(in[i]==0)st.push(i);
while(!st.empty()){
int p=st.front(); st.pop();
ans.push_back(p);
for(auto&[to,cost]:edge[p]){
if(--in[to]==0)st.push(to);
}
}
return {(int)ans.size()==size, ans};
}
};
class GridGraphBase{
protected:
static const char ROAD_CHAR='.', WALL_CHAR='#', DIRECTION_CHAR[];
static const int DY[],DX[];
};
const int GridGraphBase::DY[]={0,1,0,-1,1,1,-1,-1};
const int GridGraphBase::DX[]={1,0,-1,0,1,-1,-1,1};
const char GridGraphBase::DIRECTION_CHAR[]="RDLU";
template<class Cell=int>struct GridGraph : public Graph<int> , private GridGraphBase{
int h,w;
vector<Cell> field;
constexpr typename vector<Cell>::iterator operator[](int i) { return field.begin() + i * w; }
constexpr Cell &at(int i, int j) { return field[i*w+j]; }
constexpr Cell get(int i, int j) const { return field[i*w+j]; }
GridGraph(int&_h, int&_w):Graph((_h+=2)*(_w+=2),INF),h(_h),w(_w){
edge.resize(h*w);
field.resize(h*w,ROAD);
rep(i,h)at(i,0)=at(i,w-1)=WALL;
rep(j,w)at(0,j)=at(h-1,j)=WALL;
}
constexpr void input(){
char c;
rep(i,1,h-1)rep(j,1,w-1){cin>>c; at(i,j)=(c==WALL_CHAR?WALL:ROAD);}
rep(i,1,h-1)rep(j,1,w-1)if(get(i,j)==ROAD){
if(get(i+1,j)==ROAD)add(i*w+j, i*w+j+w, 1);
if(get(i,j+1)==ROAD)add(i*w+j, i*w+j+1, 1);
}
}
constexpr friend ostream &operator<<(ostream &os, const GridGraph<Cell> &g) {
rep(i,g.h){rep(j,g.w)os<<(g.get(i,j)==WALL?WALL_CHAR:ROAD_CHAR);os<<endl;}
return os;
}
template<int tgt=4> constexpr vector<tuple<int,int,int>> neighborIndex(int y, int x, Cell v=ROAD){
vector<tuple<int,int,int>> p;
rep(i,tgt)if(get(y+DY[i],x+DX[i])==v)p.emplace_back(y+DY[i],x+DX[i],i);
return p;
}
template<int tgt=4> constexpr vector<reference_wrapper<Cell>> neighborCell(int y, int x, Cell v=ROAD){
vector<reference_wrapper<Cell>> p;
rep(i,tgt)if(get(y+DY[i],x+DX[i])==v)p.push_back(at(y+DY[i],x+DX[i]));
return p;
}
private:
static constexpr Cell ROAD=0, WALL=-1;
};
template<class T=int>struct Tree : public Graph<T>{
Tree(int n, T inf=INF):Graph<T>(n,inf){}
static pair<int,Tree<T>> input(bool weighted=false, bool directed=false){
def(int,n);
Tree<T> g(n);
g.inputEdge(n-1,weighted,directed);
return {n,g};
}
pair<T,vi> diameter(){
auto [s,_]=getMaxAndIndex(this->bfs(0));
auto [t,w]=getMaxAndIndex(this->bfs(s));
return this->bfs(s,t);
}
};
template<class T=ll>struct WarshallFloyd{
Graph<T> g;
WarshallFloyd(Graph<T> g):g(g){}
pair<bool, vector<vector<T>>>dist(){
bool isNegativeCycle=false;
vector<vector<T>> ret(g.size,vector<T>(g.size,g.INF_VAL));
rep(f,g.size){
ret[f][f]=0;
for(auto&[t,c]:g.edge[f])ret[f][t]=c;
}
rep(k,g.size)rep(i,g.size)if(ret[i][k]!=g.INF_VAL)
rep(j,g.size)if(ret[k][j]!=g.INF_VAL)
chmin(ret[i][j],ret[i][k]+ret[k][j]);
rep(i,g.size)isNegativeCycle|=ret[i][i]<0;
return {isNegativeCycle,ret};
}
};
int main() {
/**/
def(ll,h,w,n);
vs f(h); in(f);
Graph<> g(h*w);
ll oc=0,s=0,t=0;
vl os;
rep(i,h)rep(j,w){
if(f[i][j]=='#')continue;
if(i!=h-1 and f[i+1][j]!='#'){
g.add(i*w+j, (i+1)*w+j, 1);
}
if(j!=w-1 and f[i][j+1]!='#'){
g.add(i*w+j, i*w+j+1,1);
}
if(f[i][j]=='S')s=i*w+j;
if(f[i][j]=='G')t=i*w+j;
if(f[i][j]=='o'){
oc++;
os.push_back(i*w+j);
}
}
os.push_back(t);
os.push_back(s);
reverse(all(os));
oc+=2;
Graph<> g2(oc);
rep(i,oc){
auto d=g.bfs(os[i]);
rep(j,oc)if(i!=j){
g2.add(i,j,d[os[j]]);
}
}
auto[_,war]=WarshallFloyd(g2).dist();
if(war[0][1]>n){
out(-1);
return 0;
}
debug(war);
vvl dp(oc, vl(1<<oc, LINF));
dp[0][1]=0;
rep(ss, 1<<oc){
rep(p,oc)if((1<<p)&ss)if(dp[p][ss]!=LINF){
rep(p2,oc)if(!((1<<p2)&ss)){
chmin(dp[p2][ss|(1<<p2)], dp[p][ss]+war[p][p2]);
}
}
}
ll ans=0;
rep(ss,1<<oc)if(dp[1][ss]<=n)chmax(ans, __builtin_popcount(ss)-2LL);
out(ans);
} | [
"[email protected]"
] | |
ff6c3f051f1e2e04e95f92acad72edfad63e3df7 | fb95534e8519acb3670ee9743ddb15bf09232e70 | /examples/xtd.forms.examples/others/text_box_multiline/src/text_box_multiline.cpp | a7231c6114d91bf3275065566125661aa7bee2ab | [
"MIT"
] | permissive | niansa/xtd | a5050e27fda1f092cea85db264820d6518994893 | 4d412ab046f51da2e5baf782f9f2f5bb23c49840 | refs/heads/master | 2023-09-01T01:13:25.592979 | 2021-10-28T14:30:05 | 2021-10-28T14:30:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,496 | cpp | #include <xtd/xtd>
using namespace xtd::forms;
namespace examples {
class form1 : public form {
public:
form1() {
text("Text box multiline example");
client_size({480, 320});
controls().push_back(text_box);
text_box.dock(dock_style::fill);
text_box.multiline(true);
text_box.text("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor. Cras elementum ultrices diam. Maecenas ligula massa, varius a, semper congue, euismod non, mi. Proin porttitor, orci nec nonummy molestie, enim est eleifend mi, non fermentum diam nisl sit amet erat. Duis semper. Duis arcu massa, scelerisque vitae, consequat in, pretium a, enim. Pellentesque congue. Ut in risus volutpat libero pharetra tempor. Cras vestibulum bibendum augue. Praesent egestas leo in pede. Praesent blandit odio eu enim. Pellentesque sed dui ut augue blandit sodales. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aliquam nibh. Mauris ac mauris sed pede pellentesque fermentum. Maecenas adipiscing ante non diam sodales hendrerit.\n\nUt velit mauris, egestas sed, gravida nec, ornare ut, mi. Aenean ut orci vel massa suscipit pulvinar. Nulla sollicitudin. Fusce varius, ligula non tempus aliquam, nunc turpis ullamcorper nibh, in tempus sapien eros vitae ligula. Pellentesque rhoncus nunc et augue. Integer id felis. Curabitur aliquet pellentesque diam. Integer quis metus vitae elit lobortis egestas. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Morbi vel erat non mauris convallis vehicula. Nulla et sapien. Integer tortor tellus, aliquam faucibus, convallis id, congue eu, quam. Mauris ullamcorper felis vitae erat. Proin feugiat, augue non elementum posuere, metus purus iaculis lectus, et tristique ligula justo vitae magna.\n\nAliquam convallis sollicitudin purus. Praesent aliquam, enim at fermentum mollis, ligula massa adipiscing nisl, ac euismod nibh nisl eu lectus. Fusce vulputate sem at sapien. Vivamus leo. Aliquam euismod libero eu enim. Nulla nec felis sed leo placerat imperdiet. Aenean suscipit nulla in justo. Suspendisse cursus rutrum augue. Nulla tincidunt tincidunt mi. Curabitur iaculis, lorem vel rhoncus faucibus, felis magna fermentum augue, et ultricies lacus lorem varius purus. Curabitur eu amet.\n");
}
private:
text_box text_box;
};
}
int main() {
application::run(examples::form1());
}
| [
"[email protected]"
] | |
306f7ae1ff0fc4ef312ea7d9389439dfefc45e94 | 9f04e27993784568035a4db808d34b633fba72da | /Hazel/src/Hazel/Core/Log.cpp | 28f09212d6b1cbca82ac0cf5ffcbd0699165f830 | [] | no_license | VictorNetto/Hazel-Clone | 22a99b2933b20f0229121670949c3df359814b15 | 2d9af36f9e501484db5642450f21778d7febcd7b | refs/heads/master | 2023-03-27T12:35:33.376550 | 2021-03-24T11:56:11 | 2021-03-24T11:56:11 | 351,063,472 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 507 | cpp | #include "Log.h"
#include "spdlog/sinks/stdout_color_sinks.h"
namespace Hazel {
std::shared_ptr<spdlog::logger> Log::s_CoreLogger;
std::shared_ptr<spdlog::logger> Log::s_ClientLogger;
void Log::Init()
{
spdlog::set_pattern("%^[%T] %n: %v%$");
s_CoreLogger = spdlog::stdout_color_mt("HAZEL");
s_CoreLogger->set_level(spdlog::level::trace);
s_ClientLogger = spdlog::stdout_color_mt("APP");
s_ClientLogger->set_level(spdlog::level::trace);
}
} | [
"[email protected]"
] | |
656cde9dcb312170ef0460c50cf627ff7b7615fc | de7e771699065ec21a340ada1060a3cf0bec3091 | /core/src/java/org/apache/lucene/index/IndexWriter.h | 3918a0a139ea57e7229494e434f6da8d6648bec6 | [] | no_license | sraihan73/Lucene- | 0d7290bacba05c33b8d5762e0a2a30c1ec8cf110 | 1fe2b48428dcbd1feb3e10202ec991a5ca0d54f3 | refs/heads/master | 2020-03-31T07:23:46.505891 | 2018-12-08T14:57:54 | 2018-12-08T14:57:54 | 152,020,180 | 7 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 85,679 | h | #pragma once
#include "exceptionhelper.h"
#include "stringbuilder.h"
#include "stringhelper.h"
#include <algorithm>
#include <functional>
#include <limits>
#include <deque>
#include <memory>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <deque>
// C++ NOTE: Forward class declarations:
#include "core/src/java/org/apache/lucene/store/Directory.h"
#include "core/src/java/org/apache/lucene/analysis/Analyzer.h"
#include "core/src/java/org/apache/lucene/index/SegmentCommitInfo.h"
#include "core/src/java/org/apache/lucene/index/SegmentInfos.h"
#include "core/src/java/org/apache/lucene/index/FieldInfos.h"
#include "core/src/java/org/apache/lucene/index/FieldNumbers.h"
#include "core/src/java/org/apache/lucene/index/DocumentsWriter.h"
#include "core/src/java/org/apache/lucene/index/Event.h"
#include "core/src/java/org/apache/lucene/index/IndexFileDeleter.h"
#include "core/src/java/org/apache/lucene/store/Lock.h"
#include "core/src/java/org/apache/lucene/index/MergeScheduler.h"
#include "core/src/java/org/apache/lucene/index/MergePolicy.h"
#include "core/src/java/org/apache/lucene/index/OneMerge.h"
#include "core/src/java/org/apache/lucene/index/ReaderPool.h"
#include "core/src/java/org/apache/lucene/index/BufferedUpdatesStream.h"
#include "core/src/java/org/apache/lucene/index/LiveIndexWriterConfig.h"
#include "core/src/java/org/apache/lucene/index/FlushNotifications.h"
#include "core/src/java/org/apache/lucene/index/SegmentInfo.h"
#include "core/src/java/org/apache/lucene/index/DirectoryReader.h"
#include "core/src/java/org/apache/lucene/store/AlreadyClosedException.h"
#include "core/src/java/org/apache/lucene/codecs/Codec.h"
#include "core/src/java/org/apache/lucene/index/IndexWriterConfig.h"
#include "core/src/java/org/apache/lucene/index/CorruptIndexException.h"
#include "core/src/java/org/apache/lucene/util/InfoStream.h"
#include "core/src/java/org/apache/lucene/index/Term.h"
#include "core/src/java/org/apache/lucene/index/DocumentsWriterDeleteQueue.h"
namespace org::apache::lucene::index
{
template <typename T>
class Node;
}
#include "core/src/java/org/apache/lucene/document/Field.h"
#include "core/src/java/org/apache/lucene/index/IndexReader.h"
#include "core/src/java/org/apache/lucene/index/ReadersAndUpdates.h"
#include "core/src/java/org/apache/lucene/search/Query.h"
#include "core/src/java/org/apache/lucene/util/BytesRef.h"
#include "core/src/java/org/apache/lucene/index/DocValuesUpdate.h"
#include "core/src/java/org/apache/lucene/index/FrozenBufferedUpdates.h"
#include "core/src/java/org/apache/lucene/index/Sorter.h"
#include "core/src/java/org/apache/lucene/index/DocMap.h"
#include "core/src/java/org/apache/lucene/index/CodecReader.h"
#include "core/src/java/org/apache/lucene/store/IOContext.h"
#include "core/src/java/org/apache/lucene/index/DocValuesFieldUpdates.h"
#include "core/src/java/org/apache/lucene/index/Iterator.h"
#include "core/src/java/org/apache/lucene/index/MergeState.h"
#include "core/src/java/org/apache/lucene/util/Bits.h"
#include "core/src/java/org/apache/lucene/index/LeafReader.h"
#include "core/src/java/org/apache/lucene/store/TrackingDirectoryWrapper.h"
#include "core/src/java/org/apache/lucene/util/IOUtils.h"
namespace org::apache::lucene::util
{
template <typename T>
class IOConsumer;
}
/*
* Licensed to the Syed Mamun Raihan (sraihan.com) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* sraihan.com licenses this file to You under GPLv3 License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.gnu.org/licenses/gpl-3.0.en.html
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace org::apache::lucene::index
{
using Analyzer = org::apache::lucene::analysis::Analyzer;
using Codec = org::apache::lucene::codecs::Codec;
using Field = org::apache::lucene::document::Field;
using FieldNumbers = org::apache::lucene::index::FieldInfos::FieldNumbers;
using Query = org::apache::lucene::search::Query;
using AlreadyClosedException =
org::apache::lucene::store::AlreadyClosedException;
using Directory = org::apache::lucene::store::Directory;
using IOContext = org::apache::lucene::store::IOContext;
using Lock = org::apache::lucene::store::Lock;
using TrackingDirectoryWrapper =
org::apache::lucene::store::TrackingDirectoryWrapper;
using Accountable = org::apache::lucene::util::Accountable;
using ArrayUtil = org::apache::lucene::util::ArrayUtil;
using Bits = org::apache::lucene::util::Bits;
using BytesRef = org::apache::lucene::util::BytesRef;
using IOUtils = org::apache::lucene::util::IOUtils;
using InfoStream = org::apache::lucene::util::InfoStream;
using UnicodeUtil = org::apache::lucene::util::UnicodeUtil;
// C++ TODO: The Java 'import static' statement cannot be converted to C++:
// import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
/**
An <code>IndexWriter</code> creates and maintains an index.
<p>The {@link OpenMode} option on
{@link IndexWriterConfig#setOpenMode(OpenMode)} determines
whether a new index is created, or whether an existing index is
opened. Note that you can open an index with {@link OpenMode#CREATE}
even while readers are using the index. The old readers will
continue to search the "point in time" snapshot they had opened,
and won't see the newly created index until they re-open. If
{@link OpenMode#CREATE_OR_APPEND} is used IndexWriter will create a
new index if there is not already an index at the provided path
and otherwise open the existing index.</p>
<p>In either case, documents are added with {@link #addDocument(Iterable)
addDocument} and removed with {@link #deleteDocuments(Term...)} or {@link
#deleteDocuments(Query...)}. A document can be updated with {@link
#updateDocument(Term, Iterable) updateDocument} (which just deletes
and then adds the entire document). When finished adding, deleting
and updating documents, {@link #close() close} should be called.</p>
<a name="sequence_numbers"></a>
<p>Each method that changes the index returns a {@code long} sequence number,
which expresses the effective order in which each change was applied.
{@link #commit} also returns a sequence number, describing which
changes are in the commit point and which are not. Sequence numbers
are transient (not saved into the index in any way) and only valid
within a single {@code IndexWriter} instance.</p>
<a name="flush"></a>
<p>These changes are buffered in memory and periodically
flushed to the {@link Directory} (during the above method
calls). A flush is triggered when there are enough added documents
since the last flush. Flushing is triggered either by RAM usage of the
documents (see {@link IndexWriterConfig#setRAMBufferSizeMB}) or the
number of added documents (see {@link
IndexWriterConfig#setMaxBufferedDocs(int)}). The default is to flush when RAM
usage hits
{@link IndexWriterConfig#DEFAULT_RAM_BUFFER_SIZE_MB} MB. For
best indexing speed you should flush by RAM usage with a
large RAM buffer.
In contrast to the other flush options {@link
IndexWriterConfig#setRAMBufferSizeMB} and
{@link IndexWriterConfig#setMaxBufferedDocs(int)}, deleted terms
won't trigger a segment flush. Note that flushing just moves the
internal buffered state in IndexWriter into the index, but
these changes are not visible to IndexReader until either
{@link #commit()} or {@link #close} is called. A flush may
also trigger one or more segment merges which by default
run with a background thread so as not to block the
addDocument calls (see <a href="#mergePolicy">below</a>
for changing the {@link MergeScheduler}).</p>
<p>Opening an <code>IndexWriter</code> creates a lock file for the directory
in use. Trying to open another <code>IndexWriter</code> on the same directory
will lead to a
{@link LockObtainFailedException}.</p>
<a name="deletionPolicy"></a>
<p>Expert: <code>IndexWriter</code> allows an optional
{@link IndexDeletionPolicy} implementation to be specified. You
can use this to control when prior commits are deleted from
the index. The default policy is {@link KeepOnlyLastCommitDeletionPolicy}
which removes all prior commits as soon as a new commit is
done. Creating your own policy can allow you to explicitly
keep previous "point in time" commits alive in the index for
some time, either because this is useful for your application,
or to give readers enough time to refresh to the new commit
without having the old commit deleted out from under them.
The latter is necessary when multiple computers take turns opening
their own {@code IndexWriter} and {@code IndexReader}s
against a single shared index mounted via remote filesystems
like NFS which do not support "delete on last close" semantics.
A single computer accessing an index via NFS is fine with the
default deletion policy since NFS clients emulate "delete on
last close" locally. That said, accessing an index via NFS
will likely result in poor performance compared to a local IO
device. </p>
<a name="mergePolicy"></a> <p>Expert:
<code>IndexWriter</code> allows you to separately change
the {@link MergePolicy} and the {@link MergeScheduler}.
The {@link MergePolicy} is invoked whenever there are
changes to the segments in the index. Its role is to
select which merges to do, if any, and return a {@link
MergePolicy.MergeSpecification} describing the merges.
The default is {@link LogByteSizeMergePolicy}. Then, the {@link
MergeScheduler} is invoked with the requested merges and
it decides when and how to run the merges. The default is
{@link ConcurrentMergeScheduler}. </p>
<a name="OOME"></a><p><b>NOTE</b>: if you hit a
VirtualMachineError, or disaster strikes during a checkpoint
then IndexWriter will close itself. This is a
defensive measure in case any internal state (buffered
documents, deletions, reference counts) were corrupted.
Any subsequent calls will throw an AlreadyClosedException.</p>
<a name="thread-safety"></a><p><b>NOTE</b>: {@link
IndexWriter} instances are completely thread
safe, meaning multiple threads can call any of its
methods, concurrently. If your application requires
external synchronization, you should <b>not</b>
synchronize on the <code>IndexWriter</code> instance as
this may cause deadlock; use your own (non-Lucene) objects
instead. </p>
<p><b>NOTE</b>: If you call
<code>Thread.interrupt()</code> on a thread that's within
IndexWriter, IndexWriter will try to catch this (eg, if
it's in a wait() or Thread.sleep()), and will then throw
the unchecked exception {@link ThreadInterruptedException}
and <b>clear</b> the interrupt status on the thread.</p>
*/
/*
* Clarification: Check Points (and commits)
* IndexWriter writes new index files to the directory without writing a new
* segments_N file which references these new files. It also means that the
* state of the in memory SegmentInfos object is different than the most recent
* segments_N file written to the directory.
*
* Each time the SegmentInfos is changed, and matches the (possibly
* modified) directory files, we have a new "check point".
* If the modified/new SegmentInfos is written to disk - as a new
* (generation of) segments_N file - this check point is also an
* IndexCommit.
*
* A new checkpoint always replaces the previous checkpoint and
* becomes the new "front" of the index. This allows the IndexFileDeleter
* to delete files that are referenced only by stale checkpoints.
* (files that were created since the last commit, but are no longer
* referenced by the "front" of the index). For this, IndexFileDeleter
* keeps track of the last non commit checkpoint.
*/
class IndexWriter : public std::enable_shared_from_this<IndexWriter>,
public TwoPhaseCommit,
public Accountable,
public MergePolicy::MergeContext
{
GET_CLASS_NAME(IndexWriter)
/** Hard limit on maximum number of documents that may be added to the
* index. If you try to add more than this you'll hit {@code
* IllegalArgumentException}. */
// We defensively subtract 128 to be well below the lowest
// ArrayUtil.MAX_ARRAY_LENGTH on "typical" JVMs. We don't just use
// ArrayUtil.MAX_ARRAY_LENGTH here because this can vary across JVMs:
public:
static const int MAX_DOCS = std::numeric_limits<int>::max() - 128;
/** Maximum value of the token position in an indexed field. */
static const int MAX_POSITION = std::numeric_limits<int>::max() - 128;
// Use package-private instance var to enforce the limit so testing
// can use less electricity:
private:
static int actualMaxDocs;
/** Used only for testing. */
public:
static void setMaxDocs(int maxDocs);
static int getActualMaxDocs();
/** Used only for testing. */
private:
const bool enableTestPoints;
public:
static constexpr int UNBOUNDED_MAX_MERGE_SEGMENTS = -1;
/**
* Name of the write lock in the index.
*/
static const std::wstring WRITE_LOCK_NAME;
/** Key for the source of a segment in the {@link SegmentInfo#getDiagnostics()
* diagnostics}. */
static const std::wstring SOURCE;
/** Source of a segment which results from a merge of other segments. */
static const std::wstring SOURCE_MERGE;
/** Source of a segment which results from a flush. */
static const std::wstring SOURCE_FLUSH;
/** Source of a segment which results from a call to {@link
* #addIndexes(CodecReader...)}. */
static const std::wstring SOURCE_ADDINDEXES_READERS;
/**
* Absolute hard maximum length for a term, in bytes once
* encoded as UTF8. If a term arrives from the analyzer
* longer than this length, an
* <code>IllegalArgumentException</code> is thrown
* and a message is printed to infoStream, if set (see {@link
* IndexWriterConfig#setInfoStream(InfoStream)}).
*/
static const int MAX_TERM_LENGTH =
DocumentsWriterPerThread::MAX_TERM_LENGTH_UTF8;
/**
* Maximum length string for a stored field.
*/
static const int MAX_STORED_STRING_LENGTH =
ArrayUtil::MAX_ARRAY_LENGTH / UnicodeUtil::MAX_UTF8_BYTES_PER_CHAR;
// when unrecoverable disaster strikes, we populate this with the reason that
// we had to close IndexWriter
const std::shared_ptr<AtomicReference<std::runtime_error>> tragedy =
std::make_shared<AtomicReference<std::runtime_error>>(nullptr);
private:
const std::shared_ptr<Directory> directoryOrig; // original user directory
const std::shared_ptr<Directory> directory; // wrapped with additional checks
const std::shared_ptr<Analyzer> analyzer; // how to analyze text
const std::shared_ptr<AtomicLong> changeCount =
std::make_shared<AtomicLong>(); // increments every time a change is
// completed
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: private volatile long lastCommitChangeCount;
int64_t lastCommitChangeCount = 0; // last changeCount that was committed
std::deque<std::shared_ptr<SegmentCommitInfo>>
rollbackSegments; // deque of segmentInfo we will fallback to if the commit
// fails
public:
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: volatile SegmentInfos pendingCommit;
std::shared_ptr<SegmentInfos>
pendingCommit; // set when a commit is pending (after prepareCommit() &
// before commit())
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: volatile long pendingSeqNo;
int64_t pendingSeqNo = 0;
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: volatile long pendingCommitChangeCount;
int64_t pendingCommitChangeCount = 0;
private:
std::shared_ptr<std::deque<std::wstring>> filesToCommit;
public:
const std::shared_ptr<SegmentInfos> segmentInfos; // the segments
const std::shared_ptr<FieldNumbers> globalFieldNumberMap;
const std::shared_ptr<DocumentsWriter> docWriter;
private:
const std::deque<Event> eventQueue =
std::make_shared<ConcurrentLinkedQueue<Event>>();
public:
const std::shared_ptr<IndexFileDeleter> deleter;
// used by forceMerge to note those needing merging
private:
std::unordered_map<std::shared_ptr<SegmentCommitInfo>, bool> segmentsToMerge =
std::unordered_map<std::shared_ptr<SegmentCommitInfo>, bool>();
int mergeMaxNumSegments = 0;
std::shared_ptr<Lock> writeLock;
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: private volatile bool closed;
bool closed = false;
// C++ TODO: 'volatile' has a different meaning in C++:
// ORIGINAL LINE: private volatile bool closing;
bool closing = false;
public:
// C++ NOTE: Fields cannot have the same name as methods:
const std::shared_ptr<AtomicBoolean> maybeMerge_ =
std::make_shared<AtomicBoolean>();
private:
std::deque<std::unordered_map::Entry<std::wstring, std::wstring>>
commitUserData;
// Holds all SegmentInfo instances currently involved in
// merges
public:
std::unordered_set<std::shared_ptr<SegmentCommitInfo>> mergingSegments =
std::unordered_set<std::shared_ptr<SegmentCommitInfo>>();
private:
const std::shared_ptr<MergeScheduler> mergeScheduler;
std::deque<std::shared_ptr<MergePolicy::OneMerge>> pendingMerges =
std::deque<std::shared_ptr<MergePolicy::OneMerge>>();
std::shared_ptr<Set<std::shared_ptr<MergePolicy::OneMerge>>> runningMerges =
std::unordered_set<std::shared_ptr<MergePolicy::OneMerge>>();
std::deque<std::shared_ptr<MergePolicy::OneMerge>> mergeExceptions =
std::deque<std::shared_ptr<MergePolicy::OneMerge>>();
int64_t mergeGen = 0;
bool stopMerges = false;
bool didMessageState = false;
public:
const std::shared_ptr<AtomicInteger> flushCount =
std::make_shared<AtomicInteger>();
const std::shared_ptr<AtomicInteger> flushDeletesCount =
std::make_shared<AtomicInteger>();
private:
const std::shared_ptr<ReaderPool> readerPool;
public:
const std::shared_ptr<BufferedUpdatesStream> bufferedUpdatesStream;
/** Counts how many merges have completed; this is used by {@link
* FrozenBufferedUpdates#apply} to handle concurrently apply deletes/updates
* with merges completing. */
const std::shared_ptr<AtomicLong> mergeFinishedGen =
std::make_shared<AtomicLong>();
// The instance that was passed to the constructor. It is saved only in order
// to allow users to query an IndexWriter settings.
private:
const std::shared_ptr<LiveIndexWriterConfig> config;
/** System.nanoTime() when commit started; used to write
* an infoStream message about how long commit took. */
int64_t startCommitTime = 0;
/** How many documents are in the index, or are in the process of being
* added (reserved). E.g., operations like addIndexes will first reserve
* the right to add N docs, before they actually change the index,
* much like how hotels place an "authorization hold" on your credit
* card to make sure they can later charge you when you check out. */
public:
const std::shared_ptr<AtomicLong> pendingNumDocs =
std::make_shared<AtomicLong>();
const bool softDeletesEnabled;
private:
const std::shared_ptr<DocumentsWriter::FlushNotifications>
flushNotifications =
std::make_shared<FlushNotificationsAnonymousInnerClass>();
private:
class FlushNotificationsAnonymousInnerClass
: public std::enable_shared_from_this<
FlushNotificationsAnonymousInnerClass>,
public DocumentsWriter::FlushNotifications
{
GET_CLASS_NAME(FlushNotificationsAnonymousInnerClass)
public:
FlushNotificationsAnonymousInnerClass();
void
deleteUnusedFiles(std::shared_ptr<std::deque<std::wstring>> files) override;
void flushFailed(std::shared_ptr<SegmentInfo> info) override;
void afterSegmentsFlushed() override;
void onTragicEvent(std::runtime_error event_,
const std::wstring &message) override;
void onDeletesApplied() override;
void onTicketBacklog() override;
};
public:
virtual std::shared_ptr<DirectoryReader> getReader() ;
/**
* Expert: returns a readonly reader, covering all
* committed as well as un-committed changes to the index.
* This provides "near real-time" searching, in that
* changes made during an IndexWriter session can be
* quickly made available for searching without closing
* the writer nor calling {@link #commit}.
*
* <p>Note that this is functionally equivalent to calling
* {#flush} and then opening a new reader. But the turnaround time of this
* method should be faster since it avoids the potentially
* costly {@link #commit}.</p>
*
* <p>You must close the {@link IndexReader} returned by
* this method once you are done using it.</p>
*
* <p>It's <i>near</i> real-time because there is no hard
* guarantee on how quickly you can get a new reader after
* making changes with IndexWriter. You'll have to
* experiment in your situation to determine if it's
* fast enough. As this is a new and experimental
* feature, please report back on your findings so we can
* learn, improve and iterate.</p>
*
* <p>The resulting reader supports {@link
* DirectoryReader#openIfChanged}, but that call will simply forward
* back to this method (though this may change in the
* future).</p>
*
* <p>The very first time this method is called, this
* writer instance will make every effort to pool the
* readers that it opens for doing merges, applying
* deletes, etc. This means additional resources (RAM,
* file descriptors, CPU time) will be consumed.</p>
*
* <p>For lower latency on reopening a reader, you should
* call {@link IndexWriterConfig#setMergedSegmentWarmer} to
* pre-warm a newly merged segment before it's committed
* to the index. This is important for minimizing
* index-to-search delay after a large merge. </p>
*
* <p>If an addIndexes* call is running in another thread,
* then this reader will only search those segments from
* the foreign index that have been successfully copied
* over, so far</p>.
*
* <p><b>NOTE</b>: Once the writer is closed, any
* outstanding readers may continue to be used. However,
* if you attempt to reopen any of those readers, you'll
* hit an {@link AlreadyClosedException}.</p>
*
* @lucene.experimental
*
* @return IndexReader that covers entire index plus all
* changes made so far by this IndexWriter instance
*
* @throws IOException If there is a low-level I/O error
*/
virtual std::shared_ptr<DirectoryReader>
getReader(bool applyAllDeletes, bool writeAllDeletes) ;
int64_t ramBytesUsed() override;
int64_t getReaderPoolRamBytesUsed();
private:
const std::shared_ptr<AtomicBoolean> writeDocValuesLock =
std::make_shared<AtomicBoolean>();
public:
virtual void writeSomeDocValuesUpdates() ;
/**
* Obtain the number of deleted docs for a pooled reader.
* If the reader isn't being pooled, the segmentInfo's
* delCount is returned.
*/
int numDeletedDocs(std::shared_ptr<SegmentCommitInfo> info) override;
/**
* Used internally to throw an {@link AlreadyClosedException} if this
* IndexWriter has been closed or is in the process of closing.
*
* @param failIfClosing
* if true, also fail when {@code IndexWriter} is in the process of
* closing ({@code closing=true}) but not yet done closing (
* {@code closed=false})
* @throws AlreadyClosedException
* if this IndexWriter is closed or in the process of closing
*/
protected:
void ensureOpen(bool failIfClosing) ;
/**
* Used internally to throw an {@link
* AlreadyClosedException} if this IndexWriter has been
* closed ({@code closed=true}) or is in the process of
* closing ({@code closing=true}).
* <p>
* Calls {@link #ensureOpen(bool) ensureOpen(true)}.
* @throws AlreadyClosedException if this IndexWriter is closed
*/
void ensureOpen() ;
public:
const std::shared_ptr<Codec> codec; // for writing new segments
/**
* Constructs a new IndexWriter per the settings given in <code>conf</code>.
* If you want to make "live" changes to this writer instance, use
* {@link #getConfig()}.
*
* <p>
* <b>NOTE:</b> after ths writer is created, the given configuration instance
* cannot be passed to another writer.
*
* @param d
* the index directory. The index is either created or appended
* according <code>conf.getOpenMode()</code>.
* @param conf
* the configuration settings according to which IndexWriter should
* be initialized.
* @throws IOException
* if the directory cannot be read/written to, or if it does not
* exist and <code>conf.getOpenMode()</code> is
* <code>OpenMode.APPEND</code> or if there is any other low-level
* IO error
*/
IndexWriter(std::shared_ptr<Directory> d,
std::shared_ptr<IndexWriterConfig> conf) ;
/** Confirms that the incoming index sort (if any) matches the existing index
* sort (if any). This is unfortunately just best effort, because it could be
* the old index only has unsorted flushed segments built before {@link
* Version#LUCENE_6_5_0} (flushed segments are sorted in Lucene 7.0). */
private:
void validateIndexSort() ;
// reads latest field infos for the commit
// this is used on IW init and addIndexes(Dir) to create/update the global
// field map_obj.
// TODO: fix tests abusing this method!
public:
static std::shared_ptr<FieldInfos>
readFieldInfos(std::shared_ptr<SegmentCommitInfo> si) ;
/**
* Loads or returns the already loaded the global field number map_obj for this
* {@link SegmentInfos}. If this {@link SegmentInfos} has no global field
* number map_obj the returned instance is empty
*/
private:
std::shared_ptr<FieldNumbers> getFieldNumberMap() ;
/**
* Returns a {@link LiveIndexWriterConfig}, which can be used to query the
* IndexWriter current settings, as well as modify "live" ones.
*/
public:
virtual std::shared_ptr<LiveIndexWriterConfig> getConfig();
private:
void messageState();
/**
* Gracefully closes (commits, waits for merges), but calls rollback
* if there's an exc so the IndexWriter is always closed. This is called
* from {@link #close} when {@link IndexWriterConfig#commitOnClose} is
* {@code true}.
*/
void shutdown() ;
/**
* Closes all open resources and releases the write lock.
*
* If {@link IndexWriterConfig#commitOnClose} is <code>true</code>,
* this will attempt to gracefully shut down by writing any
* changes, waiting for any running merges, committing, and closing.
* In this case, note that:
* <ul>
* <li>If you called prepareCommit but failed to call commit, this
* method will throw {@code IllegalStateException} and the {@code
* IndexWriter} will not be closed.</li> <li>If this method throws any other
* exception, the {@code IndexWriter} will be closed, but changes may have
* been lost.</li>
* </ul>
*
* <p>
* Note that this may be a costly
* operation, so, try to re-use a single writer instead of
* closing and opening a new one. See {@link #commit()} for
* caveats about write caching done by some IO devices.
*
* <p><b>NOTE</b>: You must ensure no other threads are still making
* changes at the same time that this method is invoked.</p>
*/
public:
virtual ~IndexWriter();
// Returns true if this thread should attempt to close, or
// false if IndexWriter is now closed; else,
// waits until another thread finishes closing
private:
// C++ WARNING: The following method was originally marked 'synchronized':
bool shouldClose(bool waitForClose);
/** Returns the Directory used by this index. */
public:
virtual std::shared_ptr<Directory> getDirectory();
std::shared_ptr<InfoStream> getInfoStream() override;
/** Returns the analyzer used by this index. */
virtual std::shared_ptr<Analyzer> getAnalyzer();
/** Returns total number of docs in this index, including
* docs not yet flushed (still in the RAM buffer),
* not counting deletions.
* @see #numDocs */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual int maxDoc();
/** If {@link SegmentInfos#getVersion} is below {@code newVersion} then update
* it to this value.
*
* @lucene.internal */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void advanceSegmentInfosVersion(int64_t newVersion);
/** Returns total number of docs in this index, including
* docs not yet flushed (still in the RAM buffer), and
* including deletions. <b>NOTE:</b> buffered deletions
* are not counted. If you really need these to be
* counted you should call {@link #commit()} first.
* @see #numDocs */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual int numDocs();
/**
* Returns true if this index has deletions (including
* buffered deletions). Note that this will return true
* if there are buffered Term/Query deletions, even if it
* turns out those buffered deletions don't match any
* documents.
*/
// C++ WARNING: The following method was originally marked 'synchronized':
virtual bool hasDeletions();
/**
* Adds a document to this index.
*
* <p> Note that if an Exception is hit (for example disk full)
* then the index will be consistent, but this document
* may not have been added. Furthermore, it's possible
* the index will have one segment in non-compound format
* even when using compound files (when a merge has
* partially succeeded).</p>
*
* <p> This method periodically flushes pending documents
* to the Directory (see <a href="#flush">above</a>), and
* also periodically triggers segment merges in the index
* according to the {@link MergePolicy} in use.</p>
*
* <p>Merges temporarily consume space in the
* directory. The amount of space required is up to 1X the
* size of all segments being merged, when no
* readers/searchers are open against the index, and up to
* 2X the size of all segments being merged when
* readers/searchers are open against the index (see
* {@link #forceMerge(int)} for details). The sequence of
* primitive merge operations performed is governed by the
* merge policy.
*
* <p>Note that each term in the document can be no longer
* than {@link #MAX_TERM_LENGTH} in bytes, otherwise an
* IllegalArgumentException will be thrown.</p>
*
* <p>Note that it's possible to create an invalid Unicode
* string in java if a UTF16 surrogate pair is malformed.
* In this case, the invalid characters are silently
* replaced with the Unicode replacement character
* U+FFFD.</p>
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long addDocument(Iterable<? extends
// IndexableField> doc) throws java.io.IOException
int64_t addDocument(std::deque<T1> doc) ;
/**
* Atomically adds a block of documents with sequentially
* assigned document IDs, such that an external reader
* will see all or none of the documents.
*
* <p><b>WARNING</b>: the index does not currently record
* which documents were added as a block. Today this is
* fine, because merging will preserve a block. The order of
* documents within a segment will be preserved, even when child
* documents within a block are deleted. Most search features
* (like result grouping and block joining) require you to
* mark documents; when these documents are deleted these
* search features will not work as expected. Obviously adding
* documents to an existing block will require you the reindex
* the entire block.
*
* <p>However it's possible that in the future Lucene may
* merge more aggressively re-order documents (for example,
* perhaps to obtain better index compression), in which case
* you may need to fully re-index your documents at that time.
*
* <p>See {@link #addDocument(Iterable)} for details on
* index and IndexWriter state after an Exception, and
* flushing/merging temporary free space requirements.</p>
*
* <p><b>NOTE</b>: tools that do offline splitting of an index
* (for example, IndexSplitter in contrib) or
* re-sorting of documents (for example, IndexSorter in
* contrib) are not aware of these atomically added documents
* and will likely break them up. Use such tools at your
* own risk!
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*
* @lucene.experimental
*/
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long addDocuments(Iterable<? extends
// Iterable<? extends IndexableField>> docs) throws java.io.IOException
int64_t addDocuments(std::deque<T1> docs) ;
/**
* Atomically deletes documents matching the provided
* delTerm and adds a block of documents with sequentially
* assigned document IDs, such that an external reader
* will see all or none of the documents.
*
* See {@link #addDocuments(Iterable)}.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*
* @lucene.experimental
*/
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long updateDocuments(Term delTerm,
// Iterable<? extends Iterable<? extends IndexableField>> docs) throws
// java.io.IOException
int64_t updateDocuments(std::shared_ptr<Term> delTerm,
std::deque<T1> docs) ;
private:
template <typename T1, typename T2>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: private long updateDocuments(final
// DocumentsWriterDeleteQueue.Node<?> delNode, Iterable<? extends Iterable<?
// extends IndexableField>> docs) throws java.io.IOException
int64_t
updateDocuments(std::shared_ptr<DocumentsWriterDeleteQueue::Node<T1>> delNode,
std::deque<T2> docs) ;
/**
* Expert:
* Atomically updates documents matching the provided
* term with the given doc-values fields
* and adds a block of documents with sequentially
* assigned document IDs, such that an external reader
* will see all or none of the documents.
*
* One use of this API is to retain older versions of
* documents instead of replacing them. The existing
* documents can be updated to reflect they are no
* longer current while atomically adding new documents
* at the same time.
*
* In contrast to {@link #updateDocuments(Term, Iterable)}
* this method will not delete documents in the index
* matching the given term but instead update them with
* the given doc-values fields which can be used as a
* soft-delete mechanism.
*
* See {@link #addDocuments(Iterable)}
* and {@link #updateDocuments(Term, Iterable)}.
*
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*
* @lucene.experimental
*/
public:
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long softUpdateDocuments(Term term,
// Iterable<? extends Iterable<? extends IndexableField>> docs,
// org.apache.lucene.document.Field... softDeletes) throws java.io.IOException
int64_t
softUpdateDocuments(std::shared_ptr<Term> term, std::deque<T1> docs,
std::deque<Field> &softDeletes) ;
/** Expert: attempts to delete by document ID, as long as
* the provided reader is a near-real-time reader (from {@link
* DirectoryReader#open(IndexWriter)}). If the
* provided reader is an NRT reader obtained from this
* writer, and its segment has not been merged away, then
* the delete succeeds and this method returns a valid (> 0) sequence
* number; else, it returns -1 and the caller must then
* separately delete by Term or Query.
*
* <b>NOTE</b>: this method can only delete documents
* visible to the currently open NRT reader. If you need
* to delete documents indexed after opening the NRT
* reader you must use {@link #deleteDocuments(Term...)}). */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual int64_t tryDeleteDocument(std::shared_ptr<IndexReader> readerIn,
int docID) ;
/** Expert: attempts to update doc values by document ID, as long as
* the provided reader is a near-real-time reader (from {@link
* DirectoryReader#open(IndexWriter)}). If the
* provided reader is an NRT reader obtained from this
* writer, and its segment has not been merged away, then
* the update succeeds and this method returns a valid (> 0) sequence
* number; else, it returns -1 and the caller must then
* either retry the update and resolve the document again.
* If a doc values fields data is <code>null</code> the existing
* value is removed from all documents matching the term. This can be used
* to un-delete a soft-deleted document since this method will apply the
* field update even if the document is marked as deleted.
*
* <b>NOTE</b>: this method can only updates documents
* visible to the currently open NRT reader. If you need
* to update documents indexed after opening the NRT
* reader you must use {@link #updateDocValues(Term, Field...)}. */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual int64_t
tryUpdateDocValue(std::shared_ptr<IndexReader> readerIn, int docID,
std::deque<Field> &fields) ;
using DocModifier =
std::function<void(int docId, ReadersAndUpdates readersAndUpdates)>;
private:
// C++ WARNING: The following method was originally marked 'synchronized':
int64_t tryModifyDocument(std::shared_ptr<IndexReader> readerIn, int docID,
DocModifier toApply) ;
/** Drops a segment that has 100% deleted documents. */
public:
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void dropDeletedSegment(
std::shared_ptr<SegmentCommitInfo> info) ;
/**
* Deletes the document(s) containing any of the
* terms. All given deletes are applied and flushed atomically
* at the same time.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @param terms array of terms to identify the documents
* to be deleted
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
virtual int64_t
deleteDocuments(std::deque<Term> &terms) ;
/**
* Deletes the document(s) matching any of the provided queries.
* All given deletes are applied and flushed atomically at the same time.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @param queries array of queries to identify the documents
* to be deleted
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
virtual int64_t
deleteDocuments(std::deque<Query> &queries) ;
/**
* Updates a document by first deleting the document(s)
* containing <code>term</code> and then adding the new
* document. The delete and then add are atomic as seen
* by a reader on the same index (flush may happen only after
* the add).
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @param term the term to identify the document(s) to be
* deleted
* @param doc the document to be added
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*/
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long updateDocument(Term term, Iterable<?
// extends IndexableField> doc) throws java.io.IOException
int64_t updateDocument(std::shared_ptr<Term> term,
std::deque<T1> doc) ;
private:
template <typename T1, typename T2>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: private long updateDocument(final
// DocumentsWriterDeleteQueue.Node<?> delNode, Iterable<? extends
// IndexableField> doc) throws java.io.IOException
int64_t
updateDocument(std::shared_ptr<DocumentsWriterDeleteQueue::Node<T1>> delNode,
std::deque<T2> doc) ;
/**
* Expert:
* Updates a document by first updating the document(s)
* containing <code>term</code> with the given doc-values fields
* and then adding the new document. The doc-values update and
* then add are atomic as seen by a reader on the same index
* (flush may happen only after the add).
*
* One use of this API is to retain older versions of
* documents instead of replacing them. The existing
* documents can be updated to reflect they are no
* longer current while atomically adding new documents
* at the same time.
*
* In contrast to {@link #updateDocument(Term, Iterable)}
* this method will not delete documents in the index
* matching the given term but instead update them with
* the given doc-values fields which can be used as a
* soft-delete mechanism.
*
* See {@link #addDocuments(Iterable)}
* and {@link #updateDocuments(Term, Iterable)}.
*
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
*
* @lucene.experimental
*/
public:
template <typename T1>
// C++ TODO: There is no native C++ template equivalent to this generic
// constraint: ORIGINAL LINE: public long softUpdateDocument(Term term,
// Iterable<? extends IndexableField> doc, org.apache.lucene.document.Field...
// softDeletes) throws java.io.IOException
int64_t
softUpdateDocument(std::shared_ptr<Term> term, std::deque<T1> doc,
std::deque<Field> &softDeletes) ;
/**
* Updates a document's {@link NumericDocValues} for <code>field</code> to the
* given <code>value</code>. You can only update fields that already exist in
* the index, not add new fields through this method.
*
* @param term
* the term to identify the document(s) to be updated
* @param field
* field name of the {@link NumericDocValues} field
* @param value
* new value for the field
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException
* if the index is corrupt
* @throws IOException
* if there is a low-level IO error
*/
virtual int64_t updateNumericDocValue(std::shared_ptr<Term> term,
const std::wstring &field,
int64_t value) ;
/**
* Updates a document's {@link BinaryDocValues} for <code>field</code> to the
* given <code>value</code>. You can only update fields that already exist in
* the index, not add new fields through this method.
*
* <p>
* <b>NOTE:</b> this method currently replaces the existing value of all
* affected documents with the new value.
*
* @param term
* the term to identify the document(s) to be updated
* @param field
* field name of the {@link BinaryDocValues} field
* @param value
* new value for the field
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException
* if the index is corrupt
* @throws IOException
* if there is a low-level IO error
*/
virtual int64_t
updateBinaryDocValue(std::shared_ptr<Term> term, const std::wstring &field,
std::shared_ptr<BytesRef> value) ;
/**
* Updates documents' DocValues fields to the given values. Each field update
* is applied to the set of documents that are associated with the
* {@link Term} to the same value. All updates are atomically applied and
* flushed together. If a doc values fields data is <code>null</code> the
* existing value is removed from all documents matching the term.
*
*
* @param updates
* the updates to apply
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException
* if the index is corrupt
* @throws IOException
* if there is a low-level IO error
*/
virtual int64_t
updateDocValues(std::shared_ptr<Term> term,
std::deque<Field> &updates) ;
private:
std::deque<std::shared_ptr<DocValuesUpdate>>
buildDocValuesUpdate(std::shared_ptr<Term> term,
std::deque<std::shared_ptr<Field>> &updates);
// for test purpose
public:
// C++ WARNING: The following method was originally marked 'synchronized':
int getSegmentCount();
// for test purpose
// C++ WARNING: The following method was originally marked 'synchronized':
int getNumBufferedDocuments();
// for test purpose
// C++ WARNING: The following method was originally marked 'synchronized':
int maxDoc(int i);
// for test purpose
int getFlushCount();
// for test purpose
int getFlushDeletesCount();
/**
* Return an unmodifiable set of all field names as visible
* from this IndexWriter, across all segments of the index.
* Useful for knowing which fields exist, before {@link #updateDocValues(Term,
* Field...)} is attempted. We could phase out this method if
* {@link #updateDocValues(Term, Field...)} could create the non-existent
* docValues fields as necessary, instead of throwing
* IllegalArgumentException for attempts to update non-existent
* docValues fields.
* @lucene.internal
* @lucene.experimental
*/
virtual std::shared_ptr<Set<std::wstring>> getFieldNames();
std::wstring newSegmentName();
/** If enabled, information about merges will be printed to this.
*/
const std::shared_ptr<InfoStream> infoStream;
/**
* Forces merge policy to merge segments until there are
* {@code <= maxNumSegments}. The actual merges to be
* executed are determined by the {@link MergePolicy}.
*
* <p>This is a horribly costly operation, especially when
* you pass a small {@code maxNumSegments}; usually you
* should only call this if the index is static (will no
* longer be changed).</p>
*
* <p>Note that this requires free space that is proportional
* to the size of the index in your Directory: 2X if you are
* not using compound file format, and 3X if you are.
* For example, if your index size is 10 MB then you need
* an additional 20 MB free for this to complete (30 MB if
* you're using compound file format). This is also affected
* by the {@link Codec} that is used to execute the merge,
* and may result in even a bigger index. Also, it's best
* to call {@link #commit()} afterwards, to allow IndexWriter
* to free up disk space.</p>
*
* <p>If some but not all readers re-open while merging
* is underway, this will cause {@code > 2X} temporary
* space to be consumed as those new readers will then
* hold open the temporary segments at that time. It is
* best not to re-open readers while merging is running.</p>
*
* <p>The actual temporary usage could be much less than
* these figures (it depends on many factors).</p>
*
* <p>In general, once this completes, the total size of the
* index will be less than the size of the starting index.
* It could be quite a bit smaller (if there were many
* pending deletes) or just slightly smaller.</p>
*
* <p>If an Exception is hit, for example
* due to disk full, the index will not be corrupted and no
* documents will be lost. However, it may have
* been partially merged (some segments were merged but
* not all), and it's possible that one of the segments in
* the index will be in non-compound format even when
* using compound file format. This will occur when the
* Exception is hit during conversion of the segment into
* compound format.</p>
*
* <p>This call will merge those segments present in
* the index when the call started. If other threads are
* still adding documents and flushing segments, those
* newly created segments will not be merged unless you
* call forceMerge again.</p>
*
* @param maxNumSegments maximum number of segments left
* in the index after merging finishes
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
* @see MergePolicy#findMerges
*
*/
virtual void forceMerge(int maxNumSegments) ;
/** Just like {@link #forceMerge(int)}, except you can
* specify whether the call should block until
* all merging completes. This is only meaningful with a
* {@link MergeScheduler} that is able to run merges in
* background threads.
*/
virtual void forceMerge(int maxNumSegments, bool doWait) ;
/** Returns true if any merges in pendingMerges or
* runningMerges are maxNumSegments merges. */
private:
// C++ WARNING: The following method was originally marked 'synchronized':
bool maxNumSegmentsMergesPending();
/** Just like {@link #forceMergeDeletes()}, except you can
* specify whether the call should block until the
* operation completes. This is only meaningful with a
* {@link MergeScheduler} that is able to run merges in
* background threads. */
public:
virtual void forceMergeDeletes(bool doWait) ;
/**
* Forces merging of all segments that have deleted
* documents. The actual merges to be executed are
* determined by the {@link MergePolicy}. For example,
* the default {@link TieredMergePolicy} will only
* pick a segment if the percentage of
* deleted docs is over 10%.
*
* <p>This is often a horribly costly operation; rarely
* is it warranted.</p>
*
* <p>To see how
* many deletions you have pending in your index, call
* {@link IndexReader#numDeletedDocs}.</p>
*
* <p><b>NOTE</b>: this method first flushes a new
* segment (if there are indexed documents), and applies
* all buffered deletes.
*/
virtual void forceMergeDeletes() ;
/**
* Expert: asks the mergePolicy whether any merges are
* necessary now and if so, runs the requested merges and
* then iterate (test again if merges are needed) until no
* more merges are returned by the mergePolicy.
*
* Explicit calls to maybeMerge() are usually not
* necessary. The most common case is when merge policy
* parameters have changed.
*
* This method will call the {@link MergePolicy} with
* {@link MergeTrigger#EXPLICIT}.
*/
void maybeMerge() ;
void maybeMerge(std::shared_ptr<MergePolicy> mergePolicy,
MergeTrigger trigger, int maxNumSegments) ;
private:
// C++ WARNING: The following method was originally marked 'synchronized':
bool updatePendingMerges(std::shared_ptr<MergePolicy> mergePolicy,
MergeTrigger trigger,
int maxNumSegments) ;
/** Expert: to be used by a {@link MergePolicy} to avoid
* selecting merges for segments already being merged.
* The returned collection is not cloned, and thus is
* only safe to access if you hold IndexWriter's lock
* (which you do when IndexWriter invokes the
* MergePolicy).
*
* <p>The Set is unmodifiable. */
public:
// C++ WARNING: The following method was originally marked 'synchronized':
std::shared_ptr<Set<std::shared_ptr<SegmentCommitInfo>>>
getMergingSegments() override;
/**
* Expert: the {@link MergeScheduler} calls this method to retrieve the next
* merge requested by the MergePolicy
*
* @lucene.experimental
*/
// C++ WARNING: The following method was originally marked 'synchronized':
virtual std::shared_ptr<MergePolicy::OneMerge> getNextMerge();
/**
* Expert: returns true if there are merges waiting to be scheduled.
*
* @lucene.experimental
*/
// C++ WARNING: The following method was originally marked 'synchronized':
virtual bool hasPendingMerges();
/**
* Close the <code>IndexWriter</code> without committing
* any changes that have occurred since the last commit
* (or since it was opened, if commit hasn't been called).
* This removes any temporary files that had been created,
* after which the state of the index will be the same as
* it was when commit() was last called or when this
* writer was first opened. This also clears a previous
* call to {@link #prepareCommit}.
* @throws IOException if there is a low-level IO error
*/
void rollback() override;
private:
void rollbackInternal() ;
void rollbackInternalNoCommit() ;
/**
* Delete all documents in the index.
*
* <p>
* This method will drop all buffered documents and will remove all segments
* from the index. This change will not be visible until a {@link #commit()}
* has been called. This method can be rolled back using {@link #rollback()}.
* </p>
*
* <p>
* NOTE: this method is much faster than using deleteDocuments( new
* MatchAllDocsQuery() ). Yet, this method also has different semantics
* compared to {@link #deleteDocuments(Query...)} since internal
* data-structures are cleared as well as all segment information is
* forcefully dropped anti-viral semantics like omitting norms are reset or
* doc value types are cleared. Essentially a call to {@link #deleteAll()} is
* equivalent to creating a new {@link IndexWriter} with
* {@link OpenMode#CREATE} which a delete query only marks documents as
* deleted.
* </p>
*
* <p>
* NOTE: this method will forcefully abort all merges in progress. If other
* threads are running {@link #forceMerge}, {@link #addIndexes(CodecReader[])}
* or {@link #forceMergeDeletes} methods, they may receive
* {@link MergePolicy.MergeAbortedException}s.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*/
public:
// C++ TODO: Most Java annotations will not have direct C++ equivalents:
// ORIGINAL LINE: @SuppressWarnings("try") public long deleteAll() throws
// java.io.IOException
virtual int64_t deleteAll() ;
/** Aborts running merges. Be careful when using this
* method: when you abort a long-running merge, you lose
* a lot of work that must later be redone. */
private:
// C++ WARNING: The following method was originally marked 'synchronized':
void abortMerges();
/**
* Wait for any currently outstanding merges to finish.
*
* <p>It is guaranteed that any merges started prior to calling this method
* will have completed once this method completes.</p>
*/
public:
virtual void waitForMerges() ;
/**
* Called whenever the SegmentInfos has been updated and
* the index files referenced exist (correctly) in the
* index directory.
*/
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void checkpoint() ;
/** Checkpoints with IndexFileDeleter, so it's aware of
* new files, and increments changeCount, so on
* close/commit we will write a new segments file, but
* does NOT bump segmentInfos.version. */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void checkpointNoSIS() ;
/** Called internally if any index state has changed. */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void changed();
// C++ WARNING: The following method was originally marked 'synchronized':
virtual int64_t
publishFrozenUpdates(std::shared_ptr<FrozenBufferedUpdates> packet);
/**
* Atomically adds the segment private delete packet and publishes the flushed
* segments SegmentInfo to the index writer.
*/
private:
// C++ WARNING: The following method was originally marked 'synchronized':
void publishFlushedSegment(
std::shared_ptr<SegmentCommitInfo> newSegment,
std::shared_ptr<FieldInfos> fieldInfos,
std::shared_ptr<FrozenBufferedUpdates> packet,
std::shared_ptr<FrozenBufferedUpdates> globalPacket,
std::shared_ptr<Sorter::DocMap> sortMap) ;
// C++ WARNING: The following method was originally marked 'synchronized':
void resetMergeExceptions();
void noDupDirs(std::deque<Directory> &dirs);
/** Acquires write locks on all the directories; be sure
* to match with a call to {@link IOUtils#close} in a
* finally clause. */
std::deque<std::shared_ptr<Lock>>
acquireWriteLocks(std::deque<Directory> &dirs) ;
/**
* Adds all segments from an array of indexes into this index.
*
* <p>This may be used to parallelize batch indexing. A large document
* collection can be broken into sub-collections. Each sub-collection can be
* indexed in parallel, on a different thread, process or machine. The
* complete index can then be created by merging sub-collection indexes
* with this method.
*
* <p>
* <b>NOTE:</b> this method acquires the write lock in
* each directory, to ensure that no {@code IndexWriter}
* is currently open or tries to open while this is
* running.
*
* <p>This method is transactional in how Exceptions are
* handled: it does not commit a new segments_N file until
* all indexes are added. This means if an Exception
* occurs (for example disk full), then either no indexes
* will have been added or they all will have been.
*
* <p>Note that this requires temporary free space in the
* {@link Directory} up to 2X the sum of all input indexes
* (including the starting index). If readers/searchers
* are open against the starting index, then temporary
* free space required will be higher by the size of the
* starting index (see {@link #forceMerge(int)} for details).
*
* <p>This requires this index not be among those to be added.
*
* <p>All added indexes must have been created by the same
* Lucene version as this index.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException if the index is corrupt
* @throws IOException if there is a low-level IO error
* @throws IllegalArgumentException if addIndexes would cause
* the index to exceed {@link #MAX_DOCS}, or if the indoming
* index sort does not match this index's index sort
*/
public:
virtual int64_t addIndexes(std::deque<Directory> &dirs) ;
private:
void validateMergeReader(std::shared_ptr<CodecReader> leaf);
/**
* Merges the provided indexes into this index.
*
* <p>
* The provided IndexReaders are not closed.
*
* <p>
* See {@link #addIndexes} for details on transactional semantics, temporary
* free space required in the Directory, and non-CFS segments on an Exception.
*
* <p>
* <b>NOTE:</b> empty segments are dropped by this method and not added to
* this index.
*
* <p>
* <b>NOTE:</b> this merges all given {@link LeafReader}s in one
* merge. If you intend to merge a large number of readers, it may be better
* to call this method multiple times, each time with a small set of readers.
* In principle, if you use a merge policy with a {@code mergeFactor} or
* {@code maxMergeAtOnce} parameter, you should pass that many readers in one
* call.
*
* <p>
* <b>NOTE:</b> this method does not call or make use of the {@link
* MergeScheduler}, so any custom bandwidth throttling is at the moment
* ignored.
*
* @return The <a href="#sequence_number">sequence number</a>
* for this operation
*
* @throws CorruptIndexException
* if the index is corrupt
* @throws IOException
* if there is a low-level IO error
* @throws IllegalArgumentException
* if addIndexes would cause the index to exceed {@link #MAX_DOCS}
*/
public:
virtual int64_t
addIndexes(std::deque<CodecReader> &readers) ;
/** Copies the segment files as-is into the IndexWriter's directory. */
private:
std::shared_ptr<SegmentCommitInfo>
copySegmentAsIs(std::shared_ptr<SegmentCommitInfo> info,
const std::wstring &segName,
std::shared_ptr<IOContext> context) ;
/**
* A hook for extending classes to execute operations after pending added and
* deleted documents have been flushed to the Directory but before the change
* is committed (new segments_N file written).
*/
protected:
virtual void doAfterFlush() ;
/**
* A hook for extending classes to execute operations before pending added and
* deleted documents are flushed to the Directory.
*/
virtual void doBeforeFlush() ;
/** <p>Expert: prepare for commit. This does the
* first phase of 2-phase commit. This method does all
* steps necessary to commit changes since this writer
* was opened: flushes pending added and deleted docs,
* syncs the index files, writes most of next segments_N
* file. After calling this you must call either {@link
* #commit()} to finish the commit, or {@link
* #rollback()} to revert the commit and undo all changes
* done since the writer was opened.</p>
*
* <p>You can also just call {@link #commit()} directly
* without prepareCommit first in which case that method
* will internally call prepareCommit.
*
* @return The <a href="#sequence_number">sequence number</a>
* of the last operation in the commit. All sequence numbers <= this value
* will be reflected in the commit, and all others will not.
*/
public:
int64_t prepareCommit() override;
/**
* <p>Expert: Flushes the next pending writer per thread buffer if available
* or the largest active non-pending writer per thread buffer in the calling
* thread. This can be used to flush documents to disk outside of an indexing
* thread. In contrast to {@link #flush()} this won't mark all currently
* active indexing buffers as flush-pending.
*
* Note: this method is best-effort and might not flush any segments to disk.
* If there is a full flush happening concurrently multiple segments might
* have been flushed. Users of this API can access the IndexWriters current
* memory consumption via {@link #ramBytesUsed()}
* </p>
* @return <code>true</code> iff this method flushed at least on segment to
* disk.
* @lucene.experimental
*/
bool flushNextBuffer() ;
private:
int64_t prepareCommitInternal() ;
/**
* Ensures that all changes in the reader-pool are written to disk.
* @param writeDeletes if <code>true</code> if deletes should be written to
* disk too.
*/
void writeReaderPool(bool writeDeletes) ;
/**
* Sets the iterator to provide the commit user data map_obj at commit time.
* Calling this method is considered a committable change and will be {@link
* #commit() committed} even if there are no other changes this writer. Note
* that you must call this method before {@link #prepareCommit()}. Otherwise
* it won't be included in the follow-on {@link #commit()}. <p> <b>NOTE:</b>
* the iterator is late-binding: it is only visited once all documents for the
* commit have been written to their segments, before the next segments_N file
* is written
*/
public:
// C++ WARNING: The following method was originally marked 'synchronized':
void setLiveCommitData(
std::deque<std::unordered_map::Entry<std::wstring, std::wstring>>
&commitUserData);
/**
* Sets the commit user data iterator, controlling whether to advance the
* {@link SegmentInfos#getVersion}.
*
* @see #setLiveCommitData(Iterable)
*
* @lucene.internal */
// C++ WARNING: The following method was originally marked 'synchronized':
void setLiveCommitData(
std::deque<std::unordered_map::Entry<std::wstring, std::wstring>>
&commitUserData,
bool doIncrementVersion);
/**
* Returns the commit user data iterable previously set with {@link
* #setLiveCommitData(Iterable)}, or null if nothing has been set yet.
*/
// C++ WARNING: The following method was originally marked 'synchronized':
std::deque<std::unordered_map::Entry<std::wstring, std::wstring>>
getLiveCommitData();
// Used only by commit and prepareCommit, below; lock
// order is commitLock -> IW
private:
std::mutex commitLock;
/**
* <p>Commits all pending changes (added and deleted
* documents, segment merges, added
* indexes, etc.) to the index, and syncs all referenced
* index files, such that a reader will see the changes
* and the index updates will survive an OS or machine
* crash or power loss. Note that this does not wait for
* any running background merges to finish. This may be a
* costly operation, so you should test the cost in your
* application and do it only when really necessary.</p>
*
* <p> Note that this operation calls Directory.sync on
* the index files. That call should not return until the
* file contents and metadata are on stable storage. For
* FSDirectory, this calls the OS's fsync. But, beware:
* some hardware devices may in fact cache writes even
* during fsync, and return before the bits are actually
* on stable storage, to give the appearance of faster
* performance. If you have such a device, and it does
* not have a battery backup (for example) then on power
* loss it may still lose data. Lucene cannot guarantee
* consistency on such devices. </p>
*
* <p> If nothing was committed, because there were no
* pending changes, this returns -1. Otherwise, it returns
* the sequence number such that all indexing operations
* prior to this sequence will be included in the commit
* point, and all other operations will not. </p>
*
* @see #prepareCommit
*
* @return The <a href="#sequence_number">sequence number</a>
* of the last operation in the commit. All sequence numbers <= this value
* will be reflected in the commit, and all others will not.
*/
public:
int64_t commit() override;
/** Returns true if there may be changes that have not been
* committed. There are cases where this may return true
* when there are no actual "real" changes to the index,
* for example if you've deleted by Term or Query but
* that Term or Query does not match any documents.
* Also, if a merge kicked off as a result of flushing a
* new segment during {@link #commit}, or a concurrent
* merged finished, this method may return true right
* after you had just called {@link #commit}. */
bool hasUncommittedChanges();
private:
int64_t
commitInternal(std::shared_ptr<MergePolicy> mergePolicy) ;
// C++ TODO: Most Java annotations will not have direct C++ equivalents:
// ORIGINAL LINE: @SuppressWarnings("try") private final void finishCommit()
// throws java.io.IOException
void finishCommit() ;
// Ensures only one flush() is actually flushing segments
// at a time:
std::mutex fullFlushLock;
// for assert
public:
virtual bool holdsFullFlushLock();
/** Moves all in-memory segments to the {@link Directory}, but does not commit
* (fsync) them (call {@link #commit} for that). */
void flush() ;
/**
* Flush all in-memory buffered updates (adds and deletes)
* to the Directory.
* @param triggerMerge if true, we may merge segments (if
* deletes or docs were flushed) if necessary
* @param applyAllDeletes whether pending deletes should also
*/
void flush(bool triggerMerge, bool applyAllDeletes) ;
/** Returns true a segment was flushed or deletes were applied. */
private:
bool doFlush(bool applyAllDeletes) ;
public:
void applyAllDeletesAndUpdates() ;
// for testing only
virtual std::shared_ptr<DocumentsWriter> getDocsWriter();
/** Expert: Return the number of documents currently
* buffered in RAM. */
// C++ WARNING: The following method was originally marked 'synchronized':
int numRamDocs();
private:
// C++ WARNING: The following method was originally marked 'synchronized':
void ensureValidMerge(std::shared_ptr<MergePolicy::OneMerge> merge);
void
skipDeletedDoc(std::deque<std::shared_ptr<DocValuesFieldUpdates::Iterator>>
&updatesIters,
int deletedDoc);
/**
* Carefully merges deletes and updates for the segments we just merged. This
* is tricky because, although merging will clear all deletes (compacts the
* documents) and compact all the updates, new deletes and updates may have
* been flushed to the segments since the merge was started. This method
* "carries over" such new deletes and updates onto the newly merged segment,
* and saves the resulting deletes and updates files (incrementing the delete
* and DV generations for merge.info). If no deletes were flushed, no new
* deletes file is saved.
*/
// C++ WARNING: The following method was originally marked 'synchronized':
std::shared_ptr<ReadersAndUpdates> commitMergedDeletesAndUpdates(
std::shared_ptr<MergePolicy::OneMerge> merge,
std::shared_ptr<MergeState> mergeState) ;
/**
* This method carries over hard-deleted documents that are applied to the
* source segment during a merge.
*/
static void carryOverHardDeletes(
std::shared_ptr<ReadersAndUpdates> mergedReadersAndUpdates, int maxDoc,
std::shared_ptr<Bits> mergeLiveDocs,
std::shared_ptr<Bits> prevHardLiveDocs,
std::shared_ptr<Bits> currentHardLiveDocs,
std::shared_ptr<MergeState::DocMap> segDocMap,
std::shared_ptr<MergeState::DocMap> segLeafDocMap) ;
// C++ TODO: Most Java annotations will not have direct C++ equivalents:
// ORIGINAL LINE: @SuppressWarnings("try") synchronized private bool
// commitMerge(MergePolicy.OneMerge merge, MergeState mergeState) throws
// java.io.IOException C++ WARNING: The following method was originally marked
// 'synchronized':
bool commitMerge(std::shared_ptr<MergePolicy::OneMerge> merge,
std::shared_ptr<MergeState> mergeState) ;
void handleMergeException(
std::runtime_error t,
std::shared_ptr<MergePolicy::OneMerge> merge) ;
/**
* Merges the indicated segments, replacing them in the stack with a
* single segment.
*
* @lucene.experimental
*/
public:
virtual void
merge(std::shared_ptr<MergePolicy::OneMerge> merge) ;
/** Hook that's called when the specified merge is complete. */
virtual void mergeSuccess(std::shared_ptr<MergePolicy::OneMerge> merge);
/** Checks whether this merge involves any segments
* already participating in a merge. If not, this merge
* is "registered", meaning we record that its segments
* are now participating in a merge, and true is
* returned. Else (the merge conflicts) false is
* returned. */
// C++ WARNING: The following method was originally marked 'synchronized':
bool registerMerge(std::shared_ptr<MergePolicy::OneMerge> merge) throw(
IOException);
/** Does initial setup for a merge, which is fast but holds
* the synchronized lock on IndexWriter instance. */
void
mergeInit(std::shared_ptr<MergePolicy::OneMerge> merge) ;
private:
// C++ WARNING: The following method was originally marked 'synchronized':
void
_mergeInit(std::shared_ptr<MergePolicy::OneMerge> merge) ;
public:
static void setDiagnostics(std::shared_ptr<SegmentInfo> info,
const std::wstring &source);
private:
static void
setDiagnostics(std::shared_ptr<SegmentInfo> info, const std::wstring &source,
std::unordered_map<std::wstring, std::wstring> &details);
/** Does fininishing for a merge, which is fast but holds
* the synchronized lock on IndexWriter instance. */
public:
// C++ WARNING: The following method was originally marked 'synchronized':
void mergeFinish(std::shared_ptr<MergePolicy::OneMerge> merge);
private:
// C++ TODO: Most Java annotations will not have direct C++ equivalents:
// ORIGINAL LINE: @SuppressWarnings("try") private synchronized void
// closeMergeReaders(MergePolicy.OneMerge merge, bool suppressExceptions)
// throws java.io.IOException C++ WARNING: The following method was originally
// marked 'synchronized':
void closeMergeReaders(std::shared_ptr<MergePolicy::OneMerge> merge,
bool suppressExceptions) ;
/** Does the actual (time-consuming) work of the merge,
* but without holding synchronized lock on IndexWriter
* instance */
int mergeMiddle(std::shared_ptr<MergePolicy::OneMerge> merge,
std::shared_ptr<MergePolicy> mergePolicy) ;
public:
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void addMergeException(std::shared_ptr<MergePolicy::OneMerge> merge);
// For test purposes.
int getBufferedDeleteTermsSize();
// For test purposes.
int getNumBufferedDeleteTerms();
// utility routines for tests
// C++ WARNING: The following method was originally marked 'synchronized':
virtual std::shared_ptr<SegmentCommitInfo> newestSegment();
/** Returns a string description of all segments, for
* debugging.
*
* @lucene.internal */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual std::wstring segString();
// C++ WARNING: The following method was originally marked 'synchronized':
virtual std::wstring
segString(std::deque<std::shared_ptr<SegmentCommitInfo>> &infos);
/** Returns a string description of the specified
* segment, for debugging.
*
* @lucene.internal */
private:
// C++ WARNING: The following method was originally marked 'synchronized':
std::wstring segString(std::shared_ptr<SegmentCommitInfo> info);
// C++ WARNING: The following method was originally marked 'synchronized':
void doWait();
// called only from assert
bool filesExist(std::shared_ptr<SegmentInfos> toSync) ;
// For infoStream output
public:
// C++ WARNING: The following method was originally marked 'synchronized':
virtual std::shared_ptr<SegmentInfos>
toLiveInfos(std::shared_ptr<SegmentInfos> sis);
/** Walk through all files referenced by the current
* segmentInfos and ask the Directory to sync each file,
* if it wasn't already. If that succeeds, then we
* prepare a new segments_N file but do not fully commit
* it. */
private:
void startCommit(std::shared_ptr<SegmentInfos> toSync) ;
/** If {@link DirectoryReader#open(IndexWriter)} has
* been called (ie, this writer is in near real-time
* mode), then after a merge completes, this class can be
* invoked to warm the reader on the newly merged
* segment, before the merge commits. This is not
* required for near real-time search, but will reduce
* search latency on opening a new near real-time reader
* after a merge completes.
*
* @lucene.experimental
*
* <p><b>NOTE</b>: {@link #warm(LeafReader)} is called before any
* deletes have been carried over to the merged segment. */
using IndexReaderWarmer = std::function<void(LeafReader reader)>;
/**
* This method should be called on a tragic event ie. if a downstream class of
* the writer hits an unrecoverable exception. This method does not rethrow
* the tragic event exception. Note: This method will not close the writer but
* can be called from any location without respecting any lock order
*/
public:
void onTragicEvent(std::runtime_error tragedy, const std::wstring &location);
/**
* This method set the tragic exception unless it's already set and closes the
* writer if necessary. Note this method will not rethrow the throwable passed
* to it.
*/
private:
void tragicEvent(std::runtime_error tragedy,
const std::wstring &location) ;
void maybeCloseOnTragicEvent() ;
/** If this {@code IndexWriter} was closed as a side-effect of a tragic
* exception, e.g. disk full while flushing a new segment, this returns the
* root cause exception. Otherwise (no tragic exception has occurred) it
* returns null. */
public:
virtual std::runtime_error getTragicException();
/** Returns {@code true} if this {@code IndexWriter} is still open. */
virtual bool isOpen();
// Used for testing. Current points:
// startDoFlush
// startCommitMerge
// startStartCommit
// midStartCommit
// midStartCommit2
// midStartCommitSuccess
// finishStartCommit
// startCommitMergeDeletes
// startMergeInit
// DocumentsWriter.ThreadState.init start
private:
void testPoint(const std::wstring &message);
public:
// C++ WARNING: The following method was originally marked 'synchronized':
virtual bool nrtIsCurrent(std::shared_ptr<SegmentInfos> infos);
// C++ WARNING: The following method was originally marked 'synchronized':
virtual bool isClosed();
/** Expert: remove any index files that are no longer
* used.
*
* <p> IndexWriter normally deletes unused files itself,
* during indexing. However, on Windows, which disallows
* deletion of open files, if there is a reader open on
* the index then those files cannot be deleted. This is
* fine, because IndexWriter will periodically retry
* the deletion.</p>
*
* <p> However, IndexWriter doesn't try that often: only
* on open, close, flushing a new segment, and finishing
* a merge. If you don't do any of these actions with your
* IndexWriter, you'll see the unused files linger. If
* that's a problem, call this method to delete them
* (once you've closed the open readers that were
* preventing their deletion).
*
* <p> In addition, you can call this method to delete
* unreferenced index commits. This might be useful if you
* are using an {@link IndexDeletionPolicy} which holds
* onto index commits until some criteria are met, but those
* commits are no longer needed. Otherwise, those commits will
* be deleted the next time commit() is called.
*/
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void deleteUnusedFiles() ;
/**
* NOTE: this method creates a compound file for all files returned by
* info.files(). While, generally, this may include separate norms and
* deletion files, this SegmentInfo must not reference such files when this
* method is called, because they are not allowed within a compound file.
*/
static void
createCompoundFile(std::shared_ptr<InfoStream> infoStream,
std::shared_ptr<TrackingDirectoryWrapper> directory,
std::shared_ptr<SegmentInfo> info,
std::shared_ptr<IOContext> context,
IOUtils::IOConsumer<std::deque<std::wstring>>
deleteFiles) ;
/**
* Tries to delete the given files if unreferenced
* @param files the files to delete
* @throws IOException if an {@link IOException} occurs
* @see IndexFileDeleter#deleteNewFiles(std::deque)
*/
private:
// C++ WARNING: The following method was originally marked 'synchronized':
void deleteNewFiles(std::shared_ptr<std::deque<std::wstring>> files) throw(
IOException);
/**
* Cleans up residuals from a segment that could not be entirely flushed due
* to an error
*/
// C++ WARNING: The following method was originally marked 'synchronized':
void flushFailed(std::shared_ptr<SegmentInfo> info) ;
/**
* Publishes the flushed segment, segment-private deletes (if any) and its
* associated global delete (if present) to IndexWriter. The actual
* publishing operation is synced on {@code IW -> BDS} so that the {@link
* SegmentInfo}'s delete generation is always GlobalPacket_deleteGeneration +
* 1
* @param forced if <code>true</code> this call will block on the ticket queue
* if the lock is held by another thread. if <code>false</code> the call will
* try to acquire the queue lock and exits if it's held by another thread.
*
*/
public:
virtual void publishFlushedSegments(bool forced) ;
/** Record that the files referenced by this {@link SegmentInfos} are still in
* use.
*
* @lucene.internal */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void
incRefDeleter(std::shared_ptr<SegmentInfos> segmentInfos) ;
/** Record that the files referenced by this {@link SegmentInfos} are no
* longer in use. Only call this if you are sure you previously called {@link
* #incRefDeleter}.
*
* @lucene.internal */
// C++ WARNING: The following method was originally marked 'synchronized':
virtual void
decRefDeleter(std::shared_ptr<SegmentInfos> segmentInfos) ;
private:
void processEvents(bool triggerMerge) ;
/**
* Interface for internal atomic events. See {@link DocumentsWriter} for
* details. Events are executed concurrently and no order is guaranteed. Each
* event should only rely on the serializeability within its process method.
* All actions that must happen before or after a certain action must be
* encoded inside the {@link #process(IndexWriter)} method.
*
*/
using Event = std::function<void(IndexWriter writer)>;
/** Anything that will add N docs to the index should reserve first to
* make sure it's allowed. This will throw {@code
* IllegalArgumentException} if it's not allowed. */
private:
void reserveDocs(int64_t addedNumDocs);
/** Does a best-effort check, that the current index would accept this many
* additional docs, but does not actually reserve them.
*
* @throws IllegalArgumentException if there would be too many docs */
void testReserveDocs(int64_t addedNumDocs);
void tooManyDocs(int64_t addedNumDocs);
/** Returns the highest <a href="#sequence_number">sequence number</a> across
* all completed operations, or 0 if no operations have finished yet. Still
* in-flight operations (in other threads) are not counted until they finish.
*
* @lucene.experimental */
public:
virtual int64_t getMaxCompletedSequenceNumber();
private:
int64_t adjustPendingNumDocs(int64_t numDocs);
public:
bool isFullyDeleted(
std::shared_ptr<ReadersAndUpdates> readersAndUpdates) ;
/**
* Returns the number of deletes a merge would claim back if the given segment
* is merged.
* @see MergePolicy#numDeletesToMerge(SegmentCommitInfo, int,
* org.apache.lucene.util.IOSupplier)
* @param info the segment to get the number of deletes for
* @lucene.experimental
*/
int numDeletesToMerge(std::shared_ptr<SegmentCommitInfo> info) throw(
IOException) override;
virtual void release(
std::shared_ptr<ReadersAndUpdates> readersAndUpdates) ;
private:
void release(std::shared_ptr<ReadersAndUpdates> readersAndUpdates,
bool assertLiveInfo) ;
public:
virtual std::shared_ptr<ReadersAndUpdates>
getPooledInstance(std::shared_ptr<SegmentCommitInfo> info, bool create);
virtual void finished(std::shared_ptr<FrozenBufferedUpdates> packet);
virtual int getPendingUpdatesCount();
/**
* Tests should override this to enable test points. Default is
* <code>false</code>.
*/
protected:
virtual bool isEnableTestPoints();
private:
void validate(std::shared_ptr<SegmentCommitInfo> info);
};
} // #include "core/src/java/org/apache/lucene/index/
| [
"[email protected]"
] | |
0e7cb5bb11de856c402d64884629abc1ab3efd26 | d3e3cc3cb7b655af116555988f25f10e58658e9c | /BunnyEngine2/src/GAME_SPECIFIC_FILES/sHowtoPowerup.hpp | 6c007db8dfd99f511035d139adcf150d669937c9 | [] | no_license | SeraphinaMJ/MyLittleBunny | 0c6b7afb23fc63237282f07b72fef2a5d0512162 | c9cdc763a3f2056b3a2be5e5d0986c6ea66faecf | refs/heads/master | 2023-04-19T14:52:51.718358 | 2021-05-06T10:54:31 | 2021-05-06T10:54:31 | 364,579,774 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,711 | hpp | #pragma once
/* ---------------------------------------------------------------------------
Copyright (C) 2017 DigiPen Institute of Technology.
Reproduction or disclosure of this file or its contents without the prior
written consent of DigiPen Institute of Technology is prohibited.
File Name: sHowtoPowerup.hpp
Purpose: This file contain the How to Power Up stage class.
such as number of objects.
Can be used C style with static functions or C++ with methods.
Language: C++
Project: GAM250
Author: Name : Jihwan Oh
Email: [email protected]
date: 2017.06.16
----------------------------------------------------------------------------*/
#include <BunnyEngine.hpp>
#include <BaseStage.hpp>
#include <Utilities/TimerManager.hpp>
namespace Stage
{
//! The sHowtoPowerup class.
/*!
The sHowtoPowerup class is a Stage.
It contains its own vector of Actors and its own update function.
It is used as a popup when trying to do a destructive action (quitting game, returning to menu)
NOTE: Currently, there is no way of knowing what the "result" of the ActionConfirm was. So that will need to be adressed
*/
class sHowtoPowerup : public BE::Stage::BaseStage
{
public:
sHowtoPowerup();
~sHowtoPowerup() = default;
BaseStage* cpy() final
{
return (new sHowtoPowerup());
}
void start(std::string fileName_ = "") final;
void resume() final;
void pause() final;
void update(float dt_) final;
protected:
//
private:
//
public:
//
protected:
//
private:
//
};
} | [
"[email protected]"
] | |
283bb7b89a45134f4983ba591ebfbb906654e996 | c6c81a4953cc49016bda8ad863e27e029bfed052 | /wikioi/1014 装箱问题/Run_418857_Score_100_Date_2014-01-03.cpp | 0f73ad92914ff2cd66704406ac5f6542259fa6df | [] | no_license | jay2013/NOI_ACM | 50f8c9582946536f6050e1f645ae57cd19c8447b | 749d82a1e61a6cd2a34d13d6cc65fa87f91626e3 | refs/heads/master | 2016-09-10T10:00:33.747933 | 2014-07-07T02:19:07 | 2014-07-07T02:19:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 425 | cpp | #include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main()
{
int V,n,a[33],i,j,dp[204800];
scanf("%d %d",&V,&n);
for(i=1;i<=n;i++)scanf("%d",&a[i]);
memset(dp,0,sizeof(dp));
for(i=1;i<=n;i++)
{
for(j=V;j>=a[i];j--)
{
if(dp[j-a[i]]+a[i]>dp[j])dp[j]=dp[j-a[i]]+a[i];
}
}
printf("%d\n",V-dp[V]);
return 0;
}
| [
"[email protected]"
] | |
4464be4b62c2dfc957e08a14b232e26f5b95c89b | 384ed1770ef4fb26ceddd1f696f9bce645ec7203 | /main.build/module.youtube_dl.extractor.adobetv.cpp | f5bbbad2b13824f58c5d3f5720567dc7fe1220a9 | [
"Apache-2.0"
] | permissive | omarASC5/Download-Spotify-Playlists | 0bdc4d5c27704b869d346bb57127da401bb354bd | b768ddba33f52902c9276105099514f18f5c3f77 | refs/heads/master | 2022-11-06T09:32:38.264819 | 2020-06-21T14:31:01 | 2020-06-21T14:31:01 | 272,309,286 | 1 | 1 | null | 2020-06-16T21:02:37 | 2020-06-15T00:47:16 | HTML | UTF-8 | C++ | false | false | 586,116 | cpp | /* Generated code for Python module 'youtube_dl.extractor.adobetv'
* created by Nuitka version 0.6.8.4
*
* This code is in part copyright 2020 Kay Hayen.
*
* 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 "nuitka/prelude.h"
#include "__helpers.h"
/* The "_module_youtube_dl$extractor$adobetv" is a Python object pointer of module type.
*
* Note: For full compatibility with CPython, every module variable access
* needs to go through it except for cases where the module cannot possibly
* have changed in the mean time.
*/
PyObject *module_youtube_dl$extractor$adobetv;
PyDictObject *moduledict_youtube_dl$extractor$adobetv;
/* The declarations of module constants used, if any. */
extern PyObject *const_dict_186fac6cf4e5273be066e7a2969f77c4;
extern PyObject *const_tuple_str_plain_sources_tuple;
extern PyObject *const_tuple_4de2c63cd63fd056d54944169d9bb4a6_tuple;
static PyObject *const_str_digest_05202a5100e8f881a699bee57ca574ea;
extern PyObject *const_str_plain_view_count;
static PyObject *const_tuple_str_plain_show_description_tuple;
extern PyObject *const_str_plain_metaclass;
extern PyObject *const_str_plain___spec__;
static PyObject *const_tuple_str_plain_self_str_plain_show_data_tuple;
static PyObject *const_str_digest_94d9324bf4313266f4f235e52c670f28;
extern PyObject *const_str_plain___name__;
static PyObject *const_str_digest_e66870d414502380d566e676d9cee231;
static PyObject *const_str_digest_d684f01bf89b4ee758a3ecfad8217126;
static PyObject *const_dict_5ea60a284ad730b39dc9421352bd1cb6;
static PyObject *const_str_digest_ef9409495ac7eeeca2d480ded2207637;
extern PyObject *const_tuple_str_plain___class___tuple;
extern PyObject *const_tuple_str_plain_id_tuple;
extern PyObject *const_str_angle_metaclass;
static PyObject *const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple;
extern PyObject *const_str_plain_compat_str;
extern PyObject *const_str_plain__sort_formats;
static PyObject *const_str_digest_be0726bace9f7b1b5af3d61e99668538;
static PyObject *const_str_plain__RESOURCE;
extern PyObject *const_str_plain___file__;
extern PyObject *const_str_plain_AdobeTVEmbedIE;
static PyObject *const_str_plain__extract_playlist_entries;
extern PyObject *const_str_plain_poster;
extern PyObject *const_str_plain_group;
extern PyObject *const_str_plain__match_id;
extern PyObject *const_str_plain_max;
extern PyObject *const_str_plain_scale;
static PyObject *const_str_plain_s3_extracted;
extern PyObject *const_str_plain_sources;
static PyObject *const_str_digest_9b21f56486eea5829f65df0a985977e3;
static PyObject *const_str_plain_playcount;
extern PyObject *const_str_plain_webpage;
static PyObject *const_str_digest_66715feeb3ff88b52732448550a756a2;
static PyObject *const_str_digest_bbdf4f5803fe97bbca4ce42b2c7b26e7;
extern PyObject *const_str_plain_id;
static PyObject *const_str_plain_vtt_path;
extern PyObject *const_dict_7f784dd3d97b14f8a092c7056e4a88ae;
extern PyObject *const_str_plain_str_or_none;
extern PyObject *const_str_plain_video_id;
extern PyObject *const_int_pos_25;
extern PyObject *const_str_plain_AdobeTVIE;
static PyObject *const_str_plain_AdobeTVBaseIE;
extern PyObject *const_str_plain_filter;
static PyObject *const_str_plain_video_data_rate;
static PyObject *const_str_plain__process_data;
static PyObject *const_str_digest_91049d54c42a857d6a3ba1d5cbf8cd99;
static PyObject *const_str_digest_d0c849816d2a2fdedbfbbef2ca596803;
extern PyObject *const_str_plain_43662b577c018ad707a63766462b1e87;
extern PyObject *const_str_plain_duration;
extern PyObject *const_str_plain_join;
static PyObject *const_int_pos_136;
extern PyObject *const_str_plain_utils;
extern PyObject *const_tuple_str_plain_height_tuple;
static PyObject *const_tuple_str_plain_quality_level_tuple;
extern PyObject *const_tuple_int_pos_1_tuple;
extern PyObject *const_str_digest_940c738501eab177474dd728fcc84769;
extern PyObject *const_str_plain_re;
extern PyObject *const_str_plain___doc__;
extern PyObject *const_str_plain_description;
extern PyObject *const_str_plain_show_data;
static PyObject *const_str_plain_36;
static PyObject *const_str_digest_d68478e2f15f6d7e3647320c1c45f925;
extern PyObject *const_str_plain_flv;
extern PyObject *const_str_plain___orig_bases__;
extern PyObject *const_str_plain_AdobeTVVideoIE;
extern PyObject *const_str_plain_data;
extern PyObject *const_str_plain_page;
extern PyObject *const_str_plain_int_or_none;
extern PyObject *const_str_plain_parse_duration;
extern PyObject *const_str_plain_bitrate;
static PyObject *const_str_plain_url_key;
static PyObject *const_str_plain_urlname;
static PyObject *const_tuple_str_plain_kilobytes_tuple;
extern PyObject *const_str_plain_label;
static PyObject *const_str_digest_5c4e3a3f98d6df6c4f0ea95e17d857d1;
static PyObject *const_str_digest_4d32a606745cea62faa915b57caef28d;
extern PyObject *const_str_plain_tbr;
static PyObject *const_dict_3d1ed719334bf3a6872c97da2e22d9da;
extern PyObject *const_str_plain___qualname__;
static PyObject *const_str_digest_8938fc5064524cd7b2d3d1a0524200a9;
static PyObject *const_str_digest_b1c334de9d987fec02c30dcb9b054ec0;
static PyObject *const_str_digest_e885bf143fe970625432b21db59ca551;
extern PyObject *const_str_digest_09d63a5a61044765cbef1a09e46446f1;
extern PyObject *const_str_plain__VALID_URL;
extern PyObject *const_str_plain_ext;
extern PyObject *const_tuple_str_plain_InfoExtractor_tuple;
extern PyObject *const_tuple_str_plain_bitrate_tuple;
static PyObject *const_tuple_str_plain_video_data_rate_tuple;
extern PyObject *const_str_plain_src;
extern PyObject *const_str_plain__download_webpage;
extern PyObject *const_str_plain_int;
extern PyObject *const_str_plain_path;
extern PyObject *const_str_plain_format_id;
extern PyObject *const_str_chr_45;
static PyObject *const_dict_c6e38c1dc56009c0caf23cc553110e16;
extern PyObject *const_str_plain_source_url;
static PyObject *const_str_plain_channel_urlname;
static PyObject *const_str_plain_disclosure;
static PyObject *const_str_digest_11e94e8f07bf0d0965bbec23b14f3e73;
static PyObject *const_tuple_fb825decfcef3970d54bda145de20f60_tuple;
static PyObject *const_str_digest_afba863e1889153901633aeafa890e29;
static PyObject *const_dict_76fc067bda8e821508b19c9d308e4957;
extern PyObject *const_str_plain_query;
extern PyObject *const_str_plain__search_regex;
extern PyObject *const_str_plain_mp4;
extern PyObject *const_str_plain_height;
extern PyObject *const_tuple_str_plain_description_tuple;
static PyObject *const_str_digest_e1ce97f428d8b913e7708abe37995436;
extern PyObject *const_str_plain_subtitles;
extern PyObject *const_str_plain_long2short;
extern PyObject *const_str_plain_fps;
static PyObject *const_str_digest_f60a39ae7d3b695e96126c2ac3578613;
static PyObject *const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple;
extern PyObject *const_str_plain_IE_NAME;
extern PyObject *const_tuple_empty;
static PyObject *const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b;
extern PyObject *const_str_plain_str_to_int;
extern PyObject *const_tuple_str_plain_frame_rate_tuple;
extern PyObject *const_str_plain_append;
static PyObject *const_str_plain_category_urlname;
extern PyObject *const_str_plain_title;
extern PyObject *const_tuple_str_plain_poster_tuple;
extern PyObject *const_str_plain_thumbnail;
static PyObject *const_str_plain_20091109;
static PyObject *const_str_plain_9bc5727bcdd55251f35ad311ca74fa1e;
static PyObject *const_str_plain_show_description;
static PyObject *const_str_plain_kilobytes;
extern PyObject *const_tuple_str_plain_label_tuple;
static PyObject *const_str_plain_translation;
extern PyObject *const_float_248_667;
static PyObject *const_str_digest_e5eb2bea26fcd040f068d947ea16586f;
extern PyObject *const_str_plain_filesize;
extern PyObject *const_str_plain__TEST;
extern PyObject *const_str_plain__parse_json;
extern PyObject *const_str_plain_en;
extern PyObject *const_tuple_str_plain_url_tuple;
static PyObject *const_str_plain_AdobeTVShow;
extern PyObject *const_tuple_str_plain_width_tuple;
static PyObject *const_str_digest_063577d419a945e3f6eb9d04ccb35781;
static PyObject *const_str_digest_2709ca18b0b7f1f400a7b0885f2980a2;
static PyObject *const_tuple_77ab2f217c8102229820487d620540d1_tuple;
extern PyObject *const_str_plain_frame_rate;
extern PyObject *const_int_pos_60;
static PyObject *const_tuple_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b_tuple;
extern PyObject *const_str_plain_match;
extern PyObject *const_str_plain_float_or_none;
static PyObject *const_dict_f0a1067e40cf23005c809b8ff7ef5d31;
static PyObject *const_str_digest_f98803efe7aa32cc5947018bd34448ee;
extern PyObject *const_str_plain_show;
extern PyObject *const_str_plain_video;
extern PyObject *const_str_plain__PAGE_SIZE;
extern PyObject *const_str_plain_display_id;
extern PyObject *const_str_plain___getitem__;
extern PyObject *const_int_pos_96;
extern PyObject *const_tuple_str_plain_show_name_tuple;
extern PyObject *const_str_plain_f;
static PyObject *const_str_plain_language_w3c;
extern PyObject *const_str_plain_lang;
static PyObject *const_tuple_str_plain_playcount_tuple;
extern PyObject *const_str_plain_standard;
extern PyObject *const_str_plain__real_extract;
extern PyObject *const_str_plain_formats;
extern PyObject *const_str_plain_translations;
static PyObject *const_str_digest_b6c90a0dcb28b42fff3cda6f9495e216;
extern PyObject *const_int_0;
extern PyObject *const_str_digest_7a2d943bcd947d9a84529c7e4cb0115c;
extern PyObject *const_str_plain_vtt;
static PyObject *const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple;
extern PyObject *const_str_plain_source_src;
extern PyObject *const_str_plain_videos;
static PyObject *const_str_digest_d7f80072b886f6b6c6273a3587d74d37;
static PyObject *const_str_digest_7e9c451ae054c3f5df4ae9aee8edec23;
static PyObject *const_str_digest_128580145093bad2fb6cc8410c6126ff;
static PyObject *const_str_digest_6aed0f1cd7d873ba1da23f0d536389c6;
static PyObject *const_tuple_ed2864ef392c30a12560514dea6ae132_tuple;
extern PyObject *const_str_plain_note;
extern PyObject *const_int_pos_1000;
extern PyObject *const_tuple_int_pos_2_tuple;
extern PyObject *const_str_plain_episode;
static PyObject *const_str_plain_AdobeTVPlaylistBaseIE;
static PyObject *const_str_digest_e5f7587c0206a238d49eb79d7f53cef7;
extern PyObject *const_str_plain_search;
static PyObject *const_str_plain_20110914;
static PyObject *const_str_plain_quality_level;
extern PyObject *const_str_plain_origin;
extern PyObject *const_str_plain_preference;
static PyObject *const_str_digest_2b9936044cbd24bced3dd0cab61986af;
static PyObject *const_str_digest_dc8fce64523d2f2ac46cff1514702e96;
static PyObject *const_str_plain_original_filename;
extern PyObject *const_str_digest_75fd71b1edada749c2ef7ac810062295;
static PyObject *const_tuple_str_plain_start_date_tuple;
extern PyObject *const_str_angle_listcomp;
extern PyObject *const_tuple_str_plain_src_tuple;
static PyObject *const_str_plain_language_medium;
extern PyObject *const_str_plain_video_data;
extern PyObject *const_str_plain_invscale;
static PyObject *const_str_digest_bdb546fa98754ba0cf99fdab40564bd3;
static PyObject *const_str_digest_9b792622a4a8c6de219288edd32bf03f;
static PyObject *const_tuple_str_plain_original_filename_tuple;
extern PyObject *const_str_plain_ISO639Utils;
extern PyObject *const_str_plain_setdefault;
static PyObject *const_str_digest_af523633df503b653506078243199934;
extern PyObject *const_str_plain_OnDemandPagedList;
static PyObject *const_str_plain_10981;
static PyObject *const_str_plain_development;
static PyObject *const_str_digest_5240d88f631f21ffaccd2a56fde48d8d;
extern PyObject *const_str_plain_type;
extern PyObject *const_dict_c54ad24c94e3512475ba621ffbade5fa;
static PyObject *const_tuple_c6d9a0aa6d3e3a0e302e12470e54749f_tuple;
extern PyObject *const_str_plain__download_json;
extern PyObject *const_tuple_str_plain_duration_tuple;
extern PyObject *const_str_plain_playlist_result;
static PyObject *const_str_plain__parse_subtitles;
extern PyObject *const_str_plain___cached__;
extern PyObject *const_str_plain_InfoExtractor;
extern PyObject *const_str_plain___class__;
extern PyObject *const_str_plain_url_result;
extern PyObject *const_str_plain_mobj;
extern PyObject *const_tuple_none_tuple;
extern PyObject *const_str_plain_upload_date;
extern PyObject *const_str_plain___module__;
extern PyObject *const_str_plain__parse_video_data;
extern PyObject *const_str_plain_functools;
extern PyObject *const_tuple_str_plain_thumbnail_tuple;
extern PyObject *const_str_plain_source;
extern PyObject *const_str_plain_unicode_literals;
extern PyObject *const_tuple_str_plain_source_tuple;
extern PyObject *const_str_plain_update;
extern PyObject *const_int_pos_1;
extern PyObject *const_str_plain_partial;
extern PyObject *const_str_plain_replace;
extern PyObject *const_str_plain_start_date;
extern PyObject *const_tuple_str_plain_compat_str_tuple;
static PyObject *const_str_digest_714c56ad1499fd5b62b9d350eb0f6bdd;
static PyObject *const_int_pos_377;
extern PyObject *const_str_plain_language;
static PyObject *const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple;
extern PyObject *const_str_plain_unified_strdate;
extern PyObject *const_str_plain_width;
static PyObject *const_str_digest_6696de4db3ece2bcf164d2844db12c75;
static PyObject *const_str_digest_7d18b74465ea3ff7e3ed7caf5bd84aea;
static PyObject *const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple;
extern PyObject *const_str_digest_fcf040720b88d60da4ce975010c44a3a;
extern PyObject *const_str_plain___prepare__;
static PyObject *const_tuple_str_plain_language_w3c_tuple;
static PyObject *const_str_plain_show_urlname;
extern PyObject *const_str_plain_url;
static PyObject *const_str_plain_4153;
extern PyObject *const_str_plain_AdobeTVShowIE;
extern PyObject *const_str_plain_self;
static PyObject *const_str_plain_element_data;
extern PyObject *const_str_plain_groups;
extern PyObject *const_str_plain_md5;
extern PyObject *const_str_plain_AdobeTVChannelIE;
static PyObject *const_str_digest_17cf953d9bc335c17c4eed4828d884e3;
extern PyObject *const_str_plain_original;
extern PyObject *const_str_plain_get;
extern PyObject *const_str_plain_show_name;
static PyObject *const_str_digest_64845517d9fdd6f5481d18e079915b1c;
extern PyObject *const_str_plain_has_location;
static PyObject *const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple;
extern PyObject *const_str_plain__fetch_page;
extern PyObject *const_int_pos_2;
extern PyObject *const_str_plain_2456;
extern PyObject *const_str_plain_compat;
extern PyObject *const_str_plain_playlist_mincount;
static PyObject *const_str_digest_fb250e306a67bc7d18432b489b4001a5;
extern PyObject *const_tuple_str_plain_format_tuple;
extern PyObject *const_str_plain_format;
extern PyObject *const_str_plain_adobetv;
extern PyObject *const_str_plain_startswith;
static PyObject *const_dict_b39d935d25f952b135dd1edfa70f6fb3;
static PyObject *const_tuple_d85dba18a66d34e43908411e553caeae_tuple;
extern PyObject *const_str_plain_common;
static PyObject *const_str_plain_vttPath;
static PyObject *const_str_plain_c8c0461bf04d54574fc2b4d07ac6783a;
extern PyObject *const_str_plain__call_api;
extern PyObject *const_str_plain_info_dict;
static PyObject *module_filename_obj;
/* Indicator if this modules private constants were created yet. */
static bool constants_created = false;
/* Function to create module private constants. */
static void createModuleConstants(void) {
const_str_digest_05202a5100e8f881a699bee57ca574ea = UNSTREAM_STRING_ASCII(&constant_bin[ 855447 ], 25, 0);
const_tuple_str_plain_show_description_tuple = PyTuple_New(1);
const_str_plain_show_description = UNSTREAM_STRING_ASCII(&constant_bin[ 855472 ], 16, 1);
PyTuple_SET_ITEM(const_tuple_str_plain_show_description_tuple, 0, const_str_plain_show_description); Py_INCREF(const_str_plain_show_description);
const_tuple_str_plain_self_str_plain_show_data_tuple = PyTuple_New(2);
PyTuple_SET_ITEM(const_tuple_str_plain_self_str_plain_show_data_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_str_plain_self_str_plain_show_data_tuple, 1, const_str_plain_show_data); Py_INCREF(const_str_plain_show_data);
const_str_digest_94d9324bf4313266f4f235e52c670f28 = UNSTREAM_STRING_ASCII(&constant_bin[ 855488 ], 28, 0);
const_str_digest_e66870d414502380d566e676d9cee231 = UNSTREAM_STRING_ASCII(&constant_bin[ 855516 ], 128, 0);
const_str_digest_d684f01bf89b4ee758a3ecfad8217126 = UNSTREAM_STRING_ASCII(&constant_bin[ 855644 ], 8, 0);
const_dict_5ea60a284ad730b39dc9421352bd1cb6 = _PyDict_NewPresized( 1 );
const_str_plain_development = UNSTREAM_STRING_ASCII(&constant_bin[ 855652 ], 11, 1);
PyDict_SetItem(const_dict_5ea60a284ad730b39dc9421352bd1cb6, const_str_plain_id, const_str_plain_development);
assert(PyDict_Size(const_dict_5ea60a284ad730b39dc9421352bd1cb6) == 1);
const_str_digest_ef9409495ac7eeeca2d480ded2207637 = UNSTREAM_STRING_ASCII(&constant_bin[ 855663 ], 34, 0);
const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple = PyTuple_New(8);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 0, const_str_plain_float_or_none); Py_INCREF(const_str_plain_float_or_none);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 1, const_str_plain_int_or_none); Py_INCREF(const_str_plain_int_or_none);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 2, const_str_plain_ISO639Utils); Py_INCREF(const_str_plain_ISO639Utils);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 3, const_str_plain_OnDemandPagedList); Py_INCREF(const_str_plain_OnDemandPagedList);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 4, const_str_plain_parse_duration); Py_INCREF(const_str_plain_parse_duration);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 5, const_str_plain_str_or_none); Py_INCREF(const_str_plain_str_or_none);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 6, const_str_plain_str_to_int); Py_INCREF(const_str_plain_str_to_int);
PyTuple_SET_ITEM(const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple, 7, const_str_plain_unified_strdate); Py_INCREF(const_str_plain_unified_strdate);
const_str_digest_be0726bace9f7b1b5af3d61e99668538 = UNSTREAM_STRING_ASCII(&constant_bin[ 855697 ], 36, 0);
const_str_plain__RESOURCE = UNSTREAM_STRING_ASCII(&constant_bin[ 855733 ], 9, 1);
const_str_plain__extract_playlist_entries = UNSTREAM_STRING_ASCII(&constant_bin[ 855742 ], 25, 1);
const_str_plain_s3_extracted = UNSTREAM_STRING_ASCII(&constant_bin[ 855767 ], 12, 1);
const_str_digest_9b21f56486eea5829f65df0a985977e3 = UNSTREAM_STRING_ASCII(&constant_bin[ 855779 ], 13, 0);
const_str_plain_playcount = UNSTREAM_STRING_ASCII(&constant_bin[ 855792 ], 9, 1);
const_str_digest_66715feeb3ff88b52732448550a756a2 = UNSTREAM_STRING_ASCII(&constant_bin[ 855801 ], 42, 0);
const_str_digest_bbdf4f5803fe97bbca4ce42b2c7b26e7 = UNSTREAM_STRING_ASCII(&constant_bin[ 855843 ], 45, 0);
const_str_plain_vtt_path = UNSTREAM_STRING_ASCII(&constant_bin[ 855888 ], 8, 1);
const_str_plain_AdobeTVBaseIE = UNSTREAM_STRING_ASCII(&constant_bin[ 34510 ], 13, 1);
const_str_plain_video_data_rate = UNSTREAM_STRING_ASCII(&constant_bin[ 855896 ], 15, 1);
const_str_plain__process_data = UNSTREAM_STRING_ASCII(&constant_bin[ 855911 ], 13, 1);
const_str_digest_91049d54c42a857d6a3ba1d5cbf8cd99 = UNSTREAM_STRING_ASCII(&constant_bin[ 855924 ], 28, 0);
const_str_digest_d0c849816d2a2fdedbfbbef2ca596803 = UNSTREAM_STRING_ASCII(&constant_bin[ 855952 ], 12, 0);
const_int_pos_136 = PyLong_FromUnsignedLong(136ul);
const_tuple_str_plain_quality_level_tuple = PyTuple_New(1);
const_str_plain_quality_level = UNSTREAM_STRING_ASCII(&constant_bin[ 855964 ], 13, 1);
PyTuple_SET_ITEM(const_tuple_str_plain_quality_level_tuple, 0, const_str_plain_quality_level); Py_INCREF(const_str_plain_quality_level);
const_str_plain_36 = UNSTREAM_STRING_ASCII(&constant_bin[ 6863 ], 2, 0);
const_str_digest_d68478e2f15f6d7e3647320c1c45f925 = UNSTREAM_STRING_ASCII(&constant_bin[ 855977 ], 23, 0);
const_str_plain_url_key = UNSTREAM_STRING_ASCII(&constant_bin[ 856000 ], 7, 1);
const_str_plain_urlname = UNSTREAM_STRING_ASCII(&constant_bin[ 856007 ], 7, 1);
const_tuple_str_plain_kilobytes_tuple = PyTuple_New(1);
const_str_plain_kilobytes = UNSTREAM_STRING_ASCII(&constant_bin[ 856014 ], 9, 1);
PyTuple_SET_ITEM(const_tuple_str_plain_kilobytes_tuple, 0, const_str_plain_kilobytes); Py_INCREF(const_str_plain_kilobytes);
const_str_digest_5c4e3a3f98d6df6c4f0ea95e17d857d1 = UNSTREAM_STRING_ASCII(&constant_bin[ 856023 ], 40, 0);
const_str_digest_4d32a606745cea62faa915b57caef28d = UNSTREAM_STRING_ASCII(&constant_bin[ 856063 ], 47, 0);
const_dict_3d1ed719334bf3a6872c97da2e22d9da = _PyDict_NewPresized( 3 );
const_str_digest_714c56ad1499fd5b62b9d350eb0f6bdd = UNSTREAM_STRING_ASCII(&constant_bin[ 856110 ], 65, 0);
PyDict_SetItem(const_dict_3d1ed719334bf3a6872c97da2e22d9da, const_str_plain_url, const_str_digest_714c56ad1499fd5b62b9d350eb0f6bdd);
const_dict_c6e38c1dc56009c0caf23cc553110e16 = _PyDict_NewPresized( 3 );
PyDict_SetItem(const_dict_c6e38c1dc56009c0caf23cc553110e16, const_str_plain_id, const_str_plain_36);
PyDict_SetItem(const_dict_c6e38c1dc56009c0caf23cc553110e16, const_str_plain_title, const_str_digest_5c4e3a3f98d6df6c4f0ea95e17d857d1);
const_str_digest_e1ce97f428d8b913e7708abe37995436 = UNSTREAM_STRING_ASCII(&constant_bin[ 856175 ], 36, 0);
PyDict_SetItem(const_dict_c6e38c1dc56009c0caf23cc553110e16, const_str_plain_description, const_str_digest_e1ce97f428d8b913e7708abe37995436);
assert(PyDict_Size(const_dict_c6e38c1dc56009c0caf23cc553110e16) == 3);
PyDict_SetItem(const_dict_3d1ed719334bf3a6872c97da2e22d9da, const_str_plain_info_dict, const_dict_c6e38c1dc56009c0caf23cc553110e16);
PyDict_SetItem(const_dict_3d1ed719334bf3a6872c97da2e22d9da, const_str_plain_playlist_mincount, const_int_pos_136);
assert(PyDict_Size(const_dict_3d1ed719334bf3a6872c97da2e22d9da) == 3);
const_str_digest_8938fc5064524cd7b2d3d1a0524200a9 = UNSTREAM_STRING_ASCII(&constant_bin[ 856211 ], 37, 0);
const_str_digest_b1c334de9d987fec02c30dcb9b054ec0 = UNSTREAM_STRING_ASCII(&constant_bin[ 856248 ], 109, 0);
const_str_digest_e885bf143fe970625432b21db59ca551 = UNSTREAM_STRING_ASCII(&constant_bin[ 856357 ], 8, 0);
const_tuple_str_plain_video_data_rate_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_plain_video_data_rate_tuple, 0, const_str_plain_video_data_rate); Py_INCREF(const_str_plain_video_data_rate);
const_str_plain_channel_urlname = UNSTREAM_STRING_ASCII(&constant_bin[ 856365 ], 15, 1);
const_str_plain_disclosure = UNSTREAM_STRING_ASCII(&constant_bin[ 856380 ], 10, 1);
const_str_digest_11e94e8f07bf0d0965bbec23b14f3e73 = UNSTREAM_STRING_ASCII(&constant_bin[ 856390 ], 27, 0);
const_tuple_fb825decfcef3970d54bda145de20f60_tuple = PyTuple_New(5);
PyTuple_SET_ITEM(const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 1, const_str_plain_path); Py_INCREF(const_str_plain_path);
PyTuple_SET_ITEM(const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 2, const_str_plain_video_id); Py_INCREF(const_str_plain_video_id);
PyTuple_SET_ITEM(const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 3, const_str_plain_query); Py_INCREF(const_str_plain_query);
PyTuple_SET_ITEM(const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 4, const_str_plain_note); Py_INCREF(const_str_plain_note);
const_str_digest_afba863e1889153901633aeafa890e29 = UNSTREAM_STRING_ASCII(&constant_bin[ 856417 ], 28, 0);
const_dict_76fc067bda8e821508b19c9d308e4957 = _PyDict_NewPresized( 3 );
PyDict_SetItem(const_dict_76fc067bda8e821508b19c9d308e4957, const_str_plain_url, const_str_digest_ef9409495ac7eeeca2d480ded2207637);
PyDict_SetItem(const_dict_76fc067bda8e821508b19c9d308e4957, const_str_plain_md5, const_str_plain_43662b577c018ad707a63766462b1e87);
PyDict_SetItem(const_dict_76fc067bda8e821508b19c9d308e4957, const_str_plain_info_dict, const_dict_7f784dd3d97b14f8a092c7056e4a88ae);
assert(PyDict_Size(const_dict_76fc067bda8e821508b19c9d308e4957) == 3);
const_str_digest_f60a39ae7d3b695e96126c2ac3578613 = UNSTREAM_STRING_ASCII(&constant_bin[ 856445 ], 23, 0);
const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple = PyTuple_New(3);
PyTuple_SET_ITEM(const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple, 1, const_str_plain_display_id); Py_INCREF(const_str_plain_display_id);
PyTuple_SET_ITEM(const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple, 2, const_str_plain_query); Py_INCREF(const_str_plain_query);
const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b = UNSTREAM_STRING_ASCII(&constant_bin[ 856468 ], 5, 0);
const_str_plain_category_urlname = UNSTREAM_STRING_ASCII(&constant_bin[ 856332 ], 16, 1);
const_str_plain_20091109 = UNSTREAM_STRING_ASCII(&constant_bin[ 856473 ], 8, 0);
const_str_plain_9bc5727bcdd55251f35ad311ca74fa1e = UNSTREAM_STRING_ASCII(&constant_bin[ 856481 ], 32, 0);
const_str_plain_translation = UNSTREAM_STRING_ASCII(&constant_bin[ 856513 ], 11, 1);
const_str_digest_e5eb2bea26fcd040f068d947ea16586f = UNSTREAM_STRING_ASCII(&constant_bin[ 856524 ], 16, 0);
const_str_plain_AdobeTVShow = UNSTREAM_STRING_ASCII(&constant_bin[ 856390 ], 11, 1);
const_str_digest_063577d419a945e3f6eb9d04ccb35781 = UNSTREAM_STRING_ASCII(&constant_bin[ 856540 ], 98, 0);
const_str_digest_2709ca18b0b7f1f400a7b0885f2980a2 = UNSTREAM_STRING_ASCII(&constant_bin[ 856638 ], 106, 0);
const_tuple_77ab2f217c8102229820487d620540d1_tuple = PyTuple_New(11);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 1, const_str_plain_video_data); Py_INCREF(const_str_plain_video_data);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 2, const_str_plain_video_id); Py_INCREF(const_str_plain_video_id);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 3, const_str_plain_title); Py_INCREF(const_str_plain_title);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 4, const_str_plain_s3_extracted); Py_INCREF(const_str_plain_s3_extracted);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 5, const_str_plain_formats); Py_INCREF(const_str_plain_formats);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 6, const_str_plain_source); Py_INCREF(const_str_plain_source);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 7, const_str_plain_source_url); Py_INCREF(const_str_plain_source_url);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 8, const_str_plain_f); Py_INCREF(const_str_plain_f);
const_str_plain_original_filename = UNSTREAM_STRING_ASCII(&constant_bin[ 856744 ], 17, 1);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 9, const_str_plain_original_filename); Py_INCREF(const_str_plain_original_filename);
PyTuple_SET_ITEM(const_tuple_77ab2f217c8102229820487d620540d1_tuple, 10, const_str_plain_mobj); Py_INCREF(const_str_plain_mobj);
const_tuple_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b_tuple, 0, const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b); Py_INCREF(const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b);
const_dict_f0a1067e40cf23005c809b8ff7ef5d31 = _PyDict_NewPresized( 1 );
PyDict_SetItem(const_dict_f0a1067e40cf23005c809b8ff7ef5d31, const_str_plain_disclosure, const_str_plain_standard);
assert(PyDict_Size(const_dict_f0a1067e40cf23005c809b8ff7ef5d31) == 1);
const_str_digest_f98803efe7aa32cc5947018bd34448ee = UNSTREAM_STRING_ASCII(&constant_bin[ 856761 ], 73, 0);
const_str_plain_language_w3c = UNSTREAM_STRING_ASCII(&constant_bin[ 856834 ], 12, 1);
const_tuple_str_plain_playcount_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_plain_playcount_tuple, 0, const_str_plain_playcount); Py_INCREF(const_str_plain_playcount);
const_str_digest_b6c90a0dcb28b42fff3cda6f9495e216 = UNSTREAM_STRING_ASCII(&constant_bin[ 856846 ], 44, 0);
const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple = PyTuple_New(6);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 1, const_str_plain_url); Py_INCREF(const_str_plain_url);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 2, const_str_plain_language); Py_INCREF(const_str_plain_language);
const_str_plain_show_urlname = UNSTREAM_STRING_ASCII(&constant_bin[ 856605 ], 12, 1);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 3, const_str_plain_show_urlname); Py_INCREF(const_str_plain_show_urlname);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 4, const_str_plain_urlname); Py_INCREF(const_str_plain_urlname);
PyTuple_SET_ITEM(const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 5, const_str_plain_video_data); Py_INCREF(const_str_plain_video_data);
const_str_digest_d7f80072b886f6b6c6273a3587d74d37 = UNSTREAM_STRING_ASCII(&constant_bin[ 856890 ], 11, 0);
const_str_digest_7e9c451ae054c3f5df4ae9aee8edec23 = UNSTREAM_STRING_ASCII(&constant_bin[ 856901 ], 33, 0);
const_str_digest_128580145093bad2fb6cc8410c6126ff = UNSTREAM_STRING_ASCII(&constant_bin[ 856934 ], 39, 0);
const_str_digest_6aed0f1cd7d873ba1da23f0d536389c6 = UNSTREAM_STRING_ASCII(&constant_bin[ 856973 ], 27, 0);
const_tuple_ed2864ef392c30a12560514dea6ae132_tuple = PyTuple_New(6);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 1, const_str_plain_url); Py_INCREF(const_str_plain_url);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 2, const_str_plain_language); Py_INCREF(const_str_plain_language);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 3, const_str_plain_show_urlname); Py_INCREF(const_str_plain_show_urlname);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 4, const_str_plain_query); Py_INCREF(const_str_plain_query);
PyTuple_SET_ITEM(const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 5, const_str_plain_show_data); Py_INCREF(const_str_plain_show_data);
const_str_plain_AdobeTVPlaylistBaseIE = UNSTREAM_STRING_ASCII(&constant_bin[ 34545 ], 21, 1);
const_str_digest_e5f7587c0206a238d49eb79d7f53cef7 = UNSTREAM_STRING_ASCII(&constant_bin[ 857000 ], 12, 0);
const_str_plain_20110914 = UNSTREAM_STRING_ASCII(&constant_bin[ 857012 ], 8, 0);
const_str_digest_2b9936044cbd24bced3dd0cab61986af = UNSTREAM_STRING_ASCII(&constant_bin[ 857020 ], 62, 0);
const_str_digest_dc8fce64523d2f2ac46cff1514702e96 = UNSTREAM_STRING_ASCII(&constant_bin[ 857082 ], 13, 0);
const_tuple_str_plain_start_date_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_plain_start_date_tuple, 0, const_str_plain_start_date); Py_INCREF(const_str_plain_start_date);
const_str_plain_language_medium = UNSTREAM_STRING_ASCII(&constant_bin[ 857095 ], 15, 1);
const_str_digest_bdb546fa98754ba0cf99fdab40564bd3 = UNSTREAM_STRING_ASCII(&constant_bin[ 857110 ], 15, 0);
const_str_digest_9b792622a4a8c6de219288edd32bf03f = UNSTREAM_STRING_ASCII(&constant_bin[ 857125 ], 27, 0);
const_tuple_str_plain_original_filename_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_plain_original_filename_tuple, 0, const_str_plain_original_filename); Py_INCREF(const_str_plain_original_filename);
const_str_digest_af523633df503b653506078243199934 = UNSTREAM_STRING_ASCII(&constant_bin[ 857152 ], 30, 0);
const_str_plain_10981 = UNSTREAM_STRING_ASCII(&constant_bin[ 857182 ], 5, 0);
const_str_digest_5240d88f631f21ffaccd2a56fde48d8d = UNSTREAM_STRING_ASCII(&constant_bin[ 857187 ], 31, 0);
const_tuple_c6d9a0aa6d3e3a0e302e12470e54749f_tuple = PyTuple_New(2);
PyTuple_SET_ITEM(const_tuple_c6d9a0aa6d3e3a0e302e12470e54749f_tuple, 0, const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b); Py_INCREF(const_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b);
PyTuple_SET_ITEM(const_tuple_c6d9a0aa6d3e3a0e302e12470e54749f_tuple, 1, const_str_digest_05202a5100e8f881a699bee57ca574ea); Py_INCREF(const_str_digest_05202a5100e8f881a699bee57ca574ea);
const_str_plain__parse_subtitles = UNSTREAM_STRING_ASCII(&constant_bin[ 857218 ], 16, 1);
const_int_pos_377 = PyLong_FromUnsignedLong(377ul);
const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple = PyTuple_New(6);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 1, const_str_plain_url); Py_INCREF(const_str_plain_url);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 2, const_str_plain_language); Py_INCREF(const_str_plain_language);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 3, const_str_plain_channel_urlname); Py_INCREF(const_str_plain_channel_urlname);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 4, const_str_plain_category_urlname); Py_INCREF(const_str_plain_category_urlname);
PyTuple_SET_ITEM(const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 5, const_str_plain_query); Py_INCREF(const_str_plain_query);
const_str_digest_6696de4db3ece2bcf164d2844db12c75 = UNSTREAM_STRING_ASCII(&constant_bin[ 857234 ], 12, 0);
const_str_digest_7d18b74465ea3ff7e3ed7caf5bd84aea = UNSTREAM_STRING_ASCII(&constant_bin[ 857246 ], 36, 0);
const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple = PyTuple_New(11);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 1, const_str_plain_url); Py_INCREF(const_str_plain_url);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 2, const_str_plain_video_id); Py_INCREF(const_str_plain_video_id);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 3, const_str_plain_webpage); Py_INCREF(const_str_plain_webpage);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 4, const_str_plain_video_data); Py_INCREF(const_str_plain_video_data);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 5, const_str_plain_title); Py_INCREF(const_str_plain_title);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 6, const_str_plain_formats); Py_INCREF(const_str_plain_formats);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 7, const_str_plain_sources); Py_INCREF(const_str_plain_sources);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 8, const_str_plain_source); Py_INCREF(const_str_plain_source);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 9, const_str_plain_source_src); Py_INCREF(const_str_plain_source_src);
PyTuple_SET_ITEM(const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 10, const_str_plain_duration); Py_INCREF(const_str_plain_duration);
const_tuple_str_plain_language_w3c_tuple = PyTuple_New(1);
PyTuple_SET_ITEM(const_tuple_str_plain_language_w3c_tuple, 0, const_str_plain_language_w3c); Py_INCREF(const_str_plain_language_w3c);
const_str_plain_4153 = UNSTREAM_STRING_ASCII(&constant_bin[ 857282 ], 4, 0);
const_str_plain_element_data = UNSTREAM_STRING_ASCII(&constant_bin[ 857286 ], 12, 1);
const_str_digest_17cf953d9bc335c17c4eed4828d884e3 = UNSTREAM_STRING_ASCII(&constant_bin[ 857298 ], 34, 0);
const_str_digest_64845517d9fdd6f5481d18e079915b1c = UNSTREAM_STRING_ASCII(&constant_bin[ 857332 ], 30, 0);
const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple = PyTuple_New(7);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 1, const_str_plain_video_data); Py_INCREF(const_str_plain_video_data);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 2, const_str_plain_url_key); Py_INCREF(const_str_plain_url_key);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 3, const_str_plain_subtitles); Py_INCREF(const_str_plain_subtitles);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 4, const_str_plain_translation); Py_INCREF(const_str_plain_translation);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 5, const_str_plain_vtt_path); Py_INCREF(const_str_plain_vtt_path);
PyTuple_SET_ITEM(const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 6, const_str_plain_lang); Py_INCREF(const_str_plain_lang);
const_str_digest_fb250e306a67bc7d18432b489b4001a5 = UNSTREAM_STRING_ASCII(&constant_bin[ 857362 ], 30, 0);
const_dict_b39d935d25f952b135dd1edfa70f6fb3 = _PyDict_NewPresized( 3 );
PyDict_SetItem(const_dict_b39d935d25f952b135dd1edfa70f6fb3, const_str_plain_url, const_str_digest_128580145093bad2fb6cc8410c6126ff);
PyDict_SetItem(const_dict_b39d935d25f952b135dd1edfa70f6fb3, const_str_plain_info_dict, const_dict_5ea60a284ad730b39dc9421352bd1cb6);
PyDict_SetItem(const_dict_b39d935d25f952b135dd1edfa70f6fb3, const_str_plain_playlist_mincount, const_int_pos_96);
assert(PyDict_Size(const_dict_b39d935d25f952b135dd1edfa70f6fb3) == 3);
const_tuple_d85dba18a66d34e43908411e553caeae_tuple = PyTuple_New(5);
PyTuple_SET_ITEM(const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 0, const_str_plain_self); Py_INCREF(const_str_plain_self);
PyTuple_SET_ITEM(const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 1, const_str_plain_display_id); Py_INCREF(const_str_plain_display_id);
PyTuple_SET_ITEM(const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 2, const_str_plain_query); Py_INCREF(const_str_plain_query);
PyTuple_SET_ITEM(const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 3, const_str_plain_page); Py_INCREF(const_str_plain_page);
PyTuple_SET_ITEM(const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 4, const_str_plain_element_data); Py_INCREF(const_str_plain_element_data);
const_str_plain_vttPath = UNSTREAM_STRING_ASCII(&constant_bin[ 857392 ], 7, 1);
const_str_plain_c8c0461bf04d54574fc2b4d07ac6783a = UNSTREAM_STRING_ASCII(&constant_bin[ 857399 ], 32, 1);
constants_created = true;
}
/* Function to verify module private constants for non-corruption. */
#ifndef __NUITKA_NO_ASSERT__
void checkModuleConstants_youtube_dl$extractor$adobetv(void) {
// The module may not have been used at all, then ignore this.
if (constants_created == false) return;
}
#endif
// The module code objects.
static PyCodeObject *codeobj_1e7db592e06f2b19245a7b92b16ee1ac;
static PyCodeObject *codeobj_c9377acb7551bcadf8d3742266bc3096;
static PyCodeObject *codeobj_4a4db23877cf40d63d0d3cb611eabb3d;
static PyCodeObject *codeobj_212e5f88591db5845244d4e462e25095;
static PyCodeObject *codeobj_1dd224ed6723050f9a702890ebe89e97;
static PyCodeObject *codeobj_293fae0b1c87e3c29380ffc25da7ec0e;
static PyCodeObject *codeobj_74c7094b8228d0a8210cc04eb85c548d;
static PyCodeObject *codeobj_5c0388a50dc76d1d7766415e475ed156;
static PyCodeObject *codeobj_b22fbb524a47a23a55ddf9d42313a6dc;
static PyCodeObject *codeobj_834f043b31b4afdc2588e7b3a4ba3554;
static PyCodeObject *codeobj_0c1486d9b5668f5559c676adca49b768;
static PyCodeObject *codeobj_6c3691199cab595cab8a57126f484e81;
static PyCodeObject *codeobj_09f8bb420e83a4f16794d009e8570c07;
static PyCodeObject *codeobj_1810a286a3465c5ff9e74d69681fef3b;
static PyCodeObject *codeobj_51a27b4404804636298a4a93f64122f6;
static PyCodeObject *codeobj_60871c028732697fc514e0c7e8db7eb5;
static PyCodeObject *codeobj_069782d2123400fbb5186fb48d5170e1;
static PyCodeObject *codeobj_89e9c2601f96e3e42ce33f5cf04cc314;
static PyCodeObject *codeobj_6f49301b89b3a3f4d161efa52eccb64d;
static PyCodeObject *codeobj_79314044936fe43446767356b30cc4a9;
static void createModuleCodeObjects(void) {
module_filename_obj = const_str_digest_2709ca18b0b7f1f400a7b0885f2980a2;
codeobj_1e7db592e06f2b19245a7b92b16ee1ac = MAKE_CODEOBJECT(module_filename_obj, 277, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_angle_listcomp, const_tuple_str_plain_source_tuple, 1, 0, 0);
codeobj_c9377acb7551bcadf8d3742266bc3096 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_digest_8938fc5064524cd7b2d3d1a0524200a9, const_tuple_empty, 0, 0, 0);
codeobj_4a4db23877cf40d63d0d3cb611eabb3d = MAKE_CODEOBJECT(module_filename_obj, 20, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVBaseIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_212e5f88591db5845244d4e462e25095 = MAKE_CODEOBJECT(module_filename_obj, 200, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVChannelIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_1dd224ed6723050f9a702890ebe89e97 = MAKE_CODEOBJECT(module_filename_obj, 89, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVEmbedIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_293fae0b1c87e3c29380ffc25da7ec0e = MAKE_CODEOBJECT(module_filename_obj, 115, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_74c7094b8228d0a8210cc04eb85c548d = MAKE_CODEOBJECT(module_filename_obj, 149, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVPlaylistBaseIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_5c0388a50dc76d1d7766415e475ed156 = MAKE_CODEOBJECT(module_filename_obj, 164, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVShowIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_b22fbb524a47a23a55ddf9d42313a6dc = MAKE_CODEOBJECT(module_filename_obj, 233, CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain_AdobeTVVideoIE, const_tuple_str_plain___class___tuple, 0, 0, 0);
codeobj_834f043b31b4afdc2588e7b3a4ba3554 = MAKE_CODEOBJECT(module_filename_obj, 21, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__call_api, const_tuple_fb825decfcef3970d54bda145de20f60_tuple, 5, 0, 0);
codeobj_0c1486d9b5668f5559c676adca49b768 = MAKE_CODEOBJECT(module_filename_obj, 159, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__extract_playlist_entries, const_tuple_str_plain_self_str_plain_display_id_str_plain_query_tuple, 3, 0, 0);
codeobj_6c3691199cab595cab8a57126f484e81 = MAKE_CODEOBJECT(module_filename_obj, 152, CO_GENERATOR | CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__fetch_page, const_tuple_d85dba18a66d34e43908411e553caeae_tuple, 4, 0, 0);
codeobj_09f8bb420e83a4f16794d009e8570c07 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__parse_subtitles, const_tuple_55101bef826d10bf7bd3905585ba9bed_tuple, 3, 0, 0);
codeobj_1810a286a3465c5ff9e74d69681fef3b = MAKE_CODEOBJECT(module_filename_obj, 39, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__parse_video_data, const_tuple_77ab2f217c8102229820487d620540d1_tuple, 2, 0, 0);
codeobj_51a27b4404804636298a4a93f64122f6 = MAKE_CODEOBJECT(module_filename_obj, 213, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__process_data, const_tuple_str_plain_self_str_plain_show_data_tuple, 2, 0, 0);
codeobj_60871c028732697fc514e0c7e8db7eb5 = MAKE_CODEOBJECT(module_filename_obj, 217, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__real_extract, const_tuple_a0fc6fb72362b69e53025ec32eb8c77b_tuple, 2, 0, 0);
codeobj_069782d2123400fbb5186fb48d5170e1 = MAKE_CODEOBJECT(module_filename_obj, 180, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__real_extract, const_tuple_ed2864ef392c30a12560514dea6ae132_tuple, 2, 0, 0);
codeobj_89e9c2601f96e3e42ce33f5cf04cc314 = MAKE_CODEOBJECT(module_filename_obj, 134, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__real_extract, const_tuple_a604f7fa06caf0b47e3ad0ccb3014288_tuple, 2, 0, 0);
codeobj_6f49301b89b3a3f4d161efa52eccb64d = MAKE_CODEOBJECT(module_filename_obj, 107, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__real_extract, const_tuple_4de2c63cd63fd056d54944169d9bb4a6_tuple, 2, 0, 0);
codeobj_79314044936fe43446767356b30cc4a9 = MAKE_CODEOBJECT(module_filename_obj, 250, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE | CO_FUTURE_UNICODE_LITERALS, const_str_plain__real_extract, const_tuple_33ebdd11639c9de5d41e63a6b9ed15c1_tuple, 2, 0, 0);
}
// The module function declarations.
static PyObject *youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_maker(void);
NUITKA_CROSS_MODULE PyObject *impl___internal__$$$function_4__mro_entries_conversion(PyObject **python_pars);
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_10__real_extract();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_11__real_extract();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_1__call_api(PyObject *defaults);
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_3__parse_video_data();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_4__real_extract();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_5__real_extract();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_6__fetch_page();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_8__real_extract();
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_9__process_data();
// The module function definitions.
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_1__call_api(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_path = python_pars[1];
PyObject *par_video_id = python_pars[2];
PyObject *par_query = python_pars[3];
PyObject *par_note = python_pars[4];
struct Nuitka_FrameObject *frame_834f043b31b4afdc2588e7b3a4ba3554;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *tmp_return_value = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
int tmp_res;
static struct Nuitka_FrameObject *cache_frame_834f043b31b4afdc2588e7b3a4ba3554 = NULL;
// Actual function body.
if (isFrameUnusable(cache_frame_834f043b31b4afdc2588e7b3a4ba3554)) {
Py_XDECREF(cache_frame_834f043b31b4afdc2588e7b3a4ba3554);
#if _DEBUG_REFCOUNTS
if (cache_frame_834f043b31b4afdc2588e7b3a4ba3554 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_834f043b31b4afdc2588e7b3a4ba3554 = MAKE_FUNCTION_FRAME(codeobj_834f043b31b4afdc2588e7b3a4ba3554, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_834f043b31b4afdc2588e7b3a4ba3554->m_type_description == NULL);
frame_834f043b31b4afdc2588e7b3a4ba3554 = cache_frame_834f043b31b4afdc2588e7b3a4ba3554;
// Push the new frame as the currently active one.
pushFrameStack(frame_834f043b31b4afdc2588e7b3a4ba3554);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_834f043b31b4afdc2588e7b3a4ba3554) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_expression_name_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_name_1;
PyObject *tmp_tuple_element_1;
PyObject *tmp_left_name_1;
PyObject *tmp_right_name_1;
PyObject *tmp_kw_name_1;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__download_json);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 22;
type_description_1 = "ooooo";
goto frame_exception_exit_1;
}
tmp_left_name_1 = const_str_digest_6aed0f1cd7d873ba1da23f0d536389c6;
CHECK_OBJECT(par_path);
tmp_right_name_1 = par_path;
tmp_tuple_element_1 = BINARY_OPERATION_ADD_OBJECT_UNICODE_OBJECT(tmp_left_name_1, tmp_right_name_1);
if (tmp_tuple_element_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 23;
type_description_1 = "ooooo";
goto frame_exception_exit_1;
}
tmp_args_name_1 = PyTuple_New(3);
PyTuple_SET_ITEM(tmp_args_name_1, 0, tmp_tuple_element_1);
CHECK_OBJECT(par_video_id);
tmp_tuple_element_1 = par_video_id;
Py_INCREF(tmp_tuple_element_1);
PyTuple_SET_ITEM(tmp_args_name_1, 1, tmp_tuple_element_1);
CHECK_OBJECT(par_note);
tmp_tuple_element_1 = par_note;
Py_INCREF(tmp_tuple_element_1);
PyTuple_SET_ITEM(tmp_args_name_1, 2, tmp_tuple_element_1);
tmp_dict_key_1 = const_str_plain_query;
CHECK_OBJECT(par_query);
tmp_dict_value_1 = par_query;
tmp_kw_name_1 = _PyDict_NewPresized( 1 );
tmp_res = PyDict_SetItem(tmp_kw_name_1, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
frame_834f043b31b4afdc2588e7b3a4ba3554->m_frame.f_lineno = 22;
tmp_expression_name_1 = CALL_FUNCTION(tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_name_1);
Py_DECREF(tmp_kw_name_1);
if (tmp_expression_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 22;
type_description_1 = "ooooo";
goto frame_exception_exit_1;
}
tmp_subscript_name_1 = const_str_plain_data;
tmp_return_value = LOOKUP_SUBSCRIPT(tmp_expression_name_1, tmp_subscript_name_1);
Py_DECREF(tmp_expression_name_1);
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 22;
type_description_1 = "ooooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_834f043b31b4afdc2588e7b3a4ba3554);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_834f043b31b4afdc2588e7b3a4ba3554);
#endif
// Put the previous frame back on top.
popFrameStack();
goto function_return_exit;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_834f043b31b4afdc2588e7b3a4ba3554);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_834f043b31b4afdc2588e7b3a4ba3554, exception_lineno);
} else if (exception_tb->tb_frame != &frame_834f043b31b4afdc2588e7b3a4ba3554->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_834f043b31b4afdc2588e7b3a4ba3554, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_834f043b31b4afdc2588e7b3a4ba3554,
type_description_1,
par_self,
par_path,
par_video_id,
par_query,
par_note
);
// Release cached frame.
if (frame_834f043b31b4afdc2588e7b3a4ba3554 == cache_frame_834f043b31b4afdc2588e7b3a4ba3554) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_834f043b31b4afdc2588e7b3a4ba3554);
}
cache_frame_834f043b31b4afdc2588e7b3a4ba3554 = NULL;
assertFrameObject(frame_834f043b31b4afdc2588e7b3a4ba3554);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto function_exception_exit;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_path);
Py_DECREF(par_path);
CHECK_OBJECT(par_video_id);
Py_DECREF(par_video_id);
CHECK_OBJECT(par_query);
Py_DECREF(par_query);
CHECK_OBJECT(par_note);
Py_DECREF(par_note); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_path);
Py_DECREF(par_path);
CHECK_OBJECT(par_video_id);
Py_DECREF(par_video_id);
CHECK_OBJECT(par_query);
Py_DECREF(par_query);
CHECK_OBJECT(par_note);
Py_DECREF(par_note);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_video_data = python_pars[1];
PyObject *par_url_key = python_pars[2];
PyObject *var_subtitles = NULL;
PyObject *var_translation = NULL;
PyObject *var_vtt_path = NULL;
PyObject *var_lang = NULL;
PyObject *tmp_for_loop_1__for_iterator = NULL;
PyObject *tmp_for_loop_1__iter_value = NULL;
struct Nuitka_FrameObject *frame_09f8bb420e83a4f16794d009e8570c07;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
int tmp_res;
NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
static struct Nuitka_FrameObject *cache_frame_09f8bb420e83a4f16794d009e8570c07 = NULL;
PyObject *tmp_return_value = NULL;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
// Actual function body.
{
PyObject *tmp_assign_source_1;
tmp_assign_source_1 = PyDict_New();
assert(var_subtitles == NULL);
var_subtitles = tmp_assign_source_1;
}
// Tried code:
if (isFrameUnusable(cache_frame_09f8bb420e83a4f16794d009e8570c07)) {
Py_XDECREF(cache_frame_09f8bb420e83a4f16794d009e8570c07);
#if _DEBUG_REFCOUNTS
if (cache_frame_09f8bb420e83a4f16794d009e8570c07 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_09f8bb420e83a4f16794d009e8570c07 = MAKE_FUNCTION_FRAME(codeobj_09f8bb420e83a4f16794d009e8570c07, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_09f8bb420e83a4f16794d009e8570c07->m_type_description == NULL);
frame_09f8bb420e83a4f16794d009e8570c07 = cache_frame_09f8bb420e83a4f16794d009e8570c07;
// Push the new frame as the currently active one.
pushFrameStack(frame_09f8bb420e83a4f16794d009e8570c07);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_09f8bb420e83a4f16794d009e8570c07) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_assign_source_2;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_call_arg_element_1;
PyObject *tmp_call_arg_element_2;
CHECK_OBJECT(par_video_data);
tmp_called_instance_1 = par_video_data;
tmp_call_arg_element_1 = const_str_plain_translations;
tmp_call_arg_element_2 = PyList_New(0);
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 28;
{
PyObject *call_args[] = {tmp_call_arg_element_1, tmp_call_arg_element_2};
tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, const_str_plain_get, call_args);
}
Py_DECREF(tmp_call_arg_element_2);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 28;
type_description_1 = "ooooooo";
goto frame_exception_exit_1;
}
tmp_assign_source_2 = MAKE_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 28;
type_description_1 = "ooooooo";
goto frame_exception_exit_1;
}
assert(tmp_for_loop_1__for_iterator == NULL);
tmp_for_loop_1__for_iterator = tmp_assign_source_2;
}
// Tried code:
loop_start_1:;
{
PyObject *tmp_next_source_1;
PyObject *tmp_assign_source_3;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
tmp_next_source_1 = tmp_for_loop_1__for_iterator;
tmp_assign_source_3 = ITERATOR_NEXT(tmp_next_source_1);
if (tmp_assign_source_3 == NULL) {
if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
goto loop_end_1;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "ooooooo";
exception_lineno = 28;
goto try_except_handler_2;
}
}
{
PyObject *old = tmp_for_loop_1__iter_value;
tmp_for_loop_1__iter_value = tmp_assign_source_3;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_4;
CHECK_OBJECT(tmp_for_loop_1__iter_value);
tmp_assign_source_4 = tmp_for_loop_1__iter_value;
{
PyObject *old = var_translation;
var_translation = tmp_assign_source_4;
Py_INCREF(var_translation);
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_5;
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_1;
CHECK_OBJECT(var_translation);
tmp_called_instance_2 = var_translation;
CHECK_OBJECT(par_url_key);
tmp_args_element_name_1 = par_url_key;
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 29;
{
PyObject *call_args[] = {tmp_args_element_name_1};
tmp_assign_source_5 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_2, const_str_plain_get, call_args);
}
if (tmp_assign_source_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 29;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
{
PyObject *old = var_vtt_path;
var_vtt_path = tmp_assign_source_5;
Py_XDECREF(old);
}
}
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_vtt_path);
tmp_operand_name_1 = var_vtt_path;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 30;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
goto loop_start_1;
branch_no_1:;
{
PyObject *tmp_assign_source_6;
int tmp_or_left_truth_1;
PyObject *tmp_or_left_value_1;
PyObject *tmp_or_right_value_1;
PyObject *tmp_called_instance_3;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_2;
PyObject *tmp_expression_name_2;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(var_translation);
tmp_called_instance_3 = var_translation;
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 32;
tmp_or_left_value_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_3, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_language_w3c_tuple, 0));
if (tmp_or_left_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
tmp_or_left_truth_1 = CHECK_IF_TRUE(tmp_or_left_value_1);
if (tmp_or_left_truth_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_or_left_value_1);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
if (tmp_or_left_truth_1 == 1) {
goto or_left_1;
} else {
goto or_right_1;
}
or_right_1:;
Py_DECREF(tmp_or_left_value_1);
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_ISO639Utils);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_ISO639Utils);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34366 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
tmp_expression_name_1 = tmp_mvar_value_1;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_long2short);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(var_translation);
tmp_expression_name_2 = var_translation;
tmp_subscript_name_1 = const_str_plain_language_medium;
tmp_args_element_name_2 = LOOKUP_SUBSCRIPT(tmp_expression_name_2, tmp_subscript_name_1);
if (tmp_args_element_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 32;
tmp_or_right_value_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_1, tmp_args_element_name_2);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_2);
if (tmp_or_right_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 32;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
tmp_assign_source_6 = tmp_or_right_value_1;
goto or_end_1;
or_left_1:;
tmp_assign_source_6 = tmp_or_left_value_1;
or_end_1:;
{
PyObject *old = var_lang;
var_lang = tmp_assign_source_6;
Py_XDECREF(old);
}
}
{
PyObject *tmp_called_instance_4;
PyObject *tmp_called_instance_5;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_call_result_1;
PyObject *tmp_args_element_name_5;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
CHECK_OBJECT(var_subtitles);
tmp_called_instance_5 = var_subtitles;
CHECK_OBJECT(var_lang);
tmp_args_element_name_3 = var_lang;
tmp_args_element_name_4 = PyList_New(0);
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 33;
{
PyObject *call_args[] = {tmp_args_element_name_3, tmp_args_element_name_4};
tmp_called_instance_4 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_5, const_str_plain_setdefault, call_args);
}
Py_DECREF(tmp_args_element_name_4);
if (tmp_called_instance_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 33;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
tmp_dict_key_1 = const_str_plain_ext;
tmp_dict_value_1 = const_str_plain_vtt;
tmp_args_element_name_5 = _PyDict_NewPresized( 2 );
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_url;
CHECK_OBJECT(var_vtt_path);
tmp_dict_value_2 = var_vtt_path;
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_2, tmp_dict_value_2);
assert(!(tmp_res != 0));
frame_09f8bb420e83a4f16794d009e8570c07->m_frame.f_lineno = 33;
{
PyObject *call_args[] = {tmp_args_element_name_5};
tmp_call_result_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_4, const_str_plain_append, call_args);
}
Py_DECREF(tmp_called_instance_4);
Py_DECREF(tmp_args_element_name_5);
if (tmp_call_result_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 33;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
Py_DECREF(tmp_call_result_1);
}
if (CONSIDER_THREADING() == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 28;
type_description_1 = "ooooooo";
goto try_except_handler_2;
}
goto loop_start_1;
loop_end_1:;
goto try_end_1;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto frame_exception_exit_1;
// End of try:
try_end_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_09f8bb420e83a4f16794d009e8570c07);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_09f8bb420e83a4f16794d009e8570c07);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_09f8bb420e83a4f16794d009e8570c07, exception_lineno);
} else if (exception_tb->tb_frame != &frame_09f8bb420e83a4f16794d009e8570c07->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_09f8bb420e83a4f16794d009e8570c07, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_09f8bb420e83a4f16794d009e8570c07,
type_description_1,
par_self,
par_video_data,
par_url_key,
var_subtitles,
var_translation,
var_vtt_path,
var_lang
);
// Release cached frame.
if (frame_09f8bb420e83a4f16794d009e8570c07 == cache_frame_09f8bb420e83a4f16794d009e8570c07) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_09f8bb420e83a4f16794d009e8570c07);
}
cache_frame_09f8bb420e83a4f16794d009e8570c07 = NULL;
assertFrameObject(frame_09f8bb420e83a4f16794d009e8570c07);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
CHECK_OBJECT(var_subtitles);
tmp_return_value = var_subtitles;
Py_INCREF(tmp_return_value);
goto try_return_handler_1;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_subtitles);
Py_DECREF(var_subtitles);
var_subtitles = NULL;
Py_XDECREF(var_translation);
var_translation = NULL;
Py_XDECREF(var_vtt_path);
var_vtt_path = NULL;
Py_XDECREF(var_lang);
var_lang = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(var_subtitles);
Py_DECREF(var_subtitles);
var_subtitles = NULL;
Py_XDECREF(var_translation);
var_translation = NULL;
Py_XDECREF(var_vtt_path);
var_vtt_path = NULL;
Py_XDECREF(var_lang);
var_lang = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_video_data);
Py_DECREF(par_video_data);
CHECK_OBJECT(par_url_key);
Py_DECREF(par_url_key); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_video_data);
Py_DECREF(par_video_data);
CHECK_OBJECT(par_url_key);
Py_DECREF(par_url_key);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_3__parse_video_data(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_video_data = python_pars[1];
PyObject *var_video_id = NULL;
PyObject *var_title = NULL;
PyObject *var_s3_extracted = NULL;
PyObject *var_formats = NULL;
PyObject *var_source = NULL;
PyObject *var_source_url = NULL;
PyObject *var_f = NULL;
PyObject *var_original_filename = NULL;
PyObject *var_mobj = NULL;
PyObject *tmp_for_loop_1__for_iterator = NULL;
PyObject *tmp_for_loop_1__iter_value = NULL;
struct Nuitka_FrameObject *frame_1810a286a3465c5ff9e74d69681fef3b;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
int tmp_res;
NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_1810a286a3465c5ff9e74d69681fef3b = NULL;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_1810a286a3465c5ff9e74d69681fef3b)) {
Py_XDECREF(cache_frame_1810a286a3465c5ff9e74d69681fef3b);
#if _DEBUG_REFCOUNTS
if (cache_frame_1810a286a3465c5ff9e74d69681fef3b == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_1810a286a3465c5ff9e74d69681fef3b = MAKE_FUNCTION_FRAME(codeobj_1810a286a3465c5ff9e74d69681fef3b, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_1810a286a3465c5ff9e74d69681fef3b->m_type_description == NULL);
frame_1810a286a3465c5ff9e74d69681fef3b = cache_frame_1810a286a3465c5ff9e74d69681fef3b;
// Push the new frame as the currently active one.
pushFrameStack(frame_1810a286a3465c5ff9e74d69681fef3b);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_1810a286a3465c5ff9e74d69681fef3b) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_called_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_subscript_name_1;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_compat_str);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_compat_str);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 26637 ], 32, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 40;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_called_name_1 = tmp_mvar_value_1;
CHECK_OBJECT(par_video_data);
tmp_expression_name_1 = par_video_data;
tmp_subscript_name_1 = const_str_plain_id;
tmp_args_element_name_1 = LOOKUP_SUBSCRIPT(tmp_expression_name_1, tmp_subscript_name_1);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 40;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 40;
tmp_assign_source_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_1, tmp_args_element_name_1);
Py_DECREF(tmp_args_element_name_1);
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 40;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_video_id == NULL);
var_video_id = tmp_assign_source_1;
}
{
PyObject *tmp_assign_source_2;
PyObject *tmp_expression_name_2;
PyObject *tmp_subscript_name_2;
CHECK_OBJECT(par_video_data);
tmp_expression_name_2 = par_video_data;
tmp_subscript_name_2 = const_str_plain_title;
tmp_assign_source_2 = LOOKUP_SUBSCRIPT(tmp_expression_name_2, tmp_subscript_name_2);
if (tmp_assign_source_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 41;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_title == NULL);
var_title = tmp_assign_source_2;
}
{
PyObject *tmp_assign_source_3;
tmp_assign_source_3 = Py_False;
assert(var_s3_extracted == NULL);
Py_INCREF(tmp_assign_source_3);
var_s3_extracted = tmp_assign_source_3;
}
{
PyObject *tmp_assign_source_4;
tmp_assign_source_4 = PyList_New(0);
assert(var_formats == NULL);
var_formats = tmp_assign_source_4;
}
{
PyObject *tmp_assign_source_5;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_call_arg_element_1;
PyObject *tmp_call_arg_element_2;
CHECK_OBJECT(par_video_data);
tmp_called_instance_1 = par_video_data;
tmp_call_arg_element_1 = const_str_plain_videos;
tmp_call_arg_element_2 = PyList_New(0);
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 45;
{
PyObject *call_args[] = {tmp_call_arg_element_1, tmp_call_arg_element_2};
tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, const_str_plain_get, call_args);
}
Py_DECREF(tmp_call_arg_element_2);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 45;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_assign_source_5 = MAKE_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 45;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(tmp_for_loop_1__for_iterator == NULL);
tmp_for_loop_1__for_iterator = tmp_assign_source_5;
}
// Tried code:
loop_start_1:;
{
PyObject *tmp_next_source_1;
PyObject *tmp_assign_source_6;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
tmp_next_source_1 = tmp_for_loop_1__for_iterator;
tmp_assign_source_6 = ITERATOR_NEXT(tmp_next_source_1);
if (tmp_assign_source_6 == NULL) {
if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
goto loop_end_1;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "ooooooooooo";
exception_lineno = 45;
goto try_except_handler_2;
}
}
{
PyObject *old = tmp_for_loop_1__iter_value;
tmp_for_loop_1__iter_value = tmp_assign_source_6;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_7;
CHECK_OBJECT(tmp_for_loop_1__iter_value);
tmp_assign_source_7 = tmp_for_loop_1__iter_value;
{
PyObject *old = var_source;
var_source = tmp_assign_source_7;
Py_INCREF(var_source);
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_8;
PyObject *tmp_called_instance_2;
CHECK_OBJECT(var_source);
tmp_called_instance_2 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 46;
tmp_assign_source_8 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_2, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_url_tuple, 0));
if (tmp_assign_source_8 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 46;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
{
PyObject *old = var_source_url;
var_source_url = tmp_assign_source_8;
Py_XDECREF(old);
}
}
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_source_url);
tmp_operand_name_1 = var_source_url;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 47;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
goto loop_start_1;
branch_no_1:;
{
PyObject *tmp_assign_source_9;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_called_instance_3;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
PyObject *tmp_called_name_2;
PyObject *tmp_mvar_value_2;
PyObject *tmp_args_element_name_2;
PyObject *tmp_called_instance_4;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_3;
PyObject *tmp_called_name_3;
PyObject *tmp_mvar_value_3;
PyObject *tmp_args_element_name_3;
PyObject *tmp_called_instance_5;
PyObject *tmp_dict_key_4;
PyObject *tmp_dict_value_4;
PyObject *tmp_called_name_4;
PyObject *tmp_mvar_value_4;
PyObject *tmp_args_element_name_4;
PyObject *tmp_called_instance_6;
PyObject *tmp_dict_key_5;
PyObject *tmp_dict_value_5;
PyObject *tmp_called_name_5;
PyObject *tmp_mvar_value_5;
PyObject *tmp_args_element_name_5;
PyObject *tmp_called_instance_7;
PyObject *tmp_dict_key_6;
PyObject *tmp_dict_value_6;
tmp_dict_key_1 = const_str_plain_format_id;
CHECK_OBJECT(var_source);
tmp_called_instance_3 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 50;
tmp_dict_value_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_3, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_quality_level_tuple, 0));
if (tmp_dict_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 50;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_assign_source_9 = _PyDict_NewPresized( 6 );
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_1, tmp_dict_value_1);
Py_DECREF(tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_fps;
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_2 == NULL)) {
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_2 == NULL) {
Py_DECREF(tmp_assign_source_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 51;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_2 = tmp_mvar_value_2;
CHECK_OBJECT(var_source);
tmp_called_instance_4 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 51;
tmp_args_element_name_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_4, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_frame_rate_tuple, 0));
if (tmp_args_element_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 51;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 51;
tmp_dict_value_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, tmp_args_element_name_2);
Py_DECREF(tmp_args_element_name_2);
if (tmp_dict_value_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 51;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_2, tmp_dict_value_2);
Py_DECREF(tmp_dict_value_2);
assert(!(tmp_res != 0));
tmp_dict_key_3 = const_str_plain_height;
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_3 == NULL)) {
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_3 == NULL) {
Py_DECREF(tmp_assign_source_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 52;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_3 = tmp_mvar_value_3;
CHECK_OBJECT(var_source);
tmp_called_instance_5 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 52;
tmp_args_element_name_3 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_5, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_height_tuple, 0));
if (tmp_args_element_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 52;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 52;
tmp_dict_value_3 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_3, tmp_args_element_name_3);
Py_DECREF(tmp_args_element_name_3);
if (tmp_dict_value_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 52;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_3, tmp_dict_value_3);
Py_DECREF(tmp_dict_value_3);
assert(!(tmp_res != 0));
tmp_dict_key_4 = const_str_plain_tbr;
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_4 == NULL)) {
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_4 == NULL) {
Py_DECREF(tmp_assign_source_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 53;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_4 = tmp_mvar_value_4;
CHECK_OBJECT(var_source);
tmp_called_instance_6 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 53;
tmp_args_element_name_4 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_6, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_video_data_rate_tuple, 0));
if (tmp_args_element_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 53;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 53;
tmp_dict_value_4 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_4, tmp_args_element_name_4);
Py_DECREF(tmp_args_element_name_4);
if (tmp_dict_value_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 53;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_4, tmp_dict_value_4);
Py_DECREF(tmp_dict_value_4);
assert(!(tmp_res != 0));
tmp_dict_key_5 = const_str_plain_width;
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_5 == NULL)) {
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_5 == NULL) {
Py_DECREF(tmp_assign_source_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 54;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_5 = tmp_mvar_value_5;
CHECK_OBJECT(var_source);
tmp_called_instance_7 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 54;
tmp_args_element_name_5 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_7, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_width_tuple, 0));
if (tmp_args_element_name_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 54;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 54;
tmp_dict_value_5 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_5, tmp_args_element_name_5);
Py_DECREF(tmp_args_element_name_5);
if (tmp_dict_value_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_assign_source_9);
exception_lineno = 54;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_5, tmp_dict_value_5);
Py_DECREF(tmp_dict_value_5);
assert(!(tmp_res != 0));
tmp_dict_key_6 = const_str_plain_url;
CHECK_OBJECT(var_source_url);
tmp_dict_value_6 = var_source_url;
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_6, tmp_dict_value_6);
assert(!(tmp_res != 0));
{
PyObject *old = var_f;
var_f = tmp_assign_source_9;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_10;
PyObject *tmp_called_instance_8;
CHECK_OBJECT(var_source);
tmp_called_instance_8 = var_source;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 57;
tmp_assign_source_10 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_8, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_original_filename_tuple, 0));
if (tmp_assign_source_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 57;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
{
PyObject *old = var_original_filename;
var_original_filename = tmp_assign_source_10;
Py_XDECREF(old);
}
}
{
nuitka_bool tmp_condition_result_2;
int tmp_truth_name_1;
CHECK_OBJECT(var_original_filename);
tmp_truth_name_1 = CHECK_IF_TRUE(var_original_filename);
if (tmp_truth_name_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 58;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_2 == NUITKA_BOOL_TRUE) {
goto branch_yes_2;
} else {
goto branch_no_2;
}
}
branch_yes_2:;
{
nuitka_bool tmp_condition_result_3;
PyObject *tmp_operand_name_2;
int tmp_and_left_truth_1;
PyObject *tmp_and_left_value_1;
PyObject *tmp_and_right_value_1;
PyObject *tmp_called_instance_9;
PyObject *tmp_called_instance_10;
CHECK_OBJECT(var_f);
tmp_called_instance_9 = var_f;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 59;
tmp_and_left_value_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_9, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_height_tuple, 0));
if (tmp_and_left_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 59;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_and_left_truth_1 = CHECK_IF_TRUE(tmp_and_left_value_1);
if (tmp_and_left_truth_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_and_left_value_1);
exception_lineno = 59;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
if (tmp_and_left_truth_1 == 1) {
goto and_right_1;
} else {
goto and_left_1;
}
and_right_1:;
Py_DECREF(tmp_and_left_value_1);
CHECK_OBJECT(var_f);
tmp_called_instance_10 = var_f;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 59;
tmp_and_right_value_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_10, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_width_tuple, 0));
if (tmp_and_right_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 59;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_operand_name_2 = tmp_and_right_value_1;
goto and_end_1;
and_left_1:;
tmp_operand_name_2 = tmp_and_left_value_1;
and_end_1:;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_2);
Py_DECREF(tmp_operand_name_2);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 59;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_condition_result_3 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_3 == NUITKA_BOOL_TRUE) {
goto branch_yes_3;
} else {
goto branch_no_3;
}
}
branch_yes_3:;
{
PyObject *tmp_assign_source_11;
PyObject *tmp_called_instance_11;
PyObject *tmp_mvar_value_6;
PyObject *tmp_args_element_name_6;
PyObject *tmp_args_element_name_7;
tmp_mvar_value_6 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_re);
if (unlikely(tmp_mvar_value_6 == NULL)) {
tmp_mvar_value_6 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_re);
}
if (tmp_mvar_value_6 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 2114 ], 24, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 60;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_instance_11 = tmp_mvar_value_6;
tmp_args_element_name_6 = const_str_digest_6696de4db3ece2bcf164d2844db12c75;
CHECK_OBJECT(var_original_filename);
tmp_args_element_name_7 = var_original_filename;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 60;
{
PyObject *call_args[] = {tmp_args_element_name_6, tmp_args_element_name_7};
tmp_assign_source_11 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_11, const_str_plain_search, call_args);
}
if (tmp_assign_source_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 60;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
{
PyObject *old = var_mobj;
var_mobj = tmp_assign_source_11;
Py_XDECREF(old);
}
}
{
nuitka_bool tmp_condition_result_4;
int tmp_truth_name_2;
CHECK_OBJECT(var_mobj);
tmp_truth_name_2 = CHECK_IF_TRUE(var_mobj);
if (tmp_truth_name_2 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 61;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_condition_result_4 = tmp_truth_name_2 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_4 == NUITKA_BOOL_TRUE) {
goto branch_yes_4;
} else {
goto branch_no_4;
}
}
branch_yes_4:;
{
PyObject *tmp_called_name_6;
PyObject *tmp_expression_name_3;
PyObject *tmp_call_result_1;
PyObject *tmp_args_element_name_8;
PyObject *tmp_dict_key_7;
PyObject *tmp_dict_value_7;
PyObject *tmp_int_arg_1;
PyObject *tmp_called_instance_12;
PyObject *tmp_dict_key_8;
PyObject *tmp_dict_value_8;
PyObject *tmp_int_arg_2;
PyObject *tmp_called_instance_13;
CHECK_OBJECT(var_f);
tmp_expression_name_3 = var_f;
tmp_called_name_6 = LOOKUP_ATTRIBUTE(tmp_expression_name_3, const_str_plain_update);
if (tmp_called_name_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 62;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_dict_key_7 = const_str_plain_height;
CHECK_OBJECT(var_mobj);
tmp_called_instance_12 = var_mobj;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 63;
tmp_int_arg_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_12, const_str_plain_group, &PyTuple_GET_ITEM(const_tuple_int_pos_2_tuple, 0));
if (tmp_int_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_6);
exception_lineno = 63;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_dict_value_7 = PyNumber_Int(tmp_int_arg_1);
Py_DECREF(tmp_int_arg_1);
if (tmp_dict_value_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_6);
exception_lineno = 63;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_args_element_name_8 = _PyDict_NewPresized( 2 );
tmp_res = PyDict_SetItem(tmp_args_element_name_8, tmp_dict_key_7, tmp_dict_value_7);
Py_DECREF(tmp_dict_value_7);
assert(!(tmp_res != 0));
tmp_dict_key_8 = const_str_plain_width;
CHECK_OBJECT(var_mobj);
tmp_called_instance_13 = var_mobj;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 64;
tmp_int_arg_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_13, const_str_plain_group, &PyTuple_GET_ITEM(const_tuple_int_pos_1_tuple, 0));
if (tmp_int_arg_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_6);
Py_DECREF(tmp_args_element_name_8);
exception_lineno = 64;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_dict_value_8 = PyNumber_Int(tmp_int_arg_2);
Py_DECREF(tmp_int_arg_2);
if (tmp_dict_value_8 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_6);
Py_DECREF(tmp_args_element_name_8);
exception_lineno = 64;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_8, tmp_dict_key_8, tmp_dict_value_8);
Py_DECREF(tmp_dict_value_8);
assert(!(tmp_res != 0));
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 62;
tmp_call_result_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_6, tmp_args_element_name_8);
Py_DECREF(tmp_called_name_6);
Py_DECREF(tmp_args_element_name_8);
if (tmp_call_result_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 62;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
Py_DECREF(tmp_call_result_1);
}
branch_no_4:;
branch_no_3:;
{
nuitka_bool tmp_condition_result_5;
int tmp_and_left_truth_2;
nuitka_bool tmp_and_left_value_2;
nuitka_bool tmp_and_right_value_2;
PyObject *tmp_called_instance_14;
PyObject *tmp_call_result_2;
int tmp_truth_name_3;
PyObject *tmp_operand_name_3;
CHECK_OBJECT(var_original_filename);
tmp_called_instance_14 = var_original_filename;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 66;
tmp_call_result_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_14, const_str_plain_startswith, &PyTuple_GET_ITEM(const_tuple_str_digest_f2ed70f3f2c547e93e6963aafbc5fc4b_tuple, 0));
if (tmp_call_result_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 66;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_truth_name_3 = CHECK_IF_TRUE(tmp_call_result_2);
if (tmp_truth_name_3 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_call_result_2);
exception_lineno = 66;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_and_left_value_2 = tmp_truth_name_3 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
Py_DECREF(tmp_call_result_2);
tmp_and_left_truth_2 = tmp_and_left_value_2 == NUITKA_BOOL_TRUE ? 1 : 0;
if (tmp_and_left_truth_2 == 1) {
goto and_right_2;
} else {
goto and_left_2;
}
and_right_2:;
if (var_s3_extracted == NULL) {
exception_type = PyExc_UnboundLocalError;
Py_INCREF(exception_type);
exception_value = PyUnicode_FromFormat("local variable '%s' referenced before assignment", "s3_extracted");
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 66;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_operand_name_3 = var_s3_extracted;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_3);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 66;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_and_right_value_2 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
tmp_condition_result_5 = tmp_and_right_value_2;
goto and_end_2;
and_left_2:;
tmp_condition_result_5 = tmp_and_left_value_2;
and_end_2:;
if (tmp_condition_result_5 == NUITKA_BOOL_TRUE) {
goto branch_yes_5;
} else {
goto branch_no_5;
}
}
branch_yes_5:;
{
PyObject *tmp_called_name_7;
PyObject *tmp_expression_name_4;
PyObject *tmp_call_result_3;
PyObject *tmp_args_element_name_9;
PyObject *tmp_dict_key_9;
PyObject *tmp_dict_value_9;
PyObject *tmp_dict_key_10;
PyObject *tmp_dict_value_10;
PyObject *tmp_dict_key_11;
PyObject *tmp_dict_value_11;
PyObject *tmp_called_instance_15;
CHECK_OBJECT(var_formats);
tmp_expression_name_4 = var_formats;
tmp_called_name_7 = LOOKUP_ATTRIBUTE(tmp_expression_name_4, const_str_plain_append);
if (tmp_called_name_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 67;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_dict_key_9 = const_str_plain_format_id;
tmp_dict_value_9 = const_str_plain_original;
tmp_args_element_name_9 = _PyDict_NewPresized( 3 );
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_9, tmp_dict_value_9);
assert(!(tmp_res != 0));
tmp_dict_key_10 = const_str_plain_preference;
tmp_dict_value_10 = const_int_pos_1;
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_10, tmp_dict_value_10);
assert(!(tmp_res != 0));
tmp_dict_key_11 = const_str_plain_url;
CHECK_OBJECT(var_original_filename);
tmp_called_instance_15 = var_original_filename;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 70;
tmp_dict_value_11 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_15, const_str_plain_replace, &PyTuple_GET_ITEM(const_tuple_c6d9a0aa6d3e3a0e302e12470e54749f_tuple, 0));
if (tmp_dict_value_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_7);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 70;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_11, tmp_dict_value_11);
Py_DECREF(tmp_dict_value_11);
assert(!(tmp_res != 0));
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 67;
tmp_call_result_3 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_7, tmp_args_element_name_9);
Py_DECREF(tmp_called_name_7);
Py_DECREF(tmp_args_element_name_9);
if (tmp_call_result_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 67;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
Py_DECREF(tmp_call_result_3);
}
{
PyObject *tmp_assign_source_12;
tmp_assign_source_12 = Py_True;
{
PyObject *old = var_s3_extracted;
var_s3_extracted = tmp_assign_source_12;
Py_INCREF(var_s3_extracted);
Py_XDECREF(old);
}
}
branch_no_5:;
branch_no_2:;
{
PyObject *tmp_called_instance_16;
PyObject *tmp_call_result_4;
PyObject *tmp_args_element_name_10;
CHECK_OBJECT(var_formats);
tmp_called_instance_16 = var_formats;
CHECK_OBJECT(var_f);
tmp_args_element_name_10 = var_f;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 73;
{
PyObject *call_args[] = {tmp_args_element_name_10};
tmp_call_result_4 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_16, const_str_plain_append, call_args);
}
if (tmp_call_result_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 73;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
Py_DECREF(tmp_call_result_4);
}
if (CONSIDER_THREADING() == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 45;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
goto loop_start_1;
loop_end_1:;
goto try_end_1;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto frame_exception_exit_1;
// End of try:
try_end_1:;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
{
PyObject *tmp_called_instance_17;
PyObject *tmp_call_result_5;
PyObject *tmp_args_element_name_11;
CHECK_OBJECT(par_self);
tmp_called_instance_17 = par_self;
CHECK_OBJECT(var_formats);
tmp_args_element_name_11 = var_formats;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 74;
{
PyObject *call_args[] = {tmp_args_element_name_11};
tmp_call_result_5 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_17, const_str_plain__sort_formats, call_args);
}
if (tmp_call_result_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 74;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
Py_DECREF(tmp_call_result_5);
}
{
PyObject *tmp_dict_key_12;
PyObject *tmp_dict_value_12;
PyObject *tmp_dict_key_13;
PyObject *tmp_dict_value_13;
PyObject *tmp_dict_key_14;
PyObject *tmp_dict_value_14;
PyObject *tmp_called_instance_18;
PyObject *tmp_dict_key_15;
PyObject *tmp_dict_value_15;
PyObject *tmp_called_instance_19;
PyObject *tmp_dict_key_16;
PyObject *tmp_dict_value_16;
PyObject *tmp_called_name_8;
PyObject *tmp_mvar_value_7;
PyObject *tmp_args_element_name_12;
PyObject *tmp_called_instance_20;
PyObject *tmp_dict_key_17;
PyObject *tmp_dict_value_17;
PyObject *tmp_called_name_9;
PyObject *tmp_mvar_value_8;
PyObject *tmp_args_element_name_13;
PyObject *tmp_called_instance_21;
PyObject *tmp_dict_key_18;
PyObject *tmp_dict_value_18;
PyObject *tmp_called_name_10;
PyObject *tmp_mvar_value_9;
PyObject *tmp_args_element_name_14;
PyObject *tmp_called_instance_22;
PyObject *tmp_dict_key_19;
PyObject *tmp_dict_value_19;
PyObject *tmp_dict_key_20;
PyObject *tmp_dict_value_20;
PyObject *tmp_called_instance_23;
PyObject *tmp_args_element_name_15;
PyObject *tmp_args_element_name_16;
tmp_dict_key_12 = const_str_plain_id;
CHECK_OBJECT(var_video_id);
tmp_dict_value_12 = var_video_id;
tmp_return_value = _PyDict_NewPresized( 9 );
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_12, tmp_dict_value_12);
assert(!(tmp_res != 0));
tmp_dict_key_13 = const_str_plain_title;
CHECK_OBJECT(var_title);
tmp_dict_value_13 = var_title;
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_13, tmp_dict_value_13);
assert(!(tmp_res != 0));
tmp_dict_key_14 = const_str_plain_description;
CHECK_OBJECT(par_video_data);
tmp_called_instance_18 = par_video_data;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 79;
tmp_dict_value_14 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_18, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_description_tuple, 0));
if (tmp_dict_value_14 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 79;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_14, tmp_dict_value_14);
Py_DECREF(tmp_dict_value_14);
assert(!(tmp_res != 0));
tmp_dict_key_15 = const_str_plain_thumbnail;
CHECK_OBJECT(par_video_data);
tmp_called_instance_19 = par_video_data;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 80;
tmp_dict_value_15 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_19, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_thumbnail_tuple, 0));
if (tmp_dict_value_15 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 80;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_15, tmp_dict_value_15);
Py_DECREF(tmp_dict_value_15);
assert(!(tmp_res != 0));
tmp_dict_key_16 = const_str_plain_upload_date;
tmp_mvar_value_7 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_unified_strdate);
if (unlikely(tmp_mvar_value_7 == NULL)) {
tmp_mvar_value_7 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_unified_strdate);
}
if (tmp_mvar_value_7 == NULL) {
Py_DECREF(tmp_return_value);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34399 ], 37, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 81;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_called_name_8 = tmp_mvar_value_7;
CHECK_OBJECT(par_video_data);
tmp_called_instance_20 = par_video_data;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 81;
tmp_args_element_name_12 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_20, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_start_date_tuple, 0));
if (tmp_args_element_name_12 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 81;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 81;
tmp_dict_value_16 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_8, tmp_args_element_name_12);
Py_DECREF(tmp_args_element_name_12);
if (tmp_dict_value_16 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 81;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_16, tmp_dict_value_16);
Py_DECREF(tmp_dict_value_16);
assert(!(tmp_res != 0));
tmp_dict_key_17 = const_str_plain_duration;
tmp_mvar_value_8 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_parse_duration);
if (unlikely(tmp_mvar_value_8 == NULL)) {
tmp_mvar_value_8 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_parse_duration);
}
if (tmp_mvar_value_8 == NULL) {
Py_DECREF(tmp_return_value);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34436 ], 36, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 82;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_called_name_9 = tmp_mvar_value_8;
CHECK_OBJECT(par_video_data);
tmp_called_instance_21 = par_video_data;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 82;
tmp_args_element_name_13 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_21, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_duration_tuple, 0));
if (tmp_args_element_name_13 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 82;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 82;
tmp_dict_value_17 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_9, tmp_args_element_name_13);
Py_DECREF(tmp_args_element_name_13);
if (tmp_dict_value_17 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 82;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_17, tmp_dict_value_17);
Py_DECREF(tmp_dict_value_17);
assert(!(tmp_res != 0));
tmp_dict_key_18 = const_str_plain_view_count;
tmp_mvar_value_9 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_str_to_int);
if (unlikely(tmp_mvar_value_9 == NULL)) {
tmp_mvar_value_9 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_str_to_int);
}
if (tmp_mvar_value_9 == NULL) {
Py_DECREF(tmp_return_value);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34472 ], 32, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 83;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_called_name_10 = tmp_mvar_value_9;
CHECK_OBJECT(par_video_data);
tmp_called_instance_22 = par_video_data;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 83;
tmp_args_element_name_14 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_22, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_playcount_tuple, 0));
if (tmp_args_element_name_14 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 83;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 83;
tmp_dict_value_18 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_10, tmp_args_element_name_14);
Py_DECREF(tmp_args_element_name_14);
if (tmp_dict_value_18 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 83;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_18, tmp_dict_value_18);
Py_DECREF(tmp_dict_value_18);
assert(!(tmp_res != 0));
tmp_dict_key_19 = const_str_plain_formats;
CHECK_OBJECT(var_formats);
tmp_dict_value_19 = var_formats;
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_19, tmp_dict_value_19);
assert(!(tmp_res != 0));
tmp_dict_key_20 = const_str_plain_subtitles;
CHECK_OBJECT(par_self);
tmp_called_instance_23 = par_self;
CHECK_OBJECT(par_video_data);
tmp_args_element_name_15 = par_video_data;
tmp_args_element_name_16 = const_str_plain_vtt;
frame_1810a286a3465c5ff9e74d69681fef3b->m_frame.f_lineno = 85;
{
PyObject *call_args[] = {tmp_args_element_name_15, tmp_args_element_name_16};
tmp_dict_value_20 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_23, const_str_plain__parse_subtitles, call_args);
}
if (tmp_dict_value_20 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 85;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_20, tmp_dict_value_20);
Py_DECREF(tmp_dict_value_20);
assert(!(tmp_res != 0));
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_1810a286a3465c5ff9e74d69681fef3b);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_1810a286a3465c5ff9e74d69681fef3b);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_1810a286a3465c5ff9e74d69681fef3b);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_1810a286a3465c5ff9e74d69681fef3b, exception_lineno);
} else if (exception_tb->tb_frame != &frame_1810a286a3465c5ff9e74d69681fef3b->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_1810a286a3465c5ff9e74d69681fef3b, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_1810a286a3465c5ff9e74d69681fef3b,
type_description_1,
par_self,
par_video_data,
var_video_id,
var_title,
var_s3_extracted,
var_formats,
var_source,
var_source_url,
var_f,
var_original_filename,
var_mobj
);
// Release cached frame.
if (frame_1810a286a3465c5ff9e74d69681fef3b == cache_frame_1810a286a3465c5ff9e74d69681fef3b) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_1810a286a3465c5ff9e74d69681fef3b);
}
cache_frame_1810a286a3465c5ff9e74d69681fef3b = NULL;
assertFrameObject(frame_1810a286a3465c5ff9e74d69681fef3b);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_video_id);
Py_DECREF(var_video_id);
var_video_id = NULL;
CHECK_OBJECT(var_title);
Py_DECREF(var_title);
var_title = NULL;
Py_XDECREF(var_s3_extracted);
var_s3_extracted = NULL;
CHECK_OBJECT(var_formats);
Py_DECREF(var_formats);
var_formats = NULL;
Py_XDECREF(var_source);
var_source = NULL;
Py_XDECREF(var_source_url);
var_source_url = NULL;
Py_XDECREF(var_f);
var_f = NULL;
Py_XDECREF(var_original_filename);
var_original_filename = NULL;
Py_XDECREF(var_mobj);
var_mobj = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_video_id);
var_video_id = NULL;
Py_XDECREF(var_title);
var_title = NULL;
Py_XDECREF(var_s3_extracted);
var_s3_extracted = NULL;
Py_XDECREF(var_formats);
var_formats = NULL;
Py_XDECREF(var_source);
var_source = NULL;
Py_XDECREF(var_source_url);
var_source_url = NULL;
Py_XDECREF(var_f);
var_f = NULL;
Py_XDECREF(var_original_filename);
var_original_filename = NULL;
Py_XDECREF(var_mobj);
var_mobj = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_video_data);
Py_DECREF(par_video_data); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_video_data);
Py_DECREF(par_video_data);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_4__real_extract(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_url = python_pars[1];
PyObject *var_video_id = NULL;
PyObject *var_video_data = NULL;
struct Nuitka_FrameObject *frame_6f49301b89b3a3f4d161efa52eccb64d;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_6f49301b89b3a3f4d161efa52eccb64d = NULL;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_6f49301b89b3a3f4d161efa52eccb64d)) {
Py_XDECREF(cache_frame_6f49301b89b3a3f4d161efa52eccb64d);
#if _DEBUG_REFCOUNTS
if (cache_frame_6f49301b89b3a3f4d161efa52eccb64d == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_6f49301b89b3a3f4d161efa52eccb64d = MAKE_FUNCTION_FRAME(codeobj_6f49301b89b3a3f4d161efa52eccb64d, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_6f49301b89b3a3f4d161efa52eccb64d->m_type_description == NULL);
frame_6f49301b89b3a3f4d161efa52eccb64d = cache_frame_6f49301b89b3a3f4d161efa52eccb64d;
// Push the new frame as the currently active one.
pushFrameStack(frame_6f49301b89b3a3f4d161efa52eccb64d);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_6f49301b89b3a3f4d161efa52eccb64d) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_args_element_name_1;
CHECK_OBJECT(par_self);
tmp_called_instance_1 = par_self;
CHECK_OBJECT(par_url);
tmp_args_element_name_1 = par_url;
frame_6f49301b89b3a3f4d161efa52eccb64d->m_frame.f_lineno = 108;
{
PyObject *call_args[] = {tmp_args_element_name_1};
tmp_assign_source_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_1, const_str_plain__match_id, call_args);
}
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 108;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
assert(var_video_id == NULL);
var_video_id = tmp_assign_source_1;
}
{
PyObject *tmp_assign_source_2;
PyObject *tmp_expression_name_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_2;
PyObject *tmp_left_name_1;
PyObject *tmp_right_name_1;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__call_api);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 110;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
tmp_left_name_1 = const_str_digest_e885bf143fe970625432b21db59ca551;
CHECK_OBJECT(var_video_id);
tmp_right_name_1 = var_video_id;
tmp_args_element_name_2 = BINARY_OPERATION_ADD_OBJECT_UNICODE_OBJECT(tmp_left_name_1, tmp_right_name_1);
if (tmp_args_element_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 111;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(var_video_id);
tmp_args_element_name_3 = var_video_id;
tmp_args_element_name_4 = PyDict_Copy(const_dict_f0a1067e40cf23005c809b8ff7ef5d31);
frame_6f49301b89b3a3f4d161efa52eccb64d->m_frame.f_lineno = 110;
{
PyObject *call_args[] = {tmp_args_element_name_2, tmp_args_element_name_3, tmp_args_element_name_4};
tmp_expression_name_1 = CALL_FUNCTION_WITH_ARGS3(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_2);
Py_DECREF(tmp_args_element_name_4);
if (tmp_expression_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 110;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
tmp_subscript_name_1 = const_int_0;
tmp_assign_source_2 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_1, tmp_subscript_name_1, 0);
Py_DECREF(tmp_expression_name_1);
if (tmp_assign_source_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 110;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
assert(var_video_data == NULL);
var_video_data = tmp_assign_source_2;
}
{
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_5;
CHECK_OBJECT(par_self);
tmp_called_instance_2 = par_self;
CHECK_OBJECT(var_video_data);
tmp_args_element_name_5 = var_video_data;
frame_6f49301b89b3a3f4d161efa52eccb64d->m_frame.f_lineno = 112;
{
PyObject *call_args[] = {tmp_args_element_name_5};
tmp_return_value = CALL_METHOD_WITH_ARGS1(tmp_called_instance_2, const_str_plain__parse_video_data, call_args);
}
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 112;
type_description_1 = "oooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_6f49301b89b3a3f4d161efa52eccb64d);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_6f49301b89b3a3f4d161efa52eccb64d);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_6f49301b89b3a3f4d161efa52eccb64d);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_6f49301b89b3a3f4d161efa52eccb64d, exception_lineno);
} else if (exception_tb->tb_frame != &frame_6f49301b89b3a3f4d161efa52eccb64d->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_6f49301b89b3a3f4d161efa52eccb64d, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_6f49301b89b3a3f4d161efa52eccb64d,
type_description_1,
par_self,
par_url,
var_video_id,
var_video_data
);
// Release cached frame.
if (frame_6f49301b89b3a3f4d161efa52eccb64d == cache_frame_6f49301b89b3a3f4d161efa52eccb64d) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_6f49301b89b3a3f4d161efa52eccb64d);
}
cache_frame_6f49301b89b3a3f4d161efa52eccb64d = NULL;
assertFrameObject(frame_6f49301b89b3a3f4d161efa52eccb64d);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_video_id);
Py_DECREF(var_video_id);
var_video_id = NULL;
CHECK_OBJECT(var_video_data);
Py_DECREF(var_video_data);
var_video_data = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_video_id);
var_video_id = NULL;
Py_XDECREF(var_video_data);
var_video_data = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_5__real_extract(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_url = python_pars[1];
PyObject *var_language = NULL;
PyObject *var_show_urlname = NULL;
PyObject *var_urlname = NULL;
PyObject *var_video_data = NULL;
PyObject *tmp_tuple_unpack_1__element_1 = NULL;
PyObject *tmp_tuple_unpack_1__element_2 = NULL;
PyObject *tmp_tuple_unpack_1__element_3 = NULL;
PyObject *tmp_tuple_unpack_1__source_iter = NULL;
struct Nuitka_FrameObject *frame_89e9c2601f96e3e42ce33f5cf04cc314;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
PyObject *tmp_iterator_attempt;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
int tmp_res;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_89e9c2601f96e3e42ce33f5cf04cc314 = NULL;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_89e9c2601f96e3e42ce33f5cf04cc314)) {
Py_XDECREF(cache_frame_89e9c2601f96e3e42ce33f5cf04cc314);
#if _DEBUG_REFCOUNTS
if (cache_frame_89e9c2601f96e3e42ce33f5cf04cc314 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_89e9c2601f96e3e42ce33f5cf04cc314 = MAKE_FUNCTION_FRAME(codeobj_89e9c2601f96e3e42ce33f5cf04cc314, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_89e9c2601f96e3e42ce33f5cf04cc314->m_type_description == NULL);
frame_89e9c2601f96e3e42ce33f5cf04cc314 = cache_frame_89e9c2601f96e3e42ce33f5cf04cc314;
// Push the new frame as the currently active one.
pushFrameStack(frame_89e9c2601f96e3e42ce33f5cf04cc314);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_89e9c2601f96e3e42ce33f5cf04cc314) == 2); // Frame stack
// Framed code:
// Tried code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_2;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_re);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_re);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 2114 ], 24, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_expression_name_1 = tmp_mvar_value_1;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_match);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_args_element_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__VALID_URL);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_url);
tmp_args_element_name_2 = par_url;
frame_89e9c2601f96e3e42ce33f5cf04cc314->m_frame.f_lineno = 135;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_2};
tmp_called_instance_1 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
if (tmp_called_instance_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
frame_89e9c2601f96e3e42ce33f5cf04cc314->m_frame.f_lineno = 135;
tmp_iter_arg_1 = CALL_METHOD_NO_ARGS(tmp_called_instance_1, const_str_plain_groups);
Py_DECREF(tmp_called_instance_1);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_assign_source_1 = MAKE_UNPACK_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 135;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
assert(tmp_tuple_unpack_1__source_iter == NULL);
tmp_tuple_unpack_1__source_iter = tmp_assign_source_1;
}
// Tried code:
{
PyObject *tmp_assign_source_2;
PyObject *tmp_unpack_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_1 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_2 = UNPACK_NEXT(tmp_unpack_1, 0, 3);
if (tmp_assign_source_2 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 135;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_1 == NULL);
tmp_tuple_unpack_1__element_1 = tmp_assign_source_2;
}
{
PyObject *tmp_assign_source_3;
PyObject *tmp_unpack_2;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_2 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_3 = UNPACK_NEXT(tmp_unpack_2, 1, 3);
if (tmp_assign_source_3 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 135;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_2 == NULL);
tmp_tuple_unpack_1__element_2 = tmp_assign_source_3;
}
{
PyObject *tmp_assign_source_4;
PyObject *tmp_unpack_3;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_3 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_4 = UNPACK_NEXT(tmp_unpack_3, 2, 3);
if (tmp_assign_source_4 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 135;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_3 == NULL);
tmp_tuple_unpack_1__element_3 = tmp_assign_source_4;
}
{
PyObject *tmp_iterator_name_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_iterator_name_1 = tmp_tuple_unpack_1__source_iter;
// Check if iterator has left-over elements.
CHECK_OBJECT(tmp_iterator_name_1); assert(HAS_ITERNEXT(tmp_iterator_name_1));
tmp_iterator_attempt = (*Py_TYPE(tmp_iterator_name_1)->tp_iternext)(tmp_iterator_name_1);
if (likely(tmp_iterator_attempt == NULL)) {
PyObject *error = GET_ERROR_OCCURRED();
if (error != NULL) {
if (EXCEPTION_MATCH_BOOL_SINGLE(error, PyExc_StopIteration)) {
CLEAR_ERROR_OCCURRED();
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "oooooo";
exception_lineno = 135;
goto try_except_handler_3;
}
}
} else {
Py_DECREF(tmp_iterator_attempt);
exception_type = PyExc_ValueError;
Py_INCREF(PyExc_ValueError);
exception_value = const_str_digest_09d63a5a61044765cbef1a09e46446f1;
Py_INCREF(exception_value);
exception_tb = NULL;
type_description_1 = "oooooo";
exception_lineno = 135;
goto try_except_handler_3;
}
}
goto try_end_1;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto try_except_handler_2;
// End of try:
try_end_1:;
goto try_end_2;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
Py_XDECREF(tmp_tuple_unpack_1__element_3);
tmp_tuple_unpack_1__element_3 = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto frame_exception_exit_1;
// End of try:
try_end_2:;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
{
PyObject *tmp_assign_source_5;
CHECK_OBJECT(tmp_tuple_unpack_1__element_1);
tmp_assign_source_5 = tmp_tuple_unpack_1__element_1;
assert(var_language == NULL);
Py_INCREF(tmp_assign_source_5);
var_language = tmp_assign_source_5;
}
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
{
PyObject *tmp_assign_source_6;
CHECK_OBJECT(tmp_tuple_unpack_1__element_2);
tmp_assign_source_6 = tmp_tuple_unpack_1__element_2;
assert(var_show_urlname == NULL);
Py_INCREF(tmp_assign_source_6);
var_show_urlname = tmp_assign_source_6;
}
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
{
PyObject *tmp_assign_source_7;
CHECK_OBJECT(tmp_tuple_unpack_1__element_3);
tmp_assign_source_7 = tmp_tuple_unpack_1__element_3;
assert(var_urlname == NULL);
Py_INCREF(tmp_assign_source_7);
var_urlname = tmp_assign_source_7;
}
Py_XDECREF(tmp_tuple_unpack_1__element_3);
tmp_tuple_unpack_1__element_3 = NULL;
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_language);
tmp_operand_name_1 = var_language;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 136;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
{
PyObject *tmp_assign_source_8;
tmp_assign_source_8 = const_str_plain_en;
{
PyObject *old = var_language;
assert(old != NULL);
var_language = tmp_assign_source_8;
Py_INCREF(var_language);
Py_DECREF(old);
}
}
branch_no_1:;
{
PyObject *tmp_assign_source_9;
PyObject *tmp_expression_name_3;
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_args_element_name_5;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_3;
PyObject *tmp_dict_key_4;
PyObject *tmp_dict_value_4;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(par_self);
tmp_called_instance_2 = par_self;
tmp_args_element_name_3 = const_str_digest_d7f80072b886f6b6c6273a3587d74d37;
CHECK_OBJECT(var_urlname);
tmp_args_element_name_4 = var_urlname;
tmp_dict_key_1 = const_str_plain_disclosure;
tmp_dict_value_1 = const_str_plain_standard;
tmp_args_element_name_5 = _PyDict_NewPresized( 4 );
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_language;
CHECK_OBJECT(var_language);
tmp_dict_value_2 = var_language;
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_2, tmp_dict_value_2);
assert(!(tmp_res != 0));
tmp_dict_key_3 = const_str_plain_show_urlname;
CHECK_OBJECT(var_show_urlname);
tmp_dict_value_3 = var_show_urlname;
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_3, tmp_dict_value_3);
assert(!(tmp_res != 0));
tmp_dict_key_4 = const_str_plain_urlname;
CHECK_OBJECT(var_urlname);
tmp_dict_value_4 = var_urlname;
tmp_res = PyDict_SetItem(tmp_args_element_name_5, tmp_dict_key_4, tmp_dict_value_4);
assert(!(tmp_res != 0));
frame_89e9c2601f96e3e42ce33f5cf04cc314->m_frame.f_lineno = 139;
{
PyObject *call_args[] = {tmp_args_element_name_3, tmp_args_element_name_4, tmp_args_element_name_5};
tmp_expression_name_3 = CALL_METHOD_WITH_ARGS3(tmp_called_instance_2, const_str_plain__call_api, call_args);
}
Py_DECREF(tmp_args_element_name_5);
if (tmp_expression_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 139;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_subscript_name_1 = const_int_0;
tmp_assign_source_9 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_3, tmp_subscript_name_1, 0);
Py_DECREF(tmp_expression_name_3);
if (tmp_assign_source_9 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 139;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
assert(var_video_data == NULL);
var_video_data = tmp_assign_source_9;
}
{
PyObject *tmp_called_instance_3;
PyObject *tmp_args_element_name_6;
CHECK_OBJECT(par_self);
tmp_called_instance_3 = par_self;
CHECK_OBJECT(var_video_data);
tmp_args_element_name_6 = var_video_data;
frame_89e9c2601f96e3e42ce33f5cf04cc314->m_frame.f_lineno = 146;
{
PyObject *call_args[] = {tmp_args_element_name_6};
tmp_return_value = CALL_METHOD_WITH_ARGS1(tmp_called_instance_3, const_str_plain__parse_video_data, call_args);
}
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 146;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_89e9c2601f96e3e42ce33f5cf04cc314);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_89e9c2601f96e3e42ce33f5cf04cc314);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_89e9c2601f96e3e42ce33f5cf04cc314);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_89e9c2601f96e3e42ce33f5cf04cc314, exception_lineno);
} else if (exception_tb->tb_frame != &frame_89e9c2601f96e3e42ce33f5cf04cc314->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_89e9c2601f96e3e42ce33f5cf04cc314, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_89e9c2601f96e3e42ce33f5cf04cc314,
type_description_1,
par_self,
par_url,
var_language,
var_show_urlname,
var_urlname,
var_video_data
);
// Release cached frame.
if (frame_89e9c2601f96e3e42ce33f5cf04cc314 == cache_frame_89e9c2601f96e3e42ce33f5cf04cc314) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_89e9c2601f96e3e42ce33f5cf04cc314);
}
cache_frame_89e9c2601f96e3e42ce33f5cf04cc314 = NULL;
assertFrameObject(frame_89e9c2601f96e3e42ce33f5cf04cc314);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_language);
Py_DECREF(var_language);
var_language = NULL;
CHECK_OBJECT(var_show_urlname);
Py_DECREF(var_show_urlname);
var_show_urlname = NULL;
CHECK_OBJECT(var_urlname);
Py_DECREF(var_urlname);
var_urlname = NULL;
CHECK_OBJECT(var_video_data);
Py_DECREF(var_video_data);
var_video_data = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_language);
var_language = NULL;
Py_XDECREF(var_show_urlname);
var_show_urlname = NULL;
Py_XDECREF(var_urlname);
var_urlname = NULL;
Py_XDECREF(var_video_data);
var_video_data = NULL;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_6__fetch_page(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
struct Nuitka_CellObject *par_self = PyCell_NEW1(python_pars[0]);
struct Nuitka_CellObject *par_display_id = PyCell_NEW1(python_pars[1]);
struct Nuitka_CellObject *par_query = PyCell_NEW1(python_pars[2]);
struct Nuitka_CellObject *par_page = PyCell_NEW1(python_pars[3]);
PyObject *tmp_return_value = NULL;
// Actual function body.
// Tried code:
tmp_return_value = youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_maker();
((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[0] = par_display_id;
Py_INCREF(((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[0]);
((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[1] = par_page;
Py_INCREF(((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[1]);
((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[2] = par_query;
Py_INCREF(((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[2]);
((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[3] = par_self;
Py_INCREF(((struct Nuitka_GeneratorObject *)tmp_return_value)->m_closure[3]);
goto try_return_handler_1;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(par_page);
Py_DECREF(par_page);
par_page = NULL;
goto function_return_exit;
// End of try:
CHECK_OBJECT(par_page);
Py_DECREF(par_page);
par_page = NULL;
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_display_id);
Py_DECREF(par_display_id);
CHECK_OBJECT(par_query);
Py_DECREF(par_query);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
struct youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_locals {
PyObject *var_element_data;
PyObject *tmp_for_loop_1__for_iterator;
PyObject *tmp_for_loop_1__iter_value;
char const *type_description_1;
PyObject *exception_type;
PyObject *exception_value;
PyTracebackObject *exception_tb;
int exception_lineno;
bool tmp_result;
char yield_tmps[1024];
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
int exception_keeper_lineno_1;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
int exception_keeper_lineno_2;
};
static PyObject *youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_context(struct Nuitka_GeneratorObject *generator, PyObject *yield_return_value) {
CHECK_OBJECT(generator);
assert(Nuitka_Generator_Check( (PyObject *)generator ));
// Heap access if used.
struct youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_locals *generator_heap = (struct youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_locals *)generator->m_heap_storage;
// Dispatch to yield based on return label index:
switch(generator->m_yield_return_index) {
case 1: goto yield_return_1;
}
// Local variable initialization
NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
static struct Nuitka_FrameObject *cache_m_frame = NULL;
generator_heap->var_element_data = NULL;
generator_heap->tmp_for_loop_1__for_iterator = NULL;
generator_heap->tmp_for_loop_1__iter_value = NULL;
generator_heap->type_description_1 = NULL;
generator_heap->exception_type = NULL;
generator_heap->exception_value = NULL;
generator_heap->exception_tb = NULL;
generator_heap->exception_lineno = 0;
// Actual generator function body.
// Tried code:
if (isFrameUnusable(cache_m_frame)) {
Py_XDECREF(cache_m_frame);
#if _DEBUG_REFCOUNTS
if (cache_m_frame == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_6c3691199cab595cab8a57126f484e81, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
generator->m_frame = cache_m_frame;
// Mark the frame object as in use, ref count 1 will be up for reuse.
Py_INCREF(generator->m_frame);
assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
#if PYTHON_VERSION >= 340
generator->m_frame->m_frame.f_gen = (PyObject *)generator;
#endif
assert(generator->m_frame->m_frame.f_back == NULL);
Py_CLEAR(generator->m_frame->m_frame.f_back);
generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
Py_INCREF(generator->m_frame->m_frame.f_back);
PyThreadState_GET()->frame = &generator->m_frame->m_frame;
Py_INCREF(generator->m_frame);
Nuitka_Frame_MarkAsExecuting(generator->m_frame);
#if PYTHON_VERSION >= 300
// Accept currently existing exception as the one to publish again when we
// yield or yield from.
{
PyThreadState *thread_state = PyThreadState_GET();
EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
Py_XINCREF(EXC_TYPE_F(generator));
EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
Py_XINCREF(EXC_VALUE_F(generator));
EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
Py_XINCREF(EXC_TRACEBACK_F(generator));
}
#endif
// Framed code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_left_name_1;
PyObject *tmp_right_name_1;
if (PyCell_GET(generator->m_closure[1]) == NULL) {
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "page");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 153;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_left_name_1 = PyCell_GET(generator->m_closure[1]);
tmp_right_name_1 = const_int_pos_1;
generator_heap->tmp_result = BINARY_OPERATION_ADD_OBJECT_LONG_INPLACE(&tmp_left_name_1, tmp_right_name_1);
if (generator_heap->tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 153;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_assign_source_1 = tmp_left_name_1;
PyCell_SET(generator->m_closure[1], tmp_assign_source_1);
}
{
PyObject *tmp_ass_subvalue_1;
PyObject *tmp_ass_subscribed_1;
PyObject *tmp_ass_subscript_1;
CHECK_OBJECT(PyCell_GET(generator->m_closure[1]));
tmp_ass_subvalue_1 = PyCell_GET(generator->m_closure[1]);
if (PyCell_GET(generator->m_closure[2]) == NULL) {
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "query");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 154;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_ass_subscribed_1 = PyCell_GET(generator->m_closure[2]);
tmp_ass_subscript_1 = const_str_plain_page;
generator_heap->tmp_result = SET_SUBSCRIPT(tmp_ass_subscribed_1, tmp_ass_subscript_1, tmp_ass_subvalue_1);
if (generator_heap->tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 154;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
}
{
PyObject *tmp_assign_source_2;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_left_name_2;
PyObject *tmp_right_name_2;
if (PyCell_GET(generator->m_closure[3]) == NULL) {
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "self");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 155;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_expression_name_1 = PyCell_GET(generator->m_closure[3]);
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain__call_api);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 155;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
if (PyCell_GET(generator->m_closure[3]) == NULL) {
Py_DECREF(tmp_called_name_1);
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "self");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 156;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_expression_name_2 = PyCell_GET(generator->m_closure[3]);
tmp_args_element_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__RESOURCE);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
Py_DECREF(tmp_called_name_1);
generator_heap->exception_lineno = 156;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
if (PyCell_GET(generator->m_closure[0]) == NULL) {
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "display_id");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 156;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_args_element_name_2 = PyCell_GET(generator->m_closure[0]);
if (PyCell_GET(generator->m_closure[2]) == NULL) {
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "query");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 156;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_args_element_name_3 = PyCell_GET(generator->m_closure[2]);
tmp_left_name_2 = const_str_digest_e5eb2bea26fcd040f068d947ea16586f;
CHECK_OBJECT(PyCell_GET(generator->m_closure[1]));
tmp_right_name_2 = PyCell_GET(generator->m_closure[1]);
tmp_args_element_name_4 = BINARY_OPERATION_MOD_OBJECT_UNICODE_OBJECT(tmp_left_name_2, tmp_right_name_2);
if (tmp_args_element_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
generator_heap->exception_lineno = 156;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
generator->m_frame->m_frame.f_lineno = 155;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3, tmp_args_element_name_4};
tmp_iter_arg_1 = CALL_FUNCTION_WITH_ARGS4(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
Py_DECREF(tmp_args_element_name_4);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 155;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
tmp_assign_source_2 = MAKE_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 155;
generator_heap->type_description_1 = "cccco";
goto frame_exception_exit_1;
}
assert(generator_heap->tmp_for_loop_1__for_iterator == NULL);
generator_heap->tmp_for_loop_1__for_iterator = tmp_assign_source_2;
}
// Tried code:
loop_start_1:;
{
PyObject *tmp_next_source_1;
PyObject *tmp_assign_source_3;
CHECK_OBJECT(generator_heap->tmp_for_loop_1__for_iterator);
tmp_next_source_1 = generator_heap->tmp_for_loop_1__for_iterator;
tmp_assign_source_3 = ITERATOR_NEXT(tmp_next_source_1);
if (tmp_assign_source_3 == NULL) {
if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
goto loop_end_1;
} else {
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->type_description_1 = "cccco";
generator_heap->exception_lineno = 155;
goto try_except_handler_2;
}
}
{
PyObject *old = generator_heap->tmp_for_loop_1__iter_value;
generator_heap->tmp_for_loop_1__iter_value = tmp_assign_source_3;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_4;
CHECK_OBJECT(generator_heap->tmp_for_loop_1__iter_value);
tmp_assign_source_4 = generator_heap->tmp_for_loop_1__iter_value;
{
PyObject *old = generator_heap->var_element_data;
generator_heap->var_element_data = tmp_assign_source_4;
Py_INCREF(generator_heap->var_element_data);
Py_XDECREF(old);
}
}
{
PyObject *tmp_expression_name_3;
PyObject *tmp_called_instance_1;
PyObject *tmp_args_element_name_5;
NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
if (PyCell_GET(generator->m_closure[3]) == NULL) {
generator_heap->exception_type = PyExc_NameError;
Py_INCREF(generator_heap->exception_type);
generator_heap->exception_value = PyUnicode_FromFormat("free variable '%s' referenced before assignment in enclosing scope", "self");
generator_heap->exception_tb = NULL;
NORMALIZE_EXCEPTION(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
CHAIN_EXCEPTION(generator_heap->exception_value);
generator_heap->exception_lineno = 157;
generator_heap->type_description_1 = "cccco";
goto try_except_handler_2;
}
tmp_called_instance_1 = PyCell_GET(generator->m_closure[3]);
CHECK_OBJECT(generator_heap->var_element_data);
tmp_args_element_name_5 = generator_heap->var_element_data;
generator->m_frame->m_frame.f_lineno = 157;
{
PyObject *call_args[] = {tmp_args_element_name_5};
tmp_expression_name_3 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_1, const_str_plain__process_data, call_args);
}
if (tmp_expression_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 157;
generator_heap->type_description_1 = "cccco";
goto try_except_handler_2;
}
Nuitka_PreserveHeap(generator_heap->yield_tmps, &tmp_called_instance_1, sizeof(PyObject *), &tmp_args_element_name_5, sizeof(PyObject *), NULL);
generator->m_yield_return_index = 1;
return tmp_expression_name_3;
yield_return_1:
Nuitka_RestoreHeap(generator_heap->yield_tmps, &tmp_called_instance_1, sizeof(PyObject *), &tmp_args_element_name_5, sizeof(PyObject *), NULL);
if (yield_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 157;
generator_heap->type_description_1 = "cccco";
goto try_except_handler_2;
}
tmp_yield_result_1 = yield_return_value;
}
if (CONSIDER_THREADING() == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
generator_heap->exception_lineno = 155;
generator_heap->type_description_1 = "cccco";
goto try_except_handler_2;
}
goto loop_start_1;
loop_end_1:;
goto try_end_1;
// Exception handler code:
try_except_handler_2:;
generator_heap->exception_keeper_type_1 = generator_heap->exception_type;
generator_heap->exception_keeper_value_1 = generator_heap->exception_value;
generator_heap->exception_keeper_tb_1 = generator_heap->exception_tb;
generator_heap->exception_keeper_lineno_1 = generator_heap->exception_lineno;
generator_heap->exception_type = NULL;
generator_heap->exception_value = NULL;
generator_heap->exception_tb = NULL;
generator_heap->exception_lineno = 0;
Py_XDECREF(generator_heap->tmp_for_loop_1__iter_value);
generator_heap->tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(generator_heap->tmp_for_loop_1__for_iterator);
Py_DECREF(generator_heap->tmp_for_loop_1__for_iterator);
generator_heap->tmp_for_loop_1__for_iterator = NULL;
// Re-raise.
generator_heap->exception_type = generator_heap->exception_keeper_type_1;
generator_heap->exception_value = generator_heap->exception_keeper_value_1;
generator_heap->exception_tb = generator_heap->exception_keeper_tb_1;
generator_heap->exception_lineno = generator_heap->exception_keeper_lineno_1;
goto frame_exception_exit_1;
// End of try:
try_end_1:;
Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
#if PYTHON_VERSION >= 300
Py_CLEAR(EXC_TYPE_F(generator));
Py_CLEAR(EXC_VALUE_F(generator));
Py_CLEAR(EXC_TRACEBACK_F(generator));
#endif
// Allow re-use of the frame again.
Py_DECREF(generator->m_frame);
goto frame_no_exception_1;
frame_exception_exit_1:;
// If it's not an exit exception, consider and create a traceback for it.
if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
if (generator_heap->exception_tb == NULL) {
generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
}
Nuitka_Frame_AttachLocals(
generator->m_frame,
generator_heap->type_description_1,
generator->m_closure[3],
generator->m_closure[0],
generator->m_closure[2],
generator->m_closure[1],
generator_heap->var_element_data
);
// Release cached frame.
if (generator->m_frame == cache_m_frame) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(generator->m_frame);
}
cache_m_frame = NULL;
assertFrameObject(generator->m_frame);
}
#if PYTHON_VERSION >= 300
Py_CLEAR(EXC_TYPE_F(generator));
Py_CLEAR(EXC_VALUE_F(generator));
Py_CLEAR(EXC_TRACEBACK_F(generator));
#endif
Py_DECREF(generator->m_frame);
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
goto try_end_2;
// Exception handler code:
try_except_handler_1:;
generator_heap->exception_keeper_type_2 = generator_heap->exception_type;
generator_heap->exception_keeper_value_2 = generator_heap->exception_value;
generator_heap->exception_keeper_tb_2 = generator_heap->exception_tb;
generator_heap->exception_keeper_lineno_2 = generator_heap->exception_lineno;
generator_heap->exception_type = NULL;
generator_heap->exception_value = NULL;
generator_heap->exception_tb = NULL;
generator_heap->exception_lineno = 0;
Py_XDECREF(generator_heap->var_element_data);
generator_heap->var_element_data = NULL;
// Re-raise.
generator_heap->exception_type = generator_heap->exception_keeper_type_2;
generator_heap->exception_value = generator_heap->exception_keeper_value_2;
generator_heap->exception_tb = generator_heap->exception_keeper_tb_2;
generator_heap->exception_lineno = generator_heap->exception_keeper_lineno_2;
goto function_exception_exit;
// End of try:
try_end_2:;
Py_XDECREF(generator_heap->tmp_for_loop_1__iter_value);
generator_heap->tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(generator_heap->tmp_for_loop_1__for_iterator);
Py_DECREF(generator_heap->tmp_for_loop_1__for_iterator);
generator_heap->tmp_for_loop_1__for_iterator = NULL;
Py_XDECREF(generator_heap->var_element_data);
generator_heap->var_element_data = NULL;
return NULL;
function_exception_exit:
assert(generator_heap->exception_type);
RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
return NULL;
}
static PyObject *youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_maker(void) {
return Nuitka_Generator_New(
youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_context,
module_youtube_dl$extractor$adobetv,
const_str_plain__fetch_page,
#if PYTHON_VERSION >= 350
const_str_digest_7e9c451ae054c3f5df4ae9aee8edec23,
#endif
codeobj_6c3691199cab595cab8a57126f484e81,
4,
sizeof(struct youtube_dl$extractor$adobetv$$$function_6__fetch_page$$$genobj_1__fetch_page_locals)
);
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_display_id = python_pars[1];
PyObject *par_query = python_pars[2];
struct Nuitka_FrameObject *frame_0c1486d9b5668f5559c676adca49b768;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *tmp_return_value = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
static struct Nuitka_FrameObject *cache_frame_0c1486d9b5668f5559c676adca49b768 = NULL;
// Actual function body.
if (isFrameUnusable(cache_frame_0c1486d9b5668f5559c676adca49b768)) {
Py_XDECREF(cache_frame_0c1486d9b5668f5559c676adca49b768);
#if _DEBUG_REFCOUNTS
if (cache_frame_0c1486d9b5668f5559c676adca49b768 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_0c1486d9b5668f5559c676adca49b768 = MAKE_FUNCTION_FRAME(codeobj_0c1486d9b5668f5559c676adca49b768, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_0c1486d9b5668f5559c676adca49b768->m_type_description == NULL);
frame_0c1486d9b5668f5559c676adca49b768 = cache_frame_0c1486d9b5668f5559c676adca49b768;
// Push the new frame as the currently active one.
pushFrameStack(frame_0c1486d9b5668f5559c676adca49b768);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_0c1486d9b5668f5559c676adca49b768) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_called_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_called_name_2;
PyObject *tmp_expression_name_1;
PyObject *tmp_mvar_value_2;
PyObject *tmp_args_element_name_2;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_args_element_name_5;
PyObject *tmp_expression_name_3;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_OnDemandPagedList);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_OnDemandPagedList);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 33981 ], 39, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 160;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
tmp_called_name_1 = tmp_mvar_value_1;
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_functools);
if (unlikely(tmp_mvar_value_2 == NULL)) {
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_functools);
}
if (tmp_mvar_value_2 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 15066 ], 31, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 160;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
tmp_expression_name_1 = tmp_mvar_value_2;
tmp_called_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_partial);
if (tmp_called_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 160;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_args_element_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__fetch_page);
if (tmp_args_element_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
exception_lineno = 161;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_display_id);
tmp_args_element_name_3 = par_display_id;
CHECK_OBJECT(par_query);
tmp_args_element_name_4 = par_query;
frame_0c1486d9b5668f5559c676adca49b768->m_frame.f_lineno = 160;
{
PyObject *call_args[] = {tmp_args_element_name_2, tmp_args_element_name_3, tmp_args_element_name_4};
tmp_args_element_name_1 = CALL_FUNCTION_WITH_ARGS3(tmp_called_name_2, call_args);
}
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_2);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 160;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_self);
tmp_expression_name_3 = par_self;
tmp_args_element_name_5 = LOOKUP_ATTRIBUTE(tmp_expression_name_3, const_str_plain__PAGE_SIZE);
if (tmp_args_element_name_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_args_element_name_1);
exception_lineno = 161;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
frame_0c1486d9b5668f5559c676adca49b768->m_frame.f_lineno = 160;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_5};
tmp_return_value = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_args_element_name_1);
Py_DECREF(tmp_args_element_name_5);
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 160;
type_description_1 = "ooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_0c1486d9b5668f5559c676adca49b768);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_0c1486d9b5668f5559c676adca49b768);
#endif
// Put the previous frame back on top.
popFrameStack();
goto function_return_exit;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_0c1486d9b5668f5559c676adca49b768);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_0c1486d9b5668f5559c676adca49b768, exception_lineno);
} else if (exception_tb->tb_frame != &frame_0c1486d9b5668f5559c676adca49b768->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_0c1486d9b5668f5559c676adca49b768, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_0c1486d9b5668f5559c676adca49b768,
type_description_1,
par_self,
par_display_id,
par_query
);
// Release cached frame.
if (frame_0c1486d9b5668f5559c676adca49b768 == cache_frame_0c1486d9b5668f5559c676adca49b768) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_0c1486d9b5668f5559c676adca49b768);
}
cache_frame_0c1486d9b5668f5559c676adca49b768 = NULL;
assertFrameObject(frame_0c1486d9b5668f5559c676adca49b768);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto function_exception_exit;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_display_id);
Py_DECREF(par_display_id);
CHECK_OBJECT(par_query);
Py_DECREF(par_query); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_display_id);
Py_DECREF(par_display_id);
CHECK_OBJECT(par_query);
Py_DECREF(par_query);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_8__real_extract(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_url = python_pars[1];
PyObject *var_language = NULL;
PyObject *var_show_urlname = NULL;
PyObject *var_query = NULL;
PyObject *var_show_data = NULL;
PyObject *tmp_tuple_unpack_1__element_1 = NULL;
PyObject *tmp_tuple_unpack_1__element_2 = NULL;
PyObject *tmp_tuple_unpack_1__source_iter = NULL;
struct Nuitka_FrameObject *frame_069782d2123400fbb5186fb48d5170e1;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
PyObject *tmp_iterator_attempt;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
int tmp_res;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_069782d2123400fbb5186fb48d5170e1 = NULL;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_069782d2123400fbb5186fb48d5170e1)) {
Py_XDECREF(cache_frame_069782d2123400fbb5186fb48d5170e1);
#if _DEBUG_REFCOUNTS
if (cache_frame_069782d2123400fbb5186fb48d5170e1 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_069782d2123400fbb5186fb48d5170e1 = MAKE_FUNCTION_FRAME(codeobj_069782d2123400fbb5186fb48d5170e1, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_069782d2123400fbb5186fb48d5170e1->m_type_description == NULL);
frame_069782d2123400fbb5186fb48d5170e1 = cache_frame_069782d2123400fbb5186fb48d5170e1;
// Push the new frame as the currently active one.
pushFrameStack(frame_069782d2123400fbb5186fb48d5170e1);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_069782d2123400fbb5186fb48d5170e1) == 2); // Frame stack
// Framed code:
// Tried code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_2;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_re);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_re);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 2114 ], 24, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_expression_name_1 = tmp_mvar_value_1;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_match);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_args_element_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__VALID_URL);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_url);
tmp_args_element_name_2 = par_url;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 181;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_2};
tmp_called_instance_1 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
if (tmp_called_instance_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 181;
tmp_iter_arg_1 = CALL_METHOD_NO_ARGS(tmp_called_instance_1, const_str_plain_groups);
Py_DECREF(tmp_called_instance_1);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_assign_source_1 = MAKE_UNPACK_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 181;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
assert(tmp_tuple_unpack_1__source_iter == NULL);
tmp_tuple_unpack_1__source_iter = tmp_assign_source_1;
}
// Tried code:
{
PyObject *tmp_assign_source_2;
PyObject *tmp_unpack_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_1 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_2 = UNPACK_NEXT(tmp_unpack_1, 0, 2);
if (tmp_assign_source_2 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 181;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_1 == NULL);
tmp_tuple_unpack_1__element_1 = tmp_assign_source_2;
}
{
PyObject *tmp_assign_source_3;
PyObject *tmp_unpack_2;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_2 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_3 = UNPACK_NEXT(tmp_unpack_2, 1, 2);
if (tmp_assign_source_3 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 181;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_2 == NULL);
tmp_tuple_unpack_1__element_2 = tmp_assign_source_3;
}
{
PyObject *tmp_iterator_name_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_iterator_name_1 = tmp_tuple_unpack_1__source_iter;
// Check if iterator has left-over elements.
CHECK_OBJECT(tmp_iterator_name_1); assert(HAS_ITERNEXT(tmp_iterator_name_1));
tmp_iterator_attempt = (*Py_TYPE(tmp_iterator_name_1)->tp_iternext)(tmp_iterator_name_1);
if (likely(tmp_iterator_attempt == NULL)) {
PyObject *error = GET_ERROR_OCCURRED();
if (error != NULL) {
if (EXCEPTION_MATCH_BOOL_SINGLE(error, PyExc_StopIteration)) {
CLEAR_ERROR_OCCURRED();
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "oooooo";
exception_lineno = 181;
goto try_except_handler_3;
}
}
} else {
Py_DECREF(tmp_iterator_attempt);
exception_type = PyExc_ValueError;
Py_INCREF(PyExc_ValueError);
exception_value = const_str_digest_fcf040720b88d60da4ce975010c44a3a;
Py_INCREF(exception_value);
exception_tb = NULL;
type_description_1 = "oooooo";
exception_lineno = 181;
goto try_except_handler_3;
}
}
goto try_end_1;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto try_except_handler_2;
// End of try:
try_end_1:;
goto try_end_2;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto frame_exception_exit_1;
// End of try:
try_end_2:;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
{
PyObject *tmp_assign_source_4;
CHECK_OBJECT(tmp_tuple_unpack_1__element_1);
tmp_assign_source_4 = tmp_tuple_unpack_1__element_1;
assert(var_language == NULL);
Py_INCREF(tmp_assign_source_4);
var_language = tmp_assign_source_4;
}
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
{
PyObject *tmp_assign_source_5;
CHECK_OBJECT(tmp_tuple_unpack_1__element_2);
tmp_assign_source_5 = tmp_tuple_unpack_1__element_2;
assert(var_show_urlname == NULL);
Py_INCREF(tmp_assign_source_5);
var_show_urlname = tmp_assign_source_5;
}
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_language);
tmp_operand_name_1 = var_language;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 182;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
{
PyObject *tmp_assign_source_6;
tmp_assign_source_6 = const_str_plain_en;
{
PyObject *old = var_language;
assert(old != NULL);
var_language = tmp_assign_source_6;
Py_INCREF(var_language);
Py_DECREF(old);
}
}
branch_no_1:;
{
PyObject *tmp_assign_source_7;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_3;
tmp_dict_key_1 = const_str_plain_disclosure;
tmp_dict_value_1 = const_str_plain_standard;
tmp_assign_source_7 = _PyDict_NewPresized( 3 );
tmp_res = PyDict_SetItem(tmp_assign_source_7, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_language;
CHECK_OBJECT(var_language);
tmp_dict_value_2 = var_language;
tmp_res = PyDict_SetItem(tmp_assign_source_7, tmp_dict_key_2, tmp_dict_value_2);
assert(!(tmp_res != 0));
tmp_dict_key_3 = const_str_plain_show_urlname;
CHECK_OBJECT(var_show_urlname);
tmp_dict_value_3 = var_show_urlname;
tmp_res = PyDict_SetItem(tmp_assign_source_7, tmp_dict_key_3, tmp_dict_value_3);
assert(!(tmp_res != 0));
assert(var_query == NULL);
var_query = tmp_assign_source_7;
}
{
PyObject *tmp_assign_source_8;
PyObject *tmp_expression_name_3;
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_args_element_name_4;
PyObject *tmp_args_element_name_5;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(par_self);
tmp_called_instance_2 = par_self;
tmp_args_element_name_3 = const_str_digest_d684f01bf89b4ee758a3ecfad8217126;
CHECK_OBJECT(var_show_urlname);
tmp_args_element_name_4 = var_show_urlname;
CHECK_OBJECT(var_query);
tmp_args_element_name_5 = var_query;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 190;
{
PyObject *call_args[] = {tmp_args_element_name_3, tmp_args_element_name_4, tmp_args_element_name_5};
tmp_expression_name_3 = CALL_METHOD_WITH_ARGS3(tmp_called_instance_2, const_str_plain__call_api, call_args);
}
if (tmp_expression_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 190;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_subscript_name_1 = const_int_0;
tmp_assign_source_8 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_3, tmp_subscript_name_1, 0);
Py_DECREF(tmp_expression_name_3);
if (tmp_assign_source_8 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 190;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
assert(var_show_data == NULL);
var_show_data = tmp_assign_source_8;
}
{
PyObject *tmp_called_name_2;
PyObject *tmp_expression_name_4;
PyObject *tmp_args_element_name_6;
PyObject *tmp_called_instance_3;
PyObject *tmp_args_element_name_7;
PyObject *tmp_args_element_name_8;
PyObject *tmp_args_element_name_9;
PyObject *tmp_called_name_3;
PyObject *tmp_mvar_value_2;
PyObject *tmp_args_element_name_10;
PyObject *tmp_called_instance_4;
PyObject *tmp_args_element_name_11;
PyObject *tmp_called_instance_5;
PyObject *tmp_args_element_name_12;
PyObject *tmp_called_instance_6;
CHECK_OBJECT(par_self);
tmp_expression_name_4 = par_self;
tmp_called_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_4, const_str_plain_playlist_result);
if (tmp_called_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 193;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_self);
tmp_called_instance_3 = par_self;
CHECK_OBJECT(var_show_urlname);
tmp_args_element_name_7 = var_show_urlname;
CHECK_OBJECT(var_query);
tmp_args_element_name_8 = var_query;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 194;
{
PyObject *call_args[] = {tmp_args_element_name_7, tmp_args_element_name_8};
tmp_args_element_name_6 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_3, const_str_plain__extract_playlist_entries, call_args);
}
if (tmp_args_element_name_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
exception_lineno = 194;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_str_or_none);
if (unlikely(tmp_mvar_value_2 == NULL)) {
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_str_or_none);
}
if (tmp_mvar_value_2 == NULL) {
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 28262 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 195;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_called_name_3 = tmp_mvar_value_2;
CHECK_OBJECT(var_show_data);
tmp_called_instance_4 = var_show_data;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 195;
tmp_args_element_name_10 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_4, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_id_tuple, 0));
if (tmp_args_element_name_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
exception_lineno = 195;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 195;
tmp_args_element_name_9 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_3, tmp_args_element_name_10);
Py_DECREF(tmp_args_element_name_10);
if (tmp_args_element_name_9 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
exception_lineno = 195;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(var_show_data);
tmp_called_instance_5 = var_show_data;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 196;
tmp_args_element_name_11 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_5, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_show_name_tuple, 0));
if (tmp_args_element_name_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 196;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(var_show_data);
tmp_called_instance_6 = var_show_data;
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 197;
tmp_args_element_name_12 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_6, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_show_description_tuple, 0));
if (tmp_args_element_name_12 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_args_element_name_11);
exception_lineno = 197;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
frame_069782d2123400fbb5186fb48d5170e1->m_frame.f_lineno = 193;
{
PyObject *call_args[] = {tmp_args_element_name_6, tmp_args_element_name_9, tmp_args_element_name_11, tmp_args_element_name_12};
tmp_return_value = CALL_FUNCTION_WITH_ARGS4(tmp_called_name_2, call_args);
}
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_6);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_args_element_name_11);
Py_DECREF(tmp_args_element_name_12);
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 193;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_069782d2123400fbb5186fb48d5170e1);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_069782d2123400fbb5186fb48d5170e1);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_069782d2123400fbb5186fb48d5170e1);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_069782d2123400fbb5186fb48d5170e1, exception_lineno);
} else if (exception_tb->tb_frame != &frame_069782d2123400fbb5186fb48d5170e1->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_069782d2123400fbb5186fb48d5170e1, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_069782d2123400fbb5186fb48d5170e1,
type_description_1,
par_self,
par_url,
var_language,
var_show_urlname,
var_query,
var_show_data
);
// Release cached frame.
if (frame_069782d2123400fbb5186fb48d5170e1 == cache_frame_069782d2123400fbb5186fb48d5170e1) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_069782d2123400fbb5186fb48d5170e1);
}
cache_frame_069782d2123400fbb5186fb48d5170e1 = NULL;
assertFrameObject(frame_069782d2123400fbb5186fb48d5170e1);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_language);
Py_DECREF(var_language);
var_language = NULL;
CHECK_OBJECT(var_show_urlname);
Py_DECREF(var_show_urlname);
var_show_urlname = NULL;
CHECK_OBJECT(var_query);
Py_DECREF(var_query);
var_query = NULL;
CHECK_OBJECT(var_show_data);
Py_DECREF(var_show_data);
var_show_data = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_language);
var_language = NULL;
Py_XDECREF(var_show_urlname);
var_show_urlname = NULL;
Py_XDECREF(var_query);
var_query = NULL;
Py_XDECREF(var_show_data);
var_show_data = NULL;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_9__process_data(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_show_data = python_pars[1];
struct Nuitka_FrameObject *frame_51a27b4404804636298a4a93f64122f6;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *tmp_return_value = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
static struct Nuitka_FrameObject *cache_frame_51a27b4404804636298a4a93f64122f6 = NULL;
// Actual function body.
if (isFrameUnusable(cache_frame_51a27b4404804636298a4a93f64122f6)) {
Py_XDECREF(cache_frame_51a27b4404804636298a4a93f64122f6);
#if _DEBUG_REFCOUNTS
if (cache_frame_51a27b4404804636298a4a93f64122f6 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_51a27b4404804636298a4a93f64122f6 = MAKE_FUNCTION_FRAME(codeobj_51a27b4404804636298a4a93f64122f6, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_51a27b4404804636298a4a93f64122f6->m_type_description == NULL);
frame_51a27b4404804636298a4a93f64122f6 = cache_frame_51a27b4404804636298a4a93f64122f6;
// Push the new frame as the currently active one.
pushFrameStack(frame_51a27b4404804636298a4a93f64122f6);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_51a27b4404804636298a4a93f64122f6) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_subscript_name_1;
PyObject *tmp_args_element_name_2;
PyObject *tmp_args_element_name_3;
PyObject *tmp_called_name_2;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_4;
PyObject *tmp_called_instance_1;
CHECK_OBJECT(par_self);
tmp_expression_name_1 = par_self;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_url_result);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 214;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_show_data);
tmp_expression_name_2 = par_show_data;
tmp_subscript_name_1 = const_str_plain_url;
tmp_args_element_name_1 = LOOKUP_SUBSCRIPT(tmp_expression_name_2, tmp_subscript_name_1);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 215;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
tmp_args_element_name_2 = const_str_plain_AdobeTVShow;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_str_or_none);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_str_or_none);
}
if (tmp_mvar_value_1 == NULL) {
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 28262 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 215;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
tmp_called_name_2 = tmp_mvar_value_1;
CHECK_OBJECT(par_show_data);
tmp_called_instance_1 = par_show_data;
frame_51a27b4404804636298a4a93f64122f6->m_frame.f_lineno = 215;
tmp_args_element_name_4 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_1, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_id_tuple, 0));
if (tmp_args_element_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
exception_lineno = 215;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
frame_51a27b4404804636298a4a93f64122f6->m_frame.f_lineno = 215;
tmp_args_element_name_3 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, tmp_args_element_name_4);
Py_DECREF(tmp_args_element_name_4);
if (tmp_args_element_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
exception_lineno = 215;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
frame_51a27b4404804636298a4a93f64122f6->m_frame.f_lineno = 214;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_2, tmp_args_element_name_3};
tmp_return_value = CALL_FUNCTION_WITH_ARGS3(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
Py_DECREF(tmp_args_element_name_3);
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 214;
type_description_1 = "oo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_51a27b4404804636298a4a93f64122f6);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_51a27b4404804636298a4a93f64122f6);
#endif
// Put the previous frame back on top.
popFrameStack();
goto function_return_exit;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_51a27b4404804636298a4a93f64122f6);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_51a27b4404804636298a4a93f64122f6, exception_lineno);
} else if (exception_tb->tb_frame != &frame_51a27b4404804636298a4a93f64122f6->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_51a27b4404804636298a4a93f64122f6, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_51a27b4404804636298a4a93f64122f6,
type_description_1,
par_self,
par_show_data
);
// Release cached frame.
if (frame_51a27b4404804636298a4a93f64122f6 == cache_frame_51a27b4404804636298a4a93f64122f6) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_51a27b4404804636298a4a93f64122f6);
}
cache_frame_51a27b4404804636298a4a93f64122f6 = NULL;
assertFrameObject(frame_51a27b4404804636298a4a93f64122f6);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto function_exception_exit;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_show_data);
Py_DECREF(par_show_data); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_show_data);
Py_DECREF(par_show_data);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_10__real_extract(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_url = python_pars[1];
PyObject *var_language = NULL;
PyObject *var_channel_urlname = NULL;
PyObject *var_category_urlname = NULL;
PyObject *var_query = NULL;
PyObject *tmp_tuple_unpack_1__element_1 = NULL;
PyObject *tmp_tuple_unpack_1__element_2 = NULL;
PyObject *tmp_tuple_unpack_1__element_3 = NULL;
PyObject *tmp_tuple_unpack_1__source_iter = NULL;
struct Nuitka_FrameObject *frame_60871c028732697fc514e0c7e8db7eb5;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
PyObject *tmp_iterator_attempt;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
int tmp_res;
PyObject *tmp_dictset_value;
PyObject *tmp_dictset_dict;
PyObject *tmp_dictset_key;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_60871c028732697fc514e0c7e8db7eb5 = NULL;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_60871c028732697fc514e0c7e8db7eb5)) {
Py_XDECREF(cache_frame_60871c028732697fc514e0c7e8db7eb5);
#if _DEBUG_REFCOUNTS
if (cache_frame_60871c028732697fc514e0c7e8db7eb5 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_60871c028732697fc514e0c7e8db7eb5 = MAKE_FUNCTION_FRAME(codeobj_60871c028732697fc514e0c7e8db7eb5, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_60871c028732697fc514e0c7e8db7eb5->m_type_description == NULL);
frame_60871c028732697fc514e0c7e8db7eb5 = cache_frame_60871c028732697fc514e0c7e8db7eb5;
// Push the new frame as the currently active one.
pushFrameStack(frame_60871c028732697fc514e0c7e8db7eb5);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_60871c028732697fc514e0c7e8db7eb5) == 2); // Frame stack
// Framed code:
// Tried code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_iter_arg_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_element_name_1;
PyObject *tmp_expression_name_2;
PyObject *tmp_args_element_name_2;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_re);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_re);
}
if (tmp_mvar_value_1 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 2114 ], 24, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_expression_name_1 = tmp_mvar_value_1;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain_match);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_self);
tmp_expression_name_2 = par_self;
tmp_args_element_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, const_str_plain__VALID_URL);
if (tmp_args_element_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
CHECK_OBJECT(par_url);
tmp_args_element_name_2 = par_url;
frame_60871c028732697fc514e0c7e8db7eb5->m_frame.f_lineno = 218;
{
PyObject *call_args[] = {tmp_args_element_name_1, tmp_args_element_name_2};
tmp_called_instance_1 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_1);
if (tmp_called_instance_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
frame_60871c028732697fc514e0c7e8db7eb5->m_frame.f_lineno = 218;
tmp_iter_arg_1 = CALL_METHOD_NO_ARGS(tmp_called_instance_1, const_str_plain_groups);
Py_DECREF(tmp_called_instance_1);
if (tmp_iter_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
tmp_assign_source_1 = MAKE_UNPACK_ITERATOR(tmp_iter_arg_1);
Py_DECREF(tmp_iter_arg_1);
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 218;
type_description_1 = "oooooo";
goto try_except_handler_2;
}
assert(tmp_tuple_unpack_1__source_iter == NULL);
tmp_tuple_unpack_1__source_iter = tmp_assign_source_1;
}
// Tried code:
{
PyObject *tmp_assign_source_2;
PyObject *tmp_unpack_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_1 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_2 = UNPACK_NEXT(tmp_unpack_1, 0, 3);
if (tmp_assign_source_2 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 218;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_1 == NULL);
tmp_tuple_unpack_1__element_1 = tmp_assign_source_2;
}
{
PyObject *tmp_assign_source_3;
PyObject *tmp_unpack_2;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_2 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_3 = UNPACK_NEXT(tmp_unpack_2, 1, 3);
if (tmp_assign_source_3 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 218;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_2 == NULL);
tmp_tuple_unpack_1__element_2 = tmp_assign_source_3;
}
{
PyObject *tmp_assign_source_4;
PyObject *tmp_unpack_3;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_unpack_3 = tmp_tuple_unpack_1__source_iter;
tmp_assign_source_4 = UNPACK_NEXT(tmp_unpack_3, 2, 3);
if (tmp_assign_source_4 == NULL) {
if (!ERROR_OCCURRED()) {
exception_type = PyExc_StopIteration;
Py_INCREF(exception_type);
exception_value = NULL;
exception_tb = NULL;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
}
type_description_1 = "oooooo";
exception_lineno = 218;
goto try_except_handler_3;
}
assert(tmp_tuple_unpack_1__element_3 == NULL);
tmp_tuple_unpack_1__element_3 = tmp_assign_source_4;
}
{
PyObject *tmp_iterator_name_1;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
tmp_iterator_name_1 = tmp_tuple_unpack_1__source_iter;
// Check if iterator has left-over elements.
CHECK_OBJECT(tmp_iterator_name_1); assert(HAS_ITERNEXT(tmp_iterator_name_1));
tmp_iterator_attempt = (*Py_TYPE(tmp_iterator_name_1)->tp_iternext)(tmp_iterator_name_1);
if (likely(tmp_iterator_attempt == NULL)) {
PyObject *error = GET_ERROR_OCCURRED();
if (error != NULL) {
if (EXCEPTION_MATCH_BOOL_SINGLE(error, PyExc_StopIteration)) {
CLEAR_ERROR_OCCURRED();
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "oooooo";
exception_lineno = 218;
goto try_except_handler_3;
}
}
} else {
Py_DECREF(tmp_iterator_attempt);
exception_type = PyExc_ValueError;
Py_INCREF(PyExc_ValueError);
exception_value = const_str_digest_09d63a5a61044765cbef1a09e46446f1;
Py_INCREF(exception_value);
exception_tb = NULL;
type_description_1 = "oooooo";
exception_lineno = 218;
goto try_except_handler_3;
}
}
goto try_end_1;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto try_except_handler_2;
// End of try:
try_end_1:;
goto try_end_2;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
Py_XDECREF(tmp_tuple_unpack_1__element_3);
tmp_tuple_unpack_1__element_3 = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto frame_exception_exit_1;
// End of try:
try_end_2:;
CHECK_OBJECT(tmp_tuple_unpack_1__source_iter);
Py_DECREF(tmp_tuple_unpack_1__source_iter);
tmp_tuple_unpack_1__source_iter = NULL;
{
PyObject *tmp_assign_source_5;
CHECK_OBJECT(tmp_tuple_unpack_1__element_1);
tmp_assign_source_5 = tmp_tuple_unpack_1__element_1;
assert(var_language == NULL);
Py_INCREF(tmp_assign_source_5);
var_language = tmp_assign_source_5;
}
Py_XDECREF(tmp_tuple_unpack_1__element_1);
tmp_tuple_unpack_1__element_1 = NULL;
{
PyObject *tmp_assign_source_6;
CHECK_OBJECT(tmp_tuple_unpack_1__element_2);
tmp_assign_source_6 = tmp_tuple_unpack_1__element_2;
assert(var_channel_urlname == NULL);
Py_INCREF(tmp_assign_source_6);
var_channel_urlname = tmp_assign_source_6;
}
Py_XDECREF(tmp_tuple_unpack_1__element_2);
tmp_tuple_unpack_1__element_2 = NULL;
{
PyObject *tmp_assign_source_7;
CHECK_OBJECT(tmp_tuple_unpack_1__element_3);
tmp_assign_source_7 = tmp_tuple_unpack_1__element_3;
assert(var_category_urlname == NULL);
Py_INCREF(tmp_assign_source_7);
var_category_urlname = tmp_assign_source_7;
}
Py_XDECREF(tmp_tuple_unpack_1__element_3);
tmp_tuple_unpack_1__element_3 = NULL;
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_language);
tmp_operand_name_1 = var_language;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 219;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
{
PyObject *tmp_assign_source_8;
tmp_assign_source_8 = const_str_plain_en;
{
PyObject *old = var_language;
assert(old != NULL);
var_language = tmp_assign_source_8;
Py_INCREF(var_language);
Py_DECREF(old);
}
}
branch_no_1:;
{
PyObject *tmp_assign_source_9;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
tmp_dict_key_1 = const_str_plain_channel_urlname;
CHECK_OBJECT(var_channel_urlname);
tmp_dict_value_1 = var_channel_urlname;
tmp_assign_source_9 = _PyDict_NewPresized( 2 );
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_language;
CHECK_OBJECT(var_language);
tmp_dict_value_2 = var_language;
tmp_res = PyDict_SetItem(tmp_assign_source_9, tmp_dict_key_2, tmp_dict_value_2);
assert(!(tmp_res != 0));
assert(var_query == NULL);
var_query = tmp_assign_source_9;
}
{
nuitka_bool tmp_condition_result_2;
int tmp_truth_name_1;
CHECK_OBJECT(var_category_urlname);
tmp_truth_name_1 = CHECK_IF_TRUE(var_category_urlname);
if (tmp_truth_name_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 225;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_2 == NUITKA_BOOL_TRUE) {
goto branch_yes_2;
} else {
goto branch_no_2;
}
}
branch_yes_2:;
CHECK_OBJECT(var_category_urlname);
tmp_dictset_value = var_category_urlname;
CHECK_OBJECT(var_query);
tmp_dictset_dict = var_query;
tmp_dictset_key = const_str_plain_category_urlname;
tmp_res = PyDict_SetItem(tmp_dictset_dict, tmp_dictset_key, tmp_dictset_value);
assert(!(tmp_res != 0));
branch_no_2:;
{
PyObject *tmp_called_name_2;
PyObject *tmp_expression_name_3;
PyObject *tmp_args_element_name_3;
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_4;
PyObject *tmp_args_element_name_5;
PyObject *tmp_args_element_name_6;
CHECK_OBJECT(par_self);
tmp_expression_name_3 = par_self;
tmp_called_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_3, const_str_plain_playlist_result);
if (tmp_called_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 228;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_self);
tmp_called_instance_2 = par_self;
CHECK_OBJECT(var_channel_urlname);
tmp_args_element_name_4 = var_channel_urlname;
CHECK_OBJECT(var_query);
tmp_args_element_name_5 = var_query;
frame_60871c028732697fc514e0c7e8db7eb5->m_frame.f_lineno = 229;
{
PyObject *call_args[] = {tmp_args_element_name_4, tmp_args_element_name_5};
tmp_args_element_name_3 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_2, const_str_plain__extract_playlist_entries, call_args);
}
if (tmp_args_element_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
exception_lineno = 229;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(var_channel_urlname);
tmp_args_element_name_6 = var_channel_urlname;
frame_60871c028732697fc514e0c7e8db7eb5->m_frame.f_lineno = 228;
{
PyObject *call_args[] = {tmp_args_element_name_3, tmp_args_element_name_6};
tmp_return_value = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_2, call_args);
}
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_3);
if (tmp_return_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 228;
type_description_1 = "oooooo";
goto frame_exception_exit_1;
}
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_60871c028732697fc514e0c7e8db7eb5);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_60871c028732697fc514e0c7e8db7eb5);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_60871c028732697fc514e0c7e8db7eb5);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_60871c028732697fc514e0c7e8db7eb5, exception_lineno);
} else if (exception_tb->tb_frame != &frame_60871c028732697fc514e0c7e8db7eb5->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_60871c028732697fc514e0c7e8db7eb5, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_60871c028732697fc514e0c7e8db7eb5,
type_description_1,
par_self,
par_url,
var_language,
var_channel_urlname,
var_category_urlname,
var_query
);
// Release cached frame.
if (frame_60871c028732697fc514e0c7e8db7eb5 == cache_frame_60871c028732697fc514e0c7e8db7eb5) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_60871c028732697fc514e0c7e8db7eb5);
}
cache_frame_60871c028732697fc514e0c7e8db7eb5 = NULL;
assertFrameObject(frame_60871c028732697fc514e0c7e8db7eb5);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_language);
Py_DECREF(var_language);
var_language = NULL;
CHECK_OBJECT(var_channel_urlname);
Py_DECREF(var_channel_urlname);
var_channel_urlname = NULL;
CHECK_OBJECT(var_category_urlname);
Py_DECREF(var_category_urlname);
var_category_urlname = NULL;
CHECK_OBJECT(var_query);
Py_DECREF(var_query);
var_query = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_language);
var_language = NULL;
Py_XDECREF(var_channel_urlname);
var_channel_urlname = NULL;
Py_XDECREF(var_category_urlname);
var_category_urlname = NULL;
Py_XDECREF(var_query);
var_query = NULL;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *impl_youtube_dl$extractor$adobetv$$$function_11__real_extract(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
// Preserve error status for checks
#ifndef __NUITKA_NO_ASSERT__
NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
#endif
// Local variable declarations.
PyObject *par_self = python_pars[0];
PyObject *par_url = python_pars[1];
PyObject *var_video_id = NULL;
PyObject *var_webpage = NULL;
PyObject *var_video_data = NULL;
PyObject *var_title = NULL;
PyObject *var_formats = NULL;
PyObject *var_sources = NULL;
PyObject *var_source = NULL;
PyObject *var_source_src = NULL;
PyObject *var_duration = NULL;
PyObject *outline_0_var_source = NULL;
PyObject *tmp_for_loop_1__for_iterator = NULL;
PyObject *tmp_for_loop_1__iter_value = NULL;
PyObject *tmp_listcomp_1__$0 = NULL;
PyObject *tmp_listcomp_1__contraction = NULL;
PyObject *tmp_listcomp_1__iter_value_0 = NULL;
struct Nuitka_FrameObject *frame_79314044936fe43446767356b30cc4a9;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
int tmp_res;
NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
struct Nuitka_FrameObject *frame_1e7db592e06f2b19245a7b92b16ee1ac_2;
NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
static struct Nuitka_FrameObject *cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2 = NULL;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
PyObject *tmp_return_value = NULL;
static struct Nuitka_FrameObject *cache_frame_79314044936fe43446767356b30cc4a9 = NULL;
PyObject *exception_keeper_type_4;
PyObject *exception_keeper_value_4;
PyTracebackObject *exception_keeper_tb_4;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4;
// Actual function body.
// Tried code:
if (isFrameUnusable(cache_frame_79314044936fe43446767356b30cc4a9)) {
Py_XDECREF(cache_frame_79314044936fe43446767356b30cc4a9);
#if _DEBUG_REFCOUNTS
if (cache_frame_79314044936fe43446767356b30cc4a9 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_79314044936fe43446767356b30cc4a9 = MAKE_FUNCTION_FRAME(codeobj_79314044936fe43446767356b30cc4a9, module_youtube_dl$extractor$adobetv, sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *)+sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_79314044936fe43446767356b30cc4a9->m_type_description == NULL);
frame_79314044936fe43446767356b30cc4a9 = cache_frame_79314044936fe43446767356b30cc4a9;
// Push the new frame as the currently active one.
pushFrameStack(frame_79314044936fe43446767356b30cc4a9);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_79314044936fe43446767356b30cc4a9) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_assign_source_1;
PyObject *tmp_called_instance_1;
PyObject *tmp_args_element_name_1;
CHECK_OBJECT(par_self);
tmp_called_instance_1 = par_self;
CHECK_OBJECT(par_url);
tmp_args_element_name_1 = par_url;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 251;
{
PyObject *call_args[] = {tmp_args_element_name_1};
tmp_assign_source_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_1, const_str_plain__match_id, call_args);
}
if (tmp_assign_source_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 251;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_video_id == NULL);
var_video_id = tmp_assign_source_1;
}
{
PyObject *tmp_assign_source_2;
PyObject *tmp_called_instance_2;
PyObject *tmp_args_element_name_2;
PyObject *tmp_args_element_name_3;
CHECK_OBJECT(par_self);
tmp_called_instance_2 = par_self;
CHECK_OBJECT(par_url);
tmp_args_element_name_2 = par_url;
CHECK_OBJECT(var_video_id);
tmp_args_element_name_3 = var_video_id;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 252;
{
PyObject *call_args[] = {tmp_args_element_name_2, tmp_args_element_name_3};
tmp_assign_source_2 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_2, const_str_plain__download_webpage, call_args);
}
if (tmp_assign_source_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 252;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_webpage == NULL);
var_webpage = tmp_assign_source_2;
}
{
PyObject *tmp_assign_source_3;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_args_element_name_4;
PyObject *tmp_called_instance_3;
PyObject *tmp_args_element_name_5;
PyObject *tmp_args_element_name_6;
PyObject *tmp_args_element_name_7;
PyObject *tmp_args_element_name_8;
CHECK_OBJECT(par_self);
tmp_expression_name_1 = par_self;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, const_str_plain__parse_json);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 254;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(par_self);
tmp_called_instance_3 = par_self;
tmp_args_element_name_5 = const_str_digest_9b792622a4a8c6de219288edd32bf03f;
CHECK_OBJECT(var_webpage);
tmp_args_element_name_6 = var_webpage;
tmp_args_element_name_7 = const_str_digest_d0c849816d2a2fdedbfbbef2ca596803;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 254;
{
PyObject *call_args[] = {tmp_args_element_name_5, tmp_args_element_name_6, tmp_args_element_name_7};
tmp_args_element_name_4 = CALL_METHOD_WITH_ARGS3(tmp_called_instance_3, const_str_plain__search_regex, call_args);
}
if (tmp_args_element_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_1);
exception_lineno = 254;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
CHECK_OBJECT(var_video_id);
tmp_args_element_name_8 = var_video_id;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 254;
{
PyObject *call_args[] = {tmp_args_element_name_4, tmp_args_element_name_8};
tmp_assign_source_3 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_1, call_args);
}
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_element_name_4);
if (tmp_assign_source_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 254;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_video_data == NULL);
var_video_data = tmp_assign_source_3;
}
{
PyObject *tmp_assign_source_4;
PyObject *tmp_expression_name_2;
PyObject *tmp_subscript_name_1;
CHECK_OBJECT(var_video_data);
tmp_expression_name_2 = var_video_data;
tmp_subscript_name_1 = const_str_plain_title;
tmp_assign_source_4 = LOOKUP_SUBSCRIPT(tmp_expression_name_2, tmp_subscript_name_1);
if (tmp_assign_source_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 256;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_title == NULL);
var_title = tmp_assign_source_4;
}
{
PyObject *tmp_assign_source_5;
tmp_assign_source_5 = PyList_New(0);
assert(var_formats == NULL);
var_formats = tmp_assign_source_5;
}
{
PyObject *tmp_assign_source_6;
int tmp_or_left_truth_1;
PyObject *tmp_or_left_value_1;
PyObject *tmp_or_right_value_1;
PyObject *tmp_called_instance_4;
CHECK_OBJECT(var_video_data);
tmp_called_instance_4 = var_video_data;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 259;
tmp_or_left_value_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_4, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_sources_tuple, 0));
if (tmp_or_left_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 259;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_or_left_truth_1 = CHECK_IF_TRUE(tmp_or_left_value_1);
if (tmp_or_left_truth_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_or_left_value_1);
exception_lineno = 259;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
if (tmp_or_left_truth_1 == 1) {
goto or_left_1;
} else {
goto or_right_1;
}
or_right_1:;
Py_DECREF(tmp_or_left_value_1);
tmp_or_right_value_1 = PyList_New(0);
tmp_assign_source_6 = tmp_or_right_value_1;
goto or_end_1;
or_left_1:;
tmp_assign_source_6 = tmp_or_left_value_1;
or_end_1:;
assert(var_sources == NULL);
var_sources = tmp_assign_source_6;
}
{
PyObject *tmp_assign_source_7;
PyObject *tmp_iter_arg_1;
CHECK_OBJECT(var_sources);
tmp_iter_arg_1 = var_sources;
tmp_assign_source_7 = MAKE_ITERATOR(tmp_iter_arg_1);
if (tmp_assign_source_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 260;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(tmp_for_loop_1__for_iterator == NULL);
tmp_for_loop_1__for_iterator = tmp_assign_source_7;
}
// Tried code:
loop_start_1:;
{
PyObject *tmp_next_source_1;
PyObject *tmp_assign_source_8;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
tmp_next_source_1 = tmp_for_loop_1__for_iterator;
tmp_assign_source_8 = ITERATOR_NEXT(tmp_next_source_1);
if (tmp_assign_source_8 == NULL) {
if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
goto loop_end_1;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_1 = "ooooooooooo";
exception_lineno = 260;
goto try_except_handler_2;
}
}
{
PyObject *old = tmp_for_loop_1__iter_value;
tmp_for_loop_1__iter_value = tmp_assign_source_8;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_9;
CHECK_OBJECT(tmp_for_loop_1__iter_value);
tmp_assign_source_9 = tmp_for_loop_1__iter_value;
{
PyObject *old = var_source;
var_source = tmp_assign_source_9;
Py_INCREF(var_source);
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_10;
PyObject *tmp_called_instance_5;
CHECK_OBJECT(var_source);
tmp_called_instance_5 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 261;
tmp_assign_source_10 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_5, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_src_tuple, 0));
if (tmp_assign_source_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 261;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
{
PyObject *old = var_source_src;
var_source_src = tmp_assign_source_10;
Py_XDECREF(old);
}
}
{
nuitka_bool tmp_condition_result_1;
PyObject *tmp_operand_name_1;
CHECK_OBJECT(var_source_src);
tmp_operand_name_1 = var_source_src;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 262;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_condition_result_1 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
goto loop_start_1;
branch_no_1:;
{
PyObject *tmp_called_name_2;
PyObject *tmp_expression_name_3;
PyObject *tmp_call_result_1;
PyObject *tmp_args_element_name_9;
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_called_name_3;
PyObject *tmp_mvar_value_1;
PyObject *tmp_args_name_1;
PyObject *tmp_tuple_element_1;
int tmp_or_left_truth_2;
PyObject *tmp_or_left_value_2;
PyObject *tmp_or_right_value_2;
PyObject *tmp_called_instance_6;
PyObject *tmp_kw_name_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
PyObject *tmp_called_name_4;
PyObject *tmp_expression_name_4;
PyObject *tmp_args_element_name_10;
PyObject *tmp_called_name_5;
PyObject *tmp_args_element_name_11;
PyObject *tmp_args_element_name_12;
PyObject *tmp_list_element_1;
PyObject *tmp_called_instance_7;
PyObject *tmp_called_instance_8;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_3;
PyObject *tmp_called_name_6;
PyObject *tmp_mvar_value_2;
PyObject *tmp_args_element_name_13;
int tmp_or_left_truth_3;
PyObject *tmp_or_left_value_3;
PyObject *tmp_or_right_value_3;
PyObject *tmp_called_instance_9;
PyObject *tmp_dict_key_4;
PyObject *tmp_dict_value_4;
PyObject *tmp_called_name_7;
PyObject *tmp_mvar_value_3;
PyObject *tmp_args_element_name_14;
int tmp_or_left_truth_4;
PyObject *tmp_or_left_value_4;
PyObject *tmp_or_right_value_4;
PyObject *tmp_called_instance_10;
PyObject *tmp_dict_key_5;
PyObject *tmp_dict_value_5;
PyObject *tmp_called_name_8;
PyObject *tmp_mvar_value_4;
PyObject *tmp_args_element_name_15;
int tmp_or_left_truth_5;
PyObject *tmp_or_left_value_5;
PyObject *tmp_or_right_value_5;
PyObject *tmp_called_instance_11;
PyObject *tmp_dict_key_6;
PyObject *tmp_dict_value_6;
CHECK_OBJECT(var_formats);
tmp_expression_name_3 = var_formats;
tmp_called_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_3, const_str_plain_append);
if (tmp_called_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 264;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_dict_key_1 = const_str_plain_filesize;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_1 == NULL) {
Py_DECREF(tmp_called_name_2);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 265;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_3 = tmp_mvar_value_1;
CHECK_OBJECT(var_source);
tmp_called_instance_6 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 265;
tmp_or_left_value_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_6, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_kilobytes_tuple, 0));
if (tmp_or_left_value_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
exception_lineno = 265;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_or_left_truth_2 = CHECK_IF_TRUE(tmp_or_left_value_2);
if (tmp_or_left_truth_2 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_or_left_value_2);
exception_lineno = 265;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
if (tmp_or_left_truth_2 == 1) {
goto or_left_2;
} else {
goto or_right_2;
}
or_right_2:;
Py_DECREF(tmp_or_left_value_2);
tmp_or_right_value_2 = Py_None;
Py_INCREF(tmp_or_right_value_2);
tmp_tuple_element_1 = tmp_or_right_value_2;
goto or_end_2;
or_left_2:;
tmp_tuple_element_1 = tmp_or_left_value_2;
or_end_2:;
tmp_args_name_1 = PyTuple_New(1);
PyTuple_SET_ITEM(tmp_args_name_1, 0, tmp_tuple_element_1);
tmp_kw_name_1 = PyDict_Copy(const_dict_c54ad24c94e3512475ba621ffbade5fa);
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 265;
tmp_dict_value_1 = CALL_FUNCTION(tmp_called_name_3, tmp_args_name_1, tmp_kw_name_1);
Py_DECREF(tmp_args_name_1);
Py_DECREF(tmp_kw_name_1);
if (tmp_dict_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
exception_lineno = 265;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_args_element_name_9 = _PyDict_NewPresized( 6 );
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_1, tmp_dict_value_1);
Py_DECREF(tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_format_id;
tmp_expression_name_4 = const_str_chr_45;
tmp_called_name_4 = LOOKUP_ATTRIBUTE(tmp_expression_name_4, const_str_plain_join);
assert(!(tmp_called_name_4 == NULL));
tmp_called_name_5 = (PyObject *)&PyFilter_Type;
tmp_args_element_name_11 = Py_None;
CHECK_OBJECT(var_source);
tmp_called_instance_7 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 266;
tmp_list_element_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_7, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_format_tuple, 0));
if (tmp_list_element_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_called_name_4);
exception_lineno = 266;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_args_element_name_12 = PyList_New(2);
PyList_SET_ITEM(tmp_args_element_name_12, 0, tmp_list_element_1);
CHECK_OBJECT(var_source);
tmp_called_instance_8 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 266;
tmp_list_element_1 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_8, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_label_tuple, 0));
if (tmp_list_element_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_called_name_4);
Py_DECREF(tmp_args_element_name_12);
exception_lineno = 266;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
PyList_SET_ITEM(tmp_args_element_name_12, 1, tmp_list_element_1);
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 266;
{
PyObject *call_args[] = {tmp_args_element_name_11, tmp_args_element_name_12};
tmp_args_element_name_10 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_5, call_args);
}
Py_DECREF(tmp_args_element_name_12);
if (tmp_args_element_name_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_called_name_4);
exception_lineno = 266;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 266;
tmp_dict_value_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_4, tmp_args_element_name_10);
Py_DECREF(tmp_called_name_4);
Py_DECREF(tmp_args_element_name_10);
if (tmp_dict_value_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 266;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_2, tmp_dict_value_2);
Py_DECREF(tmp_dict_value_2);
assert(!(tmp_res != 0));
tmp_dict_key_3 = const_str_plain_height;
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_2 == NULL)) {
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_2 == NULL) {
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 267;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_6 = tmp_mvar_value_2;
CHECK_OBJECT(var_source);
tmp_called_instance_9 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 267;
tmp_or_left_value_3 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_9, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_height_tuple, 0));
if (tmp_or_left_value_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 267;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_or_left_truth_3 = CHECK_IF_TRUE(tmp_or_left_value_3);
if (tmp_or_left_truth_3 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_or_left_value_3);
exception_lineno = 267;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
if (tmp_or_left_truth_3 == 1) {
goto or_left_3;
} else {
goto or_right_3;
}
or_right_3:;
Py_DECREF(tmp_or_left_value_3);
tmp_or_right_value_3 = Py_None;
Py_INCREF(tmp_or_right_value_3);
tmp_args_element_name_13 = tmp_or_right_value_3;
goto or_end_3;
or_left_3:;
tmp_args_element_name_13 = tmp_or_left_value_3;
or_end_3:;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 267;
tmp_dict_value_3 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_6, tmp_args_element_name_13);
Py_DECREF(tmp_args_element_name_13);
if (tmp_dict_value_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 267;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_3, tmp_dict_value_3);
Py_DECREF(tmp_dict_value_3);
assert(!(tmp_res != 0));
tmp_dict_key_4 = const_str_plain_tbr;
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_3 == NULL)) {
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_3 == NULL) {
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 268;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_7 = tmp_mvar_value_3;
CHECK_OBJECT(var_source);
tmp_called_instance_10 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 268;
tmp_or_left_value_4 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_10, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_bitrate_tuple, 0));
if (tmp_or_left_value_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 268;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_or_left_truth_4 = CHECK_IF_TRUE(tmp_or_left_value_4);
if (tmp_or_left_truth_4 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_or_left_value_4);
exception_lineno = 268;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
if (tmp_or_left_truth_4 == 1) {
goto or_left_4;
} else {
goto or_right_4;
}
or_right_4:;
Py_DECREF(tmp_or_left_value_4);
tmp_or_right_value_4 = Py_None;
Py_INCREF(tmp_or_right_value_4);
tmp_args_element_name_14 = tmp_or_right_value_4;
goto or_end_4;
or_left_4:;
tmp_args_element_name_14 = tmp_or_left_value_4;
or_end_4:;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 268;
tmp_dict_value_4 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_7, tmp_args_element_name_14);
Py_DECREF(tmp_args_element_name_14);
if (tmp_dict_value_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 268;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_4, tmp_dict_value_4);
Py_DECREF(tmp_dict_value_4);
assert(!(tmp_res != 0));
tmp_dict_key_5 = const_str_plain_width;
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none);
if (unlikely(tmp_mvar_value_4 == NULL)) {
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_int_or_none);
}
if (tmp_mvar_value_4 == NULL) {
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 27635 ], 33, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 269;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_called_name_8 = tmp_mvar_value_4;
CHECK_OBJECT(var_source);
tmp_called_instance_11 = var_source;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 269;
tmp_or_left_value_5 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_11, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_width_tuple, 0));
if (tmp_or_left_value_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 269;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_or_left_truth_5 = CHECK_IF_TRUE(tmp_or_left_value_5);
if (tmp_or_left_truth_5 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
Py_DECREF(tmp_or_left_value_5);
exception_lineno = 269;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
if (tmp_or_left_truth_5 == 1) {
goto or_left_5;
} else {
goto or_right_5;
}
or_right_5:;
Py_DECREF(tmp_or_left_value_5);
tmp_or_right_value_5 = Py_None;
Py_INCREF(tmp_or_right_value_5);
tmp_args_element_name_15 = tmp_or_right_value_5;
goto or_end_5;
or_left_5:;
tmp_args_element_name_15 = tmp_or_left_value_5;
or_end_5:;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 269;
tmp_dict_value_5 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_8, tmp_args_element_name_15);
Py_DECREF(tmp_args_element_name_15);
if (tmp_dict_value_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
exception_lineno = 269;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_5, tmp_dict_value_5);
Py_DECREF(tmp_dict_value_5);
assert(!(tmp_res != 0));
tmp_dict_key_6 = const_str_plain_url;
CHECK_OBJECT(var_source_src);
tmp_dict_value_6 = var_source_src;
tmp_res = PyDict_SetItem(tmp_args_element_name_9, tmp_dict_key_6, tmp_dict_value_6);
assert(!(tmp_res != 0));
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 264;
tmp_call_result_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, tmp_args_element_name_9);
Py_DECREF(tmp_called_name_2);
Py_DECREF(tmp_args_element_name_9);
if (tmp_call_result_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 264;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
Py_DECREF(tmp_call_result_1);
}
if (CONSIDER_THREADING() == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 260;
type_description_1 = "ooooooooooo";
goto try_except_handler_2;
}
goto loop_start_1;
loop_end_1:;
goto try_end_1;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto frame_exception_exit_1;
// End of try:
try_end_1:;
Py_XDECREF(tmp_for_loop_1__iter_value);
tmp_for_loop_1__iter_value = NULL;
CHECK_OBJECT(tmp_for_loop_1__for_iterator);
Py_DECREF(tmp_for_loop_1__for_iterator);
tmp_for_loop_1__for_iterator = NULL;
{
PyObject *tmp_called_instance_12;
PyObject *tmp_call_result_2;
PyObject *tmp_args_element_name_16;
CHECK_OBJECT(par_self);
tmp_called_instance_12 = par_self;
CHECK_OBJECT(var_formats);
tmp_args_element_name_16 = var_formats;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 272;
{
PyObject *call_args[] = {tmp_args_element_name_16};
tmp_call_result_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_12, const_str_plain__sort_formats, call_args);
}
if (tmp_call_result_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 272;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
Py_DECREF(tmp_call_result_2);
}
{
PyObject *tmp_assign_source_11;
PyObject *tmp_called_name_9;
PyObject *tmp_args_element_name_17;
PyObject *tmp_called_name_10;
PyObject *tmp_args_element_name_18;
PyObject *tmp_args_element_name_19;
tmp_called_name_9 = LOOKUP_BUILTIN(const_str_plain_max);
assert(tmp_called_name_9 != NULL);
tmp_called_name_10 = (PyObject *)&PyFilter_Type;
tmp_args_element_name_18 = Py_None;
// Tried code:
{
PyObject *tmp_assign_source_12;
PyObject *tmp_iter_arg_2;
CHECK_OBJECT(var_sources);
tmp_iter_arg_2 = var_sources;
tmp_assign_source_12 = MAKE_ITERATOR(tmp_iter_arg_2);
if (tmp_assign_source_12 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 277;
type_description_1 = "ooooooooooo";
goto try_except_handler_3;
}
assert(tmp_listcomp_1__$0 == NULL);
tmp_listcomp_1__$0 = tmp_assign_source_12;
}
{
PyObject *tmp_assign_source_13;
tmp_assign_source_13 = PyList_New(0);
assert(tmp_listcomp_1__contraction == NULL);
tmp_listcomp_1__contraction = tmp_assign_source_13;
}
if (isFrameUnusable(cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2)) {
Py_XDECREF(cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
#if _DEBUG_REFCOUNTS
if (cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2 = MAKE_FUNCTION_FRAME(codeobj_1e7db592e06f2b19245a7b92b16ee1ac, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2->m_type_description == NULL);
frame_1e7db592e06f2b19245a7b92b16ee1ac_2 = cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2;
// Push the new frame as the currently active one.
pushFrameStack(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_1e7db592e06f2b19245a7b92b16ee1ac_2) == 2); // Frame stack
// Framed code:
// Tried code:
loop_start_2:;
{
PyObject *tmp_next_source_2;
PyObject *tmp_assign_source_14;
CHECK_OBJECT(tmp_listcomp_1__$0);
tmp_next_source_2 = tmp_listcomp_1__$0;
tmp_assign_source_14 = ITERATOR_NEXT(tmp_next_source_2);
if (tmp_assign_source_14 == NULL) {
if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
goto loop_end_2;
} else {
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
type_description_2 = "o";
exception_lineno = 277;
goto try_except_handler_4;
}
}
{
PyObject *old = tmp_listcomp_1__iter_value_0;
tmp_listcomp_1__iter_value_0 = tmp_assign_source_14;
Py_XDECREF(old);
}
}
{
PyObject *tmp_assign_source_15;
CHECK_OBJECT(tmp_listcomp_1__iter_value_0);
tmp_assign_source_15 = tmp_listcomp_1__iter_value_0;
{
PyObject *old = outline_0_var_source;
outline_0_var_source = tmp_assign_source_15;
Py_INCREF(outline_0_var_source);
Py_XDECREF(old);
}
}
{
PyObject *tmp_append_list_1;
PyObject *tmp_append_value_1;
PyObject *tmp_called_name_11;
PyObject *tmp_mvar_value_5;
PyObject *tmp_args_name_2;
PyObject *tmp_tuple_element_2;
PyObject *tmp_called_instance_13;
PyObject *tmp_kw_name_2;
CHECK_OBJECT(tmp_listcomp_1__contraction);
tmp_append_list_1 = tmp_listcomp_1__contraction;
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_float_or_none);
if (unlikely(tmp_mvar_value_5 == NULL)) {
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_float_or_none);
}
if (tmp_mvar_value_5 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 33881 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 277;
type_description_2 = "o";
goto try_except_handler_4;
}
tmp_called_name_11 = tmp_mvar_value_5;
CHECK_OBJECT(outline_0_var_source);
tmp_called_instance_13 = outline_0_var_source;
frame_1e7db592e06f2b19245a7b92b16ee1ac_2->m_frame.f_lineno = 277;
tmp_tuple_element_2 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_13, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_duration_tuple, 0));
if (tmp_tuple_element_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 277;
type_description_2 = "o";
goto try_except_handler_4;
}
tmp_args_name_2 = PyTuple_New(1);
PyTuple_SET_ITEM(tmp_args_name_2, 0, tmp_tuple_element_2);
tmp_kw_name_2 = PyDict_Copy(const_dict_186fac6cf4e5273be066e7a2969f77c4);
frame_1e7db592e06f2b19245a7b92b16ee1ac_2->m_frame.f_lineno = 277;
tmp_append_value_1 = CALL_FUNCTION(tmp_called_name_11, tmp_args_name_2, tmp_kw_name_2);
Py_DECREF(tmp_args_name_2);
Py_DECREF(tmp_kw_name_2);
if (tmp_append_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 277;
type_description_2 = "o";
goto try_except_handler_4;
}
assert(PyList_Check(tmp_append_list_1));
tmp_res = PyList_Append(tmp_append_list_1, tmp_append_value_1);
Py_DECREF(tmp_append_value_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 277;
type_description_2 = "o";
goto try_except_handler_4;
}
}
if (CONSIDER_THREADING() == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 277;
type_description_2 = "o";
goto try_except_handler_4;
}
goto loop_start_2;
loop_end_2:;
CHECK_OBJECT(tmp_listcomp_1__contraction);
tmp_args_element_name_19 = tmp_listcomp_1__contraction;
Py_INCREF(tmp_args_element_name_19);
goto try_return_handler_4;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_4:;
CHECK_OBJECT(tmp_listcomp_1__$0);
Py_DECREF(tmp_listcomp_1__$0);
tmp_listcomp_1__$0 = NULL;
CHECK_OBJECT(tmp_listcomp_1__contraction);
Py_DECREF(tmp_listcomp_1__contraction);
tmp_listcomp_1__contraction = NULL;
Py_XDECREF(tmp_listcomp_1__iter_value_0);
tmp_listcomp_1__iter_value_0 = NULL;
goto frame_return_exit_2;
// Exception handler code:
try_except_handler_4:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(tmp_listcomp_1__$0);
Py_DECREF(tmp_listcomp_1__$0);
tmp_listcomp_1__$0 = NULL;
CHECK_OBJECT(tmp_listcomp_1__contraction);
Py_DECREF(tmp_listcomp_1__contraction);
tmp_listcomp_1__contraction = NULL;
Py_XDECREF(tmp_listcomp_1__iter_value_0);
tmp_listcomp_1__iter_value_0 = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto frame_exception_exit_2;
// End of try:
#if 0
RESTORE_FRAME_EXCEPTION(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_return_exit_2:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_3;
frame_exception_exit_2:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_1e7db592e06f2b19245a7b92b16ee1ac_2, exception_lineno);
} else if (exception_tb->tb_frame != &frame_1e7db592e06f2b19245a7b92b16ee1ac_2->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_1e7db592e06f2b19245a7b92b16ee1ac_2, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_1e7db592e06f2b19245a7b92b16ee1ac_2,
type_description_2,
outline_0_var_source
);
// Release cached frame.
if (frame_1e7db592e06f2b19245a7b92b16ee1ac_2 == cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
}
cache_frame_1e7db592e06f2b19245a7b92b16ee1ac_2 = NULL;
assertFrameObject(frame_1e7db592e06f2b19245a7b92b16ee1ac_2);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_1;
frame_no_exception_1:;
goto skip_nested_handling_1;
nested_frame_exit_1:;
type_description_1 = "ooooooooooo";
goto try_except_handler_3;
skip_nested_handling_1:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_3:;
Py_XDECREF(outline_0_var_source);
outline_0_var_source = NULL;
goto outline_result_1;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(outline_0_var_source);
outline_0_var_source = NULL;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto outline_exception_1;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_1:;
exception_lineno = 277;
goto frame_exception_exit_1;
outline_result_1:;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 276;
{
PyObject *call_args[] = {tmp_args_element_name_18, tmp_args_element_name_19};
tmp_args_element_name_17 = CALL_FUNCTION_WITH_ARGS2(tmp_called_name_10, call_args);
}
Py_DECREF(tmp_args_element_name_19);
if (tmp_args_element_name_17 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 276;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 276;
tmp_assign_source_11 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_9, tmp_args_element_name_17);
Py_DECREF(tmp_args_element_name_17);
if (tmp_assign_source_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 276;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
assert(var_duration == NULL);
var_duration = tmp_assign_source_11;
}
{
PyObject *tmp_dict_key_7;
PyObject *tmp_dict_value_7;
PyObject *tmp_dict_key_8;
PyObject *tmp_dict_value_8;
PyObject *tmp_dict_key_9;
PyObject *tmp_dict_value_9;
PyObject *tmp_dict_key_10;
PyObject *tmp_dict_value_10;
PyObject *tmp_called_instance_14;
PyObject *tmp_dict_key_11;
PyObject *tmp_dict_value_11;
PyObject *tmp_called_instance_15;
PyObject *tmp_called_instance_16;
PyObject *tmp_call_arg_element_1;
PyObject *tmp_call_arg_element_2;
PyObject *tmp_dict_key_12;
PyObject *tmp_dict_value_12;
PyObject *tmp_dict_key_13;
PyObject *tmp_dict_value_13;
PyObject *tmp_called_instance_17;
PyObject *tmp_args_element_name_20;
PyObject *tmp_args_element_name_21;
tmp_dict_key_7 = const_str_plain_id;
CHECK_OBJECT(var_video_id);
tmp_dict_value_7 = var_video_id;
tmp_return_value = _PyDict_NewPresized( 7 );
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_7, tmp_dict_value_7);
assert(!(tmp_res != 0));
tmp_dict_key_8 = const_str_plain_formats;
CHECK_OBJECT(var_formats);
tmp_dict_value_8 = var_formats;
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_8, tmp_dict_value_8);
assert(!(tmp_res != 0));
tmp_dict_key_9 = const_str_plain_title;
CHECK_OBJECT(var_title);
tmp_dict_value_9 = var_title;
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_9, tmp_dict_value_9);
assert(!(tmp_res != 0));
tmp_dict_key_10 = const_str_plain_description;
CHECK_OBJECT(var_video_data);
tmp_called_instance_14 = var_video_data;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 284;
tmp_dict_value_10 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_14, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_description_tuple, 0));
if (tmp_dict_value_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 284;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_10, tmp_dict_value_10);
Py_DECREF(tmp_dict_value_10);
assert(!(tmp_res != 0));
tmp_dict_key_11 = const_str_plain_thumbnail;
CHECK_OBJECT(var_video_data);
tmp_called_instance_16 = var_video_data;
tmp_call_arg_element_1 = const_str_plain_video;
tmp_call_arg_element_2 = PyDict_New();
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 285;
{
PyObject *call_args[] = {tmp_call_arg_element_1, tmp_call_arg_element_2};
tmp_called_instance_15 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_16, const_str_plain_get, call_args);
}
Py_DECREF(tmp_call_arg_element_2);
if (tmp_called_instance_15 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 285;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 285;
tmp_dict_value_11 = CALL_METHOD_WITH_ARGS1(tmp_called_instance_15, const_str_plain_get, &PyTuple_GET_ITEM(const_tuple_str_plain_poster_tuple, 0));
Py_DECREF(tmp_called_instance_15);
if (tmp_dict_value_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 285;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_11, tmp_dict_value_11);
Py_DECREF(tmp_dict_value_11);
assert(!(tmp_res != 0));
tmp_dict_key_12 = const_str_plain_duration;
CHECK_OBJECT(var_duration);
tmp_dict_value_12 = var_duration;
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_12, tmp_dict_value_12);
assert(!(tmp_res != 0));
tmp_dict_key_13 = const_str_plain_subtitles;
CHECK_OBJECT(par_self);
tmp_called_instance_17 = par_self;
CHECK_OBJECT(var_video_data);
tmp_args_element_name_20 = var_video_data;
tmp_args_element_name_21 = const_str_plain_vttPath;
frame_79314044936fe43446767356b30cc4a9->m_frame.f_lineno = 287;
{
PyObject *call_args[] = {tmp_args_element_name_20, tmp_args_element_name_21};
tmp_dict_value_13 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_17, const_str_plain__parse_subtitles, call_args);
}
if (tmp_dict_value_13 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_return_value);
exception_lineno = 287;
type_description_1 = "ooooooooooo";
goto frame_exception_exit_1;
}
tmp_res = PyDict_SetItem(tmp_return_value, tmp_dict_key_13, tmp_dict_value_13);
Py_DECREF(tmp_dict_value_13);
assert(!(tmp_res != 0));
goto frame_return_exit_1;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_79314044936fe43446767356b30cc4a9);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_2;
frame_return_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_79314044936fe43446767356b30cc4a9);
#endif
// Put the previous frame back on top.
popFrameStack();
goto try_return_handler_1;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_79314044936fe43446767356b30cc4a9);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_79314044936fe43446767356b30cc4a9, exception_lineno);
} else if (exception_tb->tb_frame != &frame_79314044936fe43446767356b30cc4a9->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_79314044936fe43446767356b30cc4a9, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_79314044936fe43446767356b30cc4a9,
type_description_1,
par_self,
par_url,
var_video_id,
var_webpage,
var_video_data,
var_title,
var_formats,
var_sources,
var_source,
var_source_src,
var_duration
);
// Release cached frame.
if (frame_79314044936fe43446767356b30cc4a9 == cache_frame_79314044936fe43446767356b30cc4a9) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_79314044936fe43446767356b30cc4a9);
}
cache_frame_79314044936fe43446767356b30cc4a9 = NULL;
assertFrameObject(frame_79314044936fe43446767356b30cc4a9);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto try_except_handler_1;
frame_no_exception_2:;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_1:;
CHECK_OBJECT(var_video_id);
Py_DECREF(var_video_id);
var_video_id = NULL;
CHECK_OBJECT(var_webpage);
Py_DECREF(var_webpage);
var_webpage = NULL;
CHECK_OBJECT(var_video_data);
Py_DECREF(var_video_data);
var_video_data = NULL;
CHECK_OBJECT(var_title);
Py_DECREF(var_title);
var_title = NULL;
CHECK_OBJECT(var_formats);
Py_DECREF(var_formats);
var_formats = NULL;
CHECK_OBJECT(var_sources);
Py_DECREF(var_sources);
var_sources = NULL;
Py_XDECREF(var_source);
var_source = NULL;
Py_XDECREF(var_source_src);
var_source_src = NULL;
CHECK_OBJECT(var_duration);
Py_DECREF(var_duration);
var_duration = NULL;
goto function_return_exit;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_4 = exception_type;
exception_keeper_value_4 = exception_value;
exception_keeper_tb_4 = exception_tb;
exception_keeper_lineno_4 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(var_video_id);
var_video_id = NULL;
Py_XDECREF(var_webpage);
var_webpage = NULL;
Py_XDECREF(var_video_data);
var_video_data = NULL;
Py_XDECREF(var_title);
var_title = NULL;
Py_XDECREF(var_formats);
var_formats = NULL;
Py_XDECREF(var_sources);
var_sources = NULL;
Py_XDECREF(var_source);
var_source = NULL;
Py_XDECREF(var_source_src);
var_source_src = NULL;
Py_XDECREF(var_duration);
var_duration = NULL;
// Re-raise.
exception_type = exception_keeper_type_4;
exception_value = exception_keeper_value_4;
exception_tb = exception_keeper_tb_4;
exception_lineno = exception_keeper_lineno_4;
goto function_exception_exit;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
function_exception_exit:
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url); assert(exception_type);
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
function_return_exit:
// Function cleanup code if any.
CHECK_OBJECT(par_self);
Py_DECREF(par_self);
CHECK_OBJECT(par_url);
Py_DECREF(par_url);
// Actual function exit with return value, making sure we did not make
// the error status worse despite non-NULL return.
CHECK_OBJECT(tmp_return_value);
assert(had_error || !ERROR_OCCURRED());
return tmp_return_value;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_10__real_extract() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_10__real_extract,
const_str_plain__real_extract,
#if PYTHON_VERSION >= 300
const_str_digest_fb250e306a67bc7d18432b489b4001a5,
#endif
codeobj_60871c028732697fc514e0c7e8db7eb5,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_11__real_extract() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_11__real_extract,
const_str_plain__real_extract,
#if PYTHON_VERSION >= 300
const_str_digest_afba863e1889153901633aeafa890e29,
#endif
codeobj_79314044936fe43446767356b30cc4a9,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_1__call_api(PyObject *defaults) {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_1__call_api,
const_str_plain__call_api,
#if PYTHON_VERSION >= 300
const_str_digest_d68478e2f15f6d7e3647320c1c45f925,
#endif
codeobj_834f043b31b4afdc2588e7b3a4ba3554,
defaults,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles,
const_str_plain__parse_subtitles,
#if PYTHON_VERSION >= 300
const_str_digest_64845517d9fdd6f5481d18e079915b1c,
#endif
codeobj_09f8bb420e83a4f16794d009e8570c07,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_3__parse_video_data() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_3__parse_video_data,
const_str_plain__parse_video_data,
#if PYTHON_VERSION >= 300
const_str_digest_5240d88f631f21ffaccd2a56fde48d8d,
#endif
codeobj_1810a286a3465c5ff9e74d69681fef3b,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_4__real_extract() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_4__real_extract,
const_str_plain__real_extract,
#if PYTHON_VERSION >= 300
const_str_digest_91049d54c42a857d6a3ba1d5cbf8cd99,
#endif
codeobj_6f49301b89b3a3f4d161efa52eccb64d,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_5__real_extract() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_5__real_extract,
const_str_plain__real_extract,
#if PYTHON_VERSION >= 300
const_str_digest_f60a39ae7d3b695e96126c2ac3578613,
#endif
codeobj_89e9c2601f96e3e42ce33f5cf04cc314,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_6__fetch_page() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_6__fetch_page,
const_str_plain__fetch_page,
#if PYTHON_VERSION >= 300
const_str_digest_7e9c451ae054c3f5df4ae9aee8edec23,
#endif
codeobj_6c3691199cab595cab8a57126f484e81,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries,
const_str_plain__extract_playlist_entries,
#if PYTHON_VERSION >= 300
const_str_digest_4d32a606745cea62faa915b57caef28d,
#endif
codeobj_0c1486d9b5668f5559c676adca49b768,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_8__real_extract() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_8__real_extract,
const_str_plain__real_extract,
#if PYTHON_VERSION >= 300
const_str_digest_11e94e8f07bf0d0965bbec23b14f3e73,
#endif
codeobj_069782d2123400fbb5186fb48d5170e1,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
static PyObject *MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_9__process_data() {
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
impl_youtube_dl$extractor$adobetv$$$function_9__process_data,
const_str_plain__process_data,
#if PYTHON_VERSION >= 300
const_str_digest_af523633df503b653506078243199934,
#endif
codeobj_51a27b4404804636298a4a93f64122f6,
NULL,
#if PYTHON_VERSION >= 300
NULL,
NULL,
#endif
module_youtube_dl$extractor$adobetv,
NULL,
0
);
return (PyObject *)result;
}
extern PyObject *const_str_plain___compiled__;
extern PyObject *const_str_plain___package__;
extern PyObject *const_str_empty;
#if PYTHON_VERSION >= 300
extern PyObject *const_str_dot;
extern PyObject *const_str_plain___loader__;
#endif
#if PYTHON_VERSION >= 340
extern PyObject *const_str_plain___spec__;
extern PyObject *const_str_plain__initializing;
extern PyObject *const_str_plain_submodule_search_locations;
#endif
extern void _initCompiledCellType();
extern void _initCompiledGeneratorType();
extern void _initCompiledFunctionType();
extern void _initCompiledMethodType();
extern void _initCompiledFrameType();
extern PyTypeObject Nuitka_Loader_Type;
#ifdef _NUITKA_PLUGIN_DILL_ENABLED
// Provide a way to create find a function via its C code and create it back
// in another process, useful for multiprocessing extensions like dill
function_impl_code functable_youtube_dl$extractor$adobetv[] = {
impl_youtube_dl$extractor$adobetv$$$function_1__call_api,
impl_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles,
impl_youtube_dl$extractor$adobetv$$$function_3__parse_video_data,
impl_youtube_dl$extractor$adobetv$$$function_4__real_extract,
impl_youtube_dl$extractor$adobetv$$$function_5__real_extract,
impl_youtube_dl$extractor$adobetv$$$function_6__fetch_page,
impl_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries,
impl_youtube_dl$extractor$adobetv$$$function_8__real_extract,
impl_youtube_dl$extractor$adobetv$$$function_9__process_data,
impl_youtube_dl$extractor$adobetv$$$function_10__real_extract,
impl_youtube_dl$extractor$adobetv$$$function_11__real_extract,
NULL
};
static char const *_reduce_compiled_function_argnames[] = {
"func",
NULL
};
static PyObject *_reduce_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
PyObject *func;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:reduce_compiled_function", (char **)_reduce_compiled_function_argnames, &func, NULL)) {
return NULL;
}
if (Nuitka_Function_Check(func) == false) {
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_TypeError, "not a compiled function");
return NULL;
}
struct Nuitka_FunctionObject *function = (struct Nuitka_FunctionObject *)func;
function_impl_code *current = functable_youtube_dl$extractor$adobetv;
int offset = 0;
while (*current != NULL) {
if (*current == function->m_c_code) {
break;
}
current += 1;
offset += 1;
}
if (*current == NULL) {
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_TypeError, "Cannot find compiled function in module.");
return NULL;
}
PyObject *code_object_desc = PyTuple_New(6);
PyTuple_SET_ITEM0(code_object_desc, 0, function->m_code_object->co_filename);
PyTuple_SET_ITEM0(code_object_desc, 1, function->m_code_object->co_name);
PyTuple_SET_ITEM(code_object_desc, 2, PyLong_FromLong(function->m_code_object->co_firstlineno));
PyTuple_SET_ITEM0(code_object_desc, 3, function->m_code_object->co_varnames);
PyTuple_SET_ITEM(code_object_desc, 4, PyLong_FromLong(function->m_code_object->co_argcount));
PyTuple_SET_ITEM(code_object_desc, 5, PyLong_FromLong(function->m_code_object->co_flags));
CHECK_OBJECT_DEEP(code_object_desc);
PyObject *result = PyTuple_New(4);
PyTuple_SET_ITEM(result, 0, PyLong_FromLong(offset));
PyTuple_SET_ITEM(result, 1, code_object_desc);
PyTuple_SET_ITEM0(result, 2, function->m_defaults);
PyTuple_SET_ITEM0(result, 3, function->m_doc != NULL ? function->m_doc : Py_None);
CHECK_OBJECT_DEEP(result);
return result;
}
static PyMethodDef _method_def_reduce_compiled_function = {"reduce_compiled_function", (PyCFunction)_reduce_compiled_function,
METH_VARARGS | METH_KEYWORDS, NULL};
static char const *_create_compiled_function_argnames[] = {
"func",
"code_object_desc",
"defaults",
"doc",
NULL
};
static PyObject *_create_compiled_function(PyObject *self, PyObject *args, PyObject *kwds) {
CHECK_OBJECT_DEEP(args);
PyObject *func;
PyObject *code_object_desc;
PyObject *defaults;
PyObject *doc;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOO:create_compiled_function", (char **)_create_compiled_function_argnames, &func, &code_object_desc, &defaults, &doc, NULL)) {
return NULL;
}
int offset = PyLong_AsLong(func);
if (offset == -1 && ERROR_OCCURRED()) {
return NULL;
}
if (offset > sizeof(functable_youtube_dl$extractor$adobetv) || offset < 0) {
SET_CURRENT_EXCEPTION_TYPE0_STR(PyExc_TypeError, "Wrong offset for compiled function.");
return NULL;
}
PyObject *filename = PyTuple_GET_ITEM(code_object_desc, 0);
PyObject *function_name = PyTuple_GET_ITEM(code_object_desc, 1);
PyObject *line = PyTuple_GET_ITEM(code_object_desc, 2);
int line_int = PyLong_AsLong(line);
assert(!ERROR_OCCURRED());
PyObject *argnames = PyTuple_GET_ITEM(code_object_desc, 3);
PyObject *arg_count = PyTuple_GET_ITEM(code_object_desc, 4);
int arg_count_int = PyLong_AsLong(arg_count);
assert(!ERROR_OCCURRED());
PyObject *flags = PyTuple_GET_ITEM(code_object_desc, 5);
int flags_int = PyLong_AsLong(flags);
assert(!ERROR_OCCURRED());
PyCodeObject *code_object = MAKE_CODEOBJECT(
filename,
line_int,
flags_int,
function_name,
argnames,
arg_count_int,
0, // TODO: Missing kw_only_count
0 // TODO: Missing pos_only_count
);
// TODO: More stuff needed for Python3, best to re-order arguments of MAKE_CODEOBJECT.
struct Nuitka_FunctionObject *result = Nuitka_Function_New(
functable_youtube_dl$extractor$adobetv[offset],
code_object->co_name,
#if PYTHON_VERSION >= 300
NULL, // TODO: Not transferring qualname yet
#endif
code_object,
defaults,
#if PYTHON_VERSION >= 300
NULL, // kwdefaults are done on the outside currently
NULL, // TODO: Not transferring annotations
#endif
module_youtube_dl$extractor$adobetv,
doc,
0
);
return (PyObject *)result;
}
static PyMethodDef _method_def_create_compiled_function = {
"create_compiled_function",
(PyCFunction)_create_compiled_function,
METH_VARARGS | METH_KEYWORDS, NULL
};
#endif
// Internal entry point for module code.
PyObject *modulecode_youtube_dl$extractor$adobetv(PyObject *module) {
module_youtube_dl$extractor$adobetv = module;
#if defined(_NUITKA_EXE) || PYTHON_VERSION >= 300
static bool _init_done = false;
// Modules might be imported repeatedly, which is to be ignored.
if (_init_done) {
return module_youtube_dl$extractor$adobetv;
} else {
_init_done = true;
}
#endif
#ifdef _NUITKA_MODULE
// In case of a stand alone extension module, need to call initialization
// the init here because that's the first and only time we are going to get
// called here.
// May have to activate constants blob.
#if defined(_NUITKA_CONSTANTS_FROM_RESOURCE)
loadConstantsResource();
#endif
// Initialize the constant values used.
_initBuiltinModule();
createGlobalConstants();
/* Initialize the compiled types of Nuitka. */
_initCompiledCellType();
_initCompiledGeneratorType();
_initCompiledFunctionType();
_initCompiledMethodType();
_initCompiledFrameType();
#if PYTHON_VERSION < 300
_initSlotCompare();
#endif
#if PYTHON_VERSION >= 270
_initSlotIternext();
#endif
patchBuiltinModule();
patchTypeComparison();
// Enable meta path based loader if not already done.
#ifdef _NUITKA_TRACE
PRINT_STRING("youtube_dl.extractor.adobetv: Calling setupMetaPathBasedLoader().\n");
#endif
setupMetaPathBasedLoader();
#if PYTHON_VERSION >= 300
patchInspectModule();
#endif
#endif
/* The constants only used by this module are created now. */
#ifdef _NUITKA_TRACE
PRINT_STRING("youtube_dl.extractor.adobetv: Calling createModuleConstants().\n");
#endif
createModuleConstants();
/* The code objects used by this module are created now. */
#ifdef _NUITKA_TRACE
PRINT_STRING("youtube_dl.extractor.adobetv: Calling createModuleCodeObjects().\n");
#endif
createModuleCodeObjects();
// PRINT_STRING("in inityoutube_dl$extractor$adobetv\n");
// Create the module object first. There are no methods initially, all are
// added dynamically in actual code only. Also no "__doc__" is initially
// set at this time, as it could not contain NUL characters this way, they
// are instead set in early module code. No "self" for modules, we have no
// use for it.
moduledict_youtube_dl$extractor$adobetv = MODULE_DICT(module_youtube_dl$extractor$adobetv);
#ifdef _NUITKA_PLUGIN_DILL_ENABLED
{
PyObject *function_tables = PyObject_GetAttrString((PyObject *)builtin_module, "compiled_function_tables");
if (function_tables == NULL)
{
DROP_ERROR_OCCURRED();
function_tables = PyDict_New();
}
PyObject_SetAttrString((PyObject *)builtin_module, "compiled_function_tables", function_tables);
PyObject *funcs = PyTuple_New(2);
PyTuple_SET_ITEM(funcs, 0, PyCFunction_New(&_method_def_reduce_compiled_function, NULL));
PyTuple_SET_ITEM(funcs, 1, PyCFunction_New(&_method_def_create_compiled_function, NULL));
PyDict_SetItemString(function_tables, module_full_name, funcs);
}
#endif
// Set "__compiled__" to what version information we have.
UPDATE_STRING_DICT0(
moduledict_youtube_dl$extractor$adobetv,
(Nuitka_StringObject *)const_str_plain___compiled__,
Nuitka_dunder_compiled_value
);
// Update "__package__" value to what it ought to be.
{
#if 0
UPDATE_STRING_DICT0(
moduledict_youtube_dl$extractor$adobetv,
(Nuitka_StringObject *)const_str_plain___package__,
const_str_empty
);
#elif 0
PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___name__);
UPDATE_STRING_DICT0(
moduledict_youtube_dl$extractor$adobetv,
(Nuitka_StringObject *)const_str_plain___package__,
module_name
);
#else
#if PYTHON_VERSION < 300
PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___name__);
char const *module_name_cstr = PyString_AS_STRING(module_name);
char const *last_dot = strrchr(module_name_cstr, '.');
if (last_dot != NULL)
{
UPDATE_STRING_DICT1(
moduledict_youtube_dl$extractor$adobetv,
(Nuitka_StringObject *)const_str_plain___package__,
PyString_FromStringAndSize(module_name_cstr, last_dot - module_name_cstr)
);
}
#else
PyObject *module_name = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___name__);
Py_ssize_t dot_index = PyUnicode_Find(module_name, const_str_dot, 0, PyUnicode_GetLength(module_name), -1);
if (dot_index != -1)
{
UPDATE_STRING_DICT1(
moduledict_youtube_dl$extractor$adobetv,
(Nuitka_StringObject *)const_str_plain___package__,
PyUnicode_Substring(module_name, 0, dot_index)
);
}
#endif
#endif
}
CHECK_OBJECT(module_youtube_dl$extractor$adobetv);
// For deep importing of a module we need to have "__builtins__", so we set
// it ourselves in the same way than CPython does. Note: This must be done
// before the frame object is allocated, or else it may fail.
if (GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___builtins__) == NULL)
{
PyObject *value = (PyObject *)builtin_module;
// Check if main module, not a dict then but the module itself.
#if !defined(_NUITKA_EXE) || !0
value = PyModule_GetDict(value);
#endif
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___builtins__, value);
}
#if PYTHON_VERSION >= 300
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___loader__, (PyObject *)&Nuitka_Loader_Type);
#endif
#if PYTHON_VERSION >= 340
// Set the "__spec__" value
#if 0
// Main modules just get "None" as spec.
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___spec__, Py_None);
#else
// Other modules get a "ModuleSpec" from the standard mechanism.
{
PyObject *bootstrap_module = PyImport_ImportModule("importlib._bootstrap");
CHECK_OBJECT(bootstrap_module);
PyObject *module_spec_class = PyObject_GetAttrString(bootstrap_module, "ModuleSpec");
Py_DECREF(bootstrap_module);
PyObject *args[] = {
GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___name__),
(PyObject *)&Nuitka_Loader_Type
};
PyObject *spec_value = CALL_FUNCTION_WITH_ARGS2(
module_spec_class,
args
);
Py_DECREF(module_spec_class);
// We can assume this to never fail, or else we are in trouble anyway.
CHECK_OBJECT(spec_value);
// For packages set the submodule search locations as well, even if to empty
// list, so investigating code will consider it a package.
#if 0
SET_ATTRIBUTE(spec_value, const_str_plain_submodule_search_locations, PyList_New(0));
#endif
// Mark the execution in the "__spec__" value.
SET_ATTRIBUTE(spec_value, const_str_plain__initializing, Py_True);
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___spec__, spec_value);
}
#endif
#endif
// Temp variables if any
PyObject *outline_0_var___class__ = NULL;
PyObject *outline_1_var___class__ = NULL;
PyObject *outline_2_var___class__ = NULL;
PyObject *outline_3_var___class__ = NULL;
PyObject *outline_4_var___class__ = NULL;
PyObject *outline_5_var___class__ = NULL;
PyObject *outline_6_var___class__ = NULL;
PyObject *tmp_class_creation_1__bases = NULL;
PyObject *tmp_class_creation_1__bases_orig = NULL;
PyObject *tmp_class_creation_1__class_decl_dict = NULL;
PyObject *tmp_class_creation_1__metaclass = NULL;
PyObject *tmp_class_creation_1__prepared = NULL;
PyObject *tmp_class_creation_2__bases = NULL;
PyObject *tmp_class_creation_2__bases_orig = NULL;
PyObject *tmp_class_creation_2__class_decl_dict = NULL;
PyObject *tmp_class_creation_2__metaclass = NULL;
PyObject *tmp_class_creation_2__prepared = NULL;
PyObject *tmp_class_creation_3__bases = NULL;
PyObject *tmp_class_creation_3__bases_orig = NULL;
PyObject *tmp_class_creation_3__class_decl_dict = NULL;
PyObject *tmp_class_creation_3__metaclass = NULL;
PyObject *tmp_class_creation_3__prepared = NULL;
PyObject *tmp_class_creation_4__bases = NULL;
PyObject *tmp_class_creation_4__bases_orig = NULL;
PyObject *tmp_class_creation_4__class_decl_dict = NULL;
PyObject *tmp_class_creation_4__metaclass = NULL;
PyObject *tmp_class_creation_4__prepared = NULL;
PyObject *tmp_class_creation_5__bases = NULL;
PyObject *tmp_class_creation_5__bases_orig = NULL;
PyObject *tmp_class_creation_5__class_decl_dict = NULL;
PyObject *tmp_class_creation_5__metaclass = NULL;
PyObject *tmp_class_creation_5__prepared = NULL;
PyObject *tmp_class_creation_6__bases = NULL;
PyObject *tmp_class_creation_6__bases_orig = NULL;
PyObject *tmp_class_creation_6__class_decl_dict = NULL;
PyObject *tmp_class_creation_6__metaclass = NULL;
PyObject *tmp_class_creation_6__prepared = NULL;
PyObject *tmp_class_creation_7__bases = NULL;
PyObject *tmp_class_creation_7__bases_orig = NULL;
PyObject *tmp_class_creation_7__class_decl_dict = NULL;
PyObject *tmp_class_creation_7__metaclass = NULL;
PyObject *tmp_class_creation_7__prepared = NULL;
PyObject *tmp_import_from_1__module = NULL;
struct Nuitka_FrameObject *frame_c9377acb7551bcadf8d3742266bc3096;
NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
bool tmp_result;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyTracebackObject *exception_tb = NULL;
NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
PyObject *exception_keeper_type_1;
PyObject *exception_keeper_value_1;
PyTracebackObject *exception_keeper_tb_1;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
int tmp_res;
PyObject *tmp_dictdel_dict;
PyObject *tmp_dictdel_key;
PyObject *locals_youtube_dl$extractor$adobetv_20 = NULL;
PyObject *tmp_dictset_value;
struct Nuitka_FrameObject *frame_4a4db23877cf40d63d0d3cb611eabb3d_2;
NUITKA_MAY_BE_UNUSED char const *type_description_2 = NULL;
static struct Nuitka_FrameObject *cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2 = NULL;
PyObject *exception_keeper_type_2;
PyObject *exception_keeper_value_2;
PyTracebackObject *exception_keeper_tb_2;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
PyObject *exception_keeper_type_3;
PyObject *exception_keeper_value_3;
PyTracebackObject *exception_keeper_tb_3;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_3;
PyObject *exception_keeper_type_4;
PyObject *exception_keeper_value_4;
PyTracebackObject *exception_keeper_tb_4;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_4;
PyObject *locals_youtube_dl$extractor$adobetv_89 = NULL;
struct Nuitka_FrameObject *frame_1dd224ed6723050f9a702890ebe89e97_3;
NUITKA_MAY_BE_UNUSED char const *type_description_3 = NULL;
static struct Nuitka_FrameObject *cache_frame_1dd224ed6723050f9a702890ebe89e97_3 = NULL;
PyObject *exception_keeper_type_5;
PyObject *exception_keeper_value_5;
PyTracebackObject *exception_keeper_tb_5;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_5;
PyObject *exception_keeper_type_6;
PyObject *exception_keeper_value_6;
PyTracebackObject *exception_keeper_tb_6;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_6;
PyObject *exception_keeper_type_7;
PyObject *exception_keeper_value_7;
PyTracebackObject *exception_keeper_tb_7;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_7;
PyObject *locals_youtube_dl$extractor$adobetv_115 = NULL;
struct Nuitka_FrameObject *frame_293fae0b1c87e3c29380ffc25da7ec0e_4;
NUITKA_MAY_BE_UNUSED char const *type_description_4 = NULL;
static struct Nuitka_FrameObject *cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4 = NULL;
PyObject *exception_keeper_type_8;
PyObject *exception_keeper_value_8;
PyTracebackObject *exception_keeper_tb_8;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_8;
PyObject *exception_keeper_type_9;
PyObject *exception_keeper_value_9;
PyTracebackObject *exception_keeper_tb_9;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_9;
PyObject *exception_keeper_type_10;
PyObject *exception_keeper_value_10;
PyTracebackObject *exception_keeper_tb_10;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_10;
PyObject *locals_youtube_dl$extractor$adobetv_149 = NULL;
struct Nuitka_FrameObject *frame_74c7094b8228d0a8210cc04eb85c548d_5;
NUITKA_MAY_BE_UNUSED char const *type_description_5 = NULL;
static struct Nuitka_FrameObject *cache_frame_74c7094b8228d0a8210cc04eb85c548d_5 = NULL;
PyObject *exception_keeper_type_11;
PyObject *exception_keeper_value_11;
PyTracebackObject *exception_keeper_tb_11;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_11;
PyObject *exception_keeper_type_12;
PyObject *exception_keeper_value_12;
PyTracebackObject *exception_keeper_tb_12;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_12;
PyObject *exception_keeper_type_13;
PyObject *exception_keeper_value_13;
PyTracebackObject *exception_keeper_tb_13;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_13;
PyObject *locals_youtube_dl$extractor$adobetv_164 = NULL;
struct Nuitka_FrameObject *frame_5c0388a50dc76d1d7766415e475ed156_6;
NUITKA_MAY_BE_UNUSED char const *type_description_6 = NULL;
static struct Nuitka_FrameObject *cache_frame_5c0388a50dc76d1d7766415e475ed156_6 = NULL;
PyObject *exception_keeper_type_14;
PyObject *exception_keeper_value_14;
PyTracebackObject *exception_keeper_tb_14;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_14;
PyObject *exception_keeper_type_15;
PyObject *exception_keeper_value_15;
PyTracebackObject *exception_keeper_tb_15;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_15;
PyObject *exception_keeper_type_16;
PyObject *exception_keeper_value_16;
PyTracebackObject *exception_keeper_tb_16;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_16;
PyObject *locals_youtube_dl$extractor$adobetv_200 = NULL;
struct Nuitka_FrameObject *frame_212e5f88591db5845244d4e462e25095_7;
NUITKA_MAY_BE_UNUSED char const *type_description_7 = NULL;
static struct Nuitka_FrameObject *cache_frame_212e5f88591db5845244d4e462e25095_7 = NULL;
PyObject *exception_keeper_type_17;
PyObject *exception_keeper_value_17;
PyTracebackObject *exception_keeper_tb_17;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_17;
PyObject *exception_keeper_type_18;
PyObject *exception_keeper_value_18;
PyTracebackObject *exception_keeper_tb_18;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_18;
PyObject *exception_keeper_type_19;
PyObject *exception_keeper_value_19;
PyTracebackObject *exception_keeper_tb_19;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_19;
PyObject *locals_youtube_dl$extractor$adobetv_233 = NULL;
struct Nuitka_FrameObject *frame_b22fbb524a47a23a55ddf9d42313a6dc_8;
NUITKA_MAY_BE_UNUSED char const *type_description_8 = NULL;
static struct Nuitka_FrameObject *cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8 = NULL;
PyObject *exception_keeper_type_20;
PyObject *exception_keeper_value_20;
PyTracebackObject *exception_keeper_tb_20;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_20;
PyObject *exception_keeper_type_21;
PyObject *exception_keeper_value_21;
PyTracebackObject *exception_keeper_tb_21;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_21;
PyObject *exception_keeper_type_22;
PyObject *exception_keeper_value_22;
PyTracebackObject *exception_keeper_tb_22;
NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_22;
// Module code.
{
PyObject *tmp_assign_source_1;
tmp_assign_source_1 = Py_None;
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___doc__, tmp_assign_source_1);
}
{
PyObject *tmp_assign_source_2;
tmp_assign_source_2 = const_str_digest_2709ca18b0b7f1f400a7b0885f2980a2;
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___file__, tmp_assign_source_2);
}
// Frame without reuse.
frame_c9377acb7551bcadf8d3742266bc3096 = MAKE_MODULE_FRAME(codeobj_c9377acb7551bcadf8d3742266bc3096, module_youtube_dl$extractor$adobetv);
// Push the new frame as the currently active one, and we should be exclusively
// owning it.
pushFrameStack(frame_c9377acb7551bcadf8d3742266bc3096);
assert(Py_REFCNT(frame_c9377acb7551bcadf8d3742266bc3096) == 2);
// Framed code:
{
PyObject *tmp_assattr_name_1;
PyObject *tmp_assattr_target_1;
PyObject *tmp_mvar_value_1;
tmp_assattr_name_1 = const_str_digest_2709ca18b0b7f1f400a7b0885f2980a2;
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___spec__);
if (unlikely(tmp_mvar_value_1 == NULL)) {
tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__);
}
CHECK_OBJECT(tmp_mvar_value_1);
tmp_assattr_target_1 = tmp_mvar_value_1;
tmp_result = SET_ATTRIBUTE(tmp_assattr_target_1, const_str_plain_origin, tmp_assattr_name_1);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 1;
goto frame_exception_exit_1;
}
}
{
PyObject *tmp_assattr_name_2;
PyObject *tmp_assattr_target_2;
PyObject *tmp_mvar_value_2;
tmp_assattr_name_2 = Py_True;
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___spec__);
if (unlikely(tmp_mvar_value_2 == NULL)) {
tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain___spec__);
}
CHECK_OBJECT(tmp_mvar_value_2);
tmp_assattr_target_2 = tmp_mvar_value_2;
tmp_result = SET_ATTRIBUTE(tmp_assattr_target_2, const_str_plain_has_location, tmp_assattr_name_2);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 1;
goto frame_exception_exit_1;
}
}
{
PyObject *tmp_assign_source_3;
tmp_assign_source_3 = Py_None;
UPDATE_STRING_DICT0(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain___cached__, tmp_assign_source_3);
}
{
PyObject *tmp_assign_source_4;
PyObject *tmp_import_name_from_1;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 1;
tmp_import_name_from_1 = PyImport_ImportModule("__future__");
assert(!(tmp_import_name_from_1 == NULL));
if (PyModule_Check(tmp_import_name_from_1)) {
tmp_assign_source_4 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_1,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_unicode_literals,
const_int_0
);
} else {
tmp_assign_source_4 = IMPORT_NAME(tmp_import_name_from_1, const_str_plain_unicode_literals);
}
if (tmp_assign_source_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 1;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_unicode_literals, tmp_assign_source_4);
}
{
PyObject *tmp_assign_source_5;
PyObject *tmp_name_name_1;
PyObject *tmp_globals_name_1;
PyObject *tmp_locals_name_1;
PyObject *tmp_fromlist_name_1;
PyObject *tmp_level_name_1;
tmp_name_name_1 = const_str_plain_functools;
tmp_globals_name_1 = (PyObject *)moduledict_youtube_dl$extractor$adobetv;
tmp_locals_name_1 = Py_None;
tmp_fromlist_name_1 = Py_None;
tmp_level_name_1 = const_int_0;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 3;
tmp_assign_source_5 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1);
if (tmp_assign_source_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 3;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_functools, tmp_assign_source_5);
}
{
PyObject *tmp_assign_source_6;
PyObject *tmp_name_name_2;
PyObject *tmp_globals_name_2;
PyObject *tmp_locals_name_2;
PyObject *tmp_fromlist_name_2;
PyObject *tmp_level_name_2;
tmp_name_name_2 = const_str_plain_re;
tmp_globals_name_2 = (PyObject *)moduledict_youtube_dl$extractor$adobetv;
tmp_locals_name_2 = Py_None;
tmp_fromlist_name_2 = Py_None;
tmp_level_name_2 = const_int_0;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 4;
tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_2, tmp_globals_name_2, tmp_locals_name_2, tmp_fromlist_name_2, tmp_level_name_2);
if (tmp_assign_source_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 4;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_re, tmp_assign_source_6);
}
{
PyObject *tmp_assign_source_7;
PyObject *tmp_import_name_from_2;
PyObject *tmp_name_name_3;
PyObject *tmp_globals_name_3;
PyObject *tmp_locals_name_3;
PyObject *tmp_fromlist_name_3;
PyObject *tmp_level_name_3;
tmp_name_name_3 = const_str_plain_common;
tmp_globals_name_3 = (PyObject *)moduledict_youtube_dl$extractor$adobetv;
tmp_locals_name_3 = Py_None;
tmp_fromlist_name_3 = const_tuple_str_plain_InfoExtractor_tuple;
tmp_level_name_3 = const_int_pos_1;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 6;
tmp_import_name_from_2 = IMPORT_MODULE5(tmp_name_name_3, tmp_globals_name_3, tmp_locals_name_3, tmp_fromlist_name_3, tmp_level_name_3);
if (tmp_import_name_from_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 6;
goto frame_exception_exit_1;
}
if (PyModule_Check(tmp_import_name_from_2)) {
tmp_assign_source_7 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_2,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_InfoExtractor,
const_int_pos_1
);
} else {
tmp_assign_source_7 = IMPORT_NAME(tmp_import_name_from_2, const_str_plain_InfoExtractor);
}
Py_DECREF(tmp_import_name_from_2);
if (tmp_assign_source_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 6;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_InfoExtractor, tmp_assign_source_7);
}
{
PyObject *tmp_assign_source_8;
PyObject *tmp_import_name_from_3;
PyObject *tmp_name_name_4;
PyObject *tmp_globals_name_4;
PyObject *tmp_locals_name_4;
PyObject *tmp_fromlist_name_4;
PyObject *tmp_level_name_4;
tmp_name_name_4 = const_str_plain_compat;
tmp_globals_name_4 = (PyObject *)moduledict_youtube_dl$extractor$adobetv;
tmp_locals_name_4 = Py_None;
tmp_fromlist_name_4 = const_tuple_str_plain_compat_str_tuple;
tmp_level_name_4 = const_int_pos_2;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 7;
tmp_import_name_from_3 = IMPORT_MODULE5(tmp_name_name_4, tmp_globals_name_4, tmp_locals_name_4, tmp_fromlist_name_4, tmp_level_name_4);
if (tmp_import_name_from_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 7;
goto frame_exception_exit_1;
}
if (PyModule_Check(tmp_import_name_from_3)) {
tmp_assign_source_8 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_3,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_compat_str,
const_int_pos_2
);
} else {
tmp_assign_source_8 = IMPORT_NAME(tmp_import_name_from_3, const_str_plain_compat_str);
}
Py_DECREF(tmp_import_name_from_3);
if (tmp_assign_source_8 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 7;
goto frame_exception_exit_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_compat_str, tmp_assign_source_8);
}
{
PyObject *tmp_assign_source_9;
PyObject *tmp_name_name_5;
PyObject *tmp_globals_name_5;
PyObject *tmp_locals_name_5;
PyObject *tmp_fromlist_name_5;
PyObject *tmp_level_name_5;
tmp_name_name_5 = const_str_plain_utils;
tmp_globals_name_5 = (PyObject *)moduledict_youtube_dl$extractor$adobetv;
tmp_locals_name_5 = Py_None;
tmp_fromlist_name_5 = const_tuple_f3beab08810b5f3093f7d3dba38214fb_tuple;
tmp_level_name_5 = const_int_pos_2;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 8;
tmp_assign_source_9 = IMPORT_MODULE5(tmp_name_name_5, tmp_globals_name_5, tmp_locals_name_5, tmp_fromlist_name_5, tmp_level_name_5);
if (tmp_assign_source_9 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto frame_exception_exit_1;
}
assert(tmp_import_from_1__module == NULL);
tmp_import_from_1__module = tmp_assign_source_9;
}
// Tried code:
{
PyObject *tmp_assign_source_10;
PyObject *tmp_import_name_from_4;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_4 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_4)) {
tmp_assign_source_10 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_4,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_float_or_none,
const_int_pos_2
);
} else {
tmp_assign_source_10 = IMPORT_NAME(tmp_import_name_from_4, const_str_plain_float_or_none);
}
if (tmp_assign_source_10 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_float_or_none, tmp_assign_source_10);
}
{
PyObject *tmp_assign_source_11;
PyObject *tmp_import_name_from_5;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_5 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_5)) {
tmp_assign_source_11 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_5,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_int_or_none,
const_int_pos_2
);
} else {
tmp_assign_source_11 = IMPORT_NAME(tmp_import_name_from_5, const_str_plain_int_or_none);
}
if (tmp_assign_source_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_int_or_none, tmp_assign_source_11);
}
{
PyObject *tmp_assign_source_12;
PyObject *tmp_import_name_from_6;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_6 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_6)) {
tmp_assign_source_12 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_6,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_ISO639Utils,
const_int_pos_2
);
} else {
tmp_assign_source_12 = IMPORT_NAME(tmp_import_name_from_6, const_str_plain_ISO639Utils);
}
if (tmp_assign_source_12 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_ISO639Utils, tmp_assign_source_12);
}
{
PyObject *tmp_assign_source_13;
PyObject *tmp_import_name_from_7;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_7 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_7)) {
tmp_assign_source_13 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_7,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_OnDemandPagedList,
const_int_pos_2
);
} else {
tmp_assign_source_13 = IMPORT_NAME(tmp_import_name_from_7, const_str_plain_OnDemandPagedList);
}
if (tmp_assign_source_13 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_OnDemandPagedList, tmp_assign_source_13);
}
{
PyObject *tmp_assign_source_14;
PyObject *tmp_import_name_from_8;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_8 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_8)) {
tmp_assign_source_14 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_8,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_parse_duration,
const_int_pos_2
);
} else {
tmp_assign_source_14 = IMPORT_NAME(tmp_import_name_from_8, const_str_plain_parse_duration);
}
if (tmp_assign_source_14 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_parse_duration, tmp_assign_source_14);
}
{
PyObject *tmp_assign_source_15;
PyObject *tmp_import_name_from_9;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_9 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_9)) {
tmp_assign_source_15 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_9,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_str_or_none,
const_int_pos_2
);
} else {
tmp_assign_source_15 = IMPORT_NAME(tmp_import_name_from_9, const_str_plain_str_or_none);
}
if (tmp_assign_source_15 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_str_or_none, tmp_assign_source_15);
}
{
PyObject *tmp_assign_source_16;
PyObject *tmp_import_name_from_10;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_10 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_10)) {
tmp_assign_source_16 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_10,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_str_to_int,
const_int_pos_2
);
} else {
tmp_assign_source_16 = IMPORT_NAME(tmp_import_name_from_10, const_str_plain_str_to_int);
}
if (tmp_assign_source_16 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_str_to_int, tmp_assign_source_16);
}
{
PyObject *tmp_assign_source_17;
PyObject *tmp_import_name_from_11;
CHECK_OBJECT(tmp_import_from_1__module);
tmp_import_name_from_11 = tmp_import_from_1__module;
if (PyModule_Check(tmp_import_name_from_11)) {
tmp_assign_source_17 = IMPORT_NAME_OR_MODULE(
tmp_import_name_from_11,
(PyObject *)moduledict_youtube_dl$extractor$adobetv,
const_str_plain_unified_strdate,
const_int_pos_2
);
} else {
tmp_assign_source_17 = IMPORT_NAME(tmp_import_name_from_11, const_str_plain_unified_strdate);
}
if (tmp_assign_source_17 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 8;
goto try_except_handler_1;
}
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_unified_strdate, tmp_assign_source_17);
}
goto try_end_1;
// Exception handler code:
try_except_handler_1:;
exception_keeper_type_1 = exception_type;
exception_keeper_value_1 = exception_value;
exception_keeper_tb_1 = exception_tb;
exception_keeper_lineno_1 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
CHECK_OBJECT(tmp_import_from_1__module);
Py_DECREF(tmp_import_from_1__module);
tmp_import_from_1__module = NULL;
// Re-raise.
exception_type = exception_keeper_type_1;
exception_value = exception_keeper_value_1;
exception_tb = exception_keeper_tb_1;
exception_lineno = exception_keeper_lineno_1;
goto frame_exception_exit_1;
// End of try:
try_end_1:;
CHECK_OBJECT(tmp_import_from_1__module);
Py_DECREF(tmp_import_from_1__module);
tmp_import_from_1__module = NULL;
// Tried code:
{
PyObject *tmp_assign_source_18;
PyObject *tmp_tuple_element_1;
PyObject *tmp_mvar_value_3;
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_InfoExtractor);
if (unlikely(tmp_mvar_value_3 == NULL)) {
tmp_mvar_value_3 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_InfoExtractor);
}
if (tmp_mvar_value_3 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 33651 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_tuple_element_1 = tmp_mvar_value_3;
tmp_assign_source_18 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_1);
PyTuple_SET_ITEM(tmp_assign_source_18, 0, tmp_tuple_element_1);
assert(tmp_class_creation_1__bases_orig == NULL);
tmp_class_creation_1__bases_orig = tmp_assign_source_18;
}
{
PyObject *tmp_assign_source_19;
PyObject *tmp_dircall_arg1_1;
CHECK_OBJECT(tmp_class_creation_1__bases_orig);
tmp_dircall_arg1_1 = tmp_class_creation_1__bases_orig;
Py_INCREF(tmp_dircall_arg1_1);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_1};
tmp_assign_source_19 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_19 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
assert(tmp_class_creation_1__bases == NULL);
tmp_class_creation_1__bases = tmp_assign_source_19;
}
{
PyObject *tmp_assign_source_20;
tmp_assign_source_20 = PyDict_New();
assert(tmp_class_creation_1__class_decl_dict == NULL);
tmp_class_creation_1__class_decl_dict = tmp_assign_source_20;
}
{
PyObject *tmp_assign_source_21;
PyObject *tmp_metaclass_name_1;
nuitka_bool tmp_condition_result_1;
PyObject *tmp_key_name_1;
PyObject *tmp_dict_name_1;
PyObject *tmp_dict_name_2;
PyObject *tmp_key_name_2;
nuitka_bool tmp_condition_result_2;
int tmp_truth_name_1;
PyObject *tmp_type_arg_1;
PyObject *tmp_expression_name_1;
PyObject *tmp_subscript_name_1;
PyObject *tmp_bases_name_1;
tmp_key_name_1 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_dict_name_1 = tmp_class_creation_1__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_1, tmp_key_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_condition_result_1 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
goto condexpr_true_1;
} else {
goto condexpr_false_1;
}
condexpr_true_1:;
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_dict_name_2 = tmp_class_creation_1__class_decl_dict;
tmp_key_name_2 = const_str_plain_metaclass;
tmp_metaclass_name_1 = DICT_GET_ITEM(tmp_dict_name_2, tmp_key_name_2);
if (tmp_metaclass_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
goto condexpr_end_1;
condexpr_false_1:;
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_truth_name_1 = CHECK_IF_TRUE(tmp_class_creation_1__bases);
if (tmp_truth_name_1 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_condition_result_2 = tmp_truth_name_1 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_2 == NUITKA_BOOL_TRUE) {
goto condexpr_true_2;
} else {
goto condexpr_false_2;
}
condexpr_true_2:;
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_expression_name_1 = tmp_class_creation_1__bases;
tmp_subscript_name_1 = const_int_0;
tmp_type_arg_1 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_1, tmp_subscript_name_1, 0);
if (tmp_type_arg_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_metaclass_name_1 = BUILTIN_TYPE1(tmp_type_arg_1);
Py_DECREF(tmp_type_arg_1);
if (tmp_metaclass_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
goto condexpr_end_2;
condexpr_false_2:;
tmp_metaclass_name_1 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_1);
condexpr_end_2:;
condexpr_end_1:;
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_bases_name_1 = tmp_class_creation_1__bases;
tmp_assign_source_21 = SELECT_METACLASS(tmp_metaclass_name_1, tmp_bases_name_1);
Py_DECREF(tmp_metaclass_name_1);
if (tmp_assign_source_21 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
assert(tmp_class_creation_1__metaclass == NULL);
tmp_class_creation_1__metaclass = tmp_assign_source_21;
}
{
nuitka_bool tmp_condition_result_3;
PyObject *tmp_key_name_3;
PyObject *tmp_dict_name_3;
tmp_key_name_3 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_dict_name_3 = tmp_class_creation_1__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_3, tmp_key_name_3);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_condition_result_3 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_3 == NUITKA_BOOL_TRUE) {
goto branch_yes_1;
} else {
goto branch_no_1;
}
}
branch_yes_1:;
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_1__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
branch_no_1:;
{
nuitka_bool tmp_condition_result_4;
PyObject *tmp_expression_name_2;
CHECK_OBJECT(tmp_class_creation_1__metaclass);
tmp_expression_name_2 = tmp_class_creation_1__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_2, const_str_plain___prepare__);
tmp_condition_result_4 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_4 == NUITKA_BOOL_TRUE) {
goto branch_yes_2;
} else {
goto branch_no_2;
}
}
branch_yes_2:;
{
PyObject *tmp_assign_source_22;
PyObject *tmp_called_name_1;
PyObject *tmp_expression_name_3;
PyObject *tmp_args_name_1;
PyObject *tmp_tuple_element_2;
PyObject *tmp_kw_name_1;
CHECK_OBJECT(tmp_class_creation_1__metaclass);
tmp_expression_name_3 = tmp_class_creation_1__metaclass;
tmp_called_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_3, const_str_plain___prepare__);
if (tmp_called_name_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_tuple_element_2 = const_str_plain_AdobeTVBaseIE;
tmp_args_name_1 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_2);
PyTuple_SET_ITEM(tmp_args_name_1, 0, tmp_tuple_element_2);
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_tuple_element_2 = tmp_class_creation_1__bases;
Py_INCREF(tmp_tuple_element_2);
PyTuple_SET_ITEM(tmp_args_name_1, 1, tmp_tuple_element_2);
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_kw_name_1 = tmp_class_creation_1__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 20;
tmp_assign_source_22 = CALL_FUNCTION(tmp_called_name_1, tmp_args_name_1, tmp_kw_name_1);
Py_DECREF(tmp_called_name_1);
Py_DECREF(tmp_args_name_1);
if (tmp_assign_source_22 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
assert(tmp_class_creation_1__prepared == NULL);
tmp_class_creation_1__prepared = tmp_assign_source_22;
}
{
nuitka_bool tmp_condition_result_5;
PyObject *tmp_operand_name_1;
PyObject *tmp_expression_name_4;
CHECK_OBJECT(tmp_class_creation_1__prepared);
tmp_expression_name_4 = tmp_class_creation_1__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_4, const_str_plain___getitem__);
tmp_operand_name_1 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_1);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_condition_result_5 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_5 == NUITKA_BOOL_TRUE) {
goto branch_yes_3;
} else {
goto branch_no_3;
}
}
branch_yes_3:;
{
PyObject *tmp_raise_type_1;
PyObject *tmp_raise_value_1;
PyObject *tmp_left_name_1;
PyObject *tmp_right_name_1;
PyObject *tmp_tuple_element_3;
PyObject *tmp_getattr_target_1;
PyObject *tmp_getattr_attr_1;
PyObject *tmp_getattr_default_1;
PyObject *tmp_expression_name_5;
PyObject *tmp_type_arg_2;
tmp_raise_type_1 = PyExc_TypeError;
tmp_left_name_1 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_1__metaclass);
tmp_getattr_target_1 = tmp_class_creation_1__metaclass;
tmp_getattr_attr_1 = const_str_plain___name__;
tmp_getattr_default_1 = const_str_angle_metaclass;
tmp_tuple_element_3 = BUILTIN_GETATTR(tmp_getattr_target_1, tmp_getattr_attr_1, tmp_getattr_default_1);
if (tmp_tuple_element_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
tmp_right_name_1 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_1, 0, tmp_tuple_element_3);
CHECK_OBJECT(tmp_class_creation_1__prepared);
tmp_type_arg_2 = tmp_class_creation_1__prepared;
tmp_expression_name_5 = BUILTIN_TYPE1(tmp_type_arg_2);
assert(!(tmp_expression_name_5 == NULL));
tmp_tuple_element_3 = LOOKUP_ATTRIBUTE(tmp_expression_name_5, const_str_plain___name__);
Py_DECREF(tmp_expression_name_5);
if (tmp_tuple_element_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_1);
exception_lineno = 20;
goto try_except_handler_2;
}
PyTuple_SET_ITEM(tmp_right_name_1, 1, tmp_tuple_element_3);
tmp_raise_value_1 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_1, tmp_right_name_1);
Py_DECREF(tmp_right_name_1);
if (tmp_raise_value_1 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_2;
}
exception_type = tmp_raise_type_1;
Py_INCREF(tmp_raise_type_1);
exception_value = tmp_raise_value_1;
exception_lineno = 20;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_2;
}
branch_no_3:;
goto branch_end_2;
branch_no_2:;
{
PyObject *tmp_assign_source_23;
tmp_assign_source_23 = PyDict_New();
assert(tmp_class_creation_1__prepared == NULL);
tmp_class_creation_1__prepared = tmp_assign_source_23;
}
branch_end_2:;
{
PyObject *tmp_assign_source_24;
{
PyObject *tmp_set_locals_1;
CHECK_OBJECT(tmp_class_creation_1__prepared);
tmp_set_locals_1 = tmp_class_creation_1__prepared;
locals_youtube_dl$extractor$adobetv_20 = tmp_set_locals_1;
Py_INCREF(tmp_set_locals_1);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_4;
}
tmp_dictset_value = const_str_plain_AdobeTVBaseIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_4;
}
if (isFrameUnusable(cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2)) {
Py_XDECREF(cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
#if _DEBUG_REFCOUNTS
if (cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2 = MAKE_FUNCTION_FRAME(codeobj_4a4db23877cf40d63d0d3cb611eabb3d, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2->m_type_description == NULL);
frame_4a4db23877cf40d63d0d3cb611eabb3d_2 = cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2;
// Push the new frame as the currently active one.
pushFrameStack(frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_4a4db23877cf40d63d0d3cb611eabb3d_2) == 2); // Frame stack
// Framed code:
{
PyObject *tmp_defaults_1;
tmp_defaults_1 = const_tuple_none_tuple;
Py_INCREF(tmp_defaults_1);
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_1__call_api(tmp_defaults_1);
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain__call_api, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 21;
type_description_2 = "o";
goto frame_exception_exit_2;
}
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_2__parse_subtitles();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain__parse_subtitles, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 26;
type_description_2 = "o";
goto frame_exception_exit_2;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_3__parse_video_data();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain__parse_video_data, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 39;
type_description_2 = "o";
goto frame_exception_exit_2;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_1;
frame_exception_exit_2:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_4a4db23877cf40d63d0d3cb611eabb3d_2, exception_lineno);
} else if (exception_tb->tb_frame != &frame_4a4db23877cf40d63d0d3cb611eabb3d_2->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_4a4db23877cf40d63d0d3cb611eabb3d_2, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_4a4db23877cf40d63d0d3cb611eabb3d_2,
type_description_2,
outline_0_var___class__
);
// Release cached frame.
if (frame_4a4db23877cf40d63d0d3cb611eabb3d_2 == cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
}
cache_frame_4a4db23877cf40d63d0d3cb611eabb3d_2 = NULL;
assertFrameObject(frame_4a4db23877cf40d63d0d3cb611eabb3d_2);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_1;
frame_no_exception_1:;
goto skip_nested_handling_1;
nested_frame_exit_1:;
goto try_except_handler_4;
skip_nested_handling_1:;
{
nuitka_bool tmp_condition_result_6;
PyObject *tmp_compexpr_left_1;
PyObject *tmp_compexpr_right_1;
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_compexpr_left_1 = tmp_class_creation_1__bases;
CHECK_OBJECT(tmp_class_creation_1__bases_orig);
tmp_compexpr_right_1 = tmp_class_creation_1__bases_orig;
tmp_condition_result_6 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_1, tmp_compexpr_right_1);
if (tmp_condition_result_6 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_4;
}
if (tmp_condition_result_6 == NUITKA_BOOL_TRUE) {
goto branch_yes_4;
} else {
goto branch_no_4;
}
}
branch_yes_4:;
CHECK_OBJECT(tmp_class_creation_1__bases_orig);
tmp_dictset_value = tmp_class_creation_1__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_20, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_4;
}
branch_no_4:;
{
PyObject *tmp_assign_source_25;
PyObject *tmp_called_name_2;
PyObject *tmp_args_name_2;
PyObject *tmp_tuple_element_4;
PyObject *tmp_kw_name_2;
CHECK_OBJECT(tmp_class_creation_1__metaclass);
tmp_called_name_2 = tmp_class_creation_1__metaclass;
tmp_tuple_element_4 = const_str_plain_AdobeTVBaseIE;
tmp_args_name_2 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_4);
PyTuple_SET_ITEM(tmp_args_name_2, 0, tmp_tuple_element_4);
CHECK_OBJECT(tmp_class_creation_1__bases);
tmp_tuple_element_4 = tmp_class_creation_1__bases;
Py_INCREF(tmp_tuple_element_4);
PyTuple_SET_ITEM(tmp_args_name_2, 1, tmp_tuple_element_4);
tmp_tuple_element_4 = locals_youtube_dl$extractor$adobetv_20;
Py_INCREF(tmp_tuple_element_4);
PyTuple_SET_ITEM(tmp_args_name_2, 2, tmp_tuple_element_4);
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
tmp_kw_name_2 = tmp_class_creation_1__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 20;
tmp_assign_source_25 = CALL_FUNCTION(tmp_called_name_2, tmp_args_name_2, tmp_kw_name_2);
Py_DECREF(tmp_args_name_2);
if (tmp_assign_source_25 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 20;
goto try_except_handler_4;
}
assert(outline_0_var___class__ == NULL);
outline_0_var___class__ = tmp_assign_source_25;
}
CHECK_OBJECT(outline_0_var___class__);
tmp_assign_source_24 = outline_0_var___class__;
Py_INCREF(tmp_assign_source_24);
goto try_return_handler_4;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_4:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_20);
locals_youtube_dl$extractor$adobetv_20 = NULL;
goto try_return_handler_3;
// Exception handler code:
try_except_handler_4:;
exception_keeper_type_2 = exception_type;
exception_keeper_value_2 = exception_value;
exception_keeper_tb_2 = exception_tb;
exception_keeper_lineno_2 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_20);
locals_youtube_dl$extractor$adobetv_20 = NULL;
// Re-raise.
exception_type = exception_keeper_type_2;
exception_value = exception_keeper_value_2;
exception_tb = exception_keeper_tb_2;
exception_lineno = exception_keeper_lineno_2;
goto try_except_handler_3;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_3:;
CHECK_OBJECT(outline_0_var___class__);
Py_DECREF(outline_0_var___class__);
outline_0_var___class__ = NULL;
goto outline_result_1;
// Exception handler code:
try_except_handler_3:;
exception_keeper_type_3 = exception_type;
exception_keeper_value_3 = exception_value;
exception_keeper_tb_3 = exception_tb;
exception_keeper_lineno_3 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_3;
exception_value = exception_keeper_value_3;
exception_tb = exception_keeper_tb_3;
exception_lineno = exception_keeper_lineno_3;
goto outline_exception_1;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_1:;
exception_lineno = 20;
goto try_except_handler_2;
outline_result_1:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE, tmp_assign_source_24);
}
goto try_end_2;
// Exception handler code:
try_except_handler_2:;
exception_keeper_type_4 = exception_type;
exception_keeper_value_4 = exception_value;
exception_keeper_tb_4 = exception_tb;
exception_keeper_lineno_4 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_1__bases_orig);
tmp_class_creation_1__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_1__bases);
tmp_class_creation_1__bases = NULL;
Py_XDECREF(tmp_class_creation_1__class_decl_dict);
tmp_class_creation_1__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_1__metaclass);
tmp_class_creation_1__metaclass = NULL;
Py_XDECREF(tmp_class_creation_1__prepared);
tmp_class_creation_1__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_4;
exception_value = exception_keeper_value_4;
exception_tb = exception_keeper_tb_4;
exception_lineno = exception_keeper_lineno_4;
goto frame_exception_exit_1;
// End of try:
try_end_2:;
CHECK_OBJECT(tmp_class_creation_1__bases_orig);
Py_DECREF(tmp_class_creation_1__bases_orig);
tmp_class_creation_1__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_1__bases);
Py_DECREF(tmp_class_creation_1__bases);
tmp_class_creation_1__bases = NULL;
CHECK_OBJECT(tmp_class_creation_1__class_decl_dict);
Py_DECREF(tmp_class_creation_1__class_decl_dict);
tmp_class_creation_1__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_1__metaclass);
Py_DECREF(tmp_class_creation_1__metaclass);
tmp_class_creation_1__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_1__prepared);
Py_DECREF(tmp_class_creation_1__prepared);
tmp_class_creation_1__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_26;
PyObject *tmp_tuple_element_5;
PyObject *tmp_mvar_value_4;
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
if (unlikely(tmp_mvar_value_4 == NULL)) {
tmp_mvar_value_4 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
}
if (tmp_mvar_value_4 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34504 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_tuple_element_5 = tmp_mvar_value_4;
tmp_assign_source_26 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_5);
PyTuple_SET_ITEM(tmp_assign_source_26, 0, tmp_tuple_element_5);
assert(tmp_class_creation_2__bases_orig == NULL);
tmp_class_creation_2__bases_orig = tmp_assign_source_26;
}
{
PyObject *tmp_assign_source_27;
PyObject *tmp_dircall_arg1_2;
CHECK_OBJECT(tmp_class_creation_2__bases_orig);
tmp_dircall_arg1_2 = tmp_class_creation_2__bases_orig;
Py_INCREF(tmp_dircall_arg1_2);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_2};
tmp_assign_source_27 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_27 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
assert(tmp_class_creation_2__bases == NULL);
tmp_class_creation_2__bases = tmp_assign_source_27;
}
{
PyObject *tmp_assign_source_28;
tmp_assign_source_28 = PyDict_New();
assert(tmp_class_creation_2__class_decl_dict == NULL);
tmp_class_creation_2__class_decl_dict = tmp_assign_source_28;
}
{
PyObject *tmp_assign_source_29;
PyObject *tmp_metaclass_name_2;
nuitka_bool tmp_condition_result_7;
PyObject *tmp_key_name_4;
PyObject *tmp_dict_name_4;
PyObject *tmp_dict_name_5;
PyObject *tmp_key_name_5;
nuitka_bool tmp_condition_result_8;
int tmp_truth_name_2;
PyObject *tmp_type_arg_3;
PyObject *tmp_expression_name_6;
PyObject *tmp_subscript_name_2;
PyObject *tmp_bases_name_2;
tmp_key_name_4 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_dict_name_4 = tmp_class_creation_2__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_4, tmp_key_name_4);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_condition_result_7 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_7 == NUITKA_BOOL_TRUE) {
goto condexpr_true_3;
} else {
goto condexpr_false_3;
}
condexpr_true_3:;
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_dict_name_5 = tmp_class_creation_2__class_decl_dict;
tmp_key_name_5 = const_str_plain_metaclass;
tmp_metaclass_name_2 = DICT_GET_ITEM(tmp_dict_name_5, tmp_key_name_5);
if (tmp_metaclass_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
goto condexpr_end_3;
condexpr_false_3:;
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_truth_name_2 = CHECK_IF_TRUE(tmp_class_creation_2__bases);
if (tmp_truth_name_2 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_condition_result_8 = tmp_truth_name_2 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_8 == NUITKA_BOOL_TRUE) {
goto condexpr_true_4;
} else {
goto condexpr_false_4;
}
condexpr_true_4:;
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_expression_name_6 = tmp_class_creation_2__bases;
tmp_subscript_name_2 = const_int_0;
tmp_type_arg_3 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_6, tmp_subscript_name_2, 0);
if (tmp_type_arg_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_metaclass_name_2 = BUILTIN_TYPE1(tmp_type_arg_3);
Py_DECREF(tmp_type_arg_3);
if (tmp_metaclass_name_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
goto condexpr_end_4;
condexpr_false_4:;
tmp_metaclass_name_2 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_2);
condexpr_end_4:;
condexpr_end_3:;
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_bases_name_2 = tmp_class_creation_2__bases;
tmp_assign_source_29 = SELECT_METACLASS(tmp_metaclass_name_2, tmp_bases_name_2);
Py_DECREF(tmp_metaclass_name_2);
if (tmp_assign_source_29 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
assert(tmp_class_creation_2__metaclass == NULL);
tmp_class_creation_2__metaclass = tmp_assign_source_29;
}
{
nuitka_bool tmp_condition_result_9;
PyObject *tmp_key_name_6;
PyObject *tmp_dict_name_6;
tmp_key_name_6 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_dict_name_6 = tmp_class_creation_2__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_6, tmp_key_name_6);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_condition_result_9 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_9 == NUITKA_BOOL_TRUE) {
goto branch_yes_5;
} else {
goto branch_no_5;
}
}
branch_yes_5:;
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_2__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
branch_no_5:;
{
nuitka_bool tmp_condition_result_10;
PyObject *tmp_expression_name_7;
CHECK_OBJECT(tmp_class_creation_2__metaclass);
tmp_expression_name_7 = tmp_class_creation_2__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_7, const_str_plain___prepare__);
tmp_condition_result_10 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_10 == NUITKA_BOOL_TRUE) {
goto branch_yes_6;
} else {
goto branch_no_6;
}
}
branch_yes_6:;
{
PyObject *tmp_assign_source_30;
PyObject *tmp_called_name_3;
PyObject *tmp_expression_name_8;
PyObject *tmp_args_name_3;
PyObject *tmp_tuple_element_6;
PyObject *tmp_kw_name_3;
CHECK_OBJECT(tmp_class_creation_2__metaclass);
tmp_expression_name_8 = tmp_class_creation_2__metaclass;
tmp_called_name_3 = LOOKUP_ATTRIBUTE(tmp_expression_name_8, const_str_plain___prepare__);
if (tmp_called_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_tuple_element_6 = const_str_plain_AdobeTVEmbedIE;
tmp_args_name_3 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_6);
PyTuple_SET_ITEM(tmp_args_name_3, 0, tmp_tuple_element_6);
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_tuple_element_6 = tmp_class_creation_2__bases;
Py_INCREF(tmp_tuple_element_6);
PyTuple_SET_ITEM(tmp_args_name_3, 1, tmp_tuple_element_6);
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_kw_name_3 = tmp_class_creation_2__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 89;
tmp_assign_source_30 = CALL_FUNCTION(tmp_called_name_3, tmp_args_name_3, tmp_kw_name_3);
Py_DECREF(tmp_called_name_3);
Py_DECREF(tmp_args_name_3);
if (tmp_assign_source_30 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
assert(tmp_class_creation_2__prepared == NULL);
tmp_class_creation_2__prepared = tmp_assign_source_30;
}
{
nuitka_bool tmp_condition_result_11;
PyObject *tmp_operand_name_2;
PyObject *tmp_expression_name_9;
CHECK_OBJECT(tmp_class_creation_2__prepared);
tmp_expression_name_9 = tmp_class_creation_2__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_9, const_str_plain___getitem__);
tmp_operand_name_2 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_2);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_condition_result_11 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_11 == NUITKA_BOOL_TRUE) {
goto branch_yes_7;
} else {
goto branch_no_7;
}
}
branch_yes_7:;
{
PyObject *tmp_raise_type_2;
PyObject *tmp_raise_value_2;
PyObject *tmp_left_name_2;
PyObject *tmp_right_name_2;
PyObject *tmp_tuple_element_7;
PyObject *tmp_getattr_target_2;
PyObject *tmp_getattr_attr_2;
PyObject *tmp_getattr_default_2;
PyObject *tmp_expression_name_10;
PyObject *tmp_type_arg_4;
tmp_raise_type_2 = PyExc_TypeError;
tmp_left_name_2 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_2__metaclass);
tmp_getattr_target_2 = tmp_class_creation_2__metaclass;
tmp_getattr_attr_2 = const_str_plain___name__;
tmp_getattr_default_2 = const_str_angle_metaclass;
tmp_tuple_element_7 = BUILTIN_GETATTR(tmp_getattr_target_2, tmp_getattr_attr_2, tmp_getattr_default_2);
if (tmp_tuple_element_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
tmp_right_name_2 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_2, 0, tmp_tuple_element_7);
CHECK_OBJECT(tmp_class_creation_2__prepared);
tmp_type_arg_4 = tmp_class_creation_2__prepared;
tmp_expression_name_10 = BUILTIN_TYPE1(tmp_type_arg_4);
assert(!(tmp_expression_name_10 == NULL));
tmp_tuple_element_7 = LOOKUP_ATTRIBUTE(tmp_expression_name_10, const_str_plain___name__);
Py_DECREF(tmp_expression_name_10);
if (tmp_tuple_element_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_2);
exception_lineno = 89;
goto try_except_handler_5;
}
PyTuple_SET_ITEM(tmp_right_name_2, 1, tmp_tuple_element_7);
tmp_raise_value_2 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_2, tmp_right_name_2);
Py_DECREF(tmp_right_name_2);
if (tmp_raise_value_2 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_5;
}
exception_type = tmp_raise_type_2;
Py_INCREF(tmp_raise_type_2);
exception_value = tmp_raise_value_2;
exception_lineno = 89;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_5;
}
branch_no_7:;
goto branch_end_6;
branch_no_6:;
{
PyObject *tmp_assign_source_31;
tmp_assign_source_31 = PyDict_New();
assert(tmp_class_creation_2__prepared == NULL);
tmp_class_creation_2__prepared = tmp_assign_source_31;
}
branch_end_6:;
{
PyObject *tmp_assign_source_32;
{
PyObject *tmp_set_locals_2;
CHECK_OBJECT(tmp_class_creation_2__prepared);
tmp_set_locals_2 = tmp_class_creation_2__prepared;
locals_youtube_dl$extractor$adobetv_89 = tmp_set_locals_2;
Py_INCREF(tmp_set_locals_2);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_7;
}
tmp_dictset_value = const_str_plain_AdobeTVEmbedIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_7;
}
if (isFrameUnusable(cache_frame_1dd224ed6723050f9a702890ebe89e97_3)) {
Py_XDECREF(cache_frame_1dd224ed6723050f9a702890ebe89e97_3);
#if _DEBUG_REFCOUNTS
if (cache_frame_1dd224ed6723050f9a702890ebe89e97_3 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_1dd224ed6723050f9a702890ebe89e97_3 = MAKE_FUNCTION_FRAME(codeobj_1dd224ed6723050f9a702890ebe89e97, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_1dd224ed6723050f9a702890ebe89e97_3->m_type_description == NULL);
frame_1dd224ed6723050f9a702890ebe89e97_3 = cache_frame_1dd224ed6723050f9a702890ebe89e97_3;
// Push the new frame as the currently active one.
pushFrameStack(frame_1dd224ed6723050f9a702890ebe89e97_3);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_1dd224ed6723050f9a702890ebe89e97_3) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_str_digest_dc8fce64523d2f2ac46cff1514702e96;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain_IE_NAME, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 90;
type_description_2 = "o";
goto frame_exception_exit_3;
}
tmp_dictset_value = const_str_digest_bbdf4f5803fe97bbca4ce42b2c7b26e7;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain__VALID_URL, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 91;
type_description_2 = "o";
goto frame_exception_exit_3;
}
{
PyObject *tmp_dict_key_1;
PyObject *tmp_dict_value_1;
PyObject *tmp_dict_key_2;
PyObject *tmp_dict_value_2;
PyObject *tmp_dict_key_3;
PyObject *tmp_dict_value_3;
PyObject *tmp_dict_key_4;
PyObject *tmp_dict_value_4;
PyObject *tmp_dict_key_5;
PyObject *tmp_dict_value_5;
PyObject *tmp_dict_key_6;
PyObject *tmp_dict_value_6;
PyObject *tmp_dict_key_7;
PyObject *tmp_dict_value_7;
PyObject *tmp_dict_key_8;
PyObject *tmp_dict_value_8;
PyObject *tmp_dict_key_9;
PyObject *tmp_dict_value_9;
PyObject *tmp_dict_key_10;
PyObject *tmp_dict_value_10;
PyObject *tmp_dict_key_11;
PyObject *tmp_dict_value_11;
tmp_dict_key_1 = const_str_plain_url;
tmp_dict_value_1 = const_str_digest_17cf953d9bc335c17c4eed4828d884e3;
tmp_dictset_value = _PyDict_NewPresized( 3 );
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_1, tmp_dict_value_1);
assert(!(tmp_res != 0));
tmp_dict_key_2 = const_str_plain_md5;
tmp_dict_value_2 = const_str_plain_c8c0461bf04d54574fc2b4d07ac6783a;
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_2, tmp_dict_value_2);
assert(!(tmp_res != 0));
tmp_dict_key_3 = const_str_plain_info_dict;
tmp_dict_key_4 = const_str_plain_id;
tmp_dict_value_4 = const_str_plain_4153;
tmp_dict_value_3 = _PyDict_NewPresized( 8 );
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_4, tmp_dict_value_4);
assert(!(tmp_res != 0));
tmp_dict_key_5 = const_str_plain_ext;
tmp_dict_value_5 = const_str_plain_flv;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_5, tmp_dict_value_5);
assert(!(tmp_res != 0));
tmp_dict_key_6 = const_str_plain_title;
tmp_dict_value_6 = const_str_digest_66715feeb3ff88b52732448550a756a2;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_6, tmp_dict_value_6);
assert(!(tmp_res != 0));
tmp_dict_key_7 = const_str_plain_description;
tmp_dict_value_7 = const_str_digest_7d18b74465ea3ff7e3ed7caf5bd84aea;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_7, tmp_dict_value_7);
assert(!(tmp_res != 0));
tmp_dict_key_8 = const_str_plain_thumbnail;
tmp_dict_value_8 = const_str_digest_940c738501eab177474dd728fcc84769;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_8, tmp_dict_value_8);
assert(!(tmp_res != 0));
tmp_dict_key_9 = const_str_plain_upload_date;
tmp_dict_value_9 = const_str_plain_20091109;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_9, tmp_dict_value_9);
assert(!(tmp_res != 0));
tmp_dict_key_10 = const_str_plain_duration;
tmp_dict_value_10 = const_int_pos_377;
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_10, tmp_dict_value_10);
assert(!(tmp_res != 0));
tmp_dict_key_11 = const_str_plain_view_count;
tmp_dict_value_11 = PyObject_GetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain_int);
if (tmp_dict_value_11 == NULL) {
if (CHECK_AND_CLEAR_KEY_ERROR_OCCURRED()) {
tmp_dict_value_11 = (PyObject *)&PyLong_Type;
Py_INCREF(tmp_dict_value_11);
}
}
tmp_res = PyDict_SetItem(tmp_dict_value_3, tmp_dict_key_11, tmp_dict_value_11);
Py_DECREF(tmp_dict_value_11);
assert(!(tmp_res != 0));
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_3, tmp_dict_value_3);
Py_DECREF(tmp_dict_value_3);
assert(!(tmp_res != 0));
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain__TEST, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 92;
type_description_2 = "o";
goto frame_exception_exit_3;
}
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_4__real_extract();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain__real_extract, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 107;
type_description_2 = "o";
goto frame_exception_exit_3;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_1dd224ed6723050f9a702890ebe89e97_3);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_2;
frame_exception_exit_3:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_1dd224ed6723050f9a702890ebe89e97_3);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_1dd224ed6723050f9a702890ebe89e97_3, exception_lineno);
} else if (exception_tb->tb_frame != &frame_1dd224ed6723050f9a702890ebe89e97_3->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_1dd224ed6723050f9a702890ebe89e97_3, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_1dd224ed6723050f9a702890ebe89e97_3,
type_description_2,
outline_1_var___class__
);
// Release cached frame.
if (frame_1dd224ed6723050f9a702890ebe89e97_3 == cache_frame_1dd224ed6723050f9a702890ebe89e97_3) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_1dd224ed6723050f9a702890ebe89e97_3);
}
cache_frame_1dd224ed6723050f9a702890ebe89e97_3 = NULL;
assertFrameObject(frame_1dd224ed6723050f9a702890ebe89e97_3);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_2;
frame_no_exception_2:;
goto skip_nested_handling_2;
nested_frame_exit_2:;
goto try_except_handler_7;
skip_nested_handling_2:;
{
nuitka_bool tmp_condition_result_12;
PyObject *tmp_compexpr_left_2;
PyObject *tmp_compexpr_right_2;
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_compexpr_left_2 = tmp_class_creation_2__bases;
CHECK_OBJECT(tmp_class_creation_2__bases_orig);
tmp_compexpr_right_2 = tmp_class_creation_2__bases_orig;
tmp_condition_result_12 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_2, tmp_compexpr_right_2);
if (tmp_condition_result_12 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_7;
}
if (tmp_condition_result_12 == NUITKA_BOOL_TRUE) {
goto branch_yes_8;
} else {
goto branch_no_8;
}
}
branch_yes_8:;
CHECK_OBJECT(tmp_class_creation_2__bases_orig);
tmp_dictset_value = tmp_class_creation_2__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_89, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_7;
}
branch_no_8:;
{
PyObject *tmp_assign_source_33;
PyObject *tmp_called_name_4;
PyObject *tmp_args_name_4;
PyObject *tmp_tuple_element_8;
PyObject *tmp_kw_name_4;
CHECK_OBJECT(tmp_class_creation_2__metaclass);
tmp_called_name_4 = tmp_class_creation_2__metaclass;
tmp_tuple_element_8 = const_str_plain_AdobeTVEmbedIE;
tmp_args_name_4 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_8);
PyTuple_SET_ITEM(tmp_args_name_4, 0, tmp_tuple_element_8);
CHECK_OBJECT(tmp_class_creation_2__bases);
tmp_tuple_element_8 = tmp_class_creation_2__bases;
Py_INCREF(tmp_tuple_element_8);
PyTuple_SET_ITEM(tmp_args_name_4, 1, tmp_tuple_element_8);
tmp_tuple_element_8 = locals_youtube_dl$extractor$adobetv_89;
Py_INCREF(tmp_tuple_element_8);
PyTuple_SET_ITEM(tmp_args_name_4, 2, tmp_tuple_element_8);
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
tmp_kw_name_4 = tmp_class_creation_2__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 89;
tmp_assign_source_33 = CALL_FUNCTION(tmp_called_name_4, tmp_args_name_4, tmp_kw_name_4);
Py_DECREF(tmp_args_name_4);
if (tmp_assign_source_33 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 89;
goto try_except_handler_7;
}
assert(outline_1_var___class__ == NULL);
outline_1_var___class__ = tmp_assign_source_33;
}
CHECK_OBJECT(outline_1_var___class__);
tmp_assign_source_32 = outline_1_var___class__;
Py_INCREF(tmp_assign_source_32);
goto try_return_handler_7;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_7:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_89);
locals_youtube_dl$extractor$adobetv_89 = NULL;
goto try_return_handler_6;
// Exception handler code:
try_except_handler_7:;
exception_keeper_type_5 = exception_type;
exception_keeper_value_5 = exception_value;
exception_keeper_tb_5 = exception_tb;
exception_keeper_lineno_5 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_89);
locals_youtube_dl$extractor$adobetv_89 = NULL;
// Re-raise.
exception_type = exception_keeper_type_5;
exception_value = exception_keeper_value_5;
exception_tb = exception_keeper_tb_5;
exception_lineno = exception_keeper_lineno_5;
goto try_except_handler_6;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_6:;
CHECK_OBJECT(outline_1_var___class__);
Py_DECREF(outline_1_var___class__);
outline_1_var___class__ = NULL;
goto outline_result_2;
// Exception handler code:
try_except_handler_6:;
exception_keeper_type_6 = exception_type;
exception_keeper_value_6 = exception_value;
exception_keeper_tb_6 = exception_tb;
exception_keeper_lineno_6 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_6;
exception_value = exception_keeper_value_6;
exception_tb = exception_keeper_tb_6;
exception_lineno = exception_keeper_lineno_6;
goto outline_exception_2;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_2:;
exception_lineno = 89;
goto try_except_handler_5;
outline_result_2:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVEmbedIE, tmp_assign_source_32);
}
goto try_end_3;
// Exception handler code:
try_except_handler_5:;
exception_keeper_type_7 = exception_type;
exception_keeper_value_7 = exception_value;
exception_keeper_tb_7 = exception_tb;
exception_keeper_lineno_7 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_2__bases_orig);
tmp_class_creation_2__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_2__bases);
tmp_class_creation_2__bases = NULL;
Py_XDECREF(tmp_class_creation_2__class_decl_dict);
tmp_class_creation_2__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_2__metaclass);
tmp_class_creation_2__metaclass = NULL;
Py_XDECREF(tmp_class_creation_2__prepared);
tmp_class_creation_2__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_7;
exception_value = exception_keeper_value_7;
exception_tb = exception_keeper_tb_7;
exception_lineno = exception_keeper_lineno_7;
goto frame_exception_exit_1;
// End of try:
try_end_3:;
CHECK_OBJECT(tmp_class_creation_2__bases_orig);
Py_DECREF(tmp_class_creation_2__bases_orig);
tmp_class_creation_2__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_2__bases);
Py_DECREF(tmp_class_creation_2__bases);
tmp_class_creation_2__bases = NULL;
CHECK_OBJECT(tmp_class_creation_2__class_decl_dict);
Py_DECREF(tmp_class_creation_2__class_decl_dict);
tmp_class_creation_2__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_2__metaclass);
Py_DECREF(tmp_class_creation_2__metaclass);
tmp_class_creation_2__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_2__prepared);
Py_DECREF(tmp_class_creation_2__prepared);
tmp_class_creation_2__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_34;
PyObject *tmp_tuple_element_9;
PyObject *tmp_mvar_value_5;
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
if (unlikely(tmp_mvar_value_5 == NULL)) {
tmp_mvar_value_5 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
}
if (tmp_mvar_value_5 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34504 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_tuple_element_9 = tmp_mvar_value_5;
tmp_assign_source_34 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_9);
PyTuple_SET_ITEM(tmp_assign_source_34, 0, tmp_tuple_element_9);
assert(tmp_class_creation_3__bases_orig == NULL);
tmp_class_creation_3__bases_orig = tmp_assign_source_34;
}
{
PyObject *tmp_assign_source_35;
PyObject *tmp_dircall_arg1_3;
CHECK_OBJECT(tmp_class_creation_3__bases_orig);
tmp_dircall_arg1_3 = tmp_class_creation_3__bases_orig;
Py_INCREF(tmp_dircall_arg1_3);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_3};
tmp_assign_source_35 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_35 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
assert(tmp_class_creation_3__bases == NULL);
tmp_class_creation_3__bases = tmp_assign_source_35;
}
{
PyObject *tmp_assign_source_36;
tmp_assign_source_36 = PyDict_New();
assert(tmp_class_creation_3__class_decl_dict == NULL);
tmp_class_creation_3__class_decl_dict = tmp_assign_source_36;
}
{
PyObject *tmp_assign_source_37;
PyObject *tmp_metaclass_name_3;
nuitka_bool tmp_condition_result_13;
PyObject *tmp_key_name_7;
PyObject *tmp_dict_name_7;
PyObject *tmp_dict_name_8;
PyObject *tmp_key_name_8;
nuitka_bool tmp_condition_result_14;
int tmp_truth_name_3;
PyObject *tmp_type_arg_5;
PyObject *tmp_expression_name_11;
PyObject *tmp_subscript_name_3;
PyObject *tmp_bases_name_3;
tmp_key_name_7 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_dict_name_7 = tmp_class_creation_3__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_7, tmp_key_name_7);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_condition_result_13 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_13 == NUITKA_BOOL_TRUE) {
goto condexpr_true_5;
} else {
goto condexpr_false_5;
}
condexpr_true_5:;
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_dict_name_8 = tmp_class_creation_3__class_decl_dict;
tmp_key_name_8 = const_str_plain_metaclass;
tmp_metaclass_name_3 = DICT_GET_ITEM(tmp_dict_name_8, tmp_key_name_8);
if (tmp_metaclass_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
goto condexpr_end_5;
condexpr_false_5:;
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_truth_name_3 = CHECK_IF_TRUE(tmp_class_creation_3__bases);
if (tmp_truth_name_3 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_condition_result_14 = tmp_truth_name_3 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_14 == NUITKA_BOOL_TRUE) {
goto condexpr_true_6;
} else {
goto condexpr_false_6;
}
condexpr_true_6:;
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_expression_name_11 = tmp_class_creation_3__bases;
tmp_subscript_name_3 = const_int_0;
tmp_type_arg_5 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_11, tmp_subscript_name_3, 0);
if (tmp_type_arg_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_metaclass_name_3 = BUILTIN_TYPE1(tmp_type_arg_5);
Py_DECREF(tmp_type_arg_5);
if (tmp_metaclass_name_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
goto condexpr_end_6;
condexpr_false_6:;
tmp_metaclass_name_3 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_3);
condexpr_end_6:;
condexpr_end_5:;
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_bases_name_3 = tmp_class_creation_3__bases;
tmp_assign_source_37 = SELECT_METACLASS(tmp_metaclass_name_3, tmp_bases_name_3);
Py_DECREF(tmp_metaclass_name_3);
if (tmp_assign_source_37 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
assert(tmp_class_creation_3__metaclass == NULL);
tmp_class_creation_3__metaclass = tmp_assign_source_37;
}
{
nuitka_bool tmp_condition_result_15;
PyObject *tmp_key_name_9;
PyObject *tmp_dict_name_9;
tmp_key_name_9 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_dict_name_9 = tmp_class_creation_3__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_9, tmp_key_name_9);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_condition_result_15 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_15 == NUITKA_BOOL_TRUE) {
goto branch_yes_9;
} else {
goto branch_no_9;
}
}
branch_yes_9:;
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_3__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
branch_no_9:;
{
nuitka_bool tmp_condition_result_16;
PyObject *tmp_expression_name_12;
CHECK_OBJECT(tmp_class_creation_3__metaclass);
tmp_expression_name_12 = tmp_class_creation_3__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_12, const_str_plain___prepare__);
tmp_condition_result_16 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_16 == NUITKA_BOOL_TRUE) {
goto branch_yes_10;
} else {
goto branch_no_10;
}
}
branch_yes_10:;
{
PyObject *tmp_assign_source_38;
PyObject *tmp_called_name_5;
PyObject *tmp_expression_name_13;
PyObject *tmp_args_name_5;
PyObject *tmp_tuple_element_10;
PyObject *tmp_kw_name_5;
CHECK_OBJECT(tmp_class_creation_3__metaclass);
tmp_expression_name_13 = tmp_class_creation_3__metaclass;
tmp_called_name_5 = LOOKUP_ATTRIBUTE(tmp_expression_name_13, const_str_plain___prepare__);
if (tmp_called_name_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_tuple_element_10 = const_str_plain_AdobeTVIE;
tmp_args_name_5 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_10);
PyTuple_SET_ITEM(tmp_args_name_5, 0, tmp_tuple_element_10);
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_tuple_element_10 = tmp_class_creation_3__bases;
Py_INCREF(tmp_tuple_element_10);
PyTuple_SET_ITEM(tmp_args_name_5, 1, tmp_tuple_element_10);
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_kw_name_5 = tmp_class_creation_3__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 115;
tmp_assign_source_38 = CALL_FUNCTION(tmp_called_name_5, tmp_args_name_5, tmp_kw_name_5);
Py_DECREF(tmp_called_name_5);
Py_DECREF(tmp_args_name_5);
if (tmp_assign_source_38 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
assert(tmp_class_creation_3__prepared == NULL);
tmp_class_creation_3__prepared = tmp_assign_source_38;
}
{
nuitka_bool tmp_condition_result_17;
PyObject *tmp_operand_name_3;
PyObject *tmp_expression_name_14;
CHECK_OBJECT(tmp_class_creation_3__prepared);
tmp_expression_name_14 = tmp_class_creation_3__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_14, const_str_plain___getitem__);
tmp_operand_name_3 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_3);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_condition_result_17 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_17 == NUITKA_BOOL_TRUE) {
goto branch_yes_11;
} else {
goto branch_no_11;
}
}
branch_yes_11:;
{
PyObject *tmp_raise_type_3;
PyObject *tmp_raise_value_3;
PyObject *tmp_left_name_3;
PyObject *tmp_right_name_3;
PyObject *tmp_tuple_element_11;
PyObject *tmp_getattr_target_3;
PyObject *tmp_getattr_attr_3;
PyObject *tmp_getattr_default_3;
PyObject *tmp_expression_name_15;
PyObject *tmp_type_arg_6;
tmp_raise_type_3 = PyExc_TypeError;
tmp_left_name_3 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_3__metaclass);
tmp_getattr_target_3 = tmp_class_creation_3__metaclass;
tmp_getattr_attr_3 = const_str_plain___name__;
tmp_getattr_default_3 = const_str_angle_metaclass;
tmp_tuple_element_11 = BUILTIN_GETATTR(tmp_getattr_target_3, tmp_getattr_attr_3, tmp_getattr_default_3);
if (tmp_tuple_element_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
tmp_right_name_3 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_3, 0, tmp_tuple_element_11);
CHECK_OBJECT(tmp_class_creation_3__prepared);
tmp_type_arg_6 = tmp_class_creation_3__prepared;
tmp_expression_name_15 = BUILTIN_TYPE1(tmp_type_arg_6);
assert(!(tmp_expression_name_15 == NULL));
tmp_tuple_element_11 = LOOKUP_ATTRIBUTE(tmp_expression_name_15, const_str_plain___name__);
Py_DECREF(tmp_expression_name_15);
if (tmp_tuple_element_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_3);
exception_lineno = 115;
goto try_except_handler_8;
}
PyTuple_SET_ITEM(tmp_right_name_3, 1, tmp_tuple_element_11);
tmp_raise_value_3 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_3, tmp_right_name_3);
Py_DECREF(tmp_right_name_3);
if (tmp_raise_value_3 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_8;
}
exception_type = tmp_raise_type_3;
Py_INCREF(tmp_raise_type_3);
exception_value = tmp_raise_value_3;
exception_lineno = 115;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_8;
}
branch_no_11:;
goto branch_end_10;
branch_no_10:;
{
PyObject *tmp_assign_source_39;
tmp_assign_source_39 = PyDict_New();
assert(tmp_class_creation_3__prepared == NULL);
tmp_class_creation_3__prepared = tmp_assign_source_39;
}
branch_end_10:;
{
PyObject *tmp_assign_source_40;
{
PyObject *tmp_set_locals_3;
CHECK_OBJECT(tmp_class_creation_3__prepared);
tmp_set_locals_3 = tmp_class_creation_3__prepared;
locals_youtube_dl$extractor$adobetv_115 = tmp_set_locals_3;
Py_INCREF(tmp_set_locals_3);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_10;
}
tmp_dictset_value = const_str_plain_AdobeTVIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_10;
}
if (isFrameUnusable(cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4)) {
Py_XDECREF(cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
#if _DEBUG_REFCOUNTS
if (cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4 = MAKE_FUNCTION_FRAME(codeobj_293fae0b1c87e3c29380ffc25da7ec0e, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4->m_type_description == NULL);
frame_293fae0b1c87e3c29380ffc25da7ec0e_4 = cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4;
// Push the new frame as the currently active one.
pushFrameStack(frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_293fae0b1c87e3c29380ffc25da7ec0e_4) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_str_plain_adobetv;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain_IE_NAME, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 116;
type_description_2 = "o";
goto frame_exception_exit_4;
}
tmp_dictset_value = const_str_digest_063577d419a945e3f6eb9d04ccb35781;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain__VALID_URL, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 117;
type_description_2 = "o";
goto frame_exception_exit_4;
}
{
PyObject *tmp_dict_key_12;
PyObject *tmp_dict_value_12;
PyObject *tmp_dict_key_13;
PyObject *tmp_dict_value_13;
PyObject *tmp_dict_key_14;
PyObject *tmp_dict_value_14;
PyObject *tmp_dict_key_15;
PyObject *tmp_dict_value_15;
PyObject *tmp_dict_key_16;
PyObject *tmp_dict_value_16;
PyObject *tmp_dict_key_17;
PyObject *tmp_dict_value_17;
PyObject *tmp_dict_key_18;
PyObject *tmp_dict_value_18;
PyObject *tmp_dict_key_19;
PyObject *tmp_dict_value_19;
PyObject *tmp_dict_key_20;
PyObject *tmp_dict_value_20;
PyObject *tmp_dict_key_21;
PyObject *tmp_dict_value_21;
PyObject *tmp_dict_key_22;
PyObject *tmp_dict_value_22;
tmp_dict_key_12 = const_str_plain_url;
tmp_dict_value_12 = const_str_digest_e66870d414502380d566e676d9cee231;
tmp_dictset_value = _PyDict_NewPresized( 3 );
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_12, tmp_dict_value_12);
assert(!(tmp_res != 0));
tmp_dict_key_13 = const_str_plain_md5;
tmp_dict_value_13 = const_str_plain_9bc5727bcdd55251f35ad311ca74fa1e;
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_13, tmp_dict_value_13);
assert(!(tmp_res != 0));
tmp_dict_key_14 = const_str_plain_info_dict;
tmp_dict_key_15 = const_str_plain_id;
tmp_dict_value_15 = const_str_plain_10981;
tmp_dict_value_14 = _PyDict_NewPresized( 8 );
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_15, tmp_dict_value_15);
assert(!(tmp_res != 0));
tmp_dict_key_16 = const_str_plain_ext;
tmp_dict_value_16 = const_str_plain_mp4;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_16, tmp_dict_value_16);
assert(!(tmp_res != 0));
tmp_dict_key_17 = const_str_plain_title;
tmp_dict_value_17 = const_str_digest_2b9936044cbd24bced3dd0cab61986af;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_17, tmp_dict_value_17);
assert(!(tmp_res != 0));
tmp_dict_key_18 = const_str_plain_description;
tmp_dict_value_18 = const_str_digest_be0726bace9f7b1b5af3d61e99668538;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_18, tmp_dict_value_18);
assert(!(tmp_res != 0));
tmp_dict_key_19 = const_str_plain_thumbnail;
tmp_dict_value_19 = const_str_digest_940c738501eab177474dd728fcc84769;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_19, tmp_dict_value_19);
assert(!(tmp_res != 0));
tmp_dict_key_20 = const_str_plain_upload_date;
tmp_dict_value_20 = const_str_plain_20110914;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_20, tmp_dict_value_20);
assert(!(tmp_res != 0));
tmp_dict_key_21 = const_str_plain_duration;
tmp_dict_value_21 = const_int_pos_60;
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_21, tmp_dict_value_21);
assert(!(tmp_res != 0));
tmp_dict_key_22 = const_str_plain_view_count;
tmp_dict_value_22 = PyObject_GetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain_int);
if (tmp_dict_value_22 == NULL) {
if (CHECK_AND_CLEAR_KEY_ERROR_OCCURRED()) {
tmp_dict_value_22 = (PyObject *)&PyLong_Type;
Py_INCREF(tmp_dict_value_22);
}
}
tmp_res = PyDict_SetItem(tmp_dict_value_14, tmp_dict_key_22, tmp_dict_value_22);
Py_DECREF(tmp_dict_value_22);
assert(!(tmp_res != 0));
tmp_res = PyDict_SetItem(tmp_dictset_value, tmp_dict_key_14, tmp_dict_value_14);
Py_DECREF(tmp_dict_value_14);
assert(!(tmp_res != 0));
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain__TEST, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 119;
type_description_2 = "o";
goto frame_exception_exit_4;
}
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_5__real_extract();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain__real_extract, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 134;
type_description_2 = "o";
goto frame_exception_exit_4;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_3;
frame_exception_exit_4:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_293fae0b1c87e3c29380ffc25da7ec0e_4, exception_lineno);
} else if (exception_tb->tb_frame != &frame_293fae0b1c87e3c29380ffc25da7ec0e_4->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_293fae0b1c87e3c29380ffc25da7ec0e_4, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_293fae0b1c87e3c29380ffc25da7ec0e_4,
type_description_2,
outline_2_var___class__
);
// Release cached frame.
if (frame_293fae0b1c87e3c29380ffc25da7ec0e_4 == cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
}
cache_frame_293fae0b1c87e3c29380ffc25da7ec0e_4 = NULL;
assertFrameObject(frame_293fae0b1c87e3c29380ffc25da7ec0e_4);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_3;
frame_no_exception_3:;
goto skip_nested_handling_3;
nested_frame_exit_3:;
goto try_except_handler_10;
skip_nested_handling_3:;
{
nuitka_bool tmp_condition_result_18;
PyObject *tmp_compexpr_left_3;
PyObject *tmp_compexpr_right_3;
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_compexpr_left_3 = tmp_class_creation_3__bases;
CHECK_OBJECT(tmp_class_creation_3__bases_orig);
tmp_compexpr_right_3 = tmp_class_creation_3__bases_orig;
tmp_condition_result_18 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_3, tmp_compexpr_right_3);
if (tmp_condition_result_18 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_10;
}
if (tmp_condition_result_18 == NUITKA_BOOL_TRUE) {
goto branch_yes_12;
} else {
goto branch_no_12;
}
}
branch_yes_12:;
CHECK_OBJECT(tmp_class_creation_3__bases_orig);
tmp_dictset_value = tmp_class_creation_3__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_115, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_10;
}
branch_no_12:;
{
PyObject *tmp_assign_source_41;
PyObject *tmp_called_name_6;
PyObject *tmp_args_name_6;
PyObject *tmp_tuple_element_12;
PyObject *tmp_kw_name_6;
CHECK_OBJECT(tmp_class_creation_3__metaclass);
tmp_called_name_6 = tmp_class_creation_3__metaclass;
tmp_tuple_element_12 = const_str_plain_AdobeTVIE;
tmp_args_name_6 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_12);
PyTuple_SET_ITEM(tmp_args_name_6, 0, tmp_tuple_element_12);
CHECK_OBJECT(tmp_class_creation_3__bases);
tmp_tuple_element_12 = tmp_class_creation_3__bases;
Py_INCREF(tmp_tuple_element_12);
PyTuple_SET_ITEM(tmp_args_name_6, 1, tmp_tuple_element_12);
tmp_tuple_element_12 = locals_youtube_dl$extractor$adobetv_115;
Py_INCREF(tmp_tuple_element_12);
PyTuple_SET_ITEM(tmp_args_name_6, 2, tmp_tuple_element_12);
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
tmp_kw_name_6 = tmp_class_creation_3__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 115;
tmp_assign_source_41 = CALL_FUNCTION(tmp_called_name_6, tmp_args_name_6, tmp_kw_name_6);
Py_DECREF(tmp_args_name_6);
if (tmp_assign_source_41 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 115;
goto try_except_handler_10;
}
assert(outline_2_var___class__ == NULL);
outline_2_var___class__ = tmp_assign_source_41;
}
CHECK_OBJECT(outline_2_var___class__);
tmp_assign_source_40 = outline_2_var___class__;
Py_INCREF(tmp_assign_source_40);
goto try_return_handler_10;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_10:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_115);
locals_youtube_dl$extractor$adobetv_115 = NULL;
goto try_return_handler_9;
// Exception handler code:
try_except_handler_10:;
exception_keeper_type_8 = exception_type;
exception_keeper_value_8 = exception_value;
exception_keeper_tb_8 = exception_tb;
exception_keeper_lineno_8 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_115);
locals_youtube_dl$extractor$adobetv_115 = NULL;
// Re-raise.
exception_type = exception_keeper_type_8;
exception_value = exception_keeper_value_8;
exception_tb = exception_keeper_tb_8;
exception_lineno = exception_keeper_lineno_8;
goto try_except_handler_9;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_9:;
CHECK_OBJECT(outline_2_var___class__);
Py_DECREF(outline_2_var___class__);
outline_2_var___class__ = NULL;
goto outline_result_3;
// Exception handler code:
try_except_handler_9:;
exception_keeper_type_9 = exception_type;
exception_keeper_value_9 = exception_value;
exception_keeper_tb_9 = exception_tb;
exception_keeper_lineno_9 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_9;
exception_value = exception_keeper_value_9;
exception_tb = exception_keeper_tb_9;
exception_lineno = exception_keeper_lineno_9;
goto outline_exception_3;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_3:;
exception_lineno = 115;
goto try_except_handler_8;
outline_result_3:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVIE, tmp_assign_source_40);
}
goto try_end_4;
// Exception handler code:
try_except_handler_8:;
exception_keeper_type_10 = exception_type;
exception_keeper_value_10 = exception_value;
exception_keeper_tb_10 = exception_tb;
exception_keeper_lineno_10 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_3__bases_orig);
tmp_class_creation_3__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_3__bases);
tmp_class_creation_3__bases = NULL;
Py_XDECREF(tmp_class_creation_3__class_decl_dict);
tmp_class_creation_3__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_3__metaclass);
tmp_class_creation_3__metaclass = NULL;
Py_XDECREF(tmp_class_creation_3__prepared);
tmp_class_creation_3__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_10;
exception_value = exception_keeper_value_10;
exception_tb = exception_keeper_tb_10;
exception_lineno = exception_keeper_lineno_10;
goto frame_exception_exit_1;
// End of try:
try_end_4:;
CHECK_OBJECT(tmp_class_creation_3__bases_orig);
Py_DECREF(tmp_class_creation_3__bases_orig);
tmp_class_creation_3__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_3__bases);
Py_DECREF(tmp_class_creation_3__bases);
tmp_class_creation_3__bases = NULL;
CHECK_OBJECT(tmp_class_creation_3__class_decl_dict);
Py_DECREF(tmp_class_creation_3__class_decl_dict);
tmp_class_creation_3__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_3__metaclass);
Py_DECREF(tmp_class_creation_3__metaclass);
tmp_class_creation_3__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_3__prepared);
Py_DECREF(tmp_class_creation_3__prepared);
tmp_class_creation_3__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_42;
PyObject *tmp_tuple_element_13;
PyObject *tmp_mvar_value_6;
tmp_mvar_value_6 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
if (unlikely(tmp_mvar_value_6 == NULL)) {
tmp_mvar_value_6 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
}
if (tmp_mvar_value_6 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34504 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_tuple_element_13 = tmp_mvar_value_6;
tmp_assign_source_42 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_13);
PyTuple_SET_ITEM(tmp_assign_source_42, 0, tmp_tuple_element_13);
assert(tmp_class_creation_4__bases_orig == NULL);
tmp_class_creation_4__bases_orig = tmp_assign_source_42;
}
{
PyObject *tmp_assign_source_43;
PyObject *tmp_dircall_arg1_4;
CHECK_OBJECT(tmp_class_creation_4__bases_orig);
tmp_dircall_arg1_4 = tmp_class_creation_4__bases_orig;
Py_INCREF(tmp_dircall_arg1_4);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_4};
tmp_assign_source_43 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_43 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
assert(tmp_class_creation_4__bases == NULL);
tmp_class_creation_4__bases = tmp_assign_source_43;
}
{
PyObject *tmp_assign_source_44;
tmp_assign_source_44 = PyDict_New();
assert(tmp_class_creation_4__class_decl_dict == NULL);
tmp_class_creation_4__class_decl_dict = tmp_assign_source_44;
}
{
PyObject *tmp_assign_source_45;
PyObject *tmp_metaclass_name_4;
nuitka_bool tmp_condition_result_19;
PyObject *tmp_key_name_10;
PyObject *tmp_dict_name_10;
PyObject *tmp_dict_name_11;
PyObject *tmp_key_name_11;
nuitka_bool tmp_condition_result_20;
int tmp_truth_name_4;
PyObject *tmp_type_arg_7;
PyObject *tmp_expression_name_16;
PyObject *tmp_subscript_name_4;
PyObject *tmp_bases_name_4;
tmp_key_name_10 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_dict_name_10 = tmp_class_creation_4__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_10, tmp_key_name_10);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_condition_result_19 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_19 == NUITKA_BOOL_TRUE) {
goto condexpr_true_7;
} else {
goto condexpr_false_7;
}
condexpr_true_7:;
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_dict_name_11 = tmp_class_creation_4__class_decl_dict;
tmp_key_name_11 = const_str_plain_metaclass;
tmp_metaclass_name_4 = DICT_GET_ITEM(tmp_dict_name_11, tmp_key_name_11);
if (tmp_metaclass_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
goto condexpr_end_7;
condexpr_false_7:;
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_truth_name_4 = CHECK_IF_TRUE(tmp_class_creation_4__bases);
if (tmp_truth_name_4 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_condition_result_20 = tmp_truth_name_4 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_20 == NUITKA_BOOL_TRUE) {
goto condexpr_true_8;
} else {
goto condexpr_false_8;
}
condexpr_true_8:;
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_expression_name_16 = tmp_class_creation_4__bases;
tmp_subscript_name_4 = const_int_0;
tmp_type_arg_7 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_16, tmp_subscript_name_4, 0);
if (tmp_type_arg_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_metaclass_name_4 = BUILTIN_TYPE1(tmp_type_arg_7);
Py_DECREF(tmp_type_arg_7);
if (tmp_metaclass_name_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
goto condexpr_end_8;
condexpr_false_8:;
tmp_metaclass_name_4 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_4);
condexpr_end_8:;
condexpr_end_7:;
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_bases_name_4 = tmp_class_creation_4__bases;
tmp_assign_source_45 = SELECT_METACLASS(tmp_metaclass_name_4, tmp_bases_name_4);
Py_DECREF(tmp_metaclass_name_4);
if (tmp_assign_source_45 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
assert(tmp_class_creation_4__metaclass == NULL);
tmp_class_creation_4__metaclass = tmp_assign_source_45;
}
{
nuitka_bool tmp_condition_result_21;
PyObject *tmp_key_name_12;
PyObject *tmp_dict_name_12;
tmp_key_name_12 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_dict_name_12 = tmp_class_creation_4__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_12, tmp_key_name_12);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_condition_result_21 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_21 == NUITKA_BOOL_TRUE) {
goto branch_yes_13;
} else {
goto branch_no_13;
}
}
branch_yes_13:;
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_4__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
branch_no_13:;
{
nuitka_bool tmp_condition_result_22;
PyObject *tmp_expression_name_17;
CHECK_OBJECT(tmp_class_creation_4__metaclass);
tmp_expression_name_17 = tmp_class_creation_4__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_17, const_str_plain___prepare__);
tmp_condition_result_22 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_22 == NUITKA_BOOL_TRUE) {
goto branch_yes_14;
} else {
goto branch_no_14;
}
}
branch_yes_14:;
{
PyObject *tmp_assign_source_46;
PyObject *tmp_called_name_7;
PyObject *tmp_expression_name_18;
PyObject *tmp_args_name_7;
PyObject *tmp_tuple_element_14;
PyObject *tmp_kw_name_7;
CHECK_OBJECT(tmp_class_creation_4__metaclass);
tmp_expression_name_18 = tmp_class_creation_4__metaclass;
tmp_called_name_7 = LOOKUP_ATTRIBUTE(tmp_expression_name_18, const_str_plain___prepare__);
if (tmp_called_name_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_tuple_element_14 = const_str_plain_AdobeTVPlaylistBaseIE;
tmp_args_name_7 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_14);
PyTuple_SET_ITEM(tmp_args_name_7, 0, tmp_tuple_element_14);
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_tuple_element_14 = tmp_class_creation_4__bases;
Py_INCREF(tmp_tuple_element_14);
PyTuple_SET_ITEM(tmp_args_name_7, 1, tmp_tuple_element_14);
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_kw_name_7 = tmp_class_creation_4__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 149;
tmp_assign_source_46 = CALL_FUNCTION(tmp_called_name_7, tmp_args_name_7, tmp_kw_name_7);
Py_DECREF(tmp_called_name_7);
Py_DECREF(tmp_args_name_7);
if (tmp_assign_source_46 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
assert(tmp_class_creation_4__prepared == NULL);
tmp_class_creation_4__prepared = tmp_assign_source_46;
}
{
nuitka_bool tmp_condition_result_23;
PyObject *tmp_operand_name_4;
PyObject *tmp_expression_name_19;
CHECK_OBJECT(tmp_class_creation_4__prepared);
tmp_expression_name_19 = tmp_class_creation_4__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_19, const_str_plain___getitem__);
tmp_operand_name_4 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_4);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_condition_result_23 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_23 == NUITKA_BOOL_TRUE) {
goto branch_yes_15;
} else {
goto branch_no_15;
}
}
branch_yes_15:;
{
PyObject *tmp_raise_type_4;
PyObject *tmp_raise_value_4;
PyObject *tmp_left_name_4;
PyObject *tmp_right_name_4;
PyObject *tmp_tuple_element_15;
PyObject *tmp_getattr_target_4;
PyObject *tmp_getattr_attr_4;
PyObject *tmp_getattr_default_4;
PyObject *tmp_expression_name_20;
PyObject *tmp_type_arg_8;
tmp_raise_type_4 = PyExc_TypeError;
tmp_left_name_4 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_4__metaclass);
tmp_getattr_target_4 = tmp_class_creation_4__metaclass;
tmp_getattr_attr_4 = const_str_plain___name__;
tmp_getattr_default_4 = const_str_angle_metaclass;
tmp_tuple_element_15 = BUILTIN_GETATTR(tmp_getattr_target_4, tmp_getattr_attr_4, tmp_getattr_default_4);
if (tmp_tuple_element_15 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
tmp_right_name_4 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_4, 0, tmp_tuple_element_15);
CHECK_OBJECT(tmp_class_creation_4__prepared);
tmp_type_arg_8 = tmp_class_creation_4__prepared;
tmp_expression_name_20 = BUILTIN_TYPE1(tmp_type_arg_8);
assert(!(tmp_expression_name_20 == NULL));
tmp_tuple_element_15 = LOOKUP_ATTRIBUTE(tmp_expression_name_20, const_str_plain___name__);
Py_DECREF(tmp_expression_name_20);
if (tmp_tuple_element_15 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_4);
exception_lineno = 149;
goto try_except_handler_11;
}
PyTuple_SET_ITEM(tmp_right_name_4, 1, tmp_tuple_element_15);
tmp_raise_value_4 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_4, tmp_right_name_4);
Py_DECREF(tmp_right_name_4);
if (tmp_raise_value_4 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_11;
}
exception_type = tmp_raise_type_4;
Py_INCREF(tmp_raise_type_4);
exception_value = tmp_raise_value_4;
exception_lineno = 149;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_11;
}
branch_no_15:;
goto branch_end_14;
branch_no_14:;
{
PyObject *tmp_assign_source_47;
tmp_assign_source_47 = PyDict_New();
assert(tmp_class_creation_4__prepared == NULL);
tmp_class_creation_4__prepared = tmp_assign_source_47;
}
branch_end_14:;
{
PyObject *tmp_assign_source_48;
{
PyObject *tmp_set_locals_4;
CHECK_OBJECT(tmp_class_creation_4__prepared);
tmp_set_locals_4 = tmp_class_creation_4__prepared;
locals_youtube_dl$extractor$adobetv_149 = tmp_set_locals_4;
Py_INCREF(tmp_set_locals_4);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_13;
}
tmp_dictset_value = const_str_plain_AdobeTVPlaylistBaseIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_13;
}
if (isFrameUnusable(cache_frame_74c7094b8228d0a8210cc04eb85c548d_5)) {
Py_XDECREF(cache_frame_74c7094b8228d0a8210cc04eb85c548d_5);
#if _DEBUG_REFCOUNTS
if (cache_frame_74c7094b8228d0a8210cc04eb85c548d_5 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_74c7094b8228d0a8210cc04eb85c548d_5 = MAKE_FUNCTION_FRAME(codeobj_74c7094b8228d0a8210cc04eb85c548d, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_74c7094b8228d0a8210cc04eb85c548d_5->m_type_description == NULL);
frame_74c7094b8228d0a8210cc04eb85c548d_5 = cache_frame_74c7094b8228d0a8210cc04eb85c548d_5;
// Push the new frame as the currently active one.
pushFrameStack(frame_74c7094b8228d0a8210cc04eb85c548d_5);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_74c7094b8228d0a8210cc04eb85c548d_5) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_int_pos_25;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain__PAGE_SIZE, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 150;
type_description_2 = "o";
goto frame_exception_exit_5;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_6__fetch_page();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain__fetch_page, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 152;
type_description_2 = "o";
goto frame_exception_exit_5;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_7__extract_playlist_entries();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain__extract_playlist_entries, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 159;
type_description_2 = "o";
goto frame_exception_exit_5;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_74c7094b8228d0a8210cc04eb85c548d_5);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_4;
frame_exception_exit_5:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_74c7094b8228d0a8210cc04eb85c548d_5);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_74c7094b8228d0a8210cc04eb85c548d_5, exception_lineno);
} else if (exception_tb->tb_frame != &frame_74c7094b8228d0a8210cc04eb85c548d_5->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_74c7094b8228d0a8210cc04eb85c548d_5, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_74c7094b8228d0a8210cc04eb85c548d_5,
type_description_2,
outline_3_var___class__
);
// Release cached frame.
if (frame_74c7094b8228d0a8210cc04eb85c548d_5 == cache_frame_74c7094b8228d0a8210cc04eb85c548d_5) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_74c7094b8228d0a8210cc04eb85c548d_5);
}
cache_frame_74c7094b8228d0a8210cc04eb85c548d_5 = NULL;
assertFrameObject(frame_74c7094b8228d0a8210cc04eb85c548d_5);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_4;
frame_no_exception_4:;
goto skip_nested_handling_4;
nested_frame_exit_4:;
goto try_except_handler_13;
skip_nested_handling_4:;
{
nuitka_bool tmp_condition_result_24;
PyObject *tmp_compexpr_left_4;
PyObject *tmp_compexpr_right_4;
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_compexpr_left_4 = tmp_class_creation_4__bases;
CHECK_OBJECT(tmp_class_creation_4__bases_orig);
tmp_compexpr_right_4 = tmp_class_creation_4__bases_orig;
tmp_condition_result_24 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_4, tmp_compexpr_right_4);
if (tmp_condition_result_24 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_13;
}
if (tmp_condition_result_24 == NUITKA_BOOL_TRUE) {
goto branch_yes_16;
} else {
goto branch_no_16;
}
}
branch_yes_16:;
CHECK_OBJECT(tmp_class_creation_4__bases_orig);
tmp_dictset_value = tmp_class_creation_4__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_149, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_13;
}
branch_no_16:;
{
PyObject *tmp_assign_source_49;
PyObject *tmp_called_name_8;
PyObject *tmp_args_name_8;
PyObject *tmp_tuple_element_16;
PyObject *tmp_kw_name_8;
CHECK_OBJECT(tmp_class_creation_4__metaclass);
tmp_called_name_8 = tmp_class_creation_4__metaclass;
tmp_tuple_element_16 = const_str_plain_AdobeTVPlaylistBaseIE;
tmp_args_name_8 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_16);
PyTuple_SET_ITEM(tmp_args_name_8, 0, tmp_tuple_element_16);
CHECK_OBJECT(tmp_class_creation_4__bases);
tmp_tuple_element_16 = tmp_class_creation_4__bases;
Py_INCREF(tmp_tuple_element_16);
PyTuple_SET_ITEM(tmp_args_name_8, 1, tmp_tuple_element_16);
tmp_tuple_element_16 = locals_youtube_dl$extractor$adobetv_149;
Py_INCREF(tmp_tuple_element_16);
PyTuple_SET_ITEM(tmp_args_name_8, 2, tmp_tuple_element_16);
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
tmp_kw_name_8 = tmp_class_creation_4__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 149;
tmp_assign_source_49 = CALL_FUNCTION(tmp_called_name_8, tmp_args_name_8, tmp_kw_name_8);
Py_DECREF(tmp_args_name_8);
if (tmp_assign_source_49 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 149;
goto try_except_handler_13;
}
assert(outline_3_var___class__ == NULL);
outline_3_var___class__ = tmp_assign_source_49;
}
CHECK_OBJECT(outline_3_var___class__);
tmp_assign_source_48 = outline_3_var___class__;
Py_INCREF(tmp_assign_source_48);
goto try_return_handler_13;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_13:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_149);
locals_youtube_dl$extractor$adobetv_149 = NULL;
goto try_return_handler_12;
// Exception handler code:
try_except_handler_13:;
exception_keeper_type_11 = exception_type;
exception_keeper_value_11 = exception_value;
exception_keeper_tb_11 = exception_tb;
exception_keeper_lineno_11 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_149);
locals_youtube_dl$extractor$adobetv_149 = NULL;
// Re-raise.
exception_type = exception_keeper_type_11;
exception_value = exception_keeper_value_11;
exception_tb = exception_keeper_tb_11;
exception_lineno = exception_keeper_lineno_11;
goto try_except_handler_12;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_12:;
CHECK_OBJECT(outline_3_var___class__);
Py_DECREF(outline_3_var___class__);
outline_3_var___class__ = NULL;
goto outline_result_4;
// Exception handler code:
try_except_handler_12:;
exception_keeper_type_12 = exception_type;
exception_keeper_value_12 = exception_value;
exception_keeper_tb_12 = exception_tb;
exception_keeper_lineno_12 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_12;
exception_value = exception_keeper_value_12;
exception_tb = exception_keeper_tb_12;
exception_lineno = exception_keeper_lineno_12;
goto outline_exception_4;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_4:;
exception_lineno = 149;
goto try_except_handler_11;
outline_result_4:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVPlaylistBaseIE, tmp_assign_source_48);
}
goto try_end_5;
// Exception handler code:
try_except_handler_11:;
exception_keeper_type_13 = exception_type;
exception_keeper_value_13 = exception_value;
exception_keeper_tb_13 = exception_tb;
exception_keeper_lineno_13 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_4__bases_orig);
tmp_class_creation_4__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_4__bases);
tmp_class_creation_4__bases = NULL;
Py_XDECREF(tmp_class_creation_4__class_decl_dict);
tmp_class_creation_4__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_4__metaclass);
tmp_class_creation_4__metaclass = NULL;
Py_XDECREF(tmp_class_creation_4__prepared);
tmp_class_creation_4__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_13;
exception_value = exception_keeper_value_13;
exception_tb = exception_keeper_tb_13;
exception_lineno = exception_keeper_lineno_13;
goto frame_exception_exit_1;
// End of try:
try_end_5:;
CHECK_OBJECT(tmp_class_creation_4__bases_orig);
Py_DECREF(tmp_class_creation_4__bases_orig);
tmp_class_creation_4__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_4__bases);
Py_DECREF(tmp_class_creation_4__bases);
tmp_class_creation_4__bases = NULL;
CHECK_OBJECT(tmp_class_creation_4__class_decl_dict);
Py_DECREF(tmp_class_creation_4__class_decl_dict);
tmp_class_creation_4__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_4__metaclass);
Py_DECREF(tmp_class_creation_4__metaclass);
tmp_class_creation_4__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_4__prepared);
Py_DECREF(tmp_class_creation_4__prepared);
tmp_class_creation_4__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_50;
PyObject *tmp_tuple_element_17;
PyObject *tmp_mvar_value_7;
tmp_mvar_value_7 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVPlaylistBaseIE);
if (unlikely(tmp_mvar_value_7 == NULL)) {
tmp_mvar_value_7 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVPlaylistBaseIE);
}
if (tmp_mvar_value_7 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34539 ], 43, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_tuple_element_17 = tmp_mvar_value_7;
tmp_assign_source_50 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_17);
PyTuple_SET_ITEM(tmp_assign_source_50, 0, tmp_tuple_element_17);
assert(tmp_class_creation_5__bases_orig == NULL);
tmp_class_creation_5__bases_orig = tmp_assign_source_50;
}
{
PyObject *tmp_assign_source_51;
PyObject *tmp_dircall_arg1_5;
CHECK_OBJECT(tmp_class_creation_5__bases_orig);
tmp_dircall_arg1_5 = tmp_class_creation_5__bases_orig;
Py_INCREF(tmp_dircall_arg1_5);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_5};
tmp_assign_source_51 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_51 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
assert(tmp_class_creation_5__bases == NULL);
tmp_class_creation_5__bases = tmp_assign_source_51;
}
{
PyObject *tmp_assign_source_52;
tmp_assign_source_52 = PyDict_New();
assert(tmp_class_creation_5__class_decl_dict == NULL);
tmp_class_creation_5__class_decl_dict = tmp_assign_source_52;
}
{
PyObject *tmp_assign_source_53;
PyObject *tmp_metaclass_name_5;
nuitka_bool tmp_condition_result_25;
PyObject *tmp_key_name_13;
PyObject *tmp_dict_name_13;
PyObject *tmp_dict_name_14;
PyObject *tmp_key_name_14;
nuitka_bool tmp_condition_result_26;
int tmp_truth_name_5;
PyObject *tmp_type_arg_9;
PyObject *tmp_expression_name_21;
PyObject *tmp_subscript_name_5;
PyObject *tmp_bases_name_5;
tmp_key_name_13 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_dict_name_13 = tmp_class_creation_5__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_13, tmp_key_name_13);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_condition_result_25 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_25 == NUITKA_BOOL_TRUE) {
goto condexpr_true_9;
} else {
goto condexpr_false_9;
}
condexpr_true_9:;
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_dict_name_14 = tmp_class_creation_5__class_decl_dict;
tmp_key_name_14 = const_str_plain_metaclass;
tmp_metaclass_name_5 = DICT_GET_ITEM(tmp_dict_name_14, tmp_key_name_14);
if (tmp_metaclass_name_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
goto condexpr_end_9;
condexpr_false_9:;
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_truth_name_5 = CHECK_IF_TRUE(tmp_class_creation_5__bases);
if (tmp_truth_name_5 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_condition_result_26 = tmp_truth_name_5 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_26 == NUITKA_BOOL_TRUE) {
goto condexpr_true_10;
} else {
goto condexpr_false_10;
}
condexpr_true_10:;
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_expression_name_21 = tmp_class_creation_5__bases;
tmp_subscript_name_5 = const_int_0;
tmp_type_arg_9 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_21, tmp_subscript_name_5, 0);
if (tmp_type_arg_9 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_metaclass_name_5 = BUILTIN_TYPE1(tmp_type_arg_9);
Py_DECREF(tmp_type_arg_9);
if (tmp_metaclass_name_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
goto condexpr_end_10;
condexpr_false_10:;
tmp_metaclass_name_5 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_5);
condexpr_end_10:;
condexpr_end_9:;
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_bases_name_5 = tmp_class_creation_5__bases;
tmp_assign_source_53 = SELECT_METACLASS(tmp_metaclass_name_5, tmp_bases_name_5);
Py_DECREF(tmp_metaclass_name_5);
if (tmp_assign_source_53 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
assert(tmp_class_creation_5__metaclass == NULL);
tmp_class_creation_5__metaclass = tmp_assign_source_53;
}
{
nuitka_bool tmp_condition_result_27;
PyObject *tmp_key_name_15;
PyObject *tmp_dict_name_15;
tmp_key_name_15 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_dict_name_15 = tmp_class_creation_5__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_15, tmp_key_name_15);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_condition_result_27 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_27 == NUITKA_BOOL_TRUE) {
goto branch_yes_17;
} else {
goto branch_no_17;
}
}
branch_yes_17:;
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_5__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
branch_no_17:;
{
nuitka_bool tmp_condition_result_28;
PyObject *tmp_expression_name_22;
CHECK_OBJECT(tmp_class_creation_5__metaclass);
tmp_expression_name_22 = tmp_class_creation_5__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_22, const_str_plain___prepare__);
tmp_condition_result_28 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_28 == NUITKA_BOOL_TRUE) {
goto branch_yes_18;
} else {
goto branch_no_18;
}
}
branch_yes_18:;
{
PyObject *tmp_assign_source_54;
PyObject *tmp_called_name_9;
PyObject *tmp_expression_name_23;
PyObject *tmp_args_name_9;
PyObject *tmp_tuple_element_18;
PyObject *tmp_kw_name_9;
CHECK_OBJECT(tmp_class_creation_5__metaclass);
tmp_expression_name_23 = tmp_class_creation_5__metaclass;
tmp_called_name_9 = LOOKUP_ATTRIBUTE(tmp_expression_name_23, const_str_plain___prepare__);
if (tmp_called_name_9 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_tuple_element_18 = const_str_plain_AdobeTVShowIE;
tmp_args_name_9 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_18);
PyTuple_SET_ITEM(tmp_args_name_9, 0, tmp_tuple_element_18);
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_tuple_element_18 = tmp_class_creation_5__bases;
Py_INCREF(tmp_tuple_element_18);
PyTuple_SET_ITEM(tmp_args_name_9, 1, tmp_tuple_element_18);
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_kw_name_9 = tmp_class_creation_5__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 164;
tmp_assign_source_54 = CALL_FUNCTION(tmp_called_name_9, tmp_args_name_9, tmp_kw_name_9);
Py_DECREF(tmp_called_name_9);
Py_DECREF(tmp_args_name_9);
if (tmp_assign_source_54 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
assert(tmp_class_creation_5__prepared == NULL);
tmp_class_creation_5__prepared = tmp_assign_source_54;
}
{
nuitka_bool tmp_condition_result_29;
PyObject *tmp_operand_name_5;
PyObject *tmp_expression_name_24;
CHECK_OBJECT(tmp_class_creation_5__prepared);
tmp_expression_name_24 = tmp_class_creation_5__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_24, const_str_plain___getitem__);
tmp_operand_name_5 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_5);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_condition_result_29 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_29 == NUITKA_BOOL_TRUE) {
goto branch_yes_19;
} else {
goto branch_no_19;
}
}
branch_yes_19:;
{
PyObject *tmp_raise_type_5;
PyObject *tmp_raise_value_5;
PyObject *tmp_left_name_5;
PyObject *tmp_right_name_5;
PyObject *tmp_tuple_element_19;
PyObject *tmp_getattr_target_5;
PyObject *tmp_getattr_attr_5;
PyObject *tmp_getattr_default_5;
PyObject *tmp_expression_name_25;
PyObject *tmp_type_arg_10;
tmp_raise_type_5 = PyExc_TypeError;
tmp_left_name_5 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_5__metaclass);
tmp_getattr_target_5 = tmp_class_creation_5__metaclass;
tmp_getattr_attr_5 = const_str_plain___name__;
tmp_getattr_default_5 = const_str_angle_metaclass;
tmp_tuple_element_19 = BUILTIN_GETATTR(tmp_getattr_target_5, tmp_getattr_attr_5, tmp_getattr_default_5);
if (tmp_tuple_element_19 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
tmp_right_name_5 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_5, 0, tmp_tuple_element_19);
CHECK_OBJECT(tmp_class_creation_5__prepared);
tmp_type_arg_10 = tmp_class_creation_5__prepared;
tmp_expression_name_25 = BUILTIN_TYPE1(tmp_type_arg_10);
assert(!(tmp_expression_name_25 == NULL));
tmp_tuple_element_19 = LOOKUP_ATTRIBUTE(tmp_expression_name_25, const_str_plain___name__);
Py_DECREF(tmp_expression_name_25);
if (tmp_tuple_element_19 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_5);
exception_lineno = 164;
goto try_except_handler_14;
}
PyTuple_SET_ITEM(tmp_right_name_5, 1, tmp_tuple_element_19);
tmp_raise_value_5 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_5, tmp_right_name_5);
Py_DECREF(tmp_right_name_5);
if (tmp_raise_value_5 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_14;
}
exception_type = tmp_raise_type_5;
Py_INCREF(tmp_raise_type_5);
exception_value = tmp_raise_value_5;
exception_lineno = 164;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_14;
}
branch_no_19:;
goto branch_end_18;
branch_no_18:;
{
PyObject *tmp_assign_source_55;
tmp_assign_source_55 = PyDict_New();
assert(tmp_class_creation_5__prepared == NULL);
tmp_class_creation_5__prepared = tmp_assign_source_55;
}
branch_end_18:;
{
PyObject *tmp_assign_source_56;
{
PyObject *tmp_set_locals_5;
CHECK_OBJECT(tmp_class_creation_5__prepared);
tmp_set_locals_5 = tmp_class_creation_5__prepared;
locals_youtube_dl$extractor$adobetv_164 = tmp_set_locals_5;
Py_INCREF(tmp_set_locals_5);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_16;
}
tmp_dictset_value = const_str_plain_AdobeTVShowIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_16;
}
if (isFrameUnusable(cache_frame_5c0388a50dc76d1d7766415e475ed156_6)) {
Py_XDECREF(cache_frame_5c0388a50dc76d1d7766415e475ed156_6);
#if _DEBUG_REFCOUNTS
if (cache_frame_5c0388a50dc76d1d7766415e475ed156_6 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_5c0388a50dc76d1d7766415e475ed156_6 = MAKE_FUNCTION_FRAME(codeobj_5c0388a50dc76d1d7766415e475ed156, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_5c0388a50dc76d1d7766415e475ed156_6->m_type_description == NULL);
frame_5c0388a50dc76d1d7766415e475ed156_6 = cache_frame_5c0388a50dc76d1d7766415e475ed156_6;
// Push the new frame as the currently active one.
pushFrameStack(frame_5c0388a50dc76d1d7766415e475ed156_6);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_5c0388a50dc76d1d7766415e475ed156_6) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_str_digest_e5f7587c0206a238d49eb79d7f53cef7;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain_IE_NAME, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 165;
type_description_2 = "o";
goto frame_exception_exit_6;
}
tmp_dictset_value = const_str_digest_f98803efe7aa32cc5947018bd34448ee;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain__VALID_URL, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 166;
type_description_2 = "o";
goto frame_exception_exit_6;
}
tmp_dictset_value = DEEP_COPY(const_dict_3d1ed719334bf3a6872c97da2e22d9da);
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain__TEST, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 168;
type_description_2 = "o";
goto frame_exception_exit_6;
}
tmp_dictset_value = const_str_plain_episode;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain__RESOURCE, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 177;
type_description_2 = "o";
goto frame_exception_exit_6;
}
{
PyObject *tmp_expression_name_26;
PyObject *tmp_mvar_value_8;
tmp_expression_name_26 = PyObject_GetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain_AdobeTVBaseIE);
if (tmp_expression_name_26 == NULL) {
if (CHECK_AND_CLEAR_KEY_ERROR_OCCURRED()) {
tmp_mvar_value_8 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
if (unlikely(tmp_mvar_value_8 == NULL)) {
tmp_mvar_value_8 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
}
if (tmp_mvar_value_8 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34504 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 178;
type_description_2 = "o";
goto frame_exception_exit_6;
}
tmp_expression_name_26 = tmp_mvar_value_8;
Py_INCREF(tmp_expression_name_26);
}
}
tmp_dictset_value = LOOKUP_ATTRIBUTE(tmp_expression_name_26, const_str_plain__parse_video_data);
Py_DECREF(tmp_expression_name_26);
if (tmp_dictset_value == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 178;
type_description_2 = "o";
goto frame_exception_exit_6;
}
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain__process_data, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 178;
type_description_2 = "o";
goto frame_exception_exit_6;
}
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_8__real_extract();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain__real_extract, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 180;
type_description_2 = "o";
goto frame_exception_exit_6;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_5c0388a50dc76d1d7766415e475ed156_6);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_5;
frame_exception_exit_6:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_5c0388a50dc76d1d7766415e475ed156_6);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_5c0388a50dc76d1d7766415e475ed156_6, exception_lineno);
} else if (exception_tb->tb_frame != &frame_5c0388a50dc76d1d7766415e475ed156_6->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_5c0388a50dc76d1d7766415e475ed156_6, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_5c0388a50dc76d1d7766415e475ed156_6,
type_description_2,
outline_4_var___class__
);
// Release cached frame.
if (frame_5c0388a50dc76d1d7766415e475ed156_6 == cache_frame_5c0388a50dc76d1d7766415e475ed156_6) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_5c0388a50dc76d1d7766415e475ed156_6);
}
cache_frame_5c0388a50dc76d1d7766415e475ed156_6 = NULL;
assertFrameObject(frame_5c0388a50dc76d1d7766415e475ed156_6);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_5;
frame_no_exception_5:;
goto skip_nested_handling_5;
nested_frame_exit_5:;
goto try_except_handler_16;
skip_nested_handling_5:;
{
nuitka_bool tmp_condition_result_30;
PyObject *tmp_compexpr_left_5;
PyObject *tmp_compexpr_right_5;
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_compexpr_left_5 = tmp_class_creation_5__bases;
CHECK_OBJECT(tmp_class_creation_5__bases_orig);
tmp_compexpr_right_5 = tmp_class_creation_5__bases_orig;
tmp_condition_result_30 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_5, tmp_compexpr_right_5);
if (tmp_condition_result_30 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_16;
}
if (tmp_condition_result_30 == NUITKA_BOOL_TRUE) {
goto branch_yes_20;
} else {
goto branch_no_20;
}
}
branch_yes_20:;
CHECK_OBJECT(tmp_class_creation_5__bases_orig);
tmp_dictset_value = tmp_class_creation_5__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_164, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_16;
}
branch_no_20:;
{
PyObject *tmp_assign_source_57;
PyObject *tmp_called_name_10;
PyObject *tmp_args_name_10;
PyObject *tmp_tuple_element_20;
PyObject *tmp_kw_name_10;
CHECK_OBJECT(tmp_class_creation_5__metaclass);
tmp_called_name_10 = tmp_class_creation_5__metaclass;
tmp_tuple_element_20 = const_str_plain_AdobeTVShowIE;
tmp_args_name_10 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_20);
PyTuple_SET_ITEM(tmp_args_name_10, 0, tmp_tuple_element_20);
CHECK_OBJECT(tmp_class_creation_5__bases);
tmp_tuple_element_20 = tmp_class_creation_5__bases;
Py_INCREF(tmp_tuple_element_20);
PyTuple_SET_ITEM(tmp_args_name_10, 1, tmp_tuple_element_20);
tmp_tuple_element_20 = locals_youtube_dl$extractor$adobetv_164;
Py_INCREF(tmp_tuple_element_20);
PyTuple_SET_ITEM(tmp_args_name_10, 2, tmp_tuple_element_20);
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
tmp_kw_name_10 = tmp_class_creation_5__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 164;
tmp_assign_source_57 = CALL_FUNCTION(tmp_called_name_10, tmp_args_name_10, tmp_kw_name_10);
Py_DECREF(tmp_args_name_10);
if (tmp_assign_source_57 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 164;
goto try_except_handler_16;
}
assert(outline_4_var___class__ == NULL);
outline_4_var___class__ = tmp_assign_source_57;
}
CHECK_OBJECT(outline_4_var___class__);
tmp_assign_source_56 = outline_4_var___class__;
Py_INCREF(tmp_assign_source_56);
goto try_return_handler_16;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_16:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_164);
locals_youtube_dl$extractor$adobetv_164 = NULL;
goto try_return_handler_15;
// Exception handler code:
try_except_handler_16:;
exception_keeper_type_14 = exception_type;
exception_keeper_value_14 = exception_value;
exception_keeper_tb_14 = exception_tb;
exception_keeper_lineno_14 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_164);
locals_youtube_dl$extractor$adobetv_164 = NULL;
// Re-raise.
exception_type = exception_keeper_type_14;
exception_value = exception_keeper_value_14;
exception_tb = exception_keeper_tb_14;
exception_lineno = exception_keeper_lineno_14;
goto try_except_handler_15;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_15:;
CHECK_OBJECT(outline_4_var___class__);
Py_DECREF(outline_4_var___class__);
outline_4_var___class__ = NULL;
goto outline_result_5;
// Exception handler code:
try_except_handler_15:;
exception_keeper_type_15 = exception_type;
exception_keeper_value_15 = exception_value;
exception_keeper_tb_15 = exception_tb;
exception_keeper_lineno_15 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_15;
exception_value = exception_keeper_value_15;
exception_tb = exception_keeper_tb_15;
exception_lineno = exception_keeper_lineno_15;
goto outline_exception_5;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_5:;
exception_lineno = 164;
goto try_except_handler_14;
outline_result_5:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVShowIE, tmp_assign_source_56);
}
goto try_end_6;
// Exception handler code:
try_except_handler_14:;
exception_keeper_type_16 = exception_type;
exception_keeper_value_16 = exception_value;
exception_keeper_tb_16 = exception_tb;
exception_keeper_lineno_16 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_5__bases_orig);
tmp_class_creation_5__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_5__bases);
tmp_class_creation_5__bases = NULL;
Py_XDECREF(tmp_class_creation_5__class_decl_dict);
tmp_class_creation_5__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_5__metaclass);
tmp_class_creation_5__metaclass = NULL;
Py_XDECREF(tmp_class_creation_5__prepared);
tmp_class_creation_5__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_16;
exception_value = exception_keeper_value_16;
exception_tb = exception_keeper_tb_16;
exception_lineno = exception_keeper_lineno_16;
goto frame_exception_exit_1;
// End of try:
try_end_6:;
CHECK_OBJECT(tmp_class_creation_5__bases_orig);
Py_DECREF(tmp_class_creation_5__bases_orig);
tmp_class_creation_5__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_5__bases);
Py_DECREF(tmp_class_creation_5__bases);
tmp_class_creation_5__bases = NULL;
CHECK_OBJECT(tmp_class_creation_5__class_decl_dict);
Py_DECREF(tmp_class_creation_5__class_decl_dict);
tmp_class_creation_5__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_5__metaclass);
Py_DECREF(tmp_class_creation_5__metaclass);
tmp_class_creation_5__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_5__prepared);
Py_DECREF(tmp_class_creation_5__prepared);
tmp_class_creation_5__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_58;
PyObject *tmp_tuple_element_21;
PyObject *tmp_mvar_value_9;
tmp_mvar_value_9 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVPlaylistBaseIE);
if (unlikely(tmp_mvar_value_9 == NULL)) {
tmp_mvar_value_9 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVPlaylistBaseIE);
}
if (tmp_mvar_value_9 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34539 ], 43, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_tuple_element_21 = tmp_mvar_value_9;
tmp_assign_source_58 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_21);
PyTuple_SET_ITEM(tmp_assign_source_58, 0, tmp_tuple_element_21);
assert(tmp_class_creation_6__bases_orig == NULL);
tmp_class_creation_6__bases_orig = tmp_assign_source_58;
}
{
PyObject *tmp_assign_source_59;
PyObject *tmp_dircall_arg1_6;
CHECK_OBJECT(tmp_class_creation_6__bases_orig);
tmp_dircall_arg1_6 = tmp_class_creation_6__bases_orig;
Py_INCREF(tmp_dircall_arg1_6);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_6};
tmp_assign_source_59 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_59 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
assert(tmp_class_creation_6__bases == NULL);
tmp_class_creation_6__bases = tmp_assign_source_59;
}
{
PyObject *tmp_assign_source_60;
tmp_assign_source_60 = PyDict_New();
assert(tmp_class_creation_6__class_decl_dict == NULL);
tmp_class_creation_6__class_decl_dict = tmp_assign_source_60;
}
{
PyObject *tmp_assign_source_61;
PyObject *tmp_metaclass_name_6;
nuitka_bool tmp_condition_result_31;
PyObject *tmp_key_name_16;
PyObject *tmp_dict_name_16;
PyObject *tmp_dict_name_17;
PyObject *tmp_key_name_17;
nuitka_bool tmp_condition_result_32;
int tmp_truth_name_6;
PyObject *tmp_type_arg_11;
PyObject *tmp_expression_name_27;
PyObject *tmp_subscript_name_6;
PyObject *tmp_bases_name_6;
tmp_key_name_16 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_dict_name_16 = tmp_class_creation_6__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_16, tmp_key_name_16);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_condition_result_31 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_31 == NUITKA_BOOL_TRUE) {
goto condexpr_true_11;
} else {
goto condexpr_false_11;
}
condexpr_true_11:;
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_dict_name_17 = tmp_class_creation_6__class_decl_dict;
tmp_key_name_17 = const_str_plain_metaclass;
tmp_metaclass_name_6 = DICT_GET_ITEM(tmp_dict_name_17, tmp_key_name_17);
if (tmp_metaclass_name_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
goto condexpr_end_11;
condexpr_false_11:;
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_truth_name_6 = CHECK_IF_TRUE(tmp_class_creation_6__bases);
if (tmp_truth_name_6 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_condition_result_32 = tmp_truth_name_6 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_32 == NUITKA_BOOL_TRUE) {
goto condexpr_true_12;
} else {
goto condexpr_false_12;
}
condexpr_true_12:;
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_expression_name_27 = tmp_class_creation_6__bases;
tmp_subscript_name_6 = const_int_0;
tmp_type_arg_11 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_27, tmp_subscript_name_6, 0);
if (tmp_type_arg_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_metaclass_name_6 = BUILTIN_TYPE1(tmp_type_arg_11);
Py_DECREF(tmp_type_arg_11);
if (tmp_metaclass_name_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
goto condexpr_end_12;
condexpr_false_12:;
tmp_metaclass_name_6 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_6);
condexpr_end_12:;
condexpr_end_11:;
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_bases_name_6 = tmp_class_creation_6__bases;
tmp_assign_source_61 = SELECT_METACLASS(tmp_metaclass_name_6, tmp_bases_name_6);
Py_DECREF(tmp_metaclass_name_6);
if (tmp_assign_source_61 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
assert(tmp_class_creation_6__metaclass == NULL);
tmp_class_creation_6__metaclass = tmp_assign_source_61;
}
{
nuitka_bool tmp_condition_result_33;
PyObject *tmp_key_name_18;
PyObject *tmp_dict_name_18;
tmp_key_name_18 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_dict_name_18 = tmp_class_creation_6__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_18, tmp_key_name_18);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_condition_result_33 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_33 == NUITKA_BOOL_TRUE) {
goto branch_yes_21;
} else {
goto branch_no_21;
}
}
branch_yes_21:;
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_6__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
branch_no_21:;
{
nuitka_bool tmp_condition_result_34;
PyObject *tmp_expression_name_28;
CHECK_OBJECT(tmp_class_creation_6__metaclass);
tmp_expression_name_28 = tmp_class_creation_6__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_28, const_str_plain___prepare__);
tmp_condition_result_34 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_34 == NUITKA_BOOL_TRUE) {
goto branch_yes_22;
} else {
goto branch_no_22;
}
}
branch_yes_22:;
{
PyObject *tmp_assign_source_62;
PyObject *tmp_called_name_11;
PyObject *tmp_expression_name_29;
PyObject *tmp_args_name_11;
PyObject *tmp_tuple_element_22;
PyObject *tmp_kw_name_11;
CHECK_OBJECT(tmp_class_creation_6__metaclass);
tmp_expression_name_29 = tmp_class_creation_6__metaclass;
tmp_called_name_11 = LOOKUP_ATTRIBUTE(tmp_expression_name_29, const_str_plain___prepare__);
if (tmp_called_name_11 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_tuple_element_22 = const_str_plain_AdobeTVChannelIE;
tmp_args_name_11 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_22);
PyTuple_SET_ITEM(tmp_args_name_11, 0, tmp_tuple_element_22);
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_tuple_element_22 = tmp_class_creation_6__bases;
Py_INCREF(tmp_tuple_element_22);
PyTuple_SET_ITEM(tmp_args_name_11, 1, tmp_tuple_element_22);
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_kw_name_11 = tmp_class_creation_6__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 200;
tmp_assign_source_62 = CALL_FUNCTION(tmp_called_name_11, tmp_args_name_11, tmp_kw_name_11);
Py_DECREF(tmp_called_name_11);
Py_DECREF(tmp_args_name_11);
if (tmp_assign_source_62 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
assert(tmp_class_creation_6__prepared == NULL);
tmp_class_creation_6__prepared = tmp_assign_source_62;
}
{
nuitka_bool tmp_condition_result_35;
PyObject *tmp_operand_name_6;
PyObject *tmp_expression_name_30;
CHECK_OBJECT(tmp_class_creation_6__prepared);
tmp_expression_name_30 = tmp_class_creation_6__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_30, const_str_plain___getitem__);
tmp_operand_name_6 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_6);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_condition_result_35 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_35 == NUITKA_BOOL_TRUE) {
goto branch_yes_23;
} else {
goto branch_no_23;
}
}
branch_yes_23:;
{
PyObject *tmp_raise_type_6;
PyObject *tmp_raise_value_6;
PyObject *tmp_left_name_6;
PyObject *tmp_right_name_6;
PyObject *tmp_tuple_element_23;
PyObject *tmp_getattr_target_6;
PyObject *tmp_getattr_attr_6;
PyObject *tmp_getattr_default_6;
PyObject *tmp_expression_name_31;
PyObject *tmp_type_arg_12;
tmp_raise_type_6 = PyExc_TypeError;
tmp_left_name_6 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_6__metaclass);
tmp_getattr_target_6 = tmp_class_creation_6__metaclass;
tmp_getattr_attr_6 = const_str_plain___name__;
tmp_getattr_default_6 = const_str_angle_metaclass;
tmp_tuple_element_23 = BUILTIN_GETATTR(tmp_getattr_target_6, tmp_getattr_attr_6, tmp_getattr_default_6);
if (tmp_tuple_element_23 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
tmp_right_name_6 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_6, 0, tmp_tuple_element_23);
CHECK_OBJECT(tmp_class_creation_6__prepared);
tmp_type_arg_12 = tmp_class_creation_6__prepared;
tmp_expression_name_31 = BUILTIN_TYPE1(tmp_type_arg_12);
assert(!(tmp_expression_name_31 == NULL));
tmp_tuple_element_23 = LOOKUP_ATTRIBUTE(tmp_expression_name_31, const_str_plain___name__);
Py_DECREF(tmp_expression_name_31);
if (tmp_tuple_element_23 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_6);
exception_lineno = 200;
goto try_except_handler_17;
}
PyTuple_SET_ITEM(tmp_right_name_6, 1, tmp_tuple_element_23);
tmp_raise_value_6 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_6, tmp_right_name_6);
Py_DECREF(tmp_right_name_6);
if (tmp_raise_value_6 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_17;
}
exception_type = tmp_raise_type_6;
Py_INCREF(tmp_raise_type_6);
exception_value = tmp_raise_value_6;
exception_lineno = 200;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_17;
}
branch_no_23:;
goto branch_end_22;
branch_no_22:;
{
PyObject *tmp_assign_source_63;
tmp_assign_source_63 = PyDict_New();
assert(tmp_class_creation_6__prepared == NULL);
tmp_class_creation_6__prepared = tmp_assign_source_63;
}
branch_end_22:;
{
PyObject *tmp_assign_source_64;
{
PyObject *tmp_set_locals_6;
CHECK_OBJECT(tmp_class_creation_6__prepared);
tmp_set_locals_6 = tmp_class_creation_6__prepared;
locals_youtube_dl$extractor$adobetv_200 = tmp_set_locals_6;
Py_INCREF(tmp_set_locals_6);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_19;
}
tmp_dictset_value = const_str_plain_AdobeTVChannelIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_19;
}
if (isFrameUnusable(cache_frame_212e5f88591db5845244d4e462e25095_7)) {
Py_XDECREF(cache_frame_212e5f88591db5845244d4e462e25095_7);
#if _DEBUG_REFCOUNTS
if (cache_frame_212e5f88591db5845244d4e462e25095_7 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_212e5f88591db5845244d4e462e25095_7 = MAKE_FUNCTION_FRAME(codeobj_212e5f88591db5845244d4e462e25095, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_212e5f88591db5845244d4e462e25095_7->m_type_description == NULL);
frame_212e5f88591db5845244d4e462e25095_7 = cache_frame_212e5f88591db5845244d4e462e25095_7;
// Push the new frame as the currently active one.
pushFrameStack(frame_212e5f88591db5845244d4e462e25095_7);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_212e5f88591db5845244d4e462e25095_7) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_str_digest_bdb546fa98754ba0cf99fdab40564bd3;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain_IE_NAME, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 201;
type_description_2 = "o";
goto frame_exception_exit_7;
}
tmp_dictset_value = const_str_digest_b1c334de9d987fec02c30dcb9b054ec0;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain__VALID_URL, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 202;
type_description_2 = "o";
goto frame_exception_exit_7;
}
tmp_dictset_value = DEEP_COPY(const_dict_b39d935d25f952b135dd1edfa70f6fb3);
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain__TEST, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 204;
type_description_2 = "o";
goto frame_exception_exit_7;
}
tmp_dictset_value = const_str_plain_show;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain__RESOURCE, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 211;
type_description_2 = "o";
goto frame_exception_exit_7;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_9__process_data();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain__process_data, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 213;
type_description_2 = "o";
goto frame_exception_exit_7;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_10__real_extract();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain__real_extract, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 217;
type_description_2 = "o";
goto frame_exception_exit_7;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_212e5f88591db5845244d4e462e25095_7);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_6;
frame_exception_exit_7:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_212e5f88591db5845244d4e462e25095_7);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_212e5f88591db5845244d4e462e25095_7, exception_lineno);
} else if (exception_tb->tb_frame != &frame_212e5f88591db5845244d4e462e25095_7->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_212e5f88591db5845244d4e462e25095_7, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_212e5f88591db5845244d4e462e25095_7,
type_description_2,
outline_5_var___class__
);
// Release cached frame.
if (frame_212e5f88591db5845244d4e462e25095_7 == cache_frame_212e5f88591db5845244d4e462e25095_7) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_212e5f88591db5845244d4e462e25095_7);
}
cache_frame_212e5f88591db5845244d4e462e25095_7 = NULL;
assertFrameObject(frame_212e5f88591db5845244d4e462e25095_7);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_6;
frame_no_exception_6:;
goto skip_nested_handling_6;
nested_frame_exit_6:;
goto try_except_handler_19;
skip_nested_handling_6:;
{
nuitka_bool tmp_condition_result_36;
PyObject *tmp_compexpr_left_6;
PyObject *tmp_compexpr_right_6;
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_compexpr_left_6 = tmp_class_creation_6__bases;
CHECK_OBJECT(tmp_class_creation_6__bases_orig);
tmp_compexpr_right_6 = tmp_class_creation_6__bases_orig;
tmp_condition_result_36 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_6, tmp_compexpr_right_6);
if (tmp_condition_result_36 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_19;
}
if (tmp_condition_result_36 == NUITKA_BOOL_TRUE) {
goto branch_yes_24;
} else {
goto branch_no_24;
}
}
branch_yes_24:;
CHECK_OBJECT(tmp_class_creation_6__bases_orig);
tmp_dictset_value = tmp_class_creation_6__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_200, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_19;
}
branch_no_24:;
{
PyObject *tmp_assign_source_65;
PyObject *tmp_called_name_12;
PyObject *tmp_args_name_12;
PyObject *tmp_tuple_element_24;
PyObject *tmp_kw_name_12;
CHECK_OBJECT(tmp_class_creation_6__metaclass);
tmp_called_name_12 = tmp_class_creation_6__metaclass;
tmp_tuple_element_24 = const_str_plain_AdobeTVChannelIE;
tmp_args_name_12 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_24);
PyTuple_SET_ITEM(tmp_args_name_12, 0, tmp_tuple_element_24);
CHECK_OBJECT(tmp_class_creation_6__bases);
tmp_tuple_element_24 = tmp_class_creation_6__bases;
Py_INCREF(tmp_tuple_element_24);
PyTuple_SET_ITEM(tmp_args_name_12, 1, tmp_tuple_element_24);
tmp_tuple_element_24 = locals_youtube_dl$extractor$adobetv_200;
Py_INCREF(tmp_tuple_element_24);
PyTuple_SET_ITEM(tmp_args_name_12, 2, tmp_tuple_element_24);
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
tmp_kw_name_12 = tmp_class_creation_6__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 200;
tmp_assign_source_65 = CALL_FUNCTION(tmp_called_name_12, tmp_args_name_12, tmp_kw_name_12);
Py_DECREF(tmp_args_name_12);
if (tmp_assign_source_65 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 200;
goto try_except_handler_19;
}
assert(outline_5_var___class__ == NULL);
outline_5_var___class__ = tmp_assign_source_65;
}
CHECK_OBJECT(outline_5_var___class__);
tmp_assign_source_64 = outline_5_var___class__;
Py_INCREF(tmp_assign_source_64);
goto try_return_handler_19;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_19:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_200);
locals_youtube_dl$extractor$adobetv_200 = NULL;
goto try_return_handler_18;
// Exception handler code:
try_except_handler_19:;
exception_keeper_type_17 = exception_type;
exception_keeper_value_17 = exception_value;
exception_keeper_tb_17 = exception_tb;
exception_keeper_lineno_17 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_200);
locals_youtube_dl$extractor$adobetv_200 = NULL;
// Re-raise.
exception_type = exception_keeper_type_17;
exception_value = exception_keeper_value_17;
exception_tb = exception_keeper_tb_17;
exception_lineno = exception_keeper_lineno_17;
goto try_except_handler_18;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_18:;
CHECK_OBJECT(outline_5_var___class__);
Py_DECREF(outline_5_var___class__);
outline_5_var___class__ = NULL;
goto outline_result_6;
// Exception handler code:
try_except_handler_18:;
exception_keeper_type_18 = exception_type;
exception_keeper_value_18 = exception_value;
exception_keeper_tb_18 = exception_tb;
exception_keeper_lineno_18 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_18;
exception_value = exception_keeper_value_18;
exception_tb = exception_keeper_tb_18;
exception_lineno = exception_keeper_lineno_18;
goto outline_exception_6;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_6:;
exception_lineno = 200;
goto try_except_handler_17;
outline_result_6:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVChannelIE, tmp_assign_source_64);
}
goto try_end_7;
// Exception handler code:
try_except_handler_17:;
exception_keeper_type_19 = exception_type;
exception_keeper_value_19 = exception_value;
exception_keeper_tb_19 = exception_tb;
exception_keeper_lineno_19 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_6__bases_orig);
tmp_class_creation_6__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_6__bases);
tmp_class_creation_6__bases = NULL;
Py_XDECREF(tmp_class_creation_6__class_decl_dict);
tmp_class_creation_6__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_6__metaclass);
tmp_class_creation_6__metaclass = NULL;
Py_XDECREF(tmp_class_creation_6__prepared);
tmp_class_creation_6__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_19;
exception_value = exception_keeper_value_19;
exception_tb = exception_keeper_tb_19;
exception_lineno = exception_keeper_lineno_19;
goto frame_exception_exit_1;
// End of try:
try_end_7:;
CHECK_OBJECT(tmp_class_creation_6__bases_orig);
Py_DECREF(tmp_class_creation_6__bases_orig);
tmp_class_creation_6__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_6__bases);
Py_DECREF(tmp_class_creation_6__bases);
tmp_class_creation_6__bases = NULL;
CHECK_OBJECT(tmp_class_creation_6__class_decl_dict);
Py_DECREF(tmp_class_creation_6__class_decl_dict);
tmp_class_creation_6__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_6__metaclass);
Py_DECREF(tmp_class_creation_6__metaclass);
tmp_class_creation_6__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_6__prepared);
Py_DECREF(tmp_class_creation_6__prepared);
tmp_class_creation_6__prepared = NULL;
// Tried code:
{
PyObject *tmp_assign_source_66;
PyObject *tmp_tuple_element_25;
PyObject *tmp_mvar_value_10;
tmp_mvar_value_10 = GET_STRING_DICT_VALUE(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
if (unlikely(tmp_mvar_value_10 == NULL)) {
tmp_mvar_value_10 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)const_str_plain_AdobeTVBaseIE);
}
if (tmp_mvar_value_10 == NULL) {
exception_type = PyExc_NameError;
Py_INCREF(exception_type);
exception_value = UNSTREAM_STRING(&constant_bin[ 34504 ], 35, 0);
exception_tb = NULL;
NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
CHAIN_EXCEPTION(exception_value);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_tuple_element_25 = tmp_mvar_value_10;
tmp_assign_source_66 = PyTuple_New(1);
Py_INCREF(tmp_tuple_element_25);
PyTuple_SET_ITEM(tmp_assign_source_66, 0, tmp_tuple_element_25);
assert(tmp_class_creation_7__bases_orig == NULL);
tmp_class_creation_7__bases_orig = tmp_assign_source_66;
}
{
PyObject *tmp_assign_source_67;
PyObject *tmp_dircall_arg1_7;
CHECK_OBJECT(tmp_class_creation_7__bases_orig);
tmp_dircall_arg1_7 = tmp_class_creation_7__bases_orig;
Py_INCREF(tmp_dircall_arg1_7);
{
PyObject *dir_call_args[] = {tmp_dircall_arg1_7};
tmp_assign_source_67 = impl___internal__$$$function_4__mro_entries_conversion(dir_call_args);
}
if (tmp_assign_source_67 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
assert(tmp_class_creation_7__bases == NULL);
tmp_class_creation_7__bases = tmp_assign_source_67;
}
{
PyObject *tmp_assign_source_68;
tmp_assign_source_68 = PyDict_New();
assert(tmp_class_creation_7__class_decl_dict == NULL);
tmp_class_creation_7__class_decl_dict = tmp_assign_source_68;
}
{
PyObject *tmp_assign_source_69;
PyObject *tmp_metaclass_name_7;
nuitka_bool tmp_condition_result_37;
PyObject *tmp_key_name_19;
PyObject *tmp_dict_name_19;
PyObject *tmp_dict_name_20;
PyObject *tmp_key_name_20;
nuitka_bool tmp_condition_result_38;
int tmp_truth_name_7;
PyObject *tmp_type_arg_13;
PyObject *tmp_expression_name_32;
PyObject *tmp_subscript_name_7;
PyObject *tmp_bases_name_7;
tmp_key_name_19 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_dict_name_19 = tmp_class_creation_7__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_19, tmp_key_name_19);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_condition_result_37 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_37 == NUITKA_BOOL_TRUE) {
goto condexpr_true_13;
} else {
goto condexpr_false_13;
}
condexpr_true_13:;
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_dict_name_20 = tmp_class_creation_7__class_decl_dict;
tmp_key_name_20 = const_str_plain_metaclass;
tmp_metaclass_name_7 = DICT_GET_ITEM(tmp_dict_name_20, tmp_key_name_20);
if (tmp_metaclass_name_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
goto condexpr_end_13;
condexpr_false_13:;
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_truth_name_7 = CHECK_IF_TRUE(tmp_class_creation_7__bases);
if (tmp_truth_name_7 == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_condition_result_38 = tmp_truth_name_7 == 1 ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_38 == NUITKA_BOOL_TRUE) {
goto condexpr_true_14;
} else {
goto condexpr_false_14;
}
condexpr_true_14:;
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_expression_name_32 = tmp_class_creation_7__bases;
tmp_subscript_name_7 = const_int_0;
tmp_type_arg_13 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_32, tmp_subscript_name_7, 0);
if (tmp_type_arg_13 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_metaclass_name_7 = BUILTIN_TYPE1(tmp_type_arg_13);
Py_DECREF(tmp_type_arg_13);
if (tmp_metaclass_name_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
goto condexpr_end_14;
condexpr_false_14:;
tmp_metaclass_name_7 = (PyObject *)&PyType_Type;
Py_INCREF(tmp_metaclass_name_7);
condexpr_end_14:;
condexpr_end_13:;
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_bases_name_7 = tmp_class_creation_7__bases;
tmp_assign_source_69 = SELECT_METACLASS(tmp_metaclass_name_7, tmp_bases_name_7);
Py_DECREF(tmp_metaclass_name_7);
if (tmp_assign_source_69 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
assert(tmp_class_creation_7__metaclass == NULL);
tmp_class_creation_7__metaclass = tmp_assign_source_69;
}
{
nuitka_bool tmp_condition_result_39;
PyObject *tmp_key_name_21;
PyObject *tmp_dict_name_21;
tmp_key_name_21 = const_str_plain_metaclass;
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_dict_name_21 = tmp_class_creation_7__class_decl_dict;
tmp_res = PyDict_Contains(tmp_dict_name_21, tmp_key_name_21);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_condition_result_39 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_39 == NUITKA_BOOL_TRUE) {
goto branch_yes_25;
} else {
goto branch_no_25;
}
}
branch_yes_25:;
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_dictdel_dict = tmp_class_creation_7__class_decl_dict;
tmp_dictdel_key = const_str_plain_metaclass;
tmp_result = DICT_REMOVE_ITEM(tmp_dictdel_dict, tmp_dictdel_key);
if (tmp_result == false) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
branch_no_25:;
{
nuitka_bool tmp_condition_result_40;
PyObject *tmp_expression_name_33;
CHECK_OBJECT(tmp_class_creation_7__metaclass);
tmp_expression_name_33 = tmp_class_creation_7__metaclass;
tmp_res = PyObject_HasAttr(tmp_expression_name_33, const_str_plain___prepare__);
tmp_condition_result_40 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_40 == NUITKA_BOOL_TRUE) {
goto branch_yes_26;
} else {
goto branch_no_26;
}
}
branch_yes_26:;
{
PyObject *tmp_assign_source_70;
PyObject *tmp_called_name_13;
PyObject *tmp_expression_name_34;
PyObject *tmp_args_name_13;
PyObject *tmp_tuple_element_26;
PyObject *tmp_kw_name_13;
CHECK_OBJECT(tmp_class_creation_7__metaclass);
tmp_expression_name_34 = tmp_class_creation_7__metaclass;
tmp_called_name_13 = LOOKUP_ATTRIBUTE(tmp_expression_name_34, const_str_plain___prepare__);
if (tmp_called_name_13 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_tuple_element_26 = const_str_plain_AdobeTVVideoIE;
tmp_args_name_13 = PyTuple_New(2);
Py_INCREF(tmp_tuple_element_26);
PyTuple_SET_ITEM(tmp_args_name_13, 0, tmp_tuple_element_26);
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_tuple_element_26 = tmp_class_creation_7__bases;
Py_INCREF(tmp_tuple_element_26);
PyTuple_SET_ITEM(tmp_args_name_13, 1, tmp_tuple_element_26);
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_kw_name_13 = tmp_class_creation_7__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 233;
tmp_assign_source_70 = CALL_FUNCTION(tmp_called_name_13, tmp_args_name_13, tmp_kw_name_13);
Py_DECREF(tmp_called_name_13);
Py_DECREF(tmp_args_name_13);
if (tmp_assign_source_70 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
assert(tmp_class_creation_7__prepared == NULL);
tmp_class_creation_7__prepared = tmp_assign_source_70;
}
{
nuitka_bool tmp_condition_result_41;
PyObject *tmp_operand_name_7;
PyObject *tmp_expression_name_35;
CHECK_OBJECT(tmp_class_creation_7__prepared);
tmp_expression_name_35 = tmp_class_creation_7__prepared;
tmp_res = PyObject_HasAttr(tmp_expression_name_35, const_str_plain___getitem__);
tmp_operand_name_7 = (tmp_res != 0) ? Py_True : Py_False;
tmp_res = CHECK_IF_TRUE(tmp_operand_name_7);
if (tmp_res == -1) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_condition_result_41 = (tmp_res == 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
if (tmp_condition_result_41 == NUITKA_BOOL_TRUE) {
goto branch_yes_27;
} else {
goto branch_no_27;
}
}
branch_yes_27:;
{
PyObject *tmp_raise_type_7;
PyObject *tmp_raise_value_7;
PyObject *tmp_left_name_7;
PyObject *tmp_right_name_7;
PyObject *tmp_tuple_element_27;
PyObject *tmp_getattr_target_7;
PyObject *tmp_getattr_attr_7;
PyObject *tmp_getattr_default_7;
PyObject *tmp_expression_name_36;
PyObject *tmp_type_arg_14;
tmp_raise_type_7 = PyExc_TypeError;
tmp_left_name_7 = const_str_digest_75fd71b1edada749c2ef7ac810062295;
CHECK_OBJECT(tmp_class_creation_7__metaclass);
tmp_getattr_target_7 = tmp_class_creation_7__metaclass;
tmp_getattr_attr_7 = const_str_plain___name__;
tmp_getattr_default_7 = const_str_angle_metaclass;
tmp_tuple_element_27 = BUILTIN_GETATTR(tmp_getattr_target_7, tmp_getattr_attr_7, tmp_getattr_default_7);
if (tmp_tuple_element_27 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
tmp_right_name_7 = PyTuple_New(2);
PyTuple_SET_ITEM(tmp_right_name_7, 0, tmp_tuple_element_27);
CHECK_OBJECT(tmp_class_creation_7__prepared);
tmp_type_arg_14 = tmp_class_creation_7__prepared;
tmp_expression_name_36 = BUILTIN_TYPE1(tmp_type_arg_14);
assert(!(tmp_expression_name_36 == NULL));
tmp_tuple_element_27 = LOOKUP_ATTRIBUTE(tmp_expression_name_36, const_str_plain___name__);
Py_DECREF(tmp_expression_name_36);
if (tmp_tuple_element_27 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
Py_DECREF(tmp_right_name_7);
exception_lineno = 233;
goto try_except_handler_20;
}
PyTuple_SET_ITEM(tmp_right_name_7, 1, tmp_tuple_element_27);
tmp_raise_value_7 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_7, tmp_right_name_7);
Py_DECREF(tmp_right_name_7);
if (tmp_raise_value_7 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_20;
}
exception_type = tmp_raise_type_7;
Py_INCREF(tmp_raise_type_7);
exception_value = tmp_raise_value_7;
exception_lineno = 233;
RAISE_EXCEPTION_IMPLICIT(&exception_type, &exception_value, &exception_tb);
goto try_except_handler_20;
}
branch_no_27:;
goto branch_end_26;
branch_no_26:;
{
PyObject *tmp_assign_source_71;
tmp_assign_source_71 = PyDict_New();
assert(tmp_class_creation_7__prepared == NULL);
tmp_class_creation_7__prepared = tmp_assign_source_71;
}
branch_end_26:;
{
PyObject *tmp_assign_source_72;
{
PyObject *tmp_set_locals_7;
CHECK_OBJECT(tmp_class_creation_7__prepared);
tmp_set_locals_7 = tmp_class_creation_7__prepared;
locals_youtube_dl$extractor$adobetv_233 = tmp_set_locals_7;
Py_INCREF(tmp_set_locals_7);
}
// Tried code:
// Tried code:
tmp_dictset_value = const_str_digest_94d9324bf4313266f4f235e52c670f28;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain___module__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_22;
}
tmp_dictset_value = const_str_plain_AdobeTVVideoIE;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain___qualname__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_22;
}
if (isFrameUnusable(cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8)) {
Py_XDECREF(cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
#if _DEBUG_REFCOUNTS
if (cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8 == NULL) {
count_active_frame_cache_instances += 1;
} else {
count_released_frame_cache_instances += 1;
}
count_allocated_frame_cache_instances += 1;
#endif
cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8 = MAKE_FUNCTION_FRAME(codeobj_b22fbb524a47a23a55ddf9d42313a6dc, module_youtube_dl$extractor$adobetv, sizeof(void *));
#if _DEBUG_REFCOUNTS
} else {
count_hit_frame_cache_instances += 1;
#endif
}
assert(cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8->m_type_description == NULL);
frame_b22fbb524a47a23a55ddf9d42313a6dc_8 = cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8;
// Push the new frame as the currently active one.
pushFrameStack(frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
// Mark the frame object as in use, ref count 1 will be up for reuse.
assert(Py_REFCNT(frame_b22fbb524a47a23a55ddf9d42313a6dc_8) == 2); // Frame stack
// Framed code:
tmp_dictset_value = const_str_digest_9b21f56486eea5829f65df0a985977e3;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain_IE_NAME, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 234;
type_description_2 = "o";
goto frame_exception_exit_8;
}
tmp_dictset_value = const_str_digest_b6c90a0dcb28b42fff3cda6f9495e216;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain__VALID_URL, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 235;
type_description_2 = "o";
goto frame_exception_exit_8;
}
tmp_dictset_value = DEEP_COPY(const_dict_76fc067bda8e821508b19c9d308e4957);
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain__TEST, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 237;
type_description_2 = "o";
goto frame_exception_exit_8;
}
tmp_dictset_value = MAKE_FUNCTION_youtube_dl$extractor$adobetv$$$function_11__real_extract();
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain__real_extract, tmp_dictset_value);
Py_DECREF(tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 250;
type_description_2 = "o";
goto frame_exception_exit_8;
}
#if 0
RESTORE_FRAME_EXCEPTION(frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
#endif
// Put the previous frame back on top.
popFrameStack();
goto frame_no_exception_7;
frame_exception_exit_8:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_b22fbb524a47a23a55ddf9d42313a6dc_8, exception_lineno);
} else if (exception_tb->tb_frame != &frame_b22fbb524a47a23a55ddf9d42313a6dc_8->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_b22fbb524a47a23a55ddf9d42313a6dc_8, exception_lineno);
}
// Attachs locals to frame if any.
Nuitka_Frame_AttachLocals(
frame_b22fbb524a47a23a55ddf9d42313a6dc_8,
type_description_2,
outline_6_var___class__
);
// Release cached frame.
if (frame_b22fbb524a47a23a55ddf9d42313a6dc_8 == cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8) {
#if _DEBUG_REFCOUNTS
count_active_frame_cache_instances -= 1;
count_released_frame_cache_instances += 1;
#endif
Py_DECREF(frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
}
cache_frame_b22fbb524a47a23a55ddf9d42313a6dc_8 = NULL;
assertFrameObject(frame_b22fbb524a47a23a55ddf9d42313a6dc_8);
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto nested_frame_exit_7;
frame_no_exception_7:;
goto skip_nested_handling_7;
nested_frame_exit_7:;
goto try_except_handler_22;
skip_nested_handling_7:;
{
nuitka_bool tmp_condition_result_42;
PyObject *tmp_compexpr_left_7;
PyObject *tmp_compexpr_right_7;
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_compexpr_left_7 = tmp_class_creation_7__bases;
CHECK_OBJECT(tmp_class_creation_7__bases_orig);
tmp_compexpr_right_7 = tmp_class_creation_7__bases_orig;
tmp_condition_result_42 = RICH_COMPARE_NE_NBOOL_OBJECT_TUPLE(tmp_compexpr_left_7, tmp_compexpr_right_7);
if (tmp_condition_result_42 == NUITKA_BOOL_EXCEPTION) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_22;
}
if (tmp_condition_result_42 == NUITKA_BOOL_TRUE) {
goto branch_yes_28;
} else {
goto branch_no_28;
}
}
branch_yes_28:;
CHECK_OBJECT(tmp_class_creation_7__bases_orig);
tmp_dictset_value = tmp_class_creation_7__bases_orig;
tmp_res = PyObject_SetItem(locals_youtube_dl$extractor$adobetv_233, const_str_plain___orig_bases__, tmp_dictset_value);
if (tmp_res != 0) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_22;
}
branch_no_28:;
{
PyObject *tmp_assign_source_73;
PyObject *tmp_called_name_14;
PyObject *tmp_args_name_14;
PyObject *tmp_tuple_element_28;
PyObject *tmp_kw_name_14;
CHECK_OBJECT(tmp_class_creation_7__metaclass);
tmp_called_name_14 = tmp_class_creation_7__metaclass;
tmp_tuple_element_28 = const_str_plain_AdobeTVVideoIE;
tmp_args_name_14 = PyTuple_New(3);
Py_INCREF(tmp_tuple_element_28);
PyTuple_SET_ITEM(tmp_args_name_14, 0, tmp_tuple_element_28);
CHECK_OBJECT(tmp_class_creation_7__bases);
tmp_tuple_element_28 = tmp_class_creation_7__bases;
Py_INCREF(tmp_tuple_element_28);
PyTuple_SET_ITEM(tmp_args_name_14, 1, tmp_tuple_element_28);
tmp_tuple_element_28 = locals_youtube_dl$extractor$adobetv_233;
Py_INCREF(tmp_tuple_element_28);
PyTuple_SET_ITEM(tmp_args_name_14, 2, tmp_tuple_element_28);
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
tmp_kw_name_14 = tmp_class_creation_7__class_decl_dict;
frame_c9377acb7551bcadf8d3742266bc3096->m_frame.f_lineno = 233;
tmp_assign_source_73 = CALL_FUNCTION(tmp_called_name_14, tmp_args_name_14, tmp_kw_name_14);
Py_DECREF(tmp_args_name_14);
if (tmp_assign_source_73 == NULL) {
assert(ERROR_OCCURRED());
FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
exception_lineno = 233;
goto try_except_handler_22;
}
assert(outline_6_var___class__ == NULL);
outline_6_var___class__ = tmp_assign_source_73;
}
CHECK_OBJECT(outline_6_var___class__);
tmp_assign_source_72 = outline_6_var___class__;
Py_INCREF(tmp_assign_source_72);
goto try_return_handler_22;
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_22:;
Py_DECREF(locals_youtube_dl$extractor$adobetv_233);
locals_youtube_dl$extractor$adobetv_233 = NULL;
goto try_return_handler_21;
// Exception handler code:
try_except_handler_22:;
exception_keeper_type_20 = exception_type;
exception_keeper_value_20 = exception_value;
exception_keeper_tb_20 = exception_tb;
exception_keeper_lineno_20 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_DECREF(locals_youtube_dl$extractor$adobetv_233);
locals_youtube_dl$extractor$adobetv_233 = NULL;
// Re-raise.
exception_type = exception_keeper_type_20;
exception_value = exception_keeper_value_20;
exception_tb = exception_keeper_tb_20;
exception_lineno = exception_keeper_lineno_20;
goto try_except_handler_21;
// End of try:
NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
return NULL;
// Return handler code:
try_return_handler_21:;
CHECK_OBJECT(outline_6_var___class__);
Py_DECREF(outline_6_var___class__);
outline_6_var___class__ = NULL;
goto outline_result_7;
// Exception handler code:
try_except_handler_21:;
exception_keeper_type_21 = exception_type;
exception_keeper_value_21 = exception_value;
exception_keeper_tb_21 = exception_tb;
exception_keeper_lineno_21 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
// Re-raise.
exception_type = exception_keeper_type_21;
exception_value = exception_keeper_value_21;
exception_tb = exception_keeper_tb_21;
exception_lineno = exception_keeper_lineno_21;
goto outline_exception_7;
// End of try:
NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
return NULL;
outline_exception_7:;
exception_lineno = 233;
goto try_except_handler_20;
outline_result_7:;
UPDATE_STRING_DICT1(moduledict_youtube_dl$extractor$adobetv, (Nuitka_StringObject *)const_str_plain_AdobeTVVideoIE, tmp_assign_source_72);
}
goto try_end_8;
// Exception handler code:
try_except_handler_20:;
exception_keeper_type_22 = exception_type;
exception_keeper_value_22 = exception_value;
exception_keeper_tb_22 = exception_tb;
exception_keeper_lineno_22 = exception_lineno;
exception_type = NULL;
exception_value = NULL;
exception_tb = NULL;
exception_lineno = 0;
Py_XDECREF(tmp_class_creation_7__bases_orig);
tmp_class_creation_7__bases_orig = NULL;
Py_XDECREF(tmp_class_creation_7__bases);
tmp_class_creation_7__bases = NULL;
Py_XDECREF(tmp_class_creation_7__class_decl_dict);
tmp_class_creation_7__class_decl_dict = NULL;
Py_XDECREF(tmp_class_creation_7__metaclass);
tmp_class_creation_7__metaclass = NULL;
Py_XDECREF(tmp_class_creation_7__prepared);
tmp_class_creation_7__prepared = NULL;
// Re-raise.
exception_type = exception_keeper_type_22;
exception_value = exception_keeper_value_22;
exception_tb = exception_keeper_tb_22;
exception_lineno = exception_keeper_lineno_22;
goto frame_exception_exit_1;
// End of try:
try_end_8:;
// Restore frame exception if necessary.
#if 0
RESTORE_FRAME_EXCEPTION(frame_c9377acb7551bcadf8d3742266bc3096);
#endif
popFrameStack();
assertFrameObject(frame_c9377acb7551bcadf8d3742266bc3096);
goto frame_no_exception_8;
frame_exception_exit_1:;
#if 0
RESTORE_FRAME_EXCEPTION(frame_c9377acb7551bcadf8d3742266bc3096);
#endif
if (exception_tb == NULL) {
exception_tb = MAKE_TRACEBACK(frame_c9377acb7551bcadf8d3742266bc3096, exception_lineno);
} else if (exception_tb->tb_frame != &frame_c9377acb7551bcadf8d3742266bc3096->m_frame) {
exception_tb = ADD_TRACEBACK(exception_tb, frame_c9377acb7551bcadf8d3742266bc3096, exception_lineno);
}
// Put the previous frame back on top.
popFrameStack();
// Return the error.
goto module_exception_exit;
frame_no_exception_8:;
CHECK_OBJECT(tmp_class_creation_7__bases_orig);
Py_DECREF(tmp_class_creation_7__bases_orig);
tmp_class_creation_7__bases_orig = NULL;
CHECK_OBJECT(tmp_class_creation_7__bases);
Py_DECREF(tmp_class_creation_7__bases);
tmp_class_creation_7__bases = NULL;
CHECK_OBJECT(tmp_class_creation_7__class_decl_dict);
Py_DECREF(tmp_class_creation_7__class_decl_dict);
tmp_class_creation_7__class_decl_dict = NULL;
CHECK_OBJECT(tmp_class_creation_7__metaclass);
Py_DECREF(tmp_class_creation_7__metaclass);
tmp_class_creation_7__metaclass = NULL;
CHECK_OBJECT(tmp_class_creation_7__prepared);
Py_DECREF(tmp_class_creation_7__prepared);
tmp_class_creation_7__prepared = NULL;
return module_youtube_dl$extractor$adobetv;
module_exception_exit:
RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
return NULL;
}
| [
"[email protected]"
] | |
fa0fcb080796c51b8532adbd30d206a83839ce8e | 7ccecdd795695cfac3857a8231375513bba6d190 | /include/rocker_switch.h | 207092dff08d3d453e83b7d36b41b9096bad38b8 | [] | no_license | project-march/input-device | 1df8d07afbeba5132a635f78f1a5eb6b264bd0df | 35531be2a1c02edbc5e3131cc1d3dc6549a99687 | refs/heads/master | 2021-06-24T05:26:49.572143 | 2020-12-01T10:48:23 | 2020-12-01T10:48:23 | 161,337,430 | 2 | 1 | null | 2020-10-22T11:12:57 | 2018-12-11T13:23:10 | C++ | UTF-8 | C++ | false | false | 668 | h | #ifndef ROCKER_SWITCH_H
#define ROCKER_SWITCH_H
#include "rocker_switch_state.h"
#include <Arduino.h>
class RockerSwitch
{
public:
explicit RockerSwitch(uint8_t up_pin, uint8_t down_pin);
RockerSwitchState getState();
private:
const uint8_t up_pin_;
const uint8_t down_pin_;
RockerSwitchState last_position_ = RockerSwitchState::NEUTRAL;
uint64_t last_print_time_ = 0;
// Microseconds. May introduce unwanted behaviour if changed
const useconds_t bounce_time_ = 20000;
// Milliseconds. Determines how often up or down are returned if the rocker
// switch is held up or down.
const uint64_t hold_time_ = 1000;
};
#endif // ROCKER_SWITCH_H
| [
"[email protected]"
] | |
a282eb17e79f517108337761b6090384dc2cef5e | 9f546f7b3ccaa2864353fc472f227ade85634cda | /tools/doc/doc_data.cpp | c278662db21056d7ea4800bf20deee06fce77562 | [
"MIT"
] | permissive | AkshayaRaj/godot | 5bd1c89dcae7d9de0b1dd09ad9f27a6a1aeef5e6 | 70752f3e4bee88bd525285fb1fef7149a636b1b2 | refs/heads/master | 2021-01-12T20:55:10.381594 | 2015-04-20T23:51:52 | 2015-04-20T23:51:52 | 34,343,451 | 1 | 0 | null | 2015-04-21T18:00:47 | 2015-04-21T18:00:46 | null | UTF-8 | C++ | false | false | 28,131 | cpp | /*************************************************************************/
/* doc_data.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "version.h"
#include "doc_data.h"
#include "global_constants.h"
#include "globals.h"
#include "script_language.h"
#include "io/marshalls.h"
#include "io/compression.h"
#include "scene/resources/theme.h"
void DocData::merge_from(const DocData& p_data) {
for( Map<String,ClassDoc>::Element *E=class_list.front();E;E=E->next()) {
ClassDoc &c = E->get();
if (!p_data.class_list.has(c.name))
continue;
const ClassDoc &cf = p_data.class_list[c.name];
c.description=cf.description;
c.brief_description=cf.brief_description;
for(int i=0;i<c.methods.size();i++) {
MethodDoc &m = c.methods[i];
for(int j=0;j<cf.methods.size();j++) {
if (cf.methods[j].name!=m.name)
continue;
const MethodDoc &mf = cf.methods[j];
m.description=mf.description;
break;
}
}
for(int i=0;i<c.signals.size();i++) {
MethodDoc &m = c.signals[i];
for(int j=0;j<cf.signals.size();j++) {
if (cf.signals[j].name!=m.name)
continue;
const MethodDoc &mf = cf.signals[j];
m.description=mf.description;
break;
}
}
for(int i=0;i<c.constants.size();i++) {
ConstantDoc &m = c.constants[i];
for(int j=0;j<cf.constants.size();j++) {
if (cf.constants[j].name!=m.name)
continue;
const ConstantDoc &mf = cf.constants[j];
m.description=mf.description;
break;
}
}
for(int i=0;i<c.properties.size();i++) {
PropertyDoc &p = c.properties[i];
for(int j=0;j<cf.properties.size();j++) {
if (cf.properties[j].name!=p.name)
continue;
const PropertyDoc &pf = cf.properties[j];
p.description=pf.description;
break;
}
}
for(int i=0;i<c.theme_properties.size();i++) {
PropertyDoc &p = c.theme_properties[i];
for(int j=0;j<cf.theme_properties.size();j++) {
if (cf.theme_properties[j].name!=p.name)
continue;
const PropertyDoc &pf = cf.theme_properties[j];
p.description=pf.description;
break;
}
}
}
}
void DocData::generate(bool p_basic_types) {
List<String> classes;
ObjectTypeDB::get_type_list(&classes);
classes.sort();
while(classes.size()) {
String name=classes.front()->get();
String cname=name;
if (cname.begins_with("_")) //proxy class
cname=cname.substr(1,name.length());
class_list[cname]=ClassDoc();
ClassDoc& c = class_list[cname];
c.name=cname;
c.inherits=ObjectTypeDB::type_inherits_from(name);
c.category=ObjectTypeDB::get_category(name);
List<MethodInfo> method_list;
ObjectTypeDB::get_method_list(name,&method_list,true);
method_list.sort();
for(List<MethodInfo>::Element *E=method_list.front();E;E=E->next()) {
if (E->get().name=="" || (E->get().name[0]=='_' && !(E->get().flags&METHOD_FLAG_VIRTUAL)))
continue; //hiden, dont count
MethodDoc method;
method.name=E->get().name;
MethodBind *m = ObjectTypeDB::get_method(name,E->get().name);
if (E->get().flags&METHOD_FLAG_VIRTUAL)
method.qualifiers="virtual";
if (E->get().flags&METHOD_FLAG_CONST) {
if (method.qualifiers!="")
method.qualifiers+=" ";
method.qualifiers+="const";
}
for(int i=-1;i<E->get().arguments.size();i++) {
PropertyInfo arginfo;
if (i==-1) {
arginfo=E->get().return_val;
if (arginfo.type==Variant::NIL)
continue;
if (m && m->get_return_type()!=StringName())
method.return_type=m->get_return_type();
else
method.return_type=(arginfo.hint==PROPERTY_HINT_RESOURCE_TYPE)?arginfo.hint_string:Variant::get_type_name(arginfo.type);
} else {
ArgumentDoc argument;
arginfo=E->get().arguments[i];
String type_name;
if (arginfo.name.find(":")!=-1) {
type_name=arginfo.name.get_slice(":",1);
arginfo.name=arginfo.name.get_slice(":",0);
} else if (arginfo.hint==PROPERTY_HINT_RESOURCE_TYPE) {
type_name=arginfo.hint_string;
} else if (arginfo.type==Variant::NIL)
type_name="var";
else
type_name=Variant::get_type_name(arginfo.type);
if (arginfo.type==Variant::OBJECT) {
//print_line("validate: "+cname+"::"+method.name);
}
if (m && m->has_default_argument(i)) {
Variant default_arg=m->get_default_argument(i);
String default_arg_text=m->get_default_argument(i);
switch(default_arg.get_type()) {
case Variant::NIL:
default_arg_text="NULL";
break;
// atomic types
case Variant::BOOL:
if (bool(default_arg))
default_arg_text="true";
else
default_arg_text="false";
break;
case Variant::INT:
case Variant::REAL:
//keep it
break;
case Variant::STRING: // 15
case Variant::NODE_PATH: // 15
default_arg_text="\""+default_arg_text+"\"";
break;
case Variant::TRANSFORM:
if (default_arg.operator Transform()==Transform()) {
default_arg_text="";
}
default_arg_text=Variant::get_type_name(default_arg.get_type())+"("+default_arg_text+")";
break;
case Variant::VECTOR2: // 5
case Variant::RECT2:
case Variant::VECTOR3:
case Variant::PLANE:
case Variant::QUAT:
case Variant::_AABB: //sorry naming convention fail :( not like it's used often // 10
case Variant::MATRIX3:
case Variant::COLOR:
case Variant::RAW_ARRAY:
case Variant::INT_ARRAY:
case Variant::REAL_ARRAY:
case Variant::STRING_ARRAY: //25
case Variant::VECTOR3_ARRAY:
case Variant::COLOR_ARRAY:
default_arg_text=Variant::get_type_name(default_arg.get_type())+"("+default_arg_text+")";
break;
case Variant::OBJECT:
case Variant::INPUT_EVENT:
case Variant::DICTIONARY: // 20
case Variant::ARRAY:
case Variant::_RID:
case Variant::IMAGE:
//case Variant::RESOURCE:
default_arg_text=Variant::get_type_name(default_arg.get_type())+"()";
break;
default: {}
}
argument.type=type_name;
argument.name=arginfo.name;
argument.default_value=default_arg_text;
} else {
argument.type=type_name;
argument.name=arginfo.name;
}
if (arginfo.type==Variant::OBJECT) {
//print_line("validate: "+cname+"::"+method.name);
}
method.arguments.push_back(argument);
}
/*
String hint;
switch(arginfo.hint) {
case PROPERTY_HINT_DIR: hint="A directory."; break;
case PROPERTY_HINT_RANGE: hint="Range - min: "+arginfo.hint_string.get_slice(",",0)+" max: "+arginfo.hint_string.get_slice(",",1)+" step: "+arginfo.hint_string.get_slice(",",2); break;
case PROPERTY_HINT_ENUM: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(j); } break;
case PROPERTY_HINT_LENGTH: hint="Length: "+arginfo.hint_string; break;
case PROPERTY_HINT_FLAGS: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(1<<j); } break;
case PROPERTY_HINT_FILE: hint="A file:"; break;
//case PROPERTY_HINT_RESOURCE_TYPE: hint="Type: "+arginfo.hint_string; break;
};
if (hint!="")
_write_string(f,4,hint);
*/
}
c.methods.push_back(method);
}
List<MethodInfo> signal_list;
ObjectTypeDB::get_signal_list(name,&signal_list,true);
if (signal_list.size()) {
for(List<MethodInfo>::Element *EV=signal_list.front();EV;EV=EV->next()) {
MethodDoc signal;
signal.name=EV->get().name;
for(int i=0;i<EV->get().arguments.size();i++) {
PropertyInfo arginfo=EV->get().arguments[i];
ArgumentDoc argument;
argument.name=arginfo.name;
argument.type=Variant::get_type_name(arginfo.type);
signal.arguments.push_back(argument);
}
c.signals.push_back(signal);
}
}
List<String> constant_list;
ObjectTypeDB::get_integer_constant_list(name, &constant_list, true);
for(List<String>::Element *E=constant_list.front();E;E=E->next()) {
ConstantDoc constant;
constant.name=E->get();
constant.value=itos(ObjectTypeDB::get_integer_constant(name, E->get()));
c.constants.push_back(constant);
}
//theme stuff
{
List<StringName> l;
Theme::get_default()->get_constant_list(cname,&l);
for (List<StringName>::Element*E=l.front();E;E=E->next()) {
PropertyDoc pd;
pd.name=E->get();
pd.type="int";
c.theme_properties.push_back(pd);
}
l.clear();
Theme::get_default()->get_color_list(cname,&l);
for (List<StringName>::Element*E=l.front();E;E=E->next()) {
PropertyDoc pd;
pd.name=E->get();
pd.type="Color";
c.theme_properties.push_back(pd);
}
l.clear();
Theme::get_default()->get_icon_list(cname,&l);
for (List<StringName>::Element*E=l.front();E;E=E->next()) {
PropertyDoc pd;
pd.name=E->get();
pd.type="Texture";
c.theme_properties.push_back(pd);
}
l.clear();
Theme::get_default()->get_font_list(cname,&l);
for (List<StringName>::Element*E=l.front();E;E=E->next()) {
PropertyDoc pd;
pd.name=E->get();
pd.type="Font";
c.theme_properties.push_back(pd);
}
l.clear();
Theme::get_default()->get_stylebox_list(cname,&l);
for (List<StringName>::Element*E=l.front();E;E=E->next()) {
PropertyDoc pd;
pd.name=E->get();
pd.type="StyleBox";
c.theme_properties.push_back(pd);
}
}
classes.pop_front();
}
if (!p_basic_types)
return;
for (int i=0;i<Variant::VARIANT_MAX;i++) {
if (i==Variant::OBJECT)
continue; //use the core type instead
int loops=1;
if (i==Variant::INPUT_EVENT)
loops=InputEvent::TYPE_MAX;
for(int j=0;j<loops;j++) {
String cname=Variant::get_type_name(Variant::Type(i));
if (i==Variant::INPUT_EVENT) {
static const char* ie_type[InputEvent::TYPE_MAX]={
"","Key","MouseMotion","MouseButton","JoyMotion","JoyButton","ScreenTouch","ScreenDrag","Action"
};
cname+=ie_type[j];
}
class_list[cname]=ClassDoc();
ClassDoc& c = class_list[cname];
c.name=cname;
c.category="Built-In Types";
Variant::CallError cerror;
Variant v=Variant::construct(Variant::Type(i),NULL,0,cerror);
if (i==Variant::INPUT_EVENT) {
v.set("type",j);
}
List<MethodInfo> method_list;
v.get_method_list(&method_list);
method_list.sort();
Variant::get_constructor_list(Variant::Type(i),&method_list);
for(List<MethodInfo>::Element *E=method_list.front();E;E=E->next()) {
MethodInfo &mi=E->get();
MethodDoc method;
method.name=mi.name;
for(int i=0;i<mi.arguments.size();i++) {
ArgumentDoc arg;
PropertyInfo pi=mi.arguments[i];
arg.name=pi.name;
//print_line("arg name: "+arg.name);
if (pi.type==Variant::NIL)
arg.type="var";
else
arg.type=Variant::get_type_name(pi.type);
int defarg = mi.default_arguments.size() - mi.arguments.size() + i;
if (defarg >=0)
arg.default_value=mi.default_arguments[defarg];
method.arguments.push_back(arg);
}
if (mi.return_val.type==Variant::NIL) {
if (mi.return_val.name!="")
method.return_type="var";
} else {
method.return_type=Variant::get_type_name(mi.return_val.type);
}
c.methods.push_back(method);
}
List<PropertyInfo> properties;
v.get_property_list(&properties);
for(List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) {
PropertyInfo pi=E->get();
PropertyDoc property;
property.name=pi.name;
property.type=Variant::get_type_name(pi.type);
c.properties.push_back(property);
}
List<StringName> constants;
Variant::get_numeric_constants_for_type(Variant::Type(i),&constants);
for(List<StringName>::Element *E=constants.front();E;E=E->next()) {
ConstantDoc constant;
constant.name=E->get();
constant.value=itos(Variant::get_numeric_constant_value(Variant::Type(i),E->get()));
c.constants.push_back(constant);
}
}
}
//built in constants and functions
{
String cname="@Global Scope";
class_list[cname]=ClassDoc();
ClassDoc& c = class_list[cname];
c.name=cname;
for(int i=0;i<GlobalConstants::get_global_constant_count();i++) {
ConstantDoc cd;
cd.name=GlobalConstants::get_global_constant_name(i);
cd.value=itos(GlobalConstants::get_global_constant_value(i));
c.constants.push_back(cd);
}
List<Globals::Singleton> singletons;
Globals::get_singleton()->get_singletons(&singletons);
//servers (this is kind of hackish)
for(List<Globals::Singleton>::Element *E=singletons.front();E;E=E->next()) {
PropertyDoc pd;
Globals::Singleton &s=E->get();
pd.name=s.name;
pd.type=s.ptr->get_type();
while (ObjectTypeDB::type_inherits_from(pd.type)!="Object")
pd.type=ObjectTypeDB::type_inherits_from(pd.type);
if (pd.type.begins_with("_"))
pd.type=pd.type.substr(1,pd.type.length());
c.properties.push_back(pd);
}
}
//built in script reference
{
for(int i=0;i<ScriptServer::get_language_count();i++) {
ScriptLanguage *lang = ScriptServer::get_language(i);
String cname="@"+lang->get_name();
class_list[cname]=ClassDoc();
ClassDoc& c = class_list[cname];
c.name=cname;
List<MethodInfo> minfo;
lang->get_public_functions(&minfo);
for(List<MethodInfo>::Element *E=minfo.front();E;E=E->next()) {
MethodInfo &mi=E->get();
MethodDoc md;
md.name=mi.name;
if (mi.return_val.name!="")
md.return_type=mi.return_val.name;
else
md.return_type=Variant::get_type_name(mi.return_val.type);
for(int i=0;i<mi.arguments.size();i++) {
PropertyInfo &pi=mi.arguments[i];
ArgumentDoc ad;
ad.name=pi.name;
if (pi.type==Variant::NIL)
ad.type="var";
else
ad.type=Variant::get_type_name( pi.type );
md.arguments.push_back(ad);
}
c.methods.push_back(md);
}
List<Pair<String,Variant> > cinfo;
lang->get_public_constants(&cinfo);
for(List<Pair<String,Variant> >::Element *E=cinfo.front();E;E=E->next()) {
ConstantDoc cd;
cd.name=E->get().first;
cd.value=E->get().second;
c.constants.push_back(cd);
}
}
}
}
static Error _parse_methods(Ref<XMLParser>& parser,Vector<DocData::MethodDoc>& methods) {
String section=parser->get_node_name();
String element=section.substr(0,section.length()-1);
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
if (parser->get_node_name()==element) {
DocData::MethodDoc method;
ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
method.name=parser->get_attribute_value("name");
if (parser->has_attribute("qualifiers"))
method.qualifiers=parser->get_attribute_value("qualifiers");
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
String name=parser->get_node_name();
if (name=="return") {
ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
method.return_type=parser->get_attribute_value("type");
} else if (name=="argument") {
DocData::ArgumentDoc argument;
ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
argument.name=parser->get_attribute_value("name");
ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
argument.type=parser->get_attribute_value("type");
method.arguments.push_back(argument);
} else if (name=="description") {
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
method.description=parser->get_node_data().strip_edges();
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()==element)
break;
}
methods.push_back(method);
} else {
ERR_EXPLAIN("Invalid tag in doc file: "+parser->get_node_name());
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()==section)
break;
}
return OK;
}
Error DocData::load(const String& p_path) {
Ref<XMLParser> parser=memnew(XMLParser);
Error err = parser->open(p_path);
if (err)
return err;
return _load(parser);
}
Error DocData::_load(Ref<XMLParser> parser) {
Error err=OK;
while((err=parser->read())==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
if (parser->get_node_name() == "doc") {
break;
} else if (!parser->is_empty())
parser->skip_section();// unknown section, likely headers
}
}
if (parser->has_attribute("version"))
version=parser->get_attribute_value("version");
while((err=parser->read())==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="doc")
break; //end of <doc>
if (parser->get_node_type() != XMLParser::NODE_ELEMENT)
continue; //no idea what this may be, but skipping anyway
ERR_FAIL_COND_V( parser->get_node_name()!="class", ERR_FILE_CORRUPT );
ERR_FAIL_COND_V( !parser->has_attribute("name"), ERR_FILE_CORRUPT);
String name = parser->get_attribute_value("name");
class_list[name]=ClassDoc();
ClassDoc& c = class_list[name];
// print_line("class: "+name);
c.name=name;
if (parser->has_attribute("inherits"))
c.inherits = parser->get_attribute_value("inherits");
if (parser->has_attribute("category"))
c.category = parser->get_attribute_value("category");
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
String name = parser->get_node_name();
if (name=="brief_description") {
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
c.brief_description=parser->get_node_data().strip_edges();
} else if (name=="description") {
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
c.description=parser->get_node_data().strip_edges();
} else if (name=="methods") {
Error err = _parse_methods(parser,c.methods);
ERR_FAIL_COND_V(err,err);
} else if (name=="signals") {
Error err = _parse_methods(parser,c.signals);
ERR_FAIL_COND_V(err,err);
} else if (name=="members") {
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
String name = parser->get_node_name();
if (name=="member") {
PropertyDoc prop;
ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
prop.name=parser->get_attribute_value("name");
ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
prop.type=parser->get_attribute_value("type");
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
prop.description=parser->get_node_data().strip_edges();
c.properties.push_back(prop);
} else {
ERR_EXPLAIN("Invalid tag in doc file: "+name);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="members")
break; //end of <constants>
}
} else if (name=="theme_items") {
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
String name = parser->get_node_name();
if (name=="theme_item") {
PropertyDoc prop;
ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
prop.name=parser->get_attribute_value("name");
ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
prop.type=parser->get_attribute_value("type");
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
prop.description=parser->get_node_data().strip_edges();
c.theme_properties.push_back(prop);
} else {
ERR_EXPLAIN("Invalid tag in doc file: "+name);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="theme_items")
break; //end of <constants>
}
} else if (name=="constants") {
while(parser->read()==OK) {
if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
String name=parser->get_node_name();
if (name=="constant") {
ConstantDoc constant;
ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
constant.name=parser->get_attribute_value("name");
ERR_FAIL_COND_V(!parser->has_attribute("value"),ERR_FILE_CORRUPT);
constant.value=parser->get_attribute_value("value");
parser->read();
if (parser->get_node_type()==XMLParser::NODE_TEXT)
constant.description=parser->get_node_data().strip_edges();
c.constants.push_back(constant);
} else {
ERR_EXPLAIN("Invalid tag in doc file: "+name);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="constants")
break; //end of <constants>
}
} else {
ERR_EXPLAIN("Invalid tag in doc file: "+name);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="class")
break; //end of <asset>
}
}
return OK;
}
static void _write_string(FileAccess *f,int p_tablevel,const String& p_string) {
String tab;
for(int i=0;i<p_tablevel;i++) tab+="\t";
f->store_string(tab+p_string+"\n");
}
Error DocData::save(const String& p_path) {
Error err;
FileAccess *f = FileAccess::open(p_path,FileAccess::WRITE,&err);
if (err) {
ERR_EXPLAIN("Can't write doc file: "+p_path);
ERR_FAIL_V(err);
}
_write_string(f,0,"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
_write_string(f,0,"<doc version=\""+String(VERSION_MKSTRING)+"\" name=\"Engine Types\">");
for( Map<String,ClassDoc>::Element *E=class_list.front();E;E=E->next()) {
ClassDoc &c=E->get();
String header="<class name=\""+c.name+"\"";
if (c.inherits!="")
header+=" inherits=\""+c.inherits+"\"";
String category=c.category;
if (c.category=="")
category="Core";
header+=" category=\""+category+"\"";
header+=">";
_write_string(f,0,header);
_write_string(f,1,"<brief_description>");
if (c.brief_description!="")
_write_string(f,1,c.brief_description.xml_escape());
_write_string(f,1,"</brief_description>");
_write_string(f,1,"<description>");
if (c.description!="")
_write_string(f,1,c.description.xml_escape());
_write_string(f,1,"</description>");
_write_string(f,1,"<methods>");
for(int i=0;i<c.methods.size();i++) {
MethodDoc &m=c.methods[i];
String qualifiers;
if (m.qualifiers!="")
qualifiers+="qualifiers=\""+m.qualifiers.xml_escape()+"\"";
_write_string(f,2,"<method name=\""+m.name+"\" "+qualifiers+" >");
if (m.return_type!="") {
_write_string(f,3,"<return type=\""+m.return_type+"\">");
_write_string(f,3,"</return>");
}
for(int j=0;j<m.arguments.size();j++) {
ArgumentDoc &a = m.arguments[j];
if (a.default_value!="")
_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\" default=\""+a.default_value.xml_escape(true)+"\">");
else
_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\">");
_write_string(f,3,"</argument>");
}
_write_string(f,3,"<description>");
if (m.description!="")
_write_string(f,3,m.description.xml_escape());
_write_string(f,3,"</description>");
_write_string(f,2,"</method>");
}
_write_string(f,1,"</methods>");
if (c.properties.size()) {
_write_string(f,1,"<members>");
for(int i=0;i<c.properties.size();i++) {
PropertyDoc &p=c.properties[i];
_write_string(f,2,"<member name=\""+p.name+"\" type=\""+p.type+"\">");
_write_string(f,2,"</member>");
}
_write_string(f,1,"</members>");
}
if (c.signals.size()) {
_write_string(f,1,"<signals>");
for(int i=0;i<c.signals.size();i++) {
MethodDoc &m=c.signals[i];
_write_string(f,2,"<signal name=\""+m.name+"\">");
for(int j=0;j<m.arguments.size();j++) {
ArgumentDoc &a = m.arguments[j];
_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\">");
_write_string(f,3,"</argument>");
}
_write_string(f,3,"<description>");
if (m.description!="")
_write_string(f,3,m.description.xml_escape());
_write_string(f,3,"</description>");
_write_string(f,2,"</signal>");
}
_write_string(f,1,"</signals>");
}
_write_string(f,1,"<constants>");
for(int i=0;i<c.constants.size();i++) {
ConstantDoc &k=c.constants[i];
_write_string(f,2,"<constant name=\""+k.name+"\" value=\""+k.value+"\">");
if (k.description!="")
_write_string(f,3,k.description.xml_escape());
_write_string(f,2,"</constant>");
}
_write_string(f,1,"</constants>");
if (c.theme_properties.size()) {
_write_string(f,1,"<theme_items>");
for(int i=0;i<c.theme_properties.size();i++) {
PropertyDoc &p=c.theme_properties[i];
_write_string(f,2,"<theme_item name=\""+p.name+"\" type=\""+p.type+"\">");
_write_string(f,2,"</theme_item>");
}
_write_string(f,1,"</theme_items>");
}
_write_string(f,0,"</class>");
}
_write_string(f,0,"</doc>");
f->close();
memdelete(f);
return OK;
}
Error DocData::load_compressed(const uint8_t *p_data, int p_compressed_size, int p_uncompressed_size) {
Vector<uint8_t> data;
data.resize(p_uncompressed_size);
Compression::decompress(data.ptr(),p_uncompressed_size,p_data,p_compressed_size,Compression::MODE_DEFLATE);
class_list.clear();
Ref<XMLParser> parser = memnew( XMLParser );
Error err = parser->open_buffer(data);
if (err)
return err;
_load(parser);
return OK;
}
| [
"[email protected]"
] | |
e9e5f0ec5d426b22ffd1aa87b9d45ba5c49e535e | a91796ab826878e54d91c32249f45bb919e0c149 | /modules/core/src/parallel/parallel.cpp | 29b482f5f35350160a9b5557d9883c89972cab2c | [
"Apache-2.0"
] | permissive | opencv/opencv | 8f1c8b5a16980f78de7c6e73a4340d302d1211cc | a308dfca9856574d37abe7628b965e29861fb105 | refs/heads/4.x | 2023-09-01T12:37:49.132527 | 2023-08-30T06:53:59 | 2023-08-30T06:53:59 | 5,108,051 | 68,495 | 62,910 | Apache-2.0 | 2023-09-14T17:37:48 | 2012-07-19T09:40:17 | C++ | UTF-8 | C++ | false | false | 5,374 | cpp | // This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "../precomp.hpp"
#include "parallel.hpp"
#include <opencv2/core/utils/configuration.private.hpp>
#include <opencv2/core/utils/logger.defines.hpp>
#ifdef NDEBUG
#define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_DEBUG + 1
#else
#define CV_LOG_STRIP_LEVEL CV_LOG_LEVEL_VERBOSE + 1
#endif
#include <opencv2/core/utils/logger.hpp>
#include "registry_parallel.hpp"
#include "registry_parallel.impl.hpp"
#include "plugin_parallel_api.hpp"
#include "plugin_parallel_wrapper.impl.hpp"
namespace cv { namespace parallel {
int numThreads = -1;
ParallelForAPI::~ParallelForAPI()
{
// nothing
}
static
std::string& getParallelBackendName()
{
static std::string g_backendName = toUpperCase(cv::utils::getConfigurationParameterString("OPENCV_PARALLEL_BACKEND", ""));
return g_backendName;
}
static bool g_initializedParallelForAPI = false;
static
std::shared_ptr<ParallelForAPI> createParallelForAPI()
{
const std::string& name = getParallelBackendName();
bool isKnown = false;
const auto& backends = getParallelBackendsInfo();
if (!name.empty())
{
CV_LOG_INFO(NULL, "core(parallel): requested backend name: " << name);
}
for (size_t i = 0; i < backends.size(); i++)
{
const auto& info = backends[i];
if (!name.empty())
{
if (name != info.name)
{
continue;
}
isKnown = true;
}
try
{
CV_LOG_DEBUG(NULL, "core(parallel): trying backend: " << info.name << " (priority=" << info.priority << ")");
if (!info.backendFactory)
{
CV_LOG_DEBUG(NULL, "core(parallel): factory is not available (plugins require filesystem support): " << info.name);
continue;
}
std::shared_ptr<ParallelForAPI> backend = info.backendFactory->create();
if (!backend)
{
CV_LOG_VERBOSE(NULL, 0, "core(parallel): not available: " << info.name);
continue;
}
CV_LOG_INFO(NULL, "core(parallel): using backend: " << info.name << " (priority=" << info.priority << ")");
g_initializedParallelForAPI = true;
getParallelBackendName() = info.name;
return backend;
}
catch (const std::exception& e)
{
CV_LOG_WARNING(NULL, "core(parallel): can't initialize " << info.name << " backend: " << e.what());
}
catch (...)
{
CV_LOG_WARNING(NULL, "core(parallel): can't initialize " << info.name << " backend: Unknown C++ exception");
}
}
if (name.empty())
{
CV_LOG_DEBUG(NULL, "core(parallel): fallback on builtin code");
}
else
{
if (!isKnown)
CV_LOG_INFO(NULL, "core(parallel): unknown backend: " << name);
}
g_initializedParallelForAPI = true;
return std::shared_ptr<ParallelForAPI>();
}
static inline
std::shared_ptr<ParallelForAPI> createDefaultParallelForAPI()
{
CV_LOG_DEBUG(NULL, "core(parallel): Initializing parallel backend...");
return createParallelForAPI();
}
std::shared_ptr<ParallelForAPI>& getCurrentParallelForAPI()
{
static std::shared_ptr<ParallelForAPI> g_currentParallelForAPI = createDefaultParallelForAPI();
return g_currentParallelForAPI;
}
void setParallelForBackend(const std::shared_ptr<ParallelForAPI>& api, bool propagateNumThreads)
{
getCurrentParallelForAPI() = api;
if (propagateNumThreads && api)
{
setNumThreads(numThreads);
}
}
bool setParallelForBackend(const std::string& backendName, bool propagateNumThreads)
{
CV_TRACE_FUNCTION();
std::string backendName_u = toUpperCase(backendName);
if (g_initializedParallelForAPI)
{
// ... already initialized
if (getParallelBackendName() == backendName_u)
{
CV_LOG_INFO(NULL, "core(parallel): backend is already activated: " << (backendName.empty() ? "builtin(legacy)" : backendName));
return true;
}
else
{
// ... re-create new
CV_LOG_DEBUG(NULL, "core(parallel): replacing parallel backend...");
getParallelBackendName() = backendName_u;
getCurrentParallelForAPI() = createParallelForAPI();
}
}
else
{
// ... no backend exists, just specify the name (initialization is triggered by getCurrentParallelForAPI() call)
getParallelBackendName() = backendName_u;
}
std::shared_ptr<ParallelForAPI> api = getCurrentParallelForAPI();
if (!api)
{
if (!backendName.empty())
{
CV_LOG_WARNING(NULL, "core(parallel): backend is not available: " << backendName << " (using builtin legacy code)");
return false;
}
else
{
CV_LOG_WARNING(NULL, "core(parallel): switched to builtin code (legacy)");
}
}
if (!backendName_u.empty())
{
CV_Assert(backendName_u == getParallelBackendName()); // data race?
}
if (propagateNumThreads)
{
setNumThreads(numThreads);
}
return true;
}
}} // namespace
| [
"[email protected]"
] | |
b110e9c4c365284c2636e34ff25c9e2b4f317e69 | fbdd47467053ea9b8f091e1bed2f3bbeca0ee4b9 | /src/MpmSim/SquareMagnitudeTermination.cpp | f2725c55e75d1e755af44868d7a732058545a32f | [] | no_license | nyue/mpmsnow | 9c11f7c6173d70fcab873b116632bc5b3fe7aba4 | 805aa483e7ce59dc7c5c11b9f8e99ea78446083c | refs/heads/master | 2021-01-09T23:36:03.633920 | 2016-11-10T01:02:13 | 2016-11-10T01:02:13 | 73,213,071 | 0 | 0 | null | 2016-11-08T18:04:38 | 2016-11-08T18:04:38 | null | UTF-8 | C++ | false | false | 793 | cpp |
#include "MpmSim/SquareMagnitudeTermination.h"
#include <iostream>
using namespace MpmSim;
SquareMagnitudeTermination::SquareMagnitudeTermination( int maxIters, float tolError )
: m_maxIters( maxIters ), m_tolError( tolError )
{
}
void SquareMagnitudeTermination::init( const ProceduralMatrix& A, const Eigen::VectorXf& b )
{
float bNorm2 = b.squaredNorm();
m_threshold = m_tolError*m_tolError*bNorm2;
}
bool SquareMagnitudeTermination::operator()( Eigen::VectorXf& r, int iterationNum ) const
{
if( iterationNum >= m_maxIters )
{
return true;
}
float rNorm2 = r.squaredNorm();
std::cerr << iterationNum << ":" << sqrt( rNorm2 ) << " / " << sqrt( m_threshold ) << std::endl;
return rNorm2 < m_threshold;
}
bool SquareMagnitudeTermination::cancelled() const
{
return false;
} | [
"[email protected]"
] | |
1522e55560e0e68907a141ab0a85eaccc16043f0 | 86faf524e69cb83846e9545d9c093379728e8fcc | /microBM/armSystem.h | c01fa6faaa21553279ec9565f93a1dfbefe31864 | [
"Apache-2.0",
"LLVM-exception"
] | permissive | zerous-nocebo/lomp | a50115997226180476019441d7afd59cdfeb3440 | 501addb72262b50c6c7736abfd21bc4de521b516 | refs/heads/main | 2023-08-14T06:01:58.841631 | 2021-08-30T10:58:15 | 2021-08-30T10:58:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,385 | h | //===------------------------------------------------------------*- C++ -*-===//
//
// Part of the LOMP project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdint.h>
#if (0)
/* This does not work since the relevant registers do not seem to be accessible
* from unprivileged code. :-(
*/
uint32_t getCacheLineWidth(int Level) {
uint64_t Res;
__asm__ volatile("msr \tccselr_el1,%1\n\t"
"mrs \t%0, ccsidr_el1"
: "=r"(Res)
: "r"(Level << 1));
return 1 << ((Res & 7) + 4);
}
#endif
#define GENERATE_READ_SYSTEM_REGISTER(ResultType, FuncName, Reg) \
ResultType funcName() { \
uint64_t Res; \
__asm__ volatile("mrs \t%0," #Reg : "=r"(Res)); \
return Res; \
}
GENERATE_READ_SYSTEM_REGISTER(uint64_t, GetHRTime, cntvct_el0)
GENERATE_READ_SYSTEM_REGISTER(uint32_t, GetHRFreq, cntfrq_el0)
void flushCache(void * addr) {
__asm__ volatile("dc civac,%0" ::"r"(addr));
}
| [
"[email protected]"
] | |
d57f3256f8ee1af1dd05fc00173e1c065933ea31 | db0da227137c5819bdff6da365c3dff7ad484092 | /2017-2018_ACM-ICPC_NEERC_ Southern_Subregional_Contest/ALL_CODE/M.cpp | 44d3a321b2079c9724d9f1925d7881289e2da077 | [] | no_license | hzy9819/ICPC-Problem-Code-Solution | 79351c4a86c113742ab4431ab3581691a87274eb | 7e6ffc0019cc40291456c129f0b541f7e58137a3 | refs/heads/main | 2023-03-30T05:26:55.686854 | 2021-04-10T09:52:56 | 2021-04-10T09:52:56 | 356,527,484 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 261 | cpp | #include <cstdio>
#include <algorithm>
int x1, y1, x2, y2;
int main() {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int t = 0;
if(x1 == x2) t += 2;
else t ++;
if(y1 == y2) t += 2;
else t ++;
printf("%d", (abs(x1 - x2) + abs(y1 - y2) + t) << 1);
return 0;
}
| [
"[email protected]"
] | |
89a5d1cc03df5caf8fcfe2e670e003ec4c44674b | 93b2e1abb38a10ee10863dcf1ca650559cb7b789 | /Source/SquadShips2/Protagonista.h | c9c7a948eacea0473fc53eaaa6b96dd851053d11 | [] | no_license | Trustday/SquadShips | 4318440b985bff69b5a2bd07783eb41f2ba204b3 | 64d5c9daae5315db33711bcfcc2f67dc8584747c | refs/heads/master | 2021-05-06T18:49:59.776193 | 2019-11-28T23:53:32 | 2019-11-28T23:53:32 | 112,042,989 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,400 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "Protagonista.generated.h"
UCLASS(Config = Game)
class AProtagonista : public ACharacter
{
GENERATED_BODY()
/** Spring arm that will offset the camera */
UPROPERTY(Category = Camera, VisibleDefaultsOnly, BlueprintReadOnly, meta = (AllowPrivateAccess = "true"))
class USpringArmComponent* SpringArm;
/** Camera component that will be our viewpoint */
UPROPERTY(Category = Camera, VisibleDefaultsOnly, BlueprintReadOnly, meta = (AllowPrivateAccess = "true"))
class UCameraComponent* Camera;
public:
// Sets default values for this character's properties
AProtagonista();
// Begin AActor overrides
//virtual void Tick(float DeltaSeconds) override;
virtual void NotifyHit(class UPrimitiveComponent* MyComp, class AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit) override;
// End AActor overrides
protected:
// Called when the game starts or when spawned
//virtual void BeginPlay() override;
// Begin APawn overrides
//virtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) override; // Allows binding actions/axes to functions
// End APawn overrides
/** Bound to the thrust axis */
void ThrustInput(float Val);
/** Bound to the vertical axis */
void MoveUpInput(float Val);
/** Bound to the horizontal axis */
void MoveRightInput(float Val);
private:
/** How quickly forward speed changes */
UPROPERTY(Category = Plane, EditAnywhere)
float Acceleration;
/** How quickly pawn can steer */
UPROPERTY(Category = Plane, EditAnywhere)
float TurnSpeed;
/** Max forward speed */
UPROPERTY(Category = Pitch, EditAnywhere)
float MaxSpeed;
/** Min forward speed */
UPROPERTY(Category = Yaw, EditAnywhere)
float MinSpeed;
/** Current forward speed */
float CurrentForwardSpeed;
/** Current yaw speed */
float CurrentYawSpeed;
/** Current pitch speed */
float CurrentPitchSpeed;
/** Current roll speed */
float CurrentRollSpeed;
public:
// Called every frame
virtual void Tick(float DeltaTime) override;
// Called to bind functionality to input
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
};
| [
"[email protected]"
] | |
3d50c06d63cb910d11d232ff31560096c50c10b0 | cbaf03b608f2410abfac46354f069436fdf5fa73 | /src/devices/board/drivers/astro/astro-sdio.cc | e4d6e8211dc7ffff0a8e086449bf82f4d07dc3a6 | [
"BSD-2-Clause"
] | permissive | carbonatedcaffeine/zircon-rpi | d58f302bcd0bee9394c306133fd3b20156343844 | b09b1eb3aa7a127c65568229fe10edd251869283 | refs/heads/master | 2023-03-01T19:42:04.300854 | 2021-02-13T02:24:09 | 2021-02-13T02:24:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,076 | cc | // Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <lib/mmio/mmio.h>
#include <lib/zircon-internal/align.h>
#include <ddk/binding.h>
#include <ddk/debug.h>
#include <ddk/metadata.h>
#include <ddk/metadata/init-step.h>
#include <ddk/platform-defs.h>
#include <fbl/algorithm.h>
#include <hw/reg.h>
#include <hwreg/bitfields.h>
#include <soc/aml-common/aml-sdmmc.h>
#include <soc/aml-s905d2/s905d2-gpio.h>
#include <soc/aml-s905d2/s905d2-hw.h>
#include <wifi/wifi-config.h>
#include "astro-gpios.h"
#include "astro.h"
namespace astro {
namespace {
constexpr uint32_t kGpioBase = fbl::round_down<uint32_t, uint32_t>(S905D2_GPIO_BASE, PAGE_SIZE);
constexpr uint32_t kGpioBaseOffset = S905D2_GPIO_BASE - kGpioBase;
class PadDsReg2A : public hwreg::RegisterBase<PadDsReg2A, uint32_t> {
public:
static constexpr uint32_t kDriveStrengthMax = 3;
static auto Get() { return hwreg::RegisterAddr<PadDsReg2A>((0xd2 * 4) + kGpioBaseOffset); }
DEF_FIELD(1, 0, gpiox_0_select);
DEF_FIELD(3, 2, gpiox_1_select);
DEF_FIELD(5, 4, gpiox_2_select);
DEF_FIELD(7, 6, gpiox_3_select);
DEF_FIELD(9, 8, gpiox_4_select);
DEF_FIELD(11, 10, gpiox_5_select);
};
} // namespace
static const pbus_boot_metadata_t wifi_boot_metadata[] = {
{
.zbi_type = DEVICE_METADATA_MAC_ADDRESS,
.zbi_extra = MACADDR_WIFI,
},
};
static const pbus_mmio_t sd_emmc_mmios[] = {
{
.base = S905D2_EMMC_B_SDIO_BASE,
.length = S905D2_EMMC_B_SDIO_LENGTH,
},
{
.base = S905D2_GPIO_BASE,
.length = S905D2_GPIO_LENGTH,
},
{
.base = S905D2_HIU_BASE,
.length = S905D2_HIU_LENGTH,
},
};
static const pbus_irq_t sd_emmc_irqs[] = {
{
.irq = S905D2_EMMC_B_SDIO_IRQ,
.mode = 0,
},
};
static const pbus_bti_t sd_emmc_btis[] = {
{
.iommu_index = 0,
.bti_id = BTI_SDIO,
},
};
static aml_sdmmc_config_t config = {
.supports_dma = true,
.min_freq = 400'000,
.max_freq = 208'000'000,
.version_3 = true,
.prefs = 0,
};
static const wifi_config_t wifi_config = {
.oob_irq_mode = ZX_INTERRUPT_MODE_LEVEL_HIGH,
.iovar_table =
{
{IOVAR_STR_TYPE, {"ampdu_ba_wsize"}, 32},
{IOVAR_CMD_TYPE, {.iovar_cmd = BRCMF_C_SET_PM}, 0},
{IOVAR_CMD_TYPE, {.iovar_cmd = BRCMF_C_SET_FAKEFRAG}, 1},
{IOVAR_LIST_END_TYPE, {{0}}, 0},
},
.cc_table =
{
{"WW", 0}, {"AU", 922}, {"CA", 900}, {"US", 842}, {"GB", 888}, {"BE", 888},
{"BG", 888}, {"CZ", 888}, {"DK", 888}, {"DE", 888}, {"EE", 888}, {"IE", 888},
{"GR", 888}, {"ES", 888}, {"FR", 888}, {"HR", 888}, {"IT", 888}, {"CY", 888},
{"LV", 888}, {"LT", 888}, {"LU", 888}, {"HU", 888}, {"MT", 888}, {"NL", 888},
{"AT", 888}, {"PL", 888}, {"PT", 888}, {"RO", 888}, {"SI", 888}, {"SK", 888},
{"FI", 888}, {"SE", 888}, {"EL", 888}, {"IS", 888}, {"LI", 888}, {"TR", 888},
{"JP", 1}, {"KR", 1}, {"TW", 1}, {"NO", 1}, {"IN", 1}, {"SG", 1},
{"MX", 1}, {"NZ", 1}, {"CH", 1}, {"", 0},
},
};
static const pbus_metadata_t sd_emmc_metadata[] = {
{
.type = DEVICE_METADATA_PRIVATE,
.data_buffer = reinterpret_cast<const uint8_t*>(&config),
.data_size = sizeof(config),
},
{
.type = DEVICE_METADATA_WIFI_CONFIG,
.data_buffer = reinterpret_cast<const uint8_t*>(&wifi_config),
.data_size = sizeof(wifi_config),
},
};
static const pbus_dev_t sd_emmc_dev = []() {
pbus_dev_t dev = {};
dev.name = "aml-sdio";
dev.vid = PDEV_VID_AMLOGIC;
dev.pid = PDEV_PID_GENERIC;
dev.did = PDEV_DID_AMLOGIC_SDMMC_B;
dev.mmio_list = sd_emmc_mmios;
dev.mmio_count = countof(sd_emmc_mmios);
dev.irq_list = sd_emmc_irqs;
dev.irq_count = countof(sd_emmc_irqs);
dev.bti_list = sd_emmc_btis;
dev.bti_count = countof(sd_emmc_btis);
dev.metadata_list = sd_emmc_metadata;
dev.metadata_count = countof(sd_emmc_metadata);
dev.boot_metadata_list = wifi_boot_metadata;
dev.boot_metadata_count = countof(wifi_boot_metadata);
return dev;
}();
// Composite binding rules for wifi driver.
static const zx_bind_inst_t root_match[] = {
BI_MATCH(),
};
static const zx_bind_inst_t sdio_fn1_match[] = {
BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_SDIO), BI_ABORT_IF(NE, BIND_SDIO_VID, 0x02d0),
BI_ABORT_IF(NE, BIND_SDIO_FUNCTION, 1), BI_MATCH_IF(EQ, BIND_SDIO_PID, 0x4345),
BI_MATCH_IF(EQ, BIND_SDIO_PID, 0x4359),
};
static const zx_bind_inst_t sdio_fn2_match[] = {
BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_SDIO), BI_ABORT_IF(NE, BIND_SDIO_VID, 0x02d0),
BI_ABORT_IF(NE, BIND_SDIO_FUNCTION, 2), BI_MATCH_IF(EQ, BIND_SDIO_PID, 0x4345),
BI_MATCH_IF(EQ, BIND_SDIO_PID, 0x4359),
};
static const zx_bind_inst_t oob_gpio_match[] = {
BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_GPIO),
BI_MATCH_IF(EQ, BIND_GPIO_PIN, S905D2_WIFI_SDIO_WAKE_HOST),
};
static const device_fragment_part_t sdio_fn1_fragment[] = {
{countof(root_match), root_match},
{countof(sdio_fn1_match), sdio_fn1_match},
};
static const device_fragment_part_t sdio_fn2_fragment[] = {
{countof(root_match), root_match},
{countof(sdio_fn2_match), sdio_fn2_match},
};
static const device_fragment_part_t oob_gpio_fragment[] = {
{countof(root_match), root_match},
{countof(oob_gpio_match), oob_gpio_match},
};
static const device_fragment_t wifi_composite[] = {
{"sdio-function-1", countof(sdio_fn1_fragment), sdio_fn1_fragment},
{"sdio-function-2", countof(sdio_fn2_fragment), sdio_fn2_fragment},
{"gpio-oob", countof(oob_gpio_fragment), oob_gpio_fragment},
};
// Composite binding rules for SDIO.
static const zx_bind_inst_t wifi_pwren_gpio_match[] = {
BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_GPIO),
BI_MATCH_IF(EQ, BIND_GPIO_PIN, GPIO_SDIO_RESET),
};
constexpr zx_bind_inst_t pwm_e_match[] = {
BI_MATCH_IF(EQ, BIND_INIT_STEP, BIND_INIT_STEP_PWM),
};
static const device_fragment_part_t wifi_pwren_gpio_fragment[] = {
{countof(root_match), root_match},
{countof(wifi_pwren_gpio_match), wifi_pwren_gpio_match},
};
constexpr device_fragment_part_t pwm_e_fragment[] = {
{std::size(root_match), root_match},
{std::size(pwm_e_match), pwm_e_match},
};
static const device_fragment_t sdio_fragments[] = {
{"gpio-wifi-power-on", countof(wifi_pwren_gpio_fragment), wifi_pwren_gpio_fragment},
{"pwm", std::size(pwm_e_fragment), pwm_e_fragment},
};
zx_status_t Astro::SdEmmcConfigurePortB() {
// Clear GPIO_X
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_D0, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_D1, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_D2, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_D3, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_CLK, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_CMD, 0);
gpio_impl_.SetAltFunction(S905D2_WIFI_SDIO_WAKE_HOST, 0);
// Clear GPIO_C
gpio_impl_.SetAltFunction(S905D2_GPIOC(0), 0);
gpio_impl_.SetAltFunction(S905D2_GPIOC(1), 0);
gpio_impl_.SetAltFunction(S905D2_GPIOC(2), 0);
gpio_impl_.SetAltFunction(S905D2_GPIOC(3), 0);
gpio_impl_.SetAltFunction(S905D2_GPIOC(4), 0);
gpio_impl_.SetAltFunction(S905D2_GPIOC(5), 0);
zx_status_t status;
std::optional<ddk::MmioBuffer> gpio_base;
// Please do not use get_root_resource() in new code. See fxbug.dev/31358.
zx::unowned_resource resource(get_root_resource());
size_t aligned_size = ZX_ROUNDUP((S905D2_GPIO_BASE - kGpioBase) + S905D2_GPIO_LENGTH, PAGE_SIZE);
status = ddk::MmioBuffer::Create(kGpioBase, aligned_size, *resource,
ZX_CACHE_POLICY_UNCACHED_DEVICE, &gpio_base);
if (status != ZX_OK) {
zxlogf(ERROR, "%s: Create(gpio) error: %d", __func__, status);
}
// TODO(ravoorir): Figure out if we need gpio protocol ops to modify these
// gpio registers.
uint32_t preg_pad_gpio5_val =
gpio_base->Read32(kGpioBaseOffset + (S905D2_PREG_PAD_GPIO5_O << 2)) |
AML_SDIO_PORTB_GPIO_REG_5_VAL;
gpio_base->Write32(preg_pad_gpio5_val, kGpioBaseOffset + (S905D2_PREG_PAD_GPIO5_O << 2));
uint32_t periphs_pin_mux2_val =
gpio_base->Read32(kGpioBaseOffset + (S905D2_PERIPHS_PIN_MUX_2 << 2)) |
AML_SDIO_PORTB_PERIPHS_PINMUX2_VAL;
gpio_base->Write32(periphs_pin_mux2_val, kGpioBaseOffset + (S905D2_PERIPHS_PIN_MUX_2 << 2));
uint32_t gpio2_en_n_val = gpio_base->Read32(kGpioBaseOffset + (S905D2_PREG_PAD_GPIO2_EN_N << 2)) &
AML_SDIO_PORTB_PERIPHS_GPIO2_EN;
gpio_base->Write32(gpio2_en_n_val, kGpioBaseOffset + (S905D2_PREG_PAD_GPIO2_EN_N << 2));
PadDsReg2A::Get()
.ReadFrom(&(*gpio_base))
.set_gpiox_0_select(PadDsReg2A::kDriveStrengthMax)
.set_gpiox_1_select(PadDsReg2A::kDriveStrengthMax)
.set_gpiox_2_select(PadDsReg2A::kDriveStrengthMax)
.set_gpiox_3_select(PadDsReg2A::kDriveStrengthMax)
.set_gpiox_4_select(PadDsReg2A::kDriveStrengthMax)
.set_gpiox_5_select(PadDsReg2A::kDriveStrengthMax)
.WriteTo(&(*gpio_base));
// Configure clock settings
std::optional<ddk::MmioBuffer> hiu_base;
status = ddk::MmioBuffer::Create(S905D2_HIU_BASE, S905D2_HIU_LENGTH, *resource,
ZX_CACHE_POLICY_UNCACHED_DEVICE, &hiu_base);
if (status != ZX_OK) {
zxlogf(ERROR, "%s: Create(hiu) error: %d", __func__, status);
}
uint32_t hhi_gclock_val =
hiu_base->Read32(HHI_GCLK_MPEG0_OFFSET << 2) | AML_SDIO_PORTB_HHI_GCLK_MPEG0_VAL;
hiu_base->Write32(hhi_gclock_val, HHI_GCLK_MPEG0_OFFSET << 2);
uint32_t hh1_sd_emmc_clock_val =
hiu_base->Read32(HHI_SD_EMMC_CLK_CNTL_OFFSET << 2) & AML_SDIO_PORTB_SDMMC_CLK_VAL;
hiu_base->Write32(hh1_sd_emmc_clock_val, HHI_SD_EMMC_CLK_CNTL_OFFSET << 2);
return status;
}
zx_status_t Astro::SdioInit() {
zx_status_t status;
SdEmmcConfigurePortB();
status = pbus_.CompositeDeviceAdd(&sd_emmc_dev, reinterpret_cast<uint64_t>(sdio_fragments),
countof(sdio_fragments), UINT32_MAX);
if (status != ZX_OK) {
zxlogf(ERROR, "%s: CompositeDeviceAdd sd_emmc failed: %d", __func__, status);
return status;
}
// Add a composite device for wifi driver.
const zx_device_prop_t props[] = {
{BIND_PLATFORM_DEV_VID, 0, PDEV_VID_BROADCOM},
{BIND_PLATFORM_DEV_PID, 0, PDEV_PID_BCM43458},
{BIND_PLATFORM_DEV_DID, 0, PDEV_DID_BCM_WIFI},
};
const composite_device_desc_t comp_desc = {
.props = props,
.props_count = countof(props),
.fragments = wifi_composite,
.fragments_count = countof(wifi_composite),
.coresident_device_index = 0,
.metadata_list = nullptr,
.metadata_count = 0,
};
status = DdkAddComposite("wifi", &comp_desc);
if (status != ZX_OK) {
zxlogf(ERROR, "%s: DdkAddComposite failed: %d", __func__, status);
return status;
}
return ZX_OK;
}
} // namespace astro
| [
"[email protected]"
] | |
6a258af2d4e33e4a72f96f6b6f9de59516b76f08 | 7d14d0d405ac06985dc373f353202734ed081b2d | /Models/Case/protectiveCase.hpp | 1250184994862a5aee76a90496b7e6cc7f2deb2a | [] | no_license | valdirsegadas/MRHSatellite | 12bfa367f34c1d2ceb962cfa5ab6550e42ede28d | f5235e8aa6b676a07afbb978a27b99a1f4173e6f | refs/heads/master | 2022-11-05T10:26:54.703505 | 2019-08-26T09:04:13 | 2019-08-26T09:04:13 | 273,993,432 | 0 | 0 | null | 2020-06-21T22:31:05 | 2020-06-21T22:31:04 | null | UTF-8 | C++ | false | false | 838 | hpp | #define mag_xx(a,b) class _xx_##a {magazine = a; count = b;}
#define weap_xx(a,b) class _xx_##a {weapon = a; count = b;}
#define item_xx(a,b) class _xx_##a {name = a; count = b;}
#define backPack_xx(a,b) class _xx_##a {backpack = a; count = b;}
class Box_NATO_Ammo_F;
class MRH_SAT_protectiveCase : Box_NATO_Ammo_F
{
displayName = $STR_MRH_SAT_ObjectsCrate;
editorCategory = "EdCat_MRH_Sat";
editorSubcategory = "EdSubcat_MRH_Objects";
model = "\MRHSatellite\Models\Case\protectiveCase.p3d";
editorPreview = "\MRHSatellite\Models\Case\protectiveCase.jpg";
class TransportWeapons{};
class TransportMagazines{};
class TransportItems{
item_xx(MRH_FoldedSatcomAntenna,4);
item_xx(MRH_TacticalDisplay,4);
item_xx(MRH_BluForTransponder,20);
};
class TransportBackpacks{
backPack_xx(B_Carryall_satellite,2);
};
}; | [
"[email protected]"
] | |
19569538de94c0d827a7550a0963b5af99accffc | 95f4b2830dd02d0653e339329c5a08f8ad19e1ff | /Actors/ScriptComponentInterface.h | d28d55f9dbaf465cbedd95e1860f46c7a8f1bc7b | [] | no_license | JDHDEV/AlphaEngine | d0459e760343f47b00d9e34be8f7e8d93d308c27 | 2c5602a4bbba966c7f31b06ce0c7eabaa97002ec | refs/heads/master | 2021-01-01T19:42:43.176631 | 2015-07-27T01:03:05 | 2015-07-27T01:03:05 | 39,701,364 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,173 | h | #pragma once
//========================================================================
// ScriptComponentInterface.h - Interface for script components
//
// Part of the Alpha Application
//
// Alpha is the sample application that encapsulates much of the source code
// discussed in "Game Coding Complete - 4th Edition" by Mike McShaffry and David
// "Rez" Graham, published by Charles River Media.
// ISBN-10: 1133776574 | ISBN-13: 978-1133776574
//
// Justin Hunt
//========================================================================
#include "ActorComponent.h"
//---------------------------------------------------------------------------------------------------------------------
// This component is essentially a placeholder for the script representation of the entity. The engine doesn't do
// much (if anything) with it, hence the lack of interface.
//---------------------------------------------------------------------------------------------------------------------
class ScriptComponentInterface : public ActorComponent
{
public:
// static ComponentId COMPONENT_ID;
// virtual ComponentId VGetComponentId(void) const { return COMPONENT_ID; }
}; | [
"[email protected]"
] | |
17df1ec8310a6d09400552baa04dfb520ed042f7 | 35abdfb049c2c2c763713e05f4ad242d02fabd32 | /tools/GRAPHOS_GUI/NewCameraDialog.cpp | 3af5f9288e9ed18be9939a83705e6601c9849564 | [] | no_license | zhanshenman/GRAPHOS | a4d4e80bf1434ac268e6874a467e90e9b52c1982 | 44663fd2d02da679333566ef36b40a283a96fac4 | refs/heads/master | 2021-01-25T14:04:51.585435 | 2018-02-12T10:23:25 | 2018-02-12T10:23:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,273 | cpp | /**
*-------------------------------------------------
* Copyright 2016 by Tidop Research Group <[email protected]>
*
* This file is part of GRAPHOS - inteGRAted PHOtogrammetric Suite.
*
* GRAPHOS - inteGRAted PHOtogrammetric Suite is free software: you can redistribute
* it and/or modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation, either
* version 3 of the License, or (at your option) any later version.
*
* GRAPHOS - inteGRAted PHOtogrammetric Suite is distributed in the hope that it will
* be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Foobar. If not, see <http://www.gnu.org/licenses/>.
*
* @license GPL-3.0+ <http://spdx.org/licenses/GPL-3.0+>
*-------------------------------------------------
*/
#include "NewCameraDialog.h"
#include "ui_NewCameraDialog.h"
#include "Camera.h"
using namespace PW;
NewCameraDialog::NewCameraDialog(PW::PersistenceManager *pm, QWidget *parent) :
QDialog(parent),
ui(new Ui::NewCameraDialog),
mPm(pm),
mAcepted(false)
{
ui->setupUi(this);
}
NewCameraDialog::~NewCameraDialog()
{
delete ui;
}
void NewCameraDialog::on_buttonBox_accepted()
{
mCameraModel = ui->ModelLineEdit->text();
mLens = ui->LenslineEdit->text();
double widht = ui->WidhtLineEdit->text().toDouble();
double height = ui->WidhtLineEdit->text().toDouble();
if (!mCameraModel.isEmpty() && widht && height){
Camera camera(mCameraModel, mLens,ui->WidhtLineEdit->text().toDouble(), ui->HeightLineEdit->text().toDouble());
mPm->writeCamera(&camera);
mAcepted = true;
}
else
mAcepted = false;
}
void NewCameraDialog::on_buttonBox_rejected()
{
mAcepted = false;
}
bool NewCameraDialog::isAcepted()
{
return mAcepted;
}
void NewCameraDialog::setData(QString cameraModel, QString lens)
{
mCameraModel = cameraModel;
mLens = lens;
ui->ModelLineEdit->setText(cameraModel);
ui->LenslineEdit->setText(lens);
ui->WidhtLineEdit->setText("");
ui->HeightLineEdit->setText("");
}
| [
"[email protected]"
] | |
205b5738a7529aa361b7637e2fbe04a0367f6f31 | 0f19568208d224b6b094542cdc7078002ecf5c3a | /ivp/src/uPokeDB/PokeDB.h | 1e18a6a7ee5ba328a90b468997aa51e97be8b4ca | [] | no_license | scottsideleau/MOOS-IvP-releases | 5e875d506f123d793e2c1568de3f3733791f7062 | bda2fc46bb7e886f05ab487f72b747521420ce86 | refs/heads/master | 2021-01-11T04:05:38.824239 | 2016-10-21T02:16:11 | 2016-10-21T02:16:11 | 71,249,151 | 1 | 1 | null | 2016-10-18T13:06:30 | 2016-10-18T13:06:29 | null | UTF-8 | C++ | false | false | 2,689 | h | /*****************************************************************/
/* NAME: Michael Benjamin, Henrik Schmidt, and John Leonard */
/* ORGN: Dept of Mechanical Eng / CSAIL, MIT Cambridge MA */
/* FILE: PokeDB.h */
/* DATE: May 9th 2008 */
/* */
/* This file is part of MOOS-IvP */
/* */
/* MOOS-IvP is free software: you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation, either version */
/* 3 of the License, or (at your option) any later version. */
/* */
/* MOOS-IvP is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty */
/* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
/* the GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public */
/* License along with MOOS-IvP. If not, see */
/* <http://www.gnu.org/licenses/>. */
/*****************************************************************/
#include <string>
#include "MOOS/libMOOS/MOOSLib.h"
class PokeDB : public CMOOSApp
{
public:
PokeDB(std::string g_server, long int g_port);
PokeDB();
virtual ~PokeDB() {}
bool Iterate();
bool OnNewMail(MOOSMSG_LIST &NewMail);
bool OnConnectToServer();
bool OnStartUp();
void setConfigureCommsLocally(bool v) {m_configure_comms_locally=v;}
void setPokeDouble(const std::string& varname, const std::string& val);
void setPokeString(const std::string& varname, const std::string& val);
protected:
void registerVariables();
void updateVariable(CMOOSMsg& msg);
void printReport();
bool ConfigureComms();
protected: // Index for each is unique per variable name
std::vector<std::string> m_varname;
std::vector<std::string> m_valtype;
std::vector<std::string> m_varvalue;
std::vector<std::string> m_svalue_read;
std::vector<std::string> m_dvalue_read;
std::vector<std::string> m_source_read;
std::vector<std::string> m_valtype_read;
std::vector<std::string> m_wrtime_read;
std::vector<bool> m_varname_recd;
double m_db_time;
double m_db_start_time;
int m_iteration;
bool m_configure_comms_locally;
};
| [
"[email protected]"
] | |
139904ab0d570bc184b3b5c4fdfdb052113e0db4 | c655c652e3a6148858fd65eb7034942b06430b28 | /src/elves.h | b987c58ec70bcef6fc8e44d69db35c73121fa9c0 | [] | no_license | LodePublishing/WarCraft-Calculator | ca0e22649d2401804aa161d6e067928a1e62c3d5 | 914c6dcfb8584d2fab4d76e5815c756c90672b1e | refs/heads/master | 2021-03-24T11:50:49.399431 | 2016-09-18T07:57:19 | 2016-09-18T07:57:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 227 | h | #include "race.h"
class Player_Elves: public RACE
{
public:
virtual void Set_Goals();
virtual void Calculate();
virtual void InitRaceSpecific();
virtual void readjust_goals();
Player_Elves();
virtual ~Player_Elves();
};
| [
"[email protected]"
] | |
6c43b95dae0b60dccf16b04ee9186ae4faa4611a | eb3f48b054e75f029e7e21b0b3dee750265e9231 | /Doctor.h | 148f5af287aac8c164195d917034dc09e89c6345 | [] | no_license | JerryDGroom/FinalProject | 4e47fa63c085449f2ff6cdd371e1df811678a7f8 | a38fa2f62671eae85fe9810993d5d77833d6d156 | refs/heads/master | 2016-09-01T18:02:01.882061 | 2015-04-29T21:30:51 | 2015-04-29T21:30:51 | 33,801,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 361 | h | #ifndef Doctor_H
#define Doctor_H
/*
Doctor class stores the name, Specialty code, room no for a doctor
*/
#include <string>
using namespace std;
class Doctor
{
public:
Doctor(string nm, string sp, int no);
// get the information
string getName();
string getSpecialty();
int getRoom();
private:
string name;
string specialty;
int room;
};
#endif
| [
"[email protected]"
] | |
9c682b61186a17e94ad10630e14e62a35566454c | ccf7d19fa0ed0d2045dd3c804d6829863a3af785 | /HookInjector/runtime_error.h | 8ccc01d8a7833362f085abaf2847e4f9a14e8339 | [
"Apache-2.0",
"MIT"
] | permissive | raiti-chan/AudioTeapot | 9c28965c920c53c82e695a143c30fd82d10c054e | 39dab73f9ef258ac5fec8ab74bcf29791f9693f8 | refs/heads/master | 2023-08-21T14:33:33.619514 | 2021-09-08T14:23:41 | 2021-09-08T14:23:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 316 | h | #pragma once
#include <stdexcept>
#define THROW_ON_FAILURE(hr, message) \
if (FAILED(hr)) { \
throw runtime_error(message); \
}
class runtime_error : public std::runtime_error
{
public:
runtime_error(const std::wstring& message);
std::wstring get_message() const;
private:
std::wstring message;
};
| [
"[email protected]"
] | |
80cf379db20b1302e220ff8f38f2ee1c9f0721e9 | becb83c217dfd906e89396ab546fa782988b2f69 | /Lab9/GameOfLife9.cpp | d5d1d2514dccbbea22d4f8b80f1f1219af507306 | [] | no_license | phillipchan124/Program-Design-Data-Structures | 6b04c8a25dfd57cd28271559acdba6ac0d3a0193 | a570f9230d73298fa6d44ece2c9622ade3cd42ea | refs/heads/master | 2021-01-10T06:15:04.507987 | 2015-12-12T00:05:10 | 2015-12-12T00:05:10 | 47,857,081 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,160 | cpp | #include <iostream>
using namespace std;
#include <cstdlib>
struct Cell
{
int row; // any +/0/- value
int col; // any +/0/- value
bool operator==(const Cell& c) const {return row == c.row && col == c.col;}
};
#include "AssociativeArray.h"
AssociativeArray<char, Cell> grid; // Older grid of life
AssociativeArray<char, Cell> newGrid; // New grid for storing the next generation
// Dimensions of the grid with the origin at the center
const int MINROW = -25;
const int MAXROW = 25;
const int MINCOL = -35;
const int MAXCOL = 35;
int neighborCount(int row, int col)
{
// Count neighboring living cells around cell at row and col
Cell temp;
int count = 0;
for (temp.row = row - 1; temp.row <= row + 1; temp.row++)
for (temp.col = col - 1; temp.col <= col + 1; temp.col++)
if (temp.row != row || temp.col != col)
if (grid.containsKey(temp))
++count;
return count;
}
void initialize()
{
// Output instructions
cout << "List the coordinates for living cells.\n";
cout << "Terminate the list with a special pair -1 -1\n";
// Get input for storing living cells
Cell temp;
char buf[100];
while (true)
{
cin >> buf; temp.row = atoi(buf);
cin >> buf; temp.col = atoi(buf);
if (temp.row == -1 && temp.col == -1) break;
grid[temp] = 'X';
}
cin.ignore();
}
void print()
{
//O utput the grid at the current generation
Cell temp;
cout << "\nThe current Life configuration is:\n";
// Nested for loop to print the grid
for (temp.row = MINROW; temp.row <= MAXROW; temp.row++)
{
for (temp.col = MINCOL; temp.col <= MAXCOL; temp.col++)
if (grid.containsKey(temp))
cout << grid[temp];
else
cout << ' ';
cout << endl;
}
cout << endl;
}
void update()
{
// Calculate new generation
Cell temp;
newGrid.clear();
// Nested for loops to traverse the grid
for (temp.row = MINROW; temp.row <= MAXROW; temp.row++)
{
for (temp.col = MINCOL; temp.col <= MAXCOL; temp.col++)
{
// Process cells based on number of neighbors
switch (neighborCount(temp.row, temp.col))
{
// If 2 neighbors, cell lives (copy old cell to next gen grid)
case 2:
if (grid.containsKey(temp)) newGrid[temp] = 'X';
break;
// Cell with 3 neighbors lives next generation
case 3:
newGrid[temp] = 'X';
break;
} // switch - process cells based on number of neighbors
} // for - traverse columns of grid
} // for - traverse rows
//Update grid
grid = newGrid;
};
int main()
{
// Prep and output grid for zeroth generation
initialize();
print();
// Game loop cycle
for (int i = 1; grid.size(); i++)
{
// Prompt user for continuing (any normal keyboard character) or quitting (hitting enter)
cout << "Generation " << i << ". Press ENTER to continue, X-ENTER to quit...\n";
if (cin.get() > 31) break;
// Process the grid and output the current generation
update();
print();
}
} // main
| [
"[email protected]"
] | |
ecca362d45108730b09aac9d3393cafd80b3d7cf | b6118068b482077be56cc25143862a025a3ed10c | /d08/ex02/mutantstack.hpp | b1d7d6dc69a941ce6d286314507e7e56cbacd268 | [] | no_license | aisenn/CPP_Piscine | 25807f08857e34a26895fa4d3e377e4174296c46 | 7433d0139c19f6434db782e940ca269a54695ff1 | refs/heads/master | 2020-06-10T20:04:50.684325 | 2019-07-07T08:43:45 | 2019-07-07T08:43:45 | 193,731,829 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 594 | hpp | #ifndef MUTANTSTACK_HPP
#define MUTANTSTACK_HPP
#include <list>
#include <stack>
#include <iterator>
template<typename T>
class MutantStack : public std::stack<T>
{
public:
MutantStack() {}
MutantStack(MutantStack const &cp) {
*this = cp;
}
~MutantStack() {}
MutantStack &operator=(MutantStack const &rhs) {
if (this != &rhs)
this->c = rhs.c;
return *this;
}
typedef typename std::stack<T>::container_type::const_iterator iterator;
iterator begin() {
return this->c.begin();
}
iterator end() {
return this->c.end();
}
};
#endif //MUTANTSTACK_HPP
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.