max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
562 | #include <Windows.h>
static LRESULT CALLBACK WndProc(HWND hwnd,
UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT res = 1;
switch (uMsg)
{
case WM_DESTROY:
::PostQuitMessage (0);
break;
default:
res = ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return res;
}
bool init_context()
{
static const wchar_t * class_name = L"ConanOpenGL";
static const wchar_t * window_name = L"Conan OpenGL";
WNDCLASSEXW wc = {0};
wc.cbSize = sizeof(WNDCLASSEXW);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.hInstance = ::GetModuleHandle(NULL);
wc.hIcon = ::LoadIcon(0, IDI_APPLICATION);
wc.hCursor = ::LoadCursor(0, IDC_ARROW);
wc.hbrBackground = (HBRUSH) ::GetStockObject(WHITE_BRUSH);
wc.lpszClassName = class_name;
if (!::RegisterClassExW(&wc))
return false;
HWND hWnd = ::CreateWindowExW(0, class_name, window_name,
WS_OVERLAPPEDWINDOW, 0, 0, 0, 0, NULL, NULL, wc.hInstance, NULL);
if (!hWnd)
return false;
HDC hDC = ::GetDC(hWnd);
if (!hDC)
return false;
PIXELFORMATDESCRIPTOR pfd = {0};
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.dwLayerMask = PFD_MAIN_PLANE;
pfd.cColorBits = 32;
pfd.cDepthBits = 16;
int pixel_format = ::ChoosePixelFormat(hDC, &pfd);
if(0 == pixel_format)
return false;
if (!::SetPixelFormat(hDC, pixel_format, &pfd))
return false;
HGLRC hGLRC = ::wglCreateContext(hDC);
if (!hGLRC)
return false;
::wglMakeCurrent(hDC, hGLRC);
return true;
}
| 849 |
478 | /*
Copyright (c) 2014 Aerys
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#pragma once
#include "minko/Common.hpp"
#include "minko/Signal.hpp"
#include "minko/render/Pass.hpp"
#include "minko/data/Provider.hpp"
#include "minko/Uuid.hpp"
#include "minko/Flyweight.hpp"
namespace minko
{
namespace render
{
class Effect :
public Uuid::has_uuid
{
public:
typedef std::shared_ptr<Effect> Ptr;
private:
typedef std::shared_ptr<Pass> PassPtr;
typedef std::shared_ptr<VertexBuffer> VertexBufferPtr;
typedef std::shared_ptr<std::function<void(PassPtr)>> OnPassFunctionPtr;
typedef std::list<std::function<void(PassPtr)>> OnPassFunctionList;
typedef std::vector<PassPtr> Technique;
typedef Signal<Ptr, const std::string&, const std::string&>::Ptr TechniqueChangedSignalPtr;
private:
std::string _name;
std::unordered_map<std::string, Technique> _techniques;
std::unordered_map<std::string, std::string> _fallback;
std::shared_ptr<data::Provider> _data;
OnPassFunctionList _uniformFunctions;
OnPassFunctionList _attributeFunctions;
OnPassFunctionList _macroFunctions;
public:
inline static
Ptr
create(const std::string& name)
{
return std::shared_ptr<Effect>(new Effect(name));
}
inline static
Ptr
create(const std::string& name, std::vector<PassPtr>& passes)
{
auto effect = create(name);
effect->_techniques["default"] = passes;
return effect;
}
inline
const std::string&
uuid() const
{
return _data->uuid();
}
inline
const std::string&
name() const
{
return _name;
}
inline
const std::unordered_map<std::string, Technique>&
techniques() const
{
return _techniques;
}
inline
std::shared_ptr<data::Provider>
data() const
{
return _data;
}
inline
const Technique&
technique(const std::string& techniqueName) const
{
if (!hasTechnique(techniqueName))
throw std::invalid_argument("techniqueName = " + techniqueName);
return _techniques.at(techniqueName);
}
inline
const std::string&
fallback(const std::string& techniqueName) const
{
auto foundFallbackIt = _fallback.find(techniqueName);
if (foundFallbackIt == _fallback.end())
throw std::invalid_argument("techniqueName = " + techniqueName);
return foundFallbackIt->second;
}
inline
bool
hasTechnique(const std::string& techniqueName) const
{
return _techniques.count(techniqueName) != 0;
}
inline
bool
hasFallback(const std::string& techniqueName) const
{
return _fallback.count(techniqueName) != 0;
}
template <typename... T>
void
setUniform(const std::string& name, const T&... values)
{
_uniformFunctions.push_back(std::bind(
&Effect::setUniformOnPass<T...>, std::placeholders::_1, name, values...
));
for (auto& technique : _techniques)
for (auto& pass : technique.second)
pass->setUniform(name, values...);
}
public:
void
setAttribute(const std::string& name, const VertexAttribute& attribute);
void
define(const std::string& macroName);
template <typename T>
inline
void
define(const std::string& macroName, T macroValue)
{
_macroFunctions.push_back(std::bind(
&Effect::defineOnPassWithValue<T>, std::placeholders::_1, macroName, macroValue
));
for (auto& technique : _techniques)
for (auto& pass : technique.second)
pass->define(macroName, macroValue);
}
void
addTechnique(const std::string& name, Technique& passes);
void
addTechnique(const std::string& name, Technique& passes, const std::string& fallback);
void
removeTechnique(const std::string& name);
template <typename T = material::Material>
std::shared_ptr<T>
initializeMaterial(std::shared_ptr<T> material, const std::string& technique = "default")
{
fillMaterial(material, technique);
return material;
}
private:
Effect(const std::string& name);
template <typename... T>
static
void
setUniformOnPass(std::shared_ptr<Pass> pass, const std::string& name, const T&... values)
{
pass->setUniform(name, values...);
}
static
void
setVertexAttributeOnPass(std::shared_ptr<Pass> pass, const std::string& name, const VertexAttribute& attribute)
{
pass->setAttribute(name, attribute);
}
static
void
defineOnPass(std::shared_ptr<Pass> pass, const std::string& macroName)
{
pass->define(macroName);
}
template <typename T>
static
void
defineOnPassWithValue(std::shared_ptr<Pass> pass, const std::string& macroName, T macroValue)
{
pass->define(macroName, macroValue);
}
void
fillMaterial(std::shared_ptr<material::Material> material,
const std::string& technique);
};
}
}
| 2,713 |
11,396 | <reponame>bhyunki/awx<filename>awxkit/awxkit/api/pages/credential_input_sources.py
from awxkit.api.resources import resources
from . import base
from . import page
class CredentialInputSource(base.Base):
pass
page.register_page(resources.credential_input_source, CredentialInputSource)
class CredentialInputSources(page.PageList, CredentialInputSource):
pass
page.register_page([resources.credential_input_sources, resources.related_input_sources], CredentialInputSources)
| 160 |
777 | // 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 CSSUnparsedValue_h
#define CSSUnparsedValue_h
#include "bindings/core/v8/Iterable.h"
#include "bindings/core/v8/StringOrCSSVariableReferenceValue.h"
#include "core/css/CSSVariableReferenceValue.h"
#include "core/css/cssom/CSSStyleValue.h"
#include "wtf/Vector.h"
namespace blink {
class CORE_EXPORT CSSUnparsedValue final
: public CSSStyleValue,
public ValueIterable<StringOrCSSVariableReferenceValue> {
WTF_MAKE_NONCOPYABLE(CSSUnparsedValue);
DEFINE_WRAPPERTYPEINFO();
public:
static CSSUnparsedValue* create(
const HeapVector<StringOrCSSVariableReferenceValue>& fragments) {
return new CSSUnparsedValue(fragments);
}
static CSSUnparsedValue* fromCSSValue(const CSSVariableReferenceValue&);
CSSValue* toCSSValue() const override;
StyleValueType type() const override { return UnparsedType; }
StringOrCSSVariableReferenceValue fragmentAtIndex(int index) const {
return m_fragments.at(index);
}
size_t size() const { return m_fragments.size(); }
DEFINE_INLINE_VIRTUAL_TRACE() {
visitor->trace(m_fragments);
CSSStyleValue::trace(visitor);
}
protected:
CSSUnparsedValue(
const HeapVector<StringOrCSSVariableReferenceValue>& fragments)
: CSSStyleValue(), m_fragments(fragments) {}
private:
static CSSUnparsedValue* fromString(String string) {
HeapVector<StringOrCSSVariableReferenceValue> fragments;
fragments.push_back(StringOrCSSVariableReferenceValue::fromString(string));
return create(fragments);
}
IterationSource* startIteration(ScriptState*, ExceptionState&) override;
FRIEND_TEST_ALL_PREFIXES(CSSUnparsedValueTest, ListOfStrings);
FRIEND_TEST_ALL_PREFIXES(CSSUnparsedValueTest,
ListOfCSSVariableReferenceValues);
FRIEND_TEST_ALL_PREFIXES(CSSUnparsedValueTest, MixedList);
FRIEND_TEST_ALL_PREFIXES(CSSVariableReferenceValueTest, MixedList);
HeapVector<StringOrCSSVariableReferenceValue> m_fragments;
};
} // namespace blink
#endif // CSSUnparsedValue_h
| 763 |
507 | <gh_stars>100-1000
# terrascript/data/external.py
# Automatically generated by tools/makecode.py (24-Sep-2021 15:16:09 UTC)
#
# For imports without namespace, e.g.
#
# >>> import terrascript.data.external
#
# instead of
#
# >>> import terrascript.data.hashicorp.external
#
# This is only available for 'official' and 'partner' providers.
from terrascript.data.hashicorp.external import *
| 130 |
1,109 | <filename>gryphon/lib/exchange/itbit_btc_usd.py<gh_stars>1000+
"""
Exchange documentation: https://api.itbit.com/docs
"""
# -*- coding: utf-8 -*-
import base64
from collections import OrderedDict, defaultdict
import hashlib
import hmac
import json
import time
import urllib
import cdecimal
from cdecimal import Decimal
from gryphon.lib.exchange import exceptions
from gryphon.lib.exchange import order_types
from gryphon.lib.exchange.exchange_api_wrapper import ExchangeAPIWrapper
from gryphon.lib.logger import get_logger
from gryphon.lib.models.exchange import Balance
from gryphon.lib.money import Money
from gryphon.lib.time_parsing import parse
logger = get_logger(__name__)
class ItbitBTCUSDExchange(ExchangeAPIWrapper):
def __init__(self, session=None, configuration=None):
super(ItbitBTCUSDExchange, self).__init__(session)
self.name = u'ITBIT_BTC_USD'
self.friendly_name = u'Itbit BTC-USD'
self.base_url = 'https://api.itbit.com/v1'
self.currency = 'USD'
self.bid_string = 'buy'
self.ask_string = 'sell'
self.nonce = 1
# Configurables with defaults.
self.market_order_fee = Decimal('0.002')
self.limit_order_fee = Decimal('0')
self.fee = self.market_order_fee
self.fiat_balance_tolerance = Money('0.0001', 'USD')
self.volume_balance_tolerance = Money('0.00000001', 'BTC')
self.max_tick_speed = 1
self.min_order_size = Money('0', 'BTC')
self.use_cached_orderbook = False
if configuration:
self.configure(configuration)
@property
def wallet_id(self):
try:
self._wallet_id
except AttributeError:
self._wallet_id = self._load_env('ITBIT_BTC_USD_WALLET_ID')
return self._wallet_id
def req(self, req_method, url, **kwargs):
# Our auth_request method expects the params in the url.
assert '?' not in url
if 'params' in kwargs:
if kwargs['params']: # Check that it's not empty.
url += '?' + urllib.urlencode(kwargs['params'])
del kwargs['params']
req = super(ItbitBTCUSDExchange, self).req(req_method, url, **kwargs)
return req
def resp(self, req):
response = super(ItbitBTCUSDExchange, self).resp(req)
if 'error' in response and response['error']:
raise exceptions.ExchangeAPIErrorException(self, response['error'])
if 'code' in response:
errors_string = str(response['description'])
error_code = int(response['code'])
if error_code == 81001:
raise exceptions.InsufficientFundsError()
elif error_code == 10002:
raise exceptions.NonceError()
elif error_code == 81002:
raise exceptions.CancelOrderNotFoundError()
else:
raise exceptions.ExchangeAPIErrorException(
self,
'Code %s: %s' % (
error_code, errors_string,
))
return response
def all_trades(self, page=1):
req = self.all_trades_req(page)
return self.all_trades_resp(req)
def all_trades_req(self, page=1):
params = {}
if page:
params['page'] = page
return self.req(
'get',
'/wallets/%s/trades' % self.wallet_id,
params=params,
)
def all_trades_resp(self, req):
response = self.resp(req)
return response['tradingHistory']
def trades_for_orders(self, order_ids):
req = self.trades_for_orders_req()
return self.trades_for_orders_resp(req, order_ids)
def trades_for_orders_req(self):
return self.all_trades_req()
def trades_for_orders_resp(self, req, order_ids):
order_ids = [str(o) for o in order_ids]
trades = self.all_trades_resp(req)
matching_trades = defaultdict(list)
for trade in trades:
oid = str(trade['orderId'])
if oid in order_ids:
matching_trades[oid].append(trade)
return matching_trades
def all_orders(self, status=None, page=1):
req = self.all_orders_req(status, page)
return self.all_orders_resp(req)
def all_orders_req(self, status=None, page=1):
params = {}
if status:
params['status'] = status
if page:
params['page'] = page
return self.req(
'get',
'/wallets/%s/orders' % self.wallet_id,
params=params,
)
def all_orders_resp(self, req):
raw_orders = self.resp(req)
orders = []
for raw_order in raw_orders:
mode = self._order_mode_to_const(raw_order['side'])
volume = Money(raw_order['amount'], 'BTC')
volume_filled = Money(raw_order['amountFilled'], 'BTC')
volume_remaining = volume - volume_filled
order = {
'mode': mode,
'id': str(raw_order['id']),
'price': Money(raw_order['price'], 'USD'),
'volume': volume,
'volume_remaining': volume_remaining,
'status': raw_order['status']
}
orders.append(order)
return orders
# Common Exchange Methods
def auth_request(self, req_method, url, request_args):
"""
This modifies request_args.
"""
try:
self.api_key
self.secret
except AttributeError:
self.api_key = self._load_env('ITBIT_BTC_USD_API_KEY')
self.secret = self._load_env('ITBIT_BTC_USD_API_SECRET').encode('utf-8')
timestamp = int(round(time.time() * 1000))
nonce = self.nonce
body = ''
if 'data' in request_args:
body = json.dumps(request_args['data'])
request_args['data'] = body
message = self._auth_create_message(req_method, url, body, nonce, timestamp)
sig = self._auth_sign_message(message, nonce, url, self.secret)
if 'headers' not in request_args:
request_args['headers'] = {}
headers = request_args['headers']
headers['Authorization'] = self.api_key + ':' + sig
headers['X-Auth-Timestamp'] = str(timestamp)
headers['X-Auth-Nonce'] = str(nonce)
headers['Content-Type'] = 'application/json'
def _auth_create_message(self, verb, url, body, nonce, timestamp):
return json.dumps(
[verb.upper(), url, body, str(nonce), str(timestamp)],
separators=(',', ':'),
)
def _auth_sign_message(self, message, nonce, url, api_secret):
sha256_hash = hashlib.sha256()
nonced_message = str(nonce) + message
sha256_hash.update(nonced_message)
hash_digest = sha256_hash.digest()
msg_to_hmac = url.encode('utf8') + hash_digest
hmac_digest = hmac.new(api_secret, msg_to_hmac, hashlib.sha512).digest()
sig = base64.b64encode(hmac_digest)
return sig
def get_balance_req(self):
try:
self.user_id
except AttributeError:
self.user_id = self._load_env('ITBIT_BTC_USD_USER_ID')
return self.req('get', '/wallets/%s' % self.wallet_id)
def get_balance_resp(self, req):
response = self.resp(req)
raw_balances = response['balances']
btc_available = None
usd_available = None
for raw_balance in raw_balances:
if raw_balance['currency'] == 'XBT':
btc_available = Money(raw_balance['availableBalance'], 'BTC')
elif raw_balance['currency'] == 'USD':
usd_available = Money(raw_balance['availableBalance'], 'USD')
if btc_available is None or usd_available is None:
raise exceptions.ExchangeAPIErrorException(
self,
'missing expected balances',
)
balance = Balance()
balance['BTC'] = btc_available
balance['USD'] = usd_available
return balance
def get_ticker_req(self, verify=True):
return self.req(
'get',
'/markets/XBTUSD/ticker',
no_auth=True,
verify=verify,
)
def get_ticker_resp(self, req):
response = self.resp(req)
return {
'high': Money(response['high24h'], 'USD'),
'low': Money(response['low24h'], 'USD'),
'last': Money(response['lastPrice'], 'USD'),
'volume': Money(response['volume24h'], 'BTC')
}
def _get_orderbook_from_api_req(self, verify=True):
return self.req(
'get',
'/markets/XBTUSD/order_book',
no_auth=True,
verify=verify,
)
def place_order_req(self, mode, volume, price=None, order_type=order_types.LIMIT_ORDER):
side = self._order_mode_from_const(mode)
if price.currency != 'USD':
raise ValueError('price must be in USD')
if volume.currency != 'BTC':
raise ValueError('volume must be in BTC')
# Truncate the volume instead of rounding it because it's better# to trade too
# little than too much.
volume = volume.round_to_decimal_places(8, rounding=cdecimal.ROUND_DOWN)
volume_str = '%.8f' % volume.amount
price_str = '%.2f' % price.amount
payload = {
'type': 'limit',
'currency': 'XBT',
'side': side,
'amount': volume_str,
'price': price_str,
'instrument': 'XBTUSD'
}
return self.req(
'post',
'/wallets/%s/orders/' % self.wallet_id,
data=payload,
)
def place_order_resp(self, req):
response = self.resp(req)
try:
order_id = str(response['id'])
return {'success': True, 'order_id': order_id}
except KeyError:
raise exceptions.ExchangeAPIErrorException(
self,
'response does not contain an order id',
)
def get_open_orders_req(self):
return self.all_orders_req(status='open')
def get_open_orders_resp(self, req):
open_orders = self.all_orders_resp(req)
for o in open_orders:
del o['status']
return open_orders
def get_order_details(self, order_id):
req = self.get_order_details_req()
return self.get_order_details_resp(req, order_id)
def get_order_details_req(self):
return self.get_multi_order_details_req()
def get_order_details_resp(self, req, order_id):
return self.get_multi_order_details_resp(req, [order_id])[order_id]
def get_multi_order_details(self, order_ids):
req = self.get_multi_order_details_req()
return self.get_multi_order_details_resp(req, order_ids)
def get_multi_order_details_req(self):
return self.trades_for_orders_req()
def get_multi_order_details_resp(self, req, order_ids):
# This is modeled after Bitstamp, where we get the order details from the
# trades endpoint directly. The caveat is that order_details will only work
# for the most recent 50 trades. Since we are always accounting trades right
# after they happen, this should be ok (and also affects Bitstamp).
order_ids = [str(o) for o in order_ids]
multi_trades = self.trades_for_orders_resp(req, order_ids)
data = {}
for order_id in order_ids:
total_usd = Money('0', 'USD')
total_btc = Money('0', 'BTC')
our_trades = []
our_type = None
if order_id in multi_trades:
trades = multi_trades[order_id]
for t in trades:
assert(t['currency1'] == 'XBT')
btc_amount = Money(t['currency1Amount'], 'BTC')
assert(t['currency2'] == 'USD')
usd_amount = Money(t['currency2Amount'], 'USD')
# This might also come back as XBT, but since ItBit has 0-fee
# trading right now, I can't tell.
assert(t['commissionCurrency'] == 'USD')
fee = Money(t['commissionPaid'], 'USD')
total_usd += usd_amount
total_btc += btc_amount
our_type = self._order_mode_to_const(t['direction'])
our_trades.append({
'time': parse(t['timestamp']).epoch,
'trade_id': None,
'fee': fee,
'btc': btc_amount,
'fiat': usd_amount,
})
time_created = None
if our_trades:
time_created = min([t['time'] for t in our_trades])
data[order_id] = {
'time_created': time_created,
'type': our_type,
'btc_total': total_btc,
'fiat_total': total_usd,
'trades': our_trades
}
return data
def cancel_order_req(self, order_id):
return self.req(
'delete',
'/wallets/%s/orders/%s' % (self.wallet_id, order_id),
)
def cancel_order_resp(self, req):
# In the success case, no response is given but we need to call resp() so it
# can catch any error cases.
response = self.resp(req) # noqa
return {'success': True}
def withdraw_crypto_req(self, address, volume):
if not isinstance(address, basestring):
raise TypeError('Withdrawal address must be a string')
if not isinstance(volume, Money) or volume.currency != self.volume_currency:
raise TypeError('Withdrawal volume must be in %s' % self.volume_currency)
volume_str = '%.8f' % volume.amount
payload = {
'currency': 'XBT',
'amount': volume_str,
'address': address,
}
return self.req(
'post',
'/wallets/%s/cryptocurrency_withdrawals' % self.wallet_id,
data=payload,
)
def withdraw_crypto_resp(self, req):
response = self.resp(req)
return {'success': True, 'exchange_withdrawal_id': response['withdrawalId']}
def get_order_audit_data(self, skip_recent=0, page=1):
"""
Returns an OrderedDict of order ids mapped to their filled volume (only include
orders that have some trades).
Dropped the skip_recent flag because we don't seem to be using it anywhere.
"""
if skip_recent != 0:
raise ValueEror('skip_recent is deprecated')
orders = OrderedDict()
trades_to_audit = self.all_trades(page=page)
for trade in trades_to_audit:
order_id = str(trade['orderId'])
assert(trade['currency1'] == 'XBT')
trade_amount = abs(Money(trade['currency1Amount'], 'BTC'))
try:
orders[order_id] += trade_amount
except KeyError:
orders[order_id] = trade_amount
# Remove the oldest 2 orders, because its trades might be wrapped around a
# page gap and this would give us an innacurate volume_filled number.
# We need to remove 2 because there could be an ask and a bid.
try:
orders.popitem()
orders.popitem()
except KeyError:
pass
return orders
def fiat_deposit_fee(self, deposit_amount):
return Money('5', 'USD')
def fiat_withdrawal_fee(self, withdrawal_amount):
"""
Itbit fee is from their documentation, and an extra $15 is being charged to us
before it shows up in our bank account (as of the September 2016), so I assume
that's an intermediary fee.
The fee should be a flat $50 on withdrawals > $10k, but we'll see.
"""
fee = Money('0', 'USD')
if withdrawal_amount < Money('10,000', 'USD'):
itbit_fee = Money('15', 'USD')
intermediary_fee = Money('15', 'USD')
fee = itbit_fee + intermediary_fee
else:
fee = Money('50', 'USD')
return fee
| 7,781 |
4,403 | package cn.hutool.poi.excel;
import cn.hutool.poi.excel.cell.values.NumericCellValue;
import java.util.Date;
import org.apache.poi.ss.usermodel.Cell;
import org.junit.Test;
public class NumericCellValueTest {
@Test
public void writeTest() {
final ExcelReader reader = ExcelUtil.getReader("1899bug_demo.xlsx");
ExcelWriter writer = ExcelUtil.getWriter("1899bug_write.xlsx");
Cell cell = reader.getCell(0, 0);
// 直接取值
// 和CellUtil.getCellValue(org.apache.poi.ss.usermodel.Cell)方法的结果一样
// 1899-12-31 04:39:00
Date cellValue = cell.getDateCellValue();
// 将这个值写入EXCEL中自定义样式的单元格，结果会是-1
writer.writeCellValue(0, 0, cellValue);
// 修改后的写入，单元格内容正常
writer.writeCellValue(1, 0, new NumericCellValue(cell).getValue());
writer.close();
reader.close();
}
}
| 393 |
945 |
//-------------------------------------
#ifdef VXL_UNISTD_USLEEP_IS_VOID
// VXL_UNISTD_USLEEP_IS_VOID is set to 1 if this test fails
#include <unistd.h>
int main() { int x = usleep(0); return x*0; }
#endif // VXL_UNISTD_USLEEP_IS_VOID
//-------------------------------------
#ifdef VCL_NUMERIC_LIMITS_HAS_INFINITY
// Does vcl_numeric_limits<float>::has_infinity == 1?
// Several versions of gcc (3.0, 3.1, and 3.2) come with a
// numeric_limits that reports that they have no infinity.
#include <limits>
int main() {
return std::numeric_limits<double>::has_infinity &&
std::numeric_limits<float>::has_infinity ? 0 : 1;
}
#endif // VCL_NUMERIC_LIMITS_HAS_INFINITY
//-------------------------------------
#ifdef VXL_HAS_TYPE_OF_SIZE
// This is used to check if (1) a type exists, (2) is has the required
// size in bytes, and (3) it is functional. The last requirement is
// driven by MSCV 6 which has __int64, but it is not fully
// functional. (It can't be cast to a double, for example.)
// CHAR_BIT is the number of bits per char.
#include <climits>
#ifndef CHAR_BIT
# define CHAR_BIT 8
#endif
#include "config.h"
#if INTEGRAL_TYPE
double cast( THE_TYPE a, unsigned THE_TYPE b, signed THE_TYPE c )
{
return double( a ) + double( b ) + double( c );
}
#else // INTEGRAL_TYPE
double cast( THE_TYPE a )
{
return double( a );
}
#endif // INTEGRAL_TYPE
// These declarations conflict unless the sizes match.
extern int (*verify_size)[sizeof(THE_TYPE) * CHAR_BIT];
extern int (*verify_size)[THE_SIZE];
int main()
{
return 0;
}
#endif // VXL_HAS_TYPE_OF_SIZE
//-------------------------------------
#ifdef VCL_HAS_LFS
// Return 1 if compiler has #define-switchable Large File Support
#define _LARGEFILE_SOURCE
#define _FILE_OFFSET_BITS 64
#include <fstream>
#include <iostream>
int main(int argc, char * argv[])
{
if( sizeof(std::streamoff)==8 )
return 0 ;
else
return 1;
}
#endif // VCL_HAS_LFS
//-------------------------------------
#ifdef VXL_HAS_DBGHELP_H
// This is a Windows header, and needs windows.h included first to make it compile properly.
#include <Windows.h>
#include <DbgHelp.h>
int main() { MINIDUMP_EXCEPTION_INFORMATION dummy; return 0; }
#endif // VXL_HAS_DBGHELP_H
//-------------------------------------
//-------------------------------------
#ifdef VXL_HAS_WIN_WCHAR_T
#ifdef _WCHAR_T_DEFINED
#include <cwchar>
int main()
{
wchar_t buf [10];
buf[0] = L'1';
buf[1] = L'\0';
return 0;
}
#else
int main() { return 1; }
#endif
#endif
//-------------------------------------
#ifdef VXL_HAS_MM_MALLOC
#include <emmintrin.h>
int main()
{
void* x = _mm_malloc(4*sizeof(float),16);
_mm_free(x);
return 0;
}
#endif
//-------------------------------------
#ifdef VXL_HAS_ALIGNED_MALLOC
#include <malloc.h>
int main()
{
void* x = _aligned_malloc(4*sizeof(float),16);
_aligned_free(x);
return 0;
}
#endif
//-------------------------------------
#ifdef VXL_HAS_MINGW_ALIGNED_MALLOC
#include <malloc.h>
int main()
{
void* x = __mingw_aligned_malloc(4*sizeof(float),16);
__mingw_aligned_free(x);
return 0;
}
#endif
//-------------------------------------
#ifdef VXL_HAS_POSIX_MEMALIGN
#include <cstdlib>
int main()
{
void* x = memalign(16,4*sizeof(float));
free(x);
return 0;
}
#endif
//-------------------------------------
#if defined(VXL_HAS_SSE2_HARDWARE_SUPPORT) || defined(VXL_SSE2_HARDWARE_SUPPORT_POSSIBLE)
#include <emmintrin.h>
int main()
{
//try to do some sse2 calculations
double d_a[] = { 6.75, 3.42 };
double d_b[] = { 2.3, 9.2 };
double res[2] = {0.0};
__m128d z;
z = _mm_mul_pd(_mm_loadu_pd(d_a),_mm_loadu_pd(d_b));
_mm_storeu_pd(res,z);
return 0;
}
#endif
| 1,424 |
2,542 | <filename>src/prod/ktl/src/src/Threadpool/UnfairSemaphore.h
#pragma once
#include "MinPal.h"
#include "Synch.h"
namespace KtlThreadpool {
class UnfairSemaphore
{
private:
BYTE padding1[64];
union Counts
{
struct
{
int spinners : 16; //how many threads are currently spin-waiting for this semaphore?
int countForSpinners : 16; //how much of the semaphore's count is availble to spinners?
int waiters : 16; //how many threads are blocked in the OS waiting for this semaphore?
int countForWaiters : 16; //how much count is available to waiters?
};
LONGLONG asLongLong;
} m_counts;
private:
Semaphore m_sem; //waiters wait on this
// padding to ensure we get our own cache line
BYTE padding2[64];
int m_maxCount;
int m_numProcessors;
bool UpdateCounts(Counts newCounts, Counts currentCounts);
public:
UnfairSemaphore(int numProcessors, int maxCount);
// no destructor - Semaphore will close itself in its own destructor.
//~UnfairSemaphore() { }
void Release(int countToRelease);
bool Wait(DWORD timeout);
};
}
| 584 |
1,454 | <reponame>UrielX14/FacebookBot
import convert, os
if 'FB_BOT_STT_API_PROVIDER' in os.environ and os.environ['FB_BOT_STT_API_PROVIDER'] == 'GOOGLE':
from speech_py import speech_to_text_google as STT
else:
from speech_py import speech_to_text_ibm_rest as STT
def transcribe(audio_url):
raw_audio = convert.convert(audio_url)
return STT(raw_audio) | 142 |
854 | <reponame>timxor/leetcode-journal
__________________________________________________________________________________________________
4ms
class Solution {
public:
int fac(int n) {
if (n == 1) return 1;
return n * fac(n - 1);
}
void getPermutation(vector<int>& remain, vector<int>& result, int k) {
int n = remain.size();
if (n == 0) return;
if (n == 1) {
result.push_back(remain[0]);
return;
}
int fact = fac(n - 1);
int offset = k / fact;
result.push_back(remain[offset]);
remain.erase(remain.begin() + offset);
getPermutation(remain, result, k % fact);
}
string getPermutation(int n, int k) {
vector<int> remain;
for (int i = 1; i <= n; ++i) {
remain.push_back(i);
}
vector<int> result;
getPermutation(remain, result, k - 1);
std::ostringstream result_oss;
for (int n : result) {
result_oss << n;
}
return result_oss.str();
}
};
__________________________________________________________________________________________________
8296 kb
static const auto speedup = []() {std::ios::sync_with_stdio(false); std::cin.tie(NULL); return 0; }();
class Solution {
public:
string ans;
int N;
vector<bool> used;
int factorial(int n){
int f=1;
for(int i=2;i<=n;i++)
f*=i;
return f;
}
void helper(int n,int k){
int fa=factorial(n-1);
int m=1+(k-1)/fa,j=0;
while(n>0){
for(int i=1;i<=N;i++){
if(!used[i]&&(++j)==m){
ans+=to_string(i);
used[i]=true;
k-=(m-1)*fa;
n--;
fa=factorial(n-1);
m=1+(k-1)/fa;
j=0;
break;
}
}
}
}
string getPermutation(int n, int k) {
N=n;
used.resize(n+1);
helper(n,k);
return ans;
}
};
__________________________________________________________________________________________________
| 1,169 |
808 | #include <benchmark/benchmark.h>
#include <symengine/parser.h>
#include <symengine/parser/parser.h>
using SymEngine::Basic;
using SymEngine::parse;
using SymEngine::RCP;
static void parse_0(benchmark::State &state)
{
RCP<const Basic> a;
for (auto _ : state) {
a = parse("0");
}
}
static void parse_long_expr1(benchmark::State &state)
{
std::string text = "1";
std::string t0 = " * (x + y - sin(x)/(z**2-4) - x**(y**z))";
for (int i = 0; i < state.range(0); i++) {
text.append(t0);
}
RCP<const Basic> a;
for (auto _ : state) {
a = parse(text);
}
state.SetComplexityN(state.range(0));
}
static void parse_long_expr2(benchmark::State &state)
{
std::string text = "1";
std::string t0 = " * (cos(x) + arcsinh(y - sin(x))/(z**2-4) - x**(y**z))";
for (int i = 0; i < state.range(0); i++) {
text.append(t0);
}
RCP<const Basic> a;
for (auto _ : state) {
a = parse(text);
}
state.SetComplexityN(state.range(0));
}
BENCHMARK(parse_0);
BENCHMARK(parse_long_expr1)->Range(2, 4096)->Complexity();
BENCHMARK(parse_long_expr2)->Range(2, 4096)->Complexity();
BENCHMARK_MAIN();
| 551 |
9,734 | <filename>cpp/src/arrow/util/time_test.cc<gh_stars>1000+
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include <gtest/gtest.h>
#include "arrow/testing/gtest_util.h"
#include "arrow/util/time.h"
namespace arrow {
namespace util {
TEST(TimeTest, ConvertTimestampValue) {
auto convert = [](TimeUnit::type in, TimeUnit::type out, int64_t value) {
return ConvertTimestampValue(timestamp(in), timestamp(out), value).ValueOrDie();
};
auto units = {
TimeUnit::SECOND,
TimeUnit::MILLI,
TimeUnit::MICRO,
TimeUnit::NANO,
};
// Test for identity
for (auto unit : units) {
EXPECT_EQ(convert(unit, unit, 0), 0);
EXPECT_EQ(convert(unit, unit, INT64_MAX), INT64_MAX);
EXPECT_EQ(convert(unit, unit, INT64_MIN), INT64_MIN);
}
EXPECT_EQ(convert(TimeUnit::SECOND, TimeUnit::MILLI, 2), 2000);
EXPECT_EQ(convert(TimeUnit::SECOND, TimeUnit::MICRO, 2), 2000000);
EXPECT_EQ(convert(TimeUnit::SECOND, TimeUnit::NANO, 2), 2000000000);
EXPECT_EQ(convert(TimeUnit::MILLI, TimeUnit::SECOND, 7000), 7);
EXPECT_EQ(convert(TimeUnit::MILLI, TimeUnit::MICRO, 7), 7000);
EXPECT_EQ(convert(TimeUnit::MILLI, TimeUnit::NANO, 7), 7000000);
EXPECT_EQ(convert(TimeUnit::MICRO, TimeUnit::SECOND, 4000000), 4);
EXPECT_EQ(convert(TimeUnit::MICRO, TimeUnit::MILLI, 4000), 4);
EXPECT_EQ(convert(TimeUnit::MICRO, TimeUnit::SECOND, 4000000), 4);
EXPECT_EQ(convert(TimeUnit::NANO, TimeUnit::SECOND, 6000000000), 6);
EXPECT_EQ(convert(TimeUnit::NANO, TimeUnit::MILLI, 6000000), 6);
EXPECT_EQ(convert(TimeUnit::NANO, TimeUnit::MICRO, 6000), 6);
}
} // namespace util
} // namespace arrow
| 847 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.microsoft.azure.eventhubs.impl;
public final class PassByRef<T extends Object> {
T t;
public T get() {
return this.t;
}
public void set(final T t) {
this.t = t;
}
}
| 119 |
348 | {"nom":"Puihardy","circ":"1ère circonscription","dpt":"Deux-Sèvres","inscrits":33,"abs":13,"votants":20,"blancs":0,"nuls":0,"exp":20,"res":[{"nuance":"FI","nom":"<NAME>","voix":12},{"nuance":"REM","nom":"<NAME>","voix":8}]} | 93 |
655 | <reponame>Watch-Later/mfcmapi
#pragma once
// Where our error array is defined
#ifndef MAPI_E_STORE_FULL
#define MAPI_E_STORE_FULL MAKE_MAPI_E(0x60C)
#endif
// [MS-OXCDATA]
#ifndef MAPI_E_LOCKID_LIMIT
#define MAPI_E_LOCKID_LIMIT MAKE_MAPI_E(0x60D)
#endif
#ifndef MAPI_E_NAMED_PROP_QUOTA_EXCEEDED
#define MAPI_E_NAMED_PROP_QUOTA_EXCEEDED MAKE_MAPI_E(0x900)
#endif
#ifndef MAPI_E_PROFILE_DELETED
#define MAPI_E_PROFILE_DELETED MAKE_MAPI_E(0x204)
#endif
#ifndef SYNC_E_CYCLE
#define SYNC_E_CYCLE MAKE_SYNC_E(0x804)
#endif
#define E_FILE_NOT_FOUND HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
#define E_ERROR_PROC_NOT_FOUND HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND)
#define E_RPC_S_INVALID_TAG HRESULT_FROM_WIN32(RPC_S_INVALID_TAG)
#define MAPI_E_RECONNECTED MAKE_MAPI_E(0x125)
#define MAPI_E_OFFLINE MAKE_MAPI_E(0x126)
#define MAIL_E_NAMENOTFOUND MAKE_SCODE(SEVERITY_ERROR, 0x0100, 10054)
#define STRSAFE_E_INSUFFICIENT_BUFFER ((HRESULT) 0x8007007AL) // 0x7A = 122L = ERROR_INSUFFICIENT_BUFFER
#define STRSAFE_E_INVALID_PARAMETER ((HRESULT) 0x80070057L) // 0x57 = 87L = ERROR_INVALID_PARAMETER
#define STRSAFE_E_END_OF_FILE ((HRESULT) 0x80070026L) // 0x26 = 38L = ERROR_HANDLE_EOF
namespace error
{
#define ERROR_ENTRY(_fName) {(ULONG) _fName, L#_fName},
// These are sorted in increasing order, with no duplicates
// We have no logic for handling duplicate error codes
ERROR_ARRAY_ENTRY g_ErrorArray[] = {
// clang-format off
ERROR_ENTRY(S_FALSE)
// IStorage success codes
ERROR_ENTRY(STG_S_CONVERTED)
ERROR_ENTRY(STG_S_BLOCK)
ERROR_ENTRY(STG_S_RETRYNOW)
ERROR_ENTRY(STG_S_MONITORING)
ERROR_ENTRY(STG_S_MULTIPLEOPENS)
ERROR_ENTRY(STG_S_CANNOTCONSOLIDATE)
ERROR_ENTRY(OLEOBJ_S_CANNOT_DOVERB_NOW)
ERROR_ENTRY(MAPI_W_NO_SERVICE)
ERROR_ENTRY(MAPI_W_ERRORS_RETURNED)
ERROR_ENTRY(MAPI_W_POSITION_CHANGED)
ERROR_ENTRY(MAPI_W_APPROX_COUNT)
ERROR_ENTRY(MAPI_W_CANCEL_MESSAGE)
ERROR_ENTRY(MAPI_W_PARTIAL_COMPLETION)
ERROR_ENTRY(SYNC_W_PROGRESS)
ERROR_ENTRY(SYNC_W_CLIENT_CHANGE_NEWER)
ERROR_ENTRY(MAPI_E_INTERFACE_NOT_SUPPORTED)
ERROR_ENTRY(MAPI_E_CALL_FAILED)
// IStorage errors
ERROR_ENTRY(STG_E_INVALIDFUNCTION)
ERROR_ENTRY(STG_E_FILENOTFOUND)
ERROR_ENTRY(STG_E_PATHNOTFOUND)
ERROR_ENTRY(STG_E_TOOMANYOPENFILES)
ERROR_ENTRY(STG_E_ACCESSDENIED)
ERROR_ENTRY(STG_E_INVALIDHANDLE)
ERROR_ENTRY(STG_E_INSUFFICIENTMEMORY)
ERROR_ENTRY(STG_E_INVALIDPOINTER)
ERROR_ENTRY(STG_E_NOMOREFILES)
ERROR_ENTRY(STG_E_DISKISWRITEPROTECTED)
ERROR_ENTRY(STG_E_SEEKERROR)
ERROR_ENTRY(STG_E_WRITEFAULT)
ERROR_ENTRY(STG_E_READFAULT)
ERROR_ENTRY(STG_E_SHAREVIOLATION)
ERROR_ENTRY(STG_E_LOCKVIOLATION)
ERROR_ENTRY(STG_E_FILEALREADYEXISTS)
ERROR_ENTRY(STG_E_INVALIDPARAMETER)
ERROR_ENTRY(STG_E_MEDIUMFULL)
ERROR_ENTRY(STG_E_PROPSETMISMATCHED)
ERROR_ENTRY(STG_E_ABNORMALAPIEXIT)
ERROR_ENTRY(STG_E_INVALIDHEADER)
ERROR_ENTRY(STG_E_INVALIDNAME)
ERROR_ENTRY(STG_E_UNKNOWN)
ERROR_ENTRY(STG_E_UNIMPLEMENTEDFUNCTION)
ERROR_ENTRY(STG_E_INVALIDFLAG)
ERROR_ENTRY(STG_E_INUSE)
ERROR_ENTRY(STG_E_NOTCURRENT)
ERROR_ENTRY(STG_E_REVERTED)
ERROR_ENTRY(STG_E_CANTSAVE)
ERROR_ENTRY(STG_E_OLDFORMAT)
ERROR_ENTRY(STG_E_OLDDLL)
ERROR_ENTRY(STG_E_SHAREREQUIRED)
ERROR_ENTRY(STG_E_NOTFILEBASEDSTORAGE)
ERROR_ENTRY(STG_E_EXTANTMARSHALLINGS)
ERROR_ENTRY(STG_E_DOCFILECORRUPT)
ERROR_ENTRY(STG_E_BADBASEADDRESS)
ERROR_ENTRY(STG_E_DOCFILETOOLARGE)
ERROR_ENTRY(STG_E_NOTSIMPLEFORMAT)
ERROR_ENTRY(STG_E_INCOMPLETE)
ERROR_ENTRY(STG_E_TERMINATED)
ERROR_ENTRY(MAPI_E_NO_SUPPORT)
ERROR_ENTRY(MAPI_E_BAD_CHARWIDTH)
ERROR_ENTRY(MAPI_E_STRING_TOO_LONG)
ERROR_ENTRY(MAPI_E_UNKNOWN_FLAGS)
ERROR_ENTRY(MAPI_E_INVALID_ENTRYID)
ERROR_ENTRY(MAPI_E_INVALID_OBJECT)
ERROR_ENTRY(MAPI_E_OBJECT_CHANGED)
ERROR_ENTRY(MAPI_E_OBJECT_DELETED)
ERROR_ENTRY(MAPI_E_BUSY)
ERROR_ENTRY(MAPI_E_NOT_ENOUGH_DISK)
ERROR_ENTRY(MAPI_E_NOT_ENOUGH_RESOURCES)
ERROR_ENTRY(MAPI_E_NOT_FOUND)
ERROR_ENTRY(MAPI_E_VERSION)
ERROR_ENTRY(MAPI_E_LOGON_FAILED)
ERROR_ENTRY(MAPI_E_SESSION_LIMIT)
ERROR_ENTRY(MAPI_E_USER_CANCEL)
ERROR_ENTRY(MAPI_E_UNABLE_TO_ABORT)
ERROR_ENTRY(MAPI_E_NETWORK_ERROR)
ERROR_ENTRY(MAPI_E_DISK_ERROR)
ERROR_ENTRY(MAPI_E_TOO_COMPLEX)
ERROR_ENTRY(MAPI_E_BAD_COLUMN)
ERROR_ENTRY(MAPI_E_EXTENDED_ERROR)
ERROR_ENTRY(MAPI_E_COMPUTED)
ERROR_ENTRY(MAPI_E_CORRUPT_DATA)
ERROR_ENTRY(MAPI_E_UNCONFIGURED)
ERROR_ENTRY(MAPI_E_FAILONEPROVIDER)
ERROR_ENTRY(MAPI_E_UNKNOWN_CPID)
ERROR_ENTRY(MAPI_E_UNKNOWN_LCID)
// Flavors of E_ACCESSDENIED, used at logon
ERROR_ENTRY(MAPI_E_PASSWORD_CHANGE_REQUIRED)
ERROR_ENTRY(MAPI_E_PASSWORD_EXPIRED)
ERROR_ENTRY(MAPI_E_INVALID_WORKSTATION_ACCOUNT)
ERROR_ENTRY(MAPI_E_INVALID_ACCESS_TIME)
ERROR_ENTRY(MAPI_E_ACCOUNT_DISABLED)
// Reconnect
ERROR_ENTRY(MAPI_E_RECONNECTED)
ERROR_ENTRY(MAPI_E_OFFLINE)
// COM errors (for CLSIDFromString)
ERROR_ENTRY(REGDB_E_WRITEREGDB)
ERROR_ENTRY(REGDB_E_CLASSNOTREG)
ERROR_ENTRY(CO_E_CLASSSTRING)
// MAPI base function and status object specific errors and warnings
ERROR_ENTRY(MAPI_E_END_OF_SESSION)
ERROR_ENTRY(MAPI_E_UNKNOWN_ENTRYID)
ERROR_ENTRY(MAPI_E_MISSING_REQUIRED_COLUMN)
ERROR_ENTRY(MAPI_E_PROFILE_DELETED)
// Property specific errors and warnings
ERROR_ENTRY(MAPI_E_BAD_VALUE)
ERROR_ENTRY(MAPI_E_INVALID_TYPE)
ERROR_ENTRY(MAPI_E_TYPE_NO_SUPPORT)
ERROR_ENTRY(MAPI_E_UNEXPECTED_TYPE)
ERROR_ENTRY(MAPI_E_TOO_BIG)
ERROR_ENTRY(MAPI_E_DECLINE_COPY)
ERROR_ENTRY(MAPI_E_UNEXPECTED_ID)
// Table specific errors and warnings
ERROR_ENTRY(MAPI_E_UNABLE_TO_COMPLETE)
ERROR_ENTRY(MAPI_E_TIMEOUT)
ERROR_ENTRY(MAPI_E_TABLE_EMPTY)
ERROR_ENTRY(MAPI_E_TABLE_TOO_BIG)
ERROR_ENTRY(MAPI_E_INVALID_BOOKMARK)
// Transport specific errors and warnings
ERROR_ENTRY(MAPI_E_WAIT)
ERROR_ENTRY(MAPI_E_CANCEL)
ERROR_ENTRY(MAPI_E_NOT_ME)
// Message Store, Folder, and Message specific errors and warnings
ERROR_ENTRY(MAPI_E_CORRUPT_STORE)
ERROR_ENTRY(MAPI_E_NOT_IN_QUEUE)
ERROR_ENTRY(MAPI_E_NO_SUPPRESS)
ERROR_ENTRY(MAPI_E_COLLISION)
ERROR_ENTRY(MAPI_E_NOT_INITIALIZED)
ERROR_ENTRY(MAPI_E_NON_STANDARD)
ERROR_ENTRY(MAPI_E_NO_RECIPIENTS)
ERROR_ENTRY(MAPI_E_SUBMITTED)
ERROR_ENTRY(MAPI_E_HAS_FOLDERS)
ERROR_ENTRY(MAPI_E_HAS_MESSAGES)
ERROR_ENTRY(MAPI_E_FOLDER_CYCLE)
ERROR_ENTRY(MAPI_E_STORE_FULL)
ERROR_ENTRY(MAPI_E_LOCKID_LIMIT)
// Address Book specific errors and warnings
ERROR_ENTRY(MAPI_E_AMBIGUOUS_RECIP)
ERROR_ENTRY(SYNC_E_OBJECT_DELETED)
ERROR_ENTRY(SYNC_E_IGNORE)
ERROR_ENTRY(SYNC_E_CONFLICT)
ERROR_ENTRY(SYNC_E_NO_PARENT)
ERROR_ENTRY(SYNC_E_CYCLE)
ERROR_ENTRY(SYNC_E_UNSYNCHRONIZED)
ERROR_ENTRY(MAPI_E_NAMED_PROP_QUOTA_EXCEEDED)
ERROR_ENTRY(E_FILE_NOT_FOUND)
ERROR_ENTRY(MAPI_E_NO_ACCESS)
ERROR_ENTRY(MAPI_E_NOT_ENOUGH_MEMORY)
// StrSafe.h error codes:
ERROR_ENTRY(STRSAFE_E_END_OF_FILE)
ERROR_ENTRY(MAPI_E_INVALID_PARAMETER)
ERROR_ENTRY(STRSAFE_E_INSUFFICIENT_BUFFER)
ERROR_ENTRY(E_ERROR_PROC_NOT_FOUND)
ERROR_ENTRY(E_RPC_S_INVALID_TAG)
ERROR_ENTRY(E_OLK_REGISTRY)
ERROR_ENTRY(E_OLK_ALREADY_INITIALIZED)
ERROR_ENTRY(E_OLK_PARAM_NOT_SUPPORTED)
ERROR_ENTRY(E_OLK_NOT_INITIALIZED)
ERROR_ENTRY(E_OLK_PROP_READ_ONLY)
ERROR_ENTRY(E_ACCT_NOT_FOUND)
ERROR_ENTRY(E_ACCT_WRONG_SORT_ORDER)
ERROR_ENTRY(E_NOTIMPL)
ERROR_ENTRY(MAIL_E_NAMENOTFOUND)
// clang-format on
};
ULONG g_ulErrorArray = _countof(g_ErrorArray);
} // namespace error
| 3,806 |
852 | <gh_stars>100-1000
# Auto generated configuration file
# using:
# Revision: 1.19
# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v
# with command line options: step5 --conditions auto:run2_mc --nThreads 2 -n 10 --era Run2_2016 --eventcontent MINIAODSIM --filein file:step3_inMINIAODSIM.root -s NANO --datatier NANOAODSIM --mc --fileout file:step5.root
import FWCore.ParameterSet.Config as cms
from Configuration.Eras.Era_Run2_2016_cff import Run2_2016
process = cms.Process('NANO',Run2_2016)
# import of standard configurations
process.load('Configuration.StandardSequences.Services_cff')
process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
process.load('FWCore.MessageService.MessageLogger_cfi')
process.load('Configuration.EventContent.EventContent_cff')
process.load('SimGeneral.MixingModule.mixNoPU_cfi')
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load('Configuration.StandardSequences.EndOfProcess_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(10),
output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
)
# Input source
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/h/hinzmann/stable_13TeV/jetmet/mtd/CMSSW_12_0_0_pre3/src/25202.0_TTbar_13+TTbar_13+DIGIUP15_PU25+RECOUP15_PU25+HARVESTUP15_PU25+NANOUP15_PU25/step3_inMINIAODSIM.root'),
secondaryFileNames = cms.untracked.vstring()
)
process.options = cms.untracked.PSet(
FailPath = cms.untracked.vstring(),
IgnoreCompletely = cms.untracked.vstring(),
Rethrow = cms.untracked.vstring(),
SkipEvent = cms.untracked.vstring(),
allowUnscheduled = cms.obsolete.untracked.bool,
canDeleteEarly = cms.untracked.vstring(),
emptyRunLumiMode = cms.obsolete.untracked.string,
eventSetup = cms.untracked.PSet(
forceNumberOfConcurrentIOVs = cms.untracked.PSet(
),
numberOfConcurrentIOVs = cms.untracked.uint32(1)
),
fileMode = cms.untracked.string('FULLMERGE'),
forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
makeTriggerResults = cms.obsolete.untracked.bool,
numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(1),
numberOfConcurrentRuns = cms.untracked.uint32(1),
numberOfStreams = cms.untracked.uint32(0),
numberOfThreads = cms.untracked.uint32(1),
printDependencies = cms.untracked.bool(False),
sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
throwIfIllegalParameter = cms.untracked.bool(True),
wantSummary = cms.untracked.bool(False)
)
# Production Info
process.configurationMetadata = cms.untracked.PSet(
annotation = cms.untracked.string('step5 nevts:10'),
name = cms.untracked.string('Applications'),
version = cms.untracked.string('$Revision: 1.19 $')
)
# Output definition
process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule",
compressionAlgorithm = cms.untracked.string('LZMA'),
compressionLevel = cms.untracked.int32(9),
dataset = cms.untracked.PSet(
dataTier = cms.untracked.string('MINIAODSIM'),
filterName = cms.untracked.string('')
),
fileName = cms.untracked.string('file:updatedMINIAODSIM.root'),
outputCommands = process.MINIAODSIMEventContent.outputCommands
)
# Additional output definition
# Other statements
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc', '')
# Rerun PUPPI MET and ak4 jets (but not ak8)
from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD
makePuppiesFromMiniAOD(process,True)
process.puppi.useExistingWeights = False
process.puppiNoLep.useExistingWeights = False
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(process,isData=False,metType="Puppi",postfix="Puppi",jetFlavor="AK4PFPuppi",recoMetFromPFCs=True)
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
addToProcessAndTask('patPuppiJetSpecificProducer', patPuppiJetSpecificProducer.clone(src=cms.InputTag("patJetsPuppi")), process, task)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
labelName = 'PuppiJetSpecific',
jetSource = cms.InputTag('patJetsPuppi'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ]
addToProcessAndTask('slimmedJetsPuppi', process.updatedPatJetsPuppiJetSpecific.clone(), process, task)
del process.updatedPatJetsPuppiJetSpecific
process.puppiSequence = cms.Sequence(process.puppiMETSequence+process.fullPatMetSequencePuppi+process.patPuppiJetSpecificProducer+process.slimmedJetsPuppi)
# Example how to not use vertex fit for track-vertex-association, but only dz
#process.packedPrimaryVertexAssociationJME.assignment.useVertexFit = False
#process.packedPrimaryVertexAssociationJME.assignment.maxDzSigForPrimaryAssignment = 5.0
#process.packedPrimaryVertexAssociationJME.assignment.maxDzForPrimaryAssignment = 0.1
#process.packedPrimaryVertexAssociationJME.assignment.maxDzErrorForPrimaryAssignment = 0.05
#process.packedPrimaryVertexAssociationJME.assignment.OnlyUseFirstDz = False
#process.pfCHS.vertexAssociationQuality = 6
# Path and EndPath definitions
process.puppi_step = cms.Path(process.puppiSequence)
process.endjob_step = cms.EndPath(process.endOfProcess)
process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput)
# Schedule definition
process.schedule = cms.Schedule(process.puppi_step,process.endjob_step,process.MINIAODSIMoutput_step)
from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask
associatePatAlgosToolsTask(process)
#Setup FWK for multithreaded
process.options.numberOfThreads=cms.untracked.uint32(2)
process.options.numberOfStreams=cms.untracked.uint32(0)
process.options.numberOfConcurrentLuminosityBlocks=cms.untracked.uint32(1)
# customisation of the process.
# End of customisation functions
# Customisation from command line
# Add early deletion of temporary data products to reduce peak memory need
from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete
process = customiseEarlyDelete(process)
# End adding early deletion
| 2,454 |
480 | /*
* Copyright [2013-2021], Alibaba Group Holding 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.
*/
package com.alibaba.polardbx.executor.ddl.job.task.gsi;
import com.alibaba.fastjson.annotation.JSONCreator;
import com.alibaba.polardbx.common.exception.TddlRuntimeException;
import com.alibaba.polardbx.common.exception.code.ErrorCode;
import com.alibaba.polardbx.executor.ddl.job.task.BaseValidateTask;
import com.alibaba.polardbx.executor.ddl.job.task.util.TaskName;
import com.alibaba.polardbx.optimizer.OptimizerContext;
import com.alibaba.polardbx.optimizer.config.table.SchemaManager;
import com.alibaba.polardbx.optimizer.context.ExecutionContext;
import lombok.Getter;
import java.util.Map;
@TaskName(name = "ValidateTableVersionTask")
@Getter
public class ValidateTableVersionTask extends BaseValidateTask {
Map<String, Long> tableVersions;
@JSONCreator
public ValidateTableVersionTask(String schemaName, Map<String, Long> tableVersions) {
super(schemaName);
this.tableVersions = tableVersions;
}
@Override
protected void executeImpl(ExecutionContext executionContext) {
doValidate(executionContext);
}
public void doValidate(ExecutionContext executionContext) {
SchemaManager sm = OptimizerContext.getContext(schemaName).getLatestSchemaManager();
for (Map.Entry<String, Long> tableVersion : tableVersions.entrySet()) {
long oldVersion = tableVersion.getValue();
if (oldVersion > 0) {
long curVersion = sm.getTable(tableVersion.getKey()).getVersion();
if (curVersion > oldVersion) {
throw new TddlRuntimeException(ErrorCode.ERR_TABLE_META_TOO_OLD, schemaName, tableVersion.getKey());
}
}
}
}
} | 815 |
335 | <filename>L/Leopard_noun.json
{
"word": "Leopard",
"definitions": [
"A large solitary cat that has a fawn or brown coat with black spots, native to the forests of Africa and southern Asia.",
"The leopard as a heraldic device.",
"A lion passant guardant as in the arms of England.",
"Spotted like a leopard."
],
"parts-of-speech": "Noun"
} | 147 |
317 | #ifndef __AIArtSet__
#define __AIArtSet__
/*
* Name: AIArtSet.h
* $Revision: 6 $
* Author:
* Date:
* Purpose: Adobe Illustrator Art Set Suite.
*
* ADOBE SYSTEMS INCORPORATED
* Copyright 1986-2014 Adobe Systems Incorporated.
* All rights reserved.
*
* NOTICE: Adobe permits you to use, modify, and distribute this file
* in accordance with the terms of the Adobe license agreement
* accompanying it. If you have received this file from a source other
* than Adobe, then your use, modification, or distribution of it
* requires the prior written permission of Adobe.
*
*/
/*******************************************************************************
**
** Imports
**
**/
#ifndef __AITypes__
#include "AITypes.h"
#endif
#ifndef __AIArt__
#include "AIArt.h"
#endif
#ifndef __AILayer__
#include "AILayer.h"
#endif
#include "AIHeaderBegin.h"
/** @file AIArtSet.h */
/*******************************************************************************
**
** Constants
**
**/
#define kAIArtSetSuite "AI Art Set Suite"
#define kAIArtSetSuiteVersion AIAPI_VERSION(9)
#define kAIArtSetVersion kAIArtSetSuiteVersion
/*******************************************************************************
**
** Types
**
**/
/** An \c AIArtSpec is a filter for matching art objects that have specific
properties. Pass an array of these to \c #AIArtSetSuite::MatchingArtSet()
to specify the art objects that should be returned.
Specify the type of art object to match, then filter objects of that type
based on their user attributes.
\li Use the special type \c kAnyArt to match any kind of art object.
\li \c whichAttr specifies the collection of attributes to be considered when filtering objects.
\li \c attr specifies the values those attributes must have to match an object.
For example, specify \c kSelected for both \c whichAttr and \c attr to match
only art objects that are selected.
Some \c #AIArtSuite::AIArtUserAttr values are not art attributes
but instead specify additional matching options. Use such a value
in the \c whichAttr field; it only needs to be in one of the art specifications.
*/
typedef struct {
/** The type of art object to match, an \c #AIArtSuite::AIArtType value. */
ai::int16 type;
/** \c #AIArtSuite::AIArtUserAttr values for which attributes to consider (\c whichAttr)
and for the matching value (\c attr).
*/
ai::int32 whichAttr, attr;
} AIArtSpec;
/** Opaque type for an ordered list of art object handles. */
typedef struct _t_AIArt *AIArtSet;
/*******************************************************************************
**
** Suite
**
**/
/** @ingroup Suites
An art set is an ordered list of art object handles. An art object handle should
appear at most once in the list. This is enforced by most but not all of the
functions for manipulating the set.
\li Acquire this suite using \c #SPBasicSuite::AcquireSuite() with the constants
\c #kAIArtSetSuite and \c #kAIArtSetVersion.
*/
typedef struct {
/** Creates a new, empty art set.
This is an opaque pointer and cannot be dereferenced.
Use functions in this suite to fill the set with art objects and access them.
@param artSet [out] A buffer in which to return the new art set.
*/
AIAPI AIErr (*NewArtSet) ( AIArtSet *artSet );
/** Frees memory associated with an art set and makes the reference null.
Does not affect any artwork referenced by the set.
@param artSet A pointer to the art set. Upon return, this reference is invalid.
*/
AIAPI AIErr (*DisposeArtSet) ( AIArtSet *artSet );
/** Gets the number of art handles stored in an art set. Use with \c #IndexArtSet() to
iterate through a set.
@param artSet The art set.
@param count [out] A buffer in which to return the number of art handles.
*/
AIAPI AIErr (*CountArtSet) ( AIArtSet artSet, size_t *count );
/** Retrieves the art object at a given index within an art set.
Use with \c #CountArtSet() to iterate through a set. This is the
most efficient way to access elements of an art set. Access speed is O(1).
@param artSet The art set.
@param index The 0-based position index, in the range \c [0..count-1].
@param art [out] A buffer in which to return the art object.
@note \c #ReplaceArtInArtSet() can put \c NULL entries into an art set.
\c #NextInArtSet() iterates through the set skipping \c NULL entries, but
is not a efficient as this function. */
AIAPI AIErr (*IndexArtSet) ( AIArtSet artSet, size_t index, AIArtHandle *art );
/** Fills an art set with an array of art objects.
The previous contents of the art set, if any, are lost. It is the
caller's responsibility to ensure that the array does not contain duplicates.
@param artSet The art set.
@param artArray A pointer to an array of art objects.
You must allocate memory for this array, and free it when it is
no longer needed.
@param count The number of entries in \c artArray.
*/
AIAPI AIErr (*ArrayArtSet) ( AIArtSet artSet, AIArtHandle *artArray, size_t count );
/** Fills an art set with currently selected art.
The previous contents of the art set, if any, are lost.
Many filters operate on the selected objects in a document. Use this function
to collect the selected art objects without having to iterate through the
artwork tree to find them.It is the same as calling \c #MatchingArtSet()
with a request for <code> { kAnyArt, kArtSelected, kArtSelected } </code>
@param artSet The art set.
*/
AIAPI AIErr (*SelectedArtSet) ( AIArtSet artSet );
/** Fills an art set with the art objects in the current document
that match the criteria given in a list of art specifications; see \c #AIArtSpec.
The art objects are added to the set in the order they are encountered by a pre-order
traversal of the document tree. An art object is included
if it matches any of the art specifications.
@param spec A pointer to an array of \c #AIArtSpec structures.
@param numSpecs The number of entries in \c specs.
@param artSet The art set.
*/
AIAPI AIErr (*MatchingArtSet) ( AIArtSpec *specs, ai::int16 numSpecs, AIArtSet artSet );
/** Fills an art set with all art objects that belong to a specific layer.
The previous contents of the art set, if any, are lost.
@param layer The layer.
@param artSet The art set.
*/
AIAPI AIErr (*LayerArtSet) ( AILayerHandle layer, AIArtSet artSet );
/** Deprecated. Fills an art set \c dst with all artwork in the
document that is not in the art set \c src.
@note This function has not been kept up
to date with changes to the object model. */
AIAPI AIErr (*NotArtSet) ( AIArtSet src, AIArtSet dst );
/** Fills an art set with all art objects contained in two art sets without duplicating
common art objects.
@param src0 The first source art set.
@param src1 The second source art set.
@param dst The destination art set.
*/
AIAPI AIErr (*UnionArtSet) ( AIArtSet src0, AIArtSet src1, AIArtSet dst );
/** Fills an art set with all art objects that are common to two art sets.
@param src0 The first source art set.
@param src1 The second source art set.
@param dst The destination art set.
*/
AIAPI AIErr (*IntersectArtSet) ( AIArtSet src0, AIArtSet src1, AIArtSet dst );
/** Retrieves an art object from an art set.
Use this function to iterate through the objects in an art set.
Unlike \c #IndexArtSet() this function skips \c NULL entries in the set, but it
is not as efficient; access speed is \c O(n). Use \c #IndexArtSet() if possible.
@param artSet The art set.
@param prevArt An art object contained in the set, or \c NULL to get the first object.
@param nextArt [out] A buffer in which to return the next art object, or a null object
if \c prevArt is not in the set or is the last member.
*/
AIAPI AIErr (*NextInArtSet) ( AIArtSet artSet, AIArtHandle prevArt, AIArtHandle *nextArt );
/* AI 9 additions. */
/** Appends an art object to an art set if it is not already there.
@param artSet The art set.
@param art The art object.
*/
AIAPI AIErr (*AddArtToArtSet) (AIArtSet artSet, AIArtHandle art);
/** Removes all occurrences of an art object from an art set.
@param artSet The art set.
@param art The art object.
*/
AIAPI AIErr (*RemoveArtFromArtSet) (AIArtSet artSet, AIArtHandle art);
/* AI 9.01 addition */
/** Replaces the first occurrence of one art object in a set with another, or, if
\c oldArt is not found, appends \c newArt to the set.
@param artSet The art set.
@param oldArt The art object to replace, if found.
@param newArt The art object to add. Can be \c NULL,
in which case a null entry is inserted or added to the set
*/
AIAPI AIErr (*ReplaceArtInArtSet) (AIArtSet artSet, AIArtHandle oldArt, AIArtHandle newArt);
/* AI 18.1 addition */
/** Clears the art set.
@param artSet The art set.
*/
AIAPI AIErr (*ClearArtSet) (AIArtSet artSet);
} AIArtSetSuite;
#include "AIHeaderEnd.h"
#endif
| 2,837 |
348 | <reponame>chamberone/Leaflet.PixiOverlay<gh_stars>100-1000
{"nom":"Bournois","circ":"3ème circonscription","dpt":"Doubs","inscrits":156,"abs":83,"votants":73,"blancs":4,"nuls":2,"exp":67,"res":[{"nuance":"LR","nom":"<NAME>","voix":44},{"nuance":"REM","nom":"M. <NAME>","voix":23}]} | 117 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.ai.textanalytics.lro;
import com.azure.ai.textanalytics.TextAnalyticsAsyncClient;
import com.azure.ai.textanalytics.TextAnalyticsClientBuilder;
import com.azure.ai.textanalytics.models.AnalyzeActionsOperationDetail;
import com.azure.ai.textanalytics.models.AnalyzeActionsResult;
import com.azure.ai.textanalytics.models.CategorizedEntity;
import com.azure.ai.textanalytics.models.RecognizeCustomEntitiesAction;
import com.azure.ai.textanalytics.models.RecognizeCustomEntitiesActionResult;
import com.azure.ai.textanalytics.models.RecognizeEntitiesResult;
import com.azure.ai.textanalytics.models.TextAnalyticsActions;
import com.azure.ai.textanalytics.util.RecognizeCustomEntitiesResultCollection;
import com.azure.core.credential.AzureKeyCredential;
import com.azure.core.http.rest.PagedResponse;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* Sample demonstrates how to asynchronously execute a "Custom Entities Recognition" action.
*/
public class RecognizeCustomEntitiesAsync {
/**
* Main method to invoke this demo about how to analyze an "Custom Entities Recognition" action.
*
* @param args Unused arguments to the program.
*/
public static void main(String[] args) {
TextAnalyticsAsyncClient client = new TextAnalyticsClientBuilder()
.credential(new AzureKeyCredential("{key}"))
.endpoint("{endpoint}")
.buildAsyncClient();
List<String> documents = new ArrayList<>();
documents.add(
"A recent report by the Government Accountability Office (GAO) found that the dramatic increase "
+ "in oil and natural gas development on federal lands over the past six years has stretched the"
+ " staff of the BLM to a point that it has been unable to meet its environmental protection "
+ "responsibilities.");
documents.add(
"<NAME>, senior vice president--Food Safety, International Food"
+ " Information Council (IFIC), Washington, D.C., discussed the physical activity component."
);
// See the service documentation for regional support and how to train a model to recognize the custom entities,
// see https://aka.ms/azsdk/textanalytics/customentityrecognition
client.beginAnalyzeActions(documents,
new TextAnalyticsActions().setDisplayName("{tasks_display_name}")
.setRecognizeCustomEntitiesActions(
new RecognizeCustomEntitiesAction("{project_name}", "{deployment_name}")),
"en",
null)
.flatMap(result -> {
AnalyzeActionsOperationDetail operationDetail = result.getValue();
System.out.printf("Action display name: %s, Successfully completed actions: %d, in-process actions: %d,"
+ " failed actions: %d, total actions: %d%n",
operationDetail.getDisplayName(), operationDetail.getSucceededCount(),
operationDetail.getInProgressCount(), operationDetail.getFailedCount(),
operationDetail.getTotalCount());
return result.getFinalResult();
})
.flatMap(analyzeActionsResultPagedFlux -> analyzeActionsResultPagedFlux.byPage())
.subscribe(
perPage -> processAnalyzeActionsResult(perPage),
ex -> System.out.println("Error listing pages: " + ex.getMessage()),
() -> System.out.println("Successfully listed all pages"));
// The .subscribe() creation and assignment is not a blocking call. For the purpose of this example, we sleep
// the thread so the program does not end before the send operation is complete. Using .block() instead of
// .subscribe() will turn this into a synchronous call.
try {
TimeUnit.MINUTES.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static void processAnalyzeActionsResult(PagedResponse<AnalyzeActionsResult> perPage) {
System.out.printf("Response code: %d, Continuation Token: %s.%n",
perPage.getStatusCode(), perPage.getContinuationToken());
for (AnalyzeActionsResult actionsResult : perPage.getElements()) {
for (RecognizeCustomEntitiesActionResult actionResult : actionsResult.getRecognizeCustomEntitiesResults()) {
if (!actionResult.isError()) {
RecognizeCustomEntitiesResultCollection documentsResults = actionResult.getDocumentsResults();
System.out.printf("Project name: %s, deployment name: %s.%n",
documentsResults.getProjectName(), documentsResults.getDeploymentName());
for (RecognizeEntitiesResult documentResult : documentsResults) {
System.out.println("Document ID: " + documentResult.getId());
if (!documentResult.isError()) {
for (CategorizedEntity entity : documentResult.getEntities()) {
System.out.printf(
"\tText: %s, category: %s, confidence score: %f.%n",
entity.getText(), entity.getCategory(), entity.getConfidenceScore());
}
} else {
System.out.printf("\tCannot recognize custom entities. Error: %s%n",
documentResult.getError().getMessage());
}
}
} else {
System.out.printf("\tCannot execute 'RecognizeCustomEntitiesAction'. Error: %s%n",
actionResult.getError().getMessage());
}
}
}
}
}
| 2,601 |
310 | <reponame>tsukoyumi/skylicht-engine<filename>Samples/DrawPrimitives/Source/CCubeData.cpp
#include "pch.h"
#include "SkylichtEngine.h"
#include "CCubeData.h"
CCubeData::CCubeData() :
CubeMeshBuffer(NULL)
{
}
CCubeData::~CCubeData()
{
if (CubeMeshBuffer != NULL)
CubeMeshBuffer->drop();
}
void CCubeData::initCube(float size)
{
if (CubeMeshBuffer != NULL)
CubeMeshBuffer->drop();
if (RenderMesh != NULL)
RenderMesh->drop();
// that will render from RenderMesh/CMeshRenderer.cpp
RenderMesh = new CMesh();
IVideoDriver *driver = getVideoDriver();
// Irrlicht Engine Mesh Buffer instance
// http://irrlicht.sourceforge.net/docu/classirr_1_1scene_1_1_c_mesh_buffer.html
CubeMeshBuffer = new CMeshBuffer<S3DVertex>(driver->getVertexDescriptor(EVT_STANDARD), EIT_16BIT);
IIndexBuffer *ib = CubeMeshBuffer->getIndexBuffer();
IVertexBuffer *vb = CubeMeshBuffer->getVertexBuffer();
// Create vertices
video::SColor clr1(255, 255, 0, 0);
video::SColor clr2(255, 0, 255, 0);
video::SColor clr3(255, 0, 0, 255);
video::SColor clr4(255, 255, 255, 255);
video::SColor clr5(255, 255, 0, 255);
video::SColor clr6(255, 255, 255, 0);
vb->reallocate(12);
video::S3DVertex Vertices[] = {
// back
video::S3DVertex(0, 0, 0, 0, 0, -1, clr1, 0, 1),
video::S3DVertex(1, 0, 0, 0, 0, -1, clr1, 1, 1),
video::S3DVertex(1, 1, 0, 0, 0, -1, clr1, 1, 0),
video::S3DVertex(0, 1, 0, 0, 0, -1, clr1, 1, 0),
// front
video::S3DVertex(0, 0, 1, 0, 0, 1, clr2, 0, 1),
video::S3DVertex(1, 0, 1, 0, 0, 1, clr2, 1, 1),
video::S3DVertex(1, 1, 1, 0, 0, 1, clr2, 1, 0),
video::S3DVertex(0, 1, 1, 0, 0, 1, clr2, 1, 0),
// bottom
video::S3DVertex(0, 0, 0, 0, -1, 0, clr3, 0, 1),
video::S3DVertex(0, 0, 1, 0, -1, 0, clr3, 1, 1),
video::S3DVertex(1, 0, 1, 0, -1, 0, clr3, 1, 0),
video::S3DVertex(1, 0, 0, 0, -1, 0, clr3, 1, 0),
// top
video::S3DVertex(0, 1, 0, 0, 1, 0, clr4, 0, 1),
video::S3DVertex(0, 1, 1, 0, 1, 0, clr4, 1, 1),
video::S3DVertex(1, 1, 1, 0, 1, 0, clr4, 1, 0),
video::S3DVertex(1, 1, 0, 0, 1, 0, clr4, 1, 0),
// left
video::S3DVertex(1, 0, 0, -1, 0, 0, clr5, 0, 1),
video::S3DVertex(1, 0, 1, -1, 0, 0, clr5, 1, 1),
video::S3DVertex(1, 1, 1, -1, 0, 0, clr5, 1, 0),
video::S3DVertex(1, 1, 0, -1, 0, 0, clr5, 1, 0),
// right
video::S3DVertex(0, 0, 0, 1, 0, 0, clr5, 0, 1),
video::S3DVertex(0, 0, 1, 1, 0, 0, clr5, 1, 1),
video::S3DVertex(0, 1, 1, 1, 0, 0, clr5, 1, 0),
video::S3DVertex(0, 1, 0, 1, 0, 0, clr5, 1, 0),
};
for (u32 i = 0; i < 24; ++i)
{
Vertices[i].Pos -= core::vector3df(0.5f, 0.5f, 0.5f);
Vertices[i].Pos *= size;
vb->addVertex(&Vertices[i]);
}
// cube mesh
// Create indices
const u16 u[36] =
{
// back
0,2,1,
0,3,2,
// front
4,5,6,
4,6,7,
// bottom
8,10,9,
8,11,10,
// top
12,13,14,
12,14,15,
// left
16,18,17,
16,19,18,
// right
20,21,22,
20,22,23
};
ib->set_used(36);
for (u32 i = 0; i < 36; ++i)
ib->setIndex(i, u[i]);
// recalc bbox
CubeMeshBuffer->recalculateBoundingBox();
// add cube mesh buffer to mesh
RenderMesh->addMeshBuffer(CubeMeshBuffer, "default_material", NULL);
// recalc bbox for culling
RenderMesh->recalculateBoundingBox();
// remeber set static mesh buffer to optimize (it will stored on GPU)
RenderMesh->setHardwareMappingHint(EHM_STATIC);
} | 1,659 |
5,169 | <gh_stars>1000+
{
"name": "MRLCircleChart",
"version": "0.0.2",
"summary": "Small and very opinionated pie-chart view written in Swift.",
"description": "MRLCircleChart is a small pie/circle chart UI component written in Swift. Aims to take care of most of the work for you (just pass in a data source and configure the view) at the expense of customizability. It's a work in progress written for a secret project.",
"homepage": "https://github.com/mlisik/MRLCircleChart.git",
"license": "MIT",
"authors": {
"mlisik": "<EMAIL>"
},
"source": {
"git": "https://github.com/mlisik/MRLCircleChart.git",
"tag": "0.0.2"
},
"platforms": {
"ios": "8.0"
},
"requires_arc": true,
"source_files": "Pod/Classes/**/*"
}
| 273 |
317 | <reponame>darkcl/drafter
//
// RegexMatch.cc
// snowcrash
//
// Created by <NAME> on 5/2/13.
// Copyright (c) 2013 Apiary Inc. All rights reserved.
//
#include <regex.h>
#include <cstring>
#include "../RegexMatch.h"
// FIXME: Migrate to C++11.
// Naive implementation of regex matching using POSIX regex
bool snowcrash::RegexMatch(const std::string& target, const std::string& expression)
{
if (target.empty() || expression.empty())
return false;
regex_t regex;
int reti = ::regcomp(®ex, expression.c_str(), REG_EXTENDED | REG_NOSUB);
if (reti) {
// Unable to compile regex
return false;
}
// Execute regular expression
reti = ::regexec(®ex, target.c_str(), 0, NULL, 0);
if (!reti) {
::regfree(®ex);
return true;
} else if (reti == REG_NOMATCH) {
::regfree(®ex);
return false;
} else {
char msgbuf[1024];
regerror(reti, ®ex, msgbuf, sizeof(msgbuf));
::regfree(®ex);
return false;
}
return false;
}
std::string snowcrash::RegexCaptureFirst(const std::string& target, const std::string& expression)
{
CaptureGroups groups;
if (!RegexCapture(target, expression, groups) || groups.size() < 2)
return std::string();
return groups[1];
}
bool snowcrash::RegexCapture(
const std::string& target, const std::string& expression, CaptureGroups& captureGroups, size_t groupSize)
{
if (target.empty() || expression.empty())
return false;
captureGroups.clear();
try {
regex_t regex;
int reti = ::regcomp(®ex, expression.c_str(), REG_EXTENDED);
if (reti)
return false;
regmatch_t* pmatch = ::new regmatch_t[groupSize];
::memset(pmatch, 0, sizeof(regmatch_t) * groupSize);
reti = ::regexec(®ex, target.c_str(), groupSize, pmatch, 0);
if (!reti) {
::regfree(®ex);
for (size_t i = 0; i < groupSize; ++i) {
if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
captureGroups.push_back(std::string());
else
captureGroups.push_back(std::string(target, pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so));
}
delete[] pmatch;
return true;
} else {
::regfree(®ex);
delete[] pmatch;
return false;
}
} catch (...) {
}
return false;
}
| 1,140 |
997 | <reponame>codekat1/liboqs<filename>src/kem/ntruprime/pqclean_ntrulpr857_avx2/crypto_decode_857xint32.h
#ifndef PQCLEAN_NTRULPR857_AVX2_CRYPTO_DECODE_857XINT32_H
#define PQCLEAN_NTRULPR857_AVX2_CRYPTO_DECODE_857XINT32_H
#include <stdint.h>
#define PQCLEAN_NTRULPR857_AVX2_crypto_decode_857xint32_STRBYTES 3428
#define PQCLEAN_NTRULPR857_AVX2_crypto_decode_857xint32_ITEMS 857
#define PQCLEAN_NTRULPR857_AVX2_crypto_decode_857xint32_ITEMBYTES 4
void PQCLEAN_NTRULPR857_AVX2_crypto_decode_857xint32(void *v, const unsigned char *s);
#endif
| 285 |
10,002 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include "pch.h"
#include "AsyncHelper.h"
#include <chrono>
#include <thread>
using namespace std;
using namespace concurrency;
using namespace Platform;
using namespace CalculatorApp;
using namespace Windows::UI::Core;
using namespace Windows::ApplicationModel::Core;
task<void> AsyncHelper::RunOnUIThreadAsync(function<void()>&& action)
{
auto callback = ref new DispatchedHandler([action]() { action(); });
return create_task(CoreApplication::MainView->CoreWindow->Dispatcher->RunAsync(CoreDispatcherPriority::Normal, callback));
}
void AsyncHelper::RunOnUIThread(function<void()>&& action, DWORD timeout)
{
task<void> waitTask = RunOnUIThreadAsync([action]() { action(); });
WaitForTask<void>(waitTask, timeout);
}
void AsyncHelper::Delay(DWORD milliseconds)
{
thread timer(bind(CalculatorApp::AsyncHelper::Sleep, milliseconds));
timer.join();
}
void AsyncHelper::Sleep(DWORD milliseconds)
{
this_thread::sleep_for(chrono::milliseconds(milliseconds));
}
| 337 |
310 | from imports import *
class feature_impact():
def __init__(self):
super(feature_impact, self).__init__()
self.param= None
def find(self, df):
df = pd.DataFrame(df)
print(df)
variables = [col for col in df.columns if '_impact' in col]
y = []
for i in range(len(variables)):
p = df[variables[i]].mean()
y.append(p)
res = {variables[i]: y[i] for i in range(len(y))}
res2 = {k: v for k, v in sorted(res.items(), key=lambda item: item[1])}
res3 = pd.Series(res2, name='Impact_Value')
res3.index.name = 'VariableName'
fi = res3.reset_index()
return fi
| 338 |
190,993 | # Copyright 2021 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Utilities for managing tf.data user-defined functions."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
import warnings
import six
from tensorflow.python.data.util import nest
from tensorflow.python.data.util import structure
from tensorflow.python.eager import context
from tensorflow.python.eager import def_function
from tensorflow.python.eager import function as eager_function
from tensorflow.python.framework import function
from tensorflow.python.framework import ops
from tensorflow.python.ops import script_ops
from tensorflow.python.util import function_utils
from tensorflow.python.util import lazy_loader
autograph = lazy_loader.LazyLoader(
"autograph", globals(),
"tensorflow.python.autograph.impl.api")
# TODO(mdan): Create a public API for this.
autograph_ctx = lazy_loader.LazyLoader(
"autograph_ctx", globals(),
"tensorflow.python.autograph.core.ag_ctx")
dataset_ops = lazy_loader.LazyLoader(
"dataset_ops", globals(),
"tensorflow.python.data.ops.dataset_ops")
def _should_pack(arg):
"""Determines whether the caller needs to pack the argument in a tuple.
If user-defined function returns a list of tensors, `nest.flatten()` and
`ops.convert_to_tensor()` and would conspire to attempt to stack those tensors
into a single tensor because the tf.data version of `nest.flatten()` does
not recurse into lists. Since it is more likely that the list arose from
returning the result of an operation (such as `tf.numpy_function()`) that
returns a list of not-necessarily-stackable tensors, we treat the returned
value as a `tuple` instead. A user wishing to pack the return value into a
single tensor can use an explicit `tf.stack()` before returning.
Args:
arg: argument to check
Returns:
Indication of whether the caller needs to pack the argument in a tuple.
"""
return isinstance(arg, list)
def _should_unpack(arg):
"""Determines whether the caller needs to unpack the argument from a tuple.
Args:
arg: argument to check
Returns:
Indication of whether the caller needs to unpack the argument from a tuple.
"""
return type(arg) is tuple # pylint: disable=unidiomatic-typecheck
class StructuredFunctionWrapper():
"""A function wrapper that supports structured arguments and return values."""
def __init__(self,
func,
transformation_name,
dataset=None,
input_classes=None,
input_shapes=None,
input_types=None,
input_structure=None,
add_to_graph=True,
use_legacy_function=False,
defun_kwargs=None):
"""Creates a new `StructuredFunctionWrapper` for the given function.
Args:
func: A function from a (nested) structure to another (nested) structure.
transformation_name: Human-readable name of the transformation in which
this function is being instantiated, for error messages.
dataset: (Optional.) A `tf.data.Dataset`. If given, the structure of this
dataset will be assumed as the structure for `func` arguments; otherwise
`input_classes`, `input_shapes`, and `input_types` must be defined.
input_classes: (Optional.) A (nested) structure of `type`. If given, this
argument defines the Python types for `func` arguments.
input_shapes: (Optional.) A (nested) structure of `tf.TensorShape`. If
given, this argument defines the shapes and structure for `func`
arguments.
input_types: (Optional.) A (nested) structure of `tf.DType`. If given,
this argument defines the element types and structure for `func`
arguments.
input_structure: (Optional.) A `Structure` object. If given, this argument
defines the element types and structure for `func` arguments.
add_to_graph: (Optional.) If `True`, the function will be added to the
default graph, if it exists.
use_legacy_function: (Optional.) A boolean that determines whether the
function be created using `tensorflow.python.eager.function.defun`
(default behavior) or `tensorflow.python.framework.function.Defun`
(legacy behavior).
defun_kwargs: (Optional.) A dictionary mapping string argument names to
values. If supplied, will be passed to `function` as keyword arguments.
Raises:
ValueError: If an invalid combination of `dataset`, `input_classes`,
`input_shapes`, and `input_types` is passed.
"""
# pylint: disable=protected-access
if input_structure is None:
if dataset is None:
if input_classes is None or input_shapes is None or input_types is None:
raise ValueError("Either `dataset`, `input_structure` or all of "
"`input_classes`, `input_shapes`, and `input_types` "
"must be specified.")
self._input_structure = structure.convert_legacy_structure(
input_types, input_shapes, input_classes)
else:
if not (input_classes is None and input_shapes is None and
input_types is None):
raise ValueError("Either `dataset`, `input_structure` or all of "
"`input_classes`, `input_shapes`, and `input_types` "
"must be specified.")
self._input_structure = dataset.element_spec
else:
if not (dataset is None and input_classes is None and
input_shapes is None and input_types is None):
raise ValueError("Either `dataset`, `input_structure`, or all of "
"`input_classes`, `input_shapes`, and `input_types` "
"must be specified.")
self._input_structure = input_structure
self._func = func
if defun_kwargs is None:
defun_kwargs = {}
readable_transformation_name = transformation_name.replace(
".", "_")[:-2] if len(transformation_name) > 2 else ""
func_name = "_".join(
[readable_transformation_name,
function_utils.get_func_name(func)])
# Sanitize function name to remove symbols that interfere with graph
# construction.
for symbol in ["<", ">", "\\", "'", " "]:
func_name = func_name.replace(symbol, "")
ag_ctx = autograph_ctx.control_status_ctx()
def wrapper_helper(*args):
"""Wrapper for passing nested structures to and from tf.data functions."""
nested_args = structure.from_compatible_tensor_list(
self._input_structure, args)
if not _should_unpack(nested_args):
nested_args = (nested_args,)
ret = autograph.tf_convert(self._func, ag_ctx)(*nested_args)
if _should_pack(ret):
ret = tuple(ret)
try:
self._output_structure = structure.type_spec_from_value(ret)
except (ValueError, TypeError):
six.reraise(
TypeError,
TypeError(f"Unsupported return value from function passed to "
f"{transformation_name}: {ret}."),
sys.exc_info()[2])
return ret
def trace_legacy_function(defun_kwargs):
@function.Defun(*structure.get_flat_tensor_types(self._input_structure),
**defun_kwargs)
def wrapped_fn(*args):
ret = wrapper_helper(*args)
return structure.to_tensor_list(self._output_structure, ret)
return lambda: wrapped_fn
def trace_py_function(defun_kwargs):
# First we trace the function to infer the output structure.
@eager_function.defun_with_attributes(
input_signature=structure.get_flat_tensor_specs(
self._input_structure),
autograph=False,
attributes=defun_kwargs)
def unused(*args): # pylint: disable=missing-docstring,unused-variable
ret = wrapper_helper(*args)
ret = structure.to_tensor_list(self._output_structure, ret)
return [ops.convert_to_tensor(t) for t in ret]
_ = unused.get_concrete_function()
def py_function_wrapper(*args):
nested_args = structure.from_compatible_tensor_list(
self._input_structure, args)
if not _should_unpack(nested_args):
nested_args = (nested_args,)
ret = self._func(*nested_args)
if _should_pack(ret):
ret = tuple(ret)
ret = structure.to_tensor_list(self._output_structure, ret)
return [ops.convert_to_tensor(t) for t in ret]
# Next we trace the function wrapped in `eager_py_func` to force eager
# execution.
@eager_function.defun_with_attributes(
input_signature=structure.get_flat_tensor_specs(
self._input_structure),
autograph=False,
attributes=defun_kwargs)
def wrapped_fn(*args): # pylint: disable=missing-docstring
return script_ops.eager_py_func(
py_function_wrapper, args,
structure.get_flat_tensor_types(self._output_structure))
return wrapped_fn.get_concrete_function
def trace_tf_function(defun_kwargs):
# Note: wrapper_helper will apply autograph based on context.
@eager_function.defun_with_attributes(
input_signature=structure.get_flat_tensor_specs(
self._input_structure),
autograph=False,
attributes=defun_kwargs)
def wrapped_fn(*args): # pylint: disable=missing-docstring
ret = wrapper_helper(*args)
ret = structure.to_tensor_list(self._output_structure, ret)
return [ops.convert_to_tensor(t) for t in ret]
return wrapped_fn.get_concrete_function
if use_legacy_function:
defun_kwargs.update({"func_name": func_name + "_" + str(ops.uid())})
fn_factory = trace_legacy_function(defun_kwargs)
else:
defun_kwargs.update({"func_name": func_name})
defun_kwargs.update({"_tf_data_function": True})
if dataset_ops.DEBUG_MODE:
fn_factory = trace_py_function(defun_kwargs)
else:
if def_function.functions_run_eagerly():
warnings.warn(
"Even though the `tf.config.experimental_run_functions_eagerly` "
"option is set, this option does not apply to tf.data functions. "
"To force eager execution of tf.data functions, please use "
"`tf.data.experimental.enable_debug_mode()`.")
fn_factory = trace_tf_function(defun_kwargs)
self._function = fn_factory()
# There is no graph to add in eager mode.
add_to_graph &= not context.executing_eagerly()
# There are some lifetime issues when a legacy function is not added to a
# out-living graph. It's already deprecated so de-prioritizing the fix.
add_to_graph |= use_legacy_function
if add_to_graph:
self._function.add_to_graph(ops.get_default_graph())
if not use_legacy_function:
outer_graph_seed = ops.get_default_graph().seed
if outer_graph_seed and self._function.graph.seed == outer_graph_seed:
if self._function.graph._seed_used:
warnings.warn(
"Seed %s from outer graph might be getting used by function %s, "
"if the random op has not been provided any seed. Explicitly set "
"the seed in the function if this is not the intended behavior." %
(outer_graph_seed, func_name),
stacklevel=4)
@property
def output_structure(self):
return self._output_structure
@property
def output_classes(self):
return nest.map_structure(
lambda component_spec: component_spec._to_legacy_output_classes(), # pylint: disable=protected-access
self._output_structure)
@property
def output_shapes(self):
return nest.map_structure(
lambda component_spec: component_spec._to_legacy_output_shapes(), # pylint: disable=protected-access
self._output_structure)
@property
def output_types(self):
return nest.map_structure(
lambda component_spec: component_spec._to_legacy_output_types(), # pylint: disable=protected-access
self._output_structure)
@property
def function(self):
return self._function
| 4,946 |
3,442 | /*
* Jitsi, the OpenSource Java VoIP and Instant Messaging client.
*
* Copyright @ 2015 Atlassian Pty Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.java.sip.communicator.slick.configuration;
import java.beans.*;
import java.util.*;
import junit.framework.*;
import org.jitsi.service.configuration.*;
import org.osgi.framework.*;
/**
* Tests basic ConfiguratioService behaviour.
*
* @author <NAME>
*/
public class TestConfigurationService extends TestCase
{
/**
* The ConfigurationService that we will be testing.
*/
private ConfigurationService configurationService = null;
/**
* The PropertyChangeEvent that our test listeners will capture for testing.
* Make sure we null that upon tear down
*/
private PropertyChangeEvent propertyChangeEvent = null;
/**
* The name of a property that we will be using for testing.
*/
private static final String propertyName = "my.test.property";
/**
* The name of a property that we will be using for testing custom event
* notification.
*/
private static final String listenedPropertyName = "a.property.i.listen.to";
/**
* The value of the property with name propertyName.
*/
private static final String propertyValue = "19200";
/**
* A new value for the property with name propertyName
*/
private static final String propertyNewValue = "19201";
/**
* A PropertyChange listener impl that registers the last received event.
*/
private PropertyChangeListener pListener = new PropertyChangeListener()
{
public void propertyChange(PropertyChangeEvent event)
{
propertyChangeEvent = event;
}
};
/**
* A straightforward Vetoable change listener that throws an exception
* upon any change
*/
ConfigVetoableChangeListener rudeVetoListener = new ConfigVetoableChangeListener()
{
public void vetoableChange(PropertyChangeEvent event) throws
ConfigPropertyVetoException
{
throw new ConfigPropertyVetoException("Just for the fun of it", event);
}
};
/**
* A straightforward implementation of a vetoable change listener that that
* does not throw a veto exception and only stored the last received event.
*/
ConfigVetoableChangeListener gentleVetoListener = new ConfigVetoableChangeListener()
{
public void vetoableChange(PropertyChangeEvent event) throws
ConfigPropertyVetoException
{
propertyChangeEvent = event;
}
};
/**
* Generic JUnit Constructor.
* @param name the name of the test
*/
public TestConfigurationService(String name)
{
super(name);
BundleContext context = ConfigurationServiceLick.bc;
ServiceReference ref = context.getServiceReference(
ConfigurationService.class.getName());
configurationService = (ConfigurationService)context.getService(ref);
}
/**
* Generic JUnit setUp method.
* @throws Exception if anything goes wrong.
*/
@Override
protected void setUp() throws Exception
{
configurationService.setProperty(propertyName, null);
configurationService.setProperty(listenedPropertyName, null);
super.setUp();
}
/**
* Generic JUnit tearDown method.
* @throws Exception if anything goes wrong.
*/
@Override
protected void tearDown() throws Exception
{
//first remove any remaining listeners
configurationService.removePropertyChangeListener(pListener);
configurationService.removeVetoableChangeListener(rudeVetoListener);
configurationService.removeVetoableChangeListener(gentleVetoListener);
//clear used properties.
configurationService.setProperty(propertyName, null);
configurationService.setProperty(listenedPropertyName, null);
propertyChangeEvent = null;
super.tearDown();
}
/**
* Tests whether setting and getting properties works correctly.
* @throws PropertyVetoException in case someone wrongfully vetoes the
* property change.
*/
public void testSetGetProperty() throws PropertyVetoException
{
String propertyName = "my.test.property";
Object property = new String("my.test.property's value");
configurationService.setProperty(propertyName, property);
Object actualReturn = configurationService.getProperty(propertyName);
assertEquals("a property was not properly stored",
property, actualReturn);
}
/**
* Tests whether removing and getting properties works correctly.
* @throws PropertyVetoException in case someone wrongfully vetoes the
* property change.
*/
public void testRemoveProperty() throws PropertyVetoException
{
String propertyName = "my.test.property.acc1234";
Object property = new String("my.test.property's value");
configurationService.setProperty(propertyName, property);
Object actualReturn = configurationService.getProperty(propertyName);
assertEquals("a property was not properly stored",
property, actualReturn);
configurationService.removeProperty(propertyName);
Object actualReturn2 = configurationService.getProperty(propertyName);
assertNull("a property was not properly removed",
actualReturn2);
}
/**
* Tests whether removing and getting properties works correctly.
* @throws PropertyVetoException in case someone wrongfully vetoes the
* property change.
*/
public void testRemovePrefixedProperty() throws PropertyVetoException
{
// this one is used in provisioning, if we have account info like:
// net.java.sip.communicator.impl.protocol.sip.acc1sip1322067404000=acc1sip1322067404000
// we need to remove it by provisioning this:
// net.java.sip.communicator.impl.protocol.sip.acc1sip=${null}
String propertyName = "my.test.property.acc1234";
String propertyPrefixName = "my.test.property.acc";
Object property = new String("my.test.property's value");
configurationService.setProperty(propertyName, property);
Object actualReturn = configurationService.getProperty(propertyName);
assertEquals("a property was not properly stored",
property, actualReturn);
configurationService.removeProperty(propertyPrefixName);
Object actualReturn2 = configurationService.getProperty(propertyName);
assertNull("a property was not properly removed by prefix",
actualReturn2);
}
/**
* Tests whether setting and getting works alright for properties declared
* as system and whether resolving and retrieving from the system property
* set are done right.
* @throws PropertyVetoException in case someone wrongfully vetoes the
* property change.
*/
public void testSystemPoperties() throws PropertyVetoException
{
//first simply store and retrieve a system property
String propertyName = "my.test.system.property";
Object property = new String("sys.value.1");
configurationService.setProperty(propertyName, property, true);
Object actualReturn = configurationService.getProperty(propertyName);
assertEquals("a sys property was not properly stored",
property, actualReturn);
//now check whether you can also retrieve it from the sys property set.
actualReturn = System.getProperty(propertyName);
assertEquals("a property was not properly stored", property, actualReturn);
//verify that modifying it in the sys property set would affect the
//value in the configuration service
property = new String("second.sys.value");
System.setProperty(propertyName, property.toString());
actualReturn = configurationService.getProperty(propertyName);
assertEquals("a property was not properly stored", property, actualReturn);
//now make sure that modifying it in the configurationService would
//result in the corresponding change in the system property set.
property = new String("third.sys.value");
configurationService.setProperty(propertyName, property.toString());
actualReturn = System.getProperty(propertyName);
assertEquals("a property was not properly stored", property, actualReturn);
}
/**
* Tests whether getString properly returns string values and that it
* correctly handles corner cases.
*
* @throws PropertyVetoException if someone vetoes our change (which
* shouldn't happen)
*/
public void testGetString() throws PropertyVetoException
{
//test a basic scenario
String propertyName = "my.test.property";
Object property = new String("my.test.property's value");
configurationService.setProperty(propertyName, property);
String actualReturn = configurationService.getString(propertyName);
assertEquals("getString failed to retrieve a property",
property.toString(), actualReturn);
//verify that setting a non string object would not mess things up
property = new Integer(7121979);
configurationService.setProperty(propertyName, property);
actualReturn = configurationService.getString(propertyName);
assertEquals("getString failed to retrieve a property",
property.toString(), actualReturn);
//verify that setting a whitespace only string would return null
property = new String("\t\n ");
configurationService.setProperty(propertyName, property);
actualReturn = configurationService.getString(propertyName);
assertNull("getString did not trim a white space only string",
actualReturn);
}
/**
* Records a few properties with a similar prefix and verifies that they're
* all returned by the getPropertyNamesByPrefix() method.
*
* @throws PropertyVetoException if someone vetoes our change (which
* shouldn't happen)
*/
public void testGetPropertyNamesByPrefix() throws PropertyVetoException
{
String prefix = "this.is.a.prefix";
String exactPrefixProp1Name = prefix + ".PROP1";
String exactPrefixProp2Name = prefix + ".PROP3";
String longerPrefixProp3Name = prefix + ".which.is.longer.PROP3";
String completeMismatchProp4Name = "and.hereis.one.other.prefix.PROP4";
configurationService.setProperty(exactPrefixProp1Name, new Object());
configurationService.setProperty(exactPrefixProp2Name, new Object());
configurationService.setProperty(longerPrefixProp3Name, new Object());
configurationService.setProperty(completeMismatchProp4Name
, new Object());
//try an exact match first
List<String> propertyNames
= configurationService.getPropertyNamesByPrefix(prefix, true);
assertTrue("Returned list did not contain all property names. "
+ " MissingPropertyName: " + exactPrefixProp1Name
, propertyNames.contains(exactPrefixProp1Name));
assertTrue("Returned list did not contain all property names. "
+ " MissingPropertyName: " + exactPrefixProp2Name
, propertyNames.contains(exactPrefixProp2Name));
assertEquals("Returned list contains more properties than expected. "
+ " List was: " + propertyNames
, 2, propertyNames.size() );
//try a broader search
propertyNames
= configurationService.getPropertyNamesByPrefix(prefix, false);
assertTrue("Returned list did not contain all property names. "
+ " MissingPropertyName: " + exactPrefixProp1Name
, propertyNames.contains(exactPrefixProp1Name));
assertTrue("Returned list did not contain all property names. "
+ " MissingPropertyName: " + exactPrefixProp2Name
, propertyNames.contains(exactPrefixProp2Name));
assertTrue("Returned list did not contain all property names. "
+ " MissingPropertyName: " + longerPrefixProp3Name
, propertyNames.contains(longerPrefixProp3Name));
assertEquals("Returned list contains more properties than expected. "
+ " List was: " + propertyNames
, 3, propertyNames.size());
}
/**
* Tests event notification through multicast listeners (those that are
* registered for the whole configuration and not a single property only).
*/
public void testMulticastEventNotification()
{
propertyChangeEvent = null;
configurationService.addPropertyChangeListener(pListener);
// test the initial set of a property.
try
{
configurationService.setProperty(propertyName, propertyValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNotNull( "No PropertyChangeEvent was delivered upon setProperty",
propertyChangeEvent);
assertNull("oldValue must be null", propertyChangeEvent.getOldValue());
assertEquals( "newValue is not the value we just set!",
propertyValue,
propertyChangeEvent.getNewValue()
);
assertEquals( "propertyName is not the value we just set!",
propertyName,
propertyChangeEvent.getPropertyName()
);
//test setting a new value;
propertyChangeEvent = null;
try
{
configurationService.setProperty(propertyName, propertyNewValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNotNull( "No PropertyChangeEvent was delivered upon setProperty",
propertyChangeEvent);
assertEquals("incorrect oldValue",
propertyValue,
propertyChangeEvent.getOldValue());
assertEquals( "newValue is not the value we just set!",
propertyNewValue,
propertyChangeEvent.getNewValue());
//test remove
propertyChangeEvent = null;
configurationService.removePropertyChangeListener(pListener);
try
{
configurationService.setProperty(propertyName, propertyValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNull( "A PropertyChangeEvent after unregistering a listener.",
propertyChangeEvent);
}
/**
* Test event dispatch to vetoable listeners registered for the whole
* configuration.
*/
public void testMulticastEventNotificationToVetoableListeners()
{
String propertyValue = "19200";
String propertyNewValue = "19201";
propertyChangeEvent = null;
configurationService.addVetoableChangeListener(gentleVetoListener);
// test the initial set of a property.
try
{
configurationService.setProperty(propertyName, propertyValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNotNull( "No PropertyChangeEvent was delivered "
+"to VetoableListeners upon setProperty",
propertyChangeEvent);
assertNull("oldValue must be null", propertyChangeEvent.getOldValue());
assertEquals( "newValue is not the value we just set!",
propertyValue,
propertyChangeEvent.getNewValue());
assertEquals( "propertyName is not the value we just set!",
propertyName,
propertyChangeEvent.getPropertyName());
//test setting a new value;
propertyChangeEvent = null;
try
{
configurationService.setProperty(propertyName, propertyNewValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNotNull( "No PropertyChangeEvent was delivered to veto listener "
+"upon setProperty",
propertyChangeEvent);
assertEquals("incorrect oldValue",
propertyValue,
propertyChangeEvent.getOldValue());
assertEquals( "newValue is not the value we just set!",
propertyNewValue,
propertyChangeEvent.getNewValue());
//test remove
propertyChangeEvent = null;
configurationService.removeVetoableChangeListener(gentleVetoListener);
try
{
configurationService.setProperty(propertyName, propertyValue);
}
catch (ConfigPropertyVetoException ex)
{
fail("A PropertyVetoException came from nowhere. Exc="
+ ex.getMessage());
}
assertNull( "A PropertyChangeEvent after unregistering a listener.",
propertyChangeEvent);
}
/**
* Test whether vetoing changes works as it is supposed to.
*/
public void testVetos()
{
propertyChangeEvent = null;
configurationService.addVetoableChangeListener(rudeVetoListener);
configurationService.addPropertyChangeListener(pListener);
ConfigPropertyVetoException exception = null;
try
{
configurationService.setProperty(propertyName, propertyValue);
}
catch (ConfigPropertyVetoException ex)
{
exception = ex;
}
//make sure the exception was thrown
assertNotNull("A vetoable change event was not dispatched or an "
+"exception was not let through.",
exception);
//make sure no further event dispatching was done
assertNull("A property change event was delivered even after "+
"the property change was vetoed.",
propertyChangeEvent);
//make sure the property did not get modified after vetoing the change
assertNull( "A property was changed even avfter vetoing the change."
,configurationService.getProperty(propertyName));
// now let's make sure that we have the right order of event dispatching.
propertyChangeEvent = null;
configurationService.removeVetoableChangeListener(rudeVetoListener);
ConfigVetoableChangeListener vcListener = new ConfigVetoableChangeListener(){
public void vetoableChange(PropertyChangeEvent event)
{
assertNull("propertyChangeEvent was not null which means that it has "
+"bean delivered to the propertyChangeListener prior to "
+"being delivered to the vetoable change listener.",
propertyChangeEvent);
}
};
try
{
configurationService.setProperty(propertyName, propertyNewValue);
}
catch (ConfigPropertyVetoException ex1)
{
ex1.printStackTrace();
fail("unexpected veto exception. message:" + ex1.getMessage());
}
configurationService.removeVetoableChangeListener(vcListener);
}
/**
* Make sure that adding listeners for a single property name
* only gets us events for that listeners. Removing a listener for a
* specific property should also be proved to no obstruct event delivery to
* the same listener had it been registered for other properties.
*
* @throws PropertyVetoException if someone vetoes our change (which
* shouldn't happen)
*/
public void testSinglePropertyEventNotification()
throws PropertyVetoException
{
String listenedPropertyValue = "19.2598";
String listenedPropertyNewValue = "19.29581";
//test basic selective event dispatch
configurationService.addPropertyChangeListener(
listenedPropertyName, pListener);
propertyChangeEvent = null;
configurationService.setProperty(
propertyName, propertyValue);
assertNull("setting prop:"+propertyName + " caused an event notif. to "+
"listener registered for prop:" + listenedPropertyName,
propertyChangeEvent);
configurationService.setProperty(
listenedPropertyName, listenedPropertyValue);
assertNotNull("No event was dispatched upon modification of prop:"
+listenedPropertyName,
propertyChangeEvent );
assertNull("oldValue must be null", propertyChangeEvent.getOldValue());
assertEquals("wrong newValue",
listenedPropertyValue,
propertyChangeEvent.getNewValue());
//test that a generic remove only removes the generic listener
propertyChangeEvent = null;
configurationService.removePropertyChangeListener(pListener);
configurationService.setProperty(
listenedPropertyName, listenedPropertyNewValue);
assertNotNull("No event was dispatched upon modification of prop:"
+listenedPropertyName
+ ". The listener was wrongfully removed.",
propertyChangeEvent );
assertEquals("wrong oldValue",
listenedPropertyValue,
propertyChangeEvent.getOldValue());
assertEquals("wrong newValue",
listenedPropertyNewValue,
propertyChangeEvent.getNewValue());
//make sure that removing the listener properly - really removes it.
propertyChangeEvent = null;
configurationService.removePropertyChangeListener(
listenedPropertyName, pListener);
configurationService.setProperty(listenedPropertyName, propertyValue);
assertNull(
"An event was wrongfully dispatched after removing a listener",
propertyChangeEvent
);
}
/**
* Make sure that adding vetoable listeners for a single property name
* only gets us events for that listeners. Removing a listener for a
* specific property should also be proved to no obstruct event delivery to
* the same listener had it been registered for other properties.
*
* @throws PropertyVetoException if someone vetoes our change (which
* shouldn't happen)
*/
public void testSinglePropertyVetoEventNotification()
throws PropertyVetoException
{
String listenedPropertyValue = "19.2598";
String listenedPropertyNewValue = "19.29581";
ConfigVetoableChangeListener vetoListener = new ConfigVetoableChangeListener()
{
public void vetoableChange(PropertyChangeEvent event)
{
propertyChangeEvent = event;
}
};
//test basic selective event dispatch
configurationService.addVetoableChangeListener(
listenedPropertyName, vetoListener);
propertyChangeEvent = null;
configurationService.setProperty(
propertyName, propertyValue);
assertNull("setting prop:" + propertyName + " caused an event notif. to " +
"listener registered for prop:" + listenedPropertyName,
propertyChangeEvent);
configurationService.setProperty(
listenedPropertyName, listenedPropertyValue);
assertNotNull("No event was dispatched upon modification of prop:"
+ listenedPropertyName,
propertyChangeEvent);
assertNull("oldValue must be null", propertyChangeEvent.getOldValue());
assertEquals("wrong newValue",
listenedPropertyValue,
propertyChangeEvent.getNewValue());
//test that a generic remove only removes the generic listener
propertyChangeEvent = null;
configurationService.removeVetoableChangeListener(vetoListener);
configurationService.setProperty(
listenedPropertyName, listenedPropertyNewValue);
assertNotNull("No event was dispatched upon modification of prop:"
+ listenedPropertyName
+ ". The listener was wrongfully removed.",
propertyChangeEvent);
assertEquals("wrong oldValue",
listenedPropertyValue,
propertyChangeEvent.getOldValue());
assertEquals("wrong newValue",
listenedPropertyNewValue,
propertyChangeEvent.getNewValue());
//make sure that removing the listener properly - really removes it.
propertyChangeEvent = null;
configurationService.removeVetoableChangeListener(
listenedPropertyName, vetoListener);
configurationService.setProperty(
listenedPropertyName, listenedPropertyValue);
assertNull(
"An event was wrongfully dispatched after removing a listener",
propertyChangeEvent
);
//make sure that adding a generic listener, then adding a custom prop
//listener, then removing it - would not remove the generic listener.
propertyChangeEvent = null;
configurationService.addVetoableChangeListener(vetoListener);
configurationService.addVetoableChangeListener(
listenedPropertyName, vetoListener);
configurationService.removeVetoableChangeListener(
listenedPropertyName, vetoListener);
configurationService.setProperty(
listenedPropertyName, listenedPropertyNewValue);
assertNotNull("No event was dispatched upon modification of prop:"
+ listenedPropertyName
+ ". The global listener was wrongfully removed.",
propertyChangeEvent);
assertEquals("wrong propertyName",
listenedPropertyName,
propertyChangeEvent.getPropertyName());
assertEquals("wrong oldValue",
listenedPropertyValue,
propertyChangeEvent.getOldValue());
assertEquals("wrong newValue",
listenedPropertyNewValue,
propertyChangeEvent.getNewValue());
//fail("Testing failures! "
//+"Wanted to know whether cruisecontrol will notice the falure. emil.");
}
}
| 10,565 |
573 | <gh_stars>100-1000
// Copyright 2015, VIXL authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of ARM Limited nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ---------------------------------------------------------------------
// This file is auto generated using tools/generate_simulator_traces.py.
//
// PLEASE DO NOT EDIT.
// ---------------------------------------------------------------------
#ifndef VIXL_ASSEMBLER_COND_RD_RN_OPERAND_RM_SHIFT_RS_SBC_A32_H_
#define VIXL_ASSEMBLER_COND_RD_RN_OPERAND_RM_SHIFT_RS_SBC_A32_H_
const byte kInstruction_sbc_mi_r8_r10_r8_LSL_r0[] = {
0x18, 0x80, 0xca, 0x40 // sbc mi r8 r10 r8 LSL r0
};
const byte kInstruction_sbc_cc_r11_r4_r13_ROR_r8[] = {
0x7d, 0xb8, 0xc4, 0x30 // sbc cc r11 r4 r13 ROR r8
};
const byte kInstruction_sbc_al_r13_r11_r3_ROR_r4[] = {
0x73, 0xd4, 0xcb, 0xe0 // sbc al r13 r11 r3 ROR r4
};
const byte kInstruction_sbc_gt_r11_r5_r4_LSR_r11[] = {
0x34, 0xbb, 0xc5, 0xc0 // sbc gt r11 r5 r4 LSR r11
};
const byte kInstruction_sbc_vs_r12_r0_r8_ROR_r13[] = {
0x78, 0xcd, 0xc0, 0x60 // sbc vs r12 r0 r8 ROR r13
};
const byte kInstruction_sbc_pl_r10_r12_r5_LSL_r5[] = {
0x15, 0xa5, 0xcc, 0x50 // sbc pl r10 r12 r5 LSL r5
};
const byte kInstruction_sbc_ls_r10_r2_r2_LSL_r9[] = {
0x12, 0xa9, 0xc2, 0x90 // sbc ls r10 r2 r2 LSL r9
};
const byte kInstruction_sbc_eq_r12_r7_r9_LSR_r7[] = {
0x39, 0xc7, 0xc7, 0x00 // sbc eq r12 r7 r9 LSR r7
};
const byte kInstruction_sbc_mi_r3_r13_r0_ROR_r11[] = {
0x70, 0x3b, 0xcd, 0x40 // sbc mi r3 r13 r0 ROR r11
};
const byte kInstruction_sbc_lt_r9_r0_r9_ASR_r12[] = {
0x59, 0x9c, 0xc0, 0xb0 // sbc lt r9 r0 r9 ASR r12
};
const byte kInstruction_sbc_le_r12_r8_r14_ROR_r1[] = {
0x7e, 0xc1, 0xc8, 0xd0 // sbc le r12 r8 r14 ROR r1
};
const byte kInstruction_sbc_cc_r7_r1_r14_LSL_r0[] = {
0x1e, 0x70, 0xc1, 0x30 // sbc cc r7 r1 r14 LSL r0
};
const byte kInstruction_sbc_le_r11_r13_r3_ROR_r6[] = {
0x73, 0xb6, 0xcd, 0xd0 // sbc le r11 r13 r3 ROR r6
};
const byte kInstruction_sbc_al_r5_r8_r9_ASR_r14[] = {
0x59, 0x5e, 0xc8, 0xe0 // sbc al r5 r8 r9 ASR r14
};
const byte kInstruction_sbc_hi_r1_r2_r7_ASR_r13[] = {
0x57, 0x1d, 0xc2, 0x80 // sbc hi r1 r2 r7 ASR r13
};
const byte kInstruction_sbc_al_r13_r8_r7_LSR_r12[] = {
0x37, 0xdc, 0xc8, 0xe0 // sbc al r13 r8 r7 LSR r12
};
const byte kInstruction_sbc_vc_r3_r6_r4_ASR_r4[] = {
0x54, 0x34, 0xc6, 0x70 // sbc vc r3 r6 r4 ASR r4
};
const byte kInstruction_sbc_lt_r12_r4_r6_LSL_r5[] = {
0x16, 0xc5, 0xc4, 0xb0 // sbc lt r12 r4 r6 LSL r5
};
const byte kInstruction_sbc_ls_r13_r5_r11_ROR_r8[] = {
0x7b, 0xd8, 0xc5, 0x90 // sbc ls r13 r5 r11 ROR r8
};
const byte kInstruction_sbc_vc_r11_r10_r11_LSL_r9[] = {
0x1b, 0xb9, 0xca, 0x70 // sbc vc r11 r10 r11 LSL r9
};
const byte kInstruction_sbc_al_r13_r14_r10_LSR_r4[] = {
0x3a, 0xd4, 0xce, 0xe0 // sbc al r13 r14 r10 LSR r4
};
const byte kInstruction_sbc_ge_r12_r13_r6_ASR_r12[] = {
0x56, 0xcc, 0xcd, 0xa0 // sbc ge r12 r13 r6 ASR r12
};
const byte kInstruction_sbc_ne_r14_r6_r12_ROR_r0[] = {
0x7c, 0xe0, 0xc6, 0x10 // sbc ne r14 r6 r12 ROR r0
};
const byte kInstruction_sbc_ls_r13_r14_r14_ASR_r13[] = {
0x5e, 0xdd, 0xce, 0x90 // sbc ls r13 r14 r14 ASR r13
};
const byte kInstruction_sbc_lt_r10_r13_r7_ROR_r8[] = {
0x77, 0xa8, 0xcd, 0xb0 // sbc lt r10 r13 r7 ROR r8
};
const byte kInstruction_sbc_lt_r8_r8_r9_ASR_r0[] = {
0x59, 0x80, 0xc8, 0xb0 // sbc lt r8 r8 r9 ASR r0
};
const byte kInstruction_sbc_ne_r7_r5_r4_LSR_r8[] = {
0x34, 0x78, 0xc5, 0x10 // sbc ne r7 r5 r4 LSR r8
};
const byte kInstruction_sbc_mi_r11_r5_r1_LSL_r13[] = {
0x11, 0xbd, 0xc5, 0x40 // sbc mi r11 r5 r1 LSL r13
};
const byte kInstruction_sbc_ge_r14_r1_r2_LSL_r1[] = {
0x12, 0xe1, 0xc1, 0xa0 // sbc ge r14 r1 r2 LSL r1
};
const byte kInstruction_sbc_ls_r6_r11_r4_ASR_r11[] = {
0x54, 0x6b, 0xcb, 0x90 // sbc ls r6 r11 r4 ASR r11
};
const byte kInstruction_sbc_hi_r11_r12_r4_LSR_r13[] = {
0x34, 0xbd, 0xcc, 0x80 // sbc hi r11 r12 r4 LSR r13
};
const byte kInstruction_sbc_le_r9_r3_r0_LSL_r7[] = {
0x10, 0x97, 0xc3, 0xd0 // sbc le r9 r3 r0 LSL r7
};
const byte kInstruction_sbc_ls_r8_r7_r4_ASR_r3[] = {
0x54, 0x83, 0xc7, 0x90 // sbc ls r8 r7 r4 ASR r3
};
const byte kInstruction_sbc_pl_r9_r13_r11_LSL_r7[] = {
0x1b, 0x97, 0xcd, 0x50 // sbc pl r9 r13 r11 LSL r7
};
const byte kInstruction_sbc_eq_r12_r7_r11_ASR_r3[] = {
0x5b, 0xc3, 0xc7, 0x00 // sbc eq r12 r7 r11 ASR r3
};
const byte kInstruction_sbc_mi_r3_r9_r13_ROR_r10[] = {
0x7d, 0x3a, 0xc9, 0x40 // sbc mi r3 r9 r13 ROR r10
};
const byte kInstruction_sbc_mi_r14_r8_r10_ROR_r10[] = {
0x7a, 0xea, 0xc8, 0x40 // sbc mi r14 r8 r10 ROR r10
};
const byte kInstruction_sbc_lt_r5_r3_r5_LSL_r1[] = {
0x15, 0x51, 0xc3, 0xb0 // sbc lt r5 r3 r5 LSL r1
};
const byte kInstruction_sbc_ne_r12_r6_r1_LSL_r7[] = {
0x11, 0xc7, 0xc6, 0x10 // sbc ne r12 r6 r1 LSL r7
};
const byte kInstruction_sbc_lt_r3_r6_r5_ASR_r1[] = {
0x55, 0x31, 0xc6, 0xb0 // sbc lt r3 r6 r5 ASR r1
};
const byte kInstruction_sbc_lt_r14_r0_r0_LSR_r11[] = {
0x30, 0xeb, 0xc0, 0xb0 // sbc lt r14 r0 r0 LSR r11
};
const byte kInstruction_sbc_eq_r11_r10_r4_LSL_r14[] = {
0x14, 0xbe, 0xca, 0x00 // sbc eq r11 r10 r4 LSL r14
};
const byte kInstruction_sbc_lt_r2_r14_r11_LSL_r9[] = {
0x1b, 0x29, 0xce, 0xb0 // sbc lt r2 r14 r11 LSL r9
};
const byte kInstruction_sbc_mi_r0_r6_r14_ASR_r11[] = {
0x5e, 0x0b, 0xc6, 0x40 // sbc mi r0 r6 r14 ASR r11
};
const byte kInstruction_sbc_le_r4_r6_r3_LSR_r11[] = {
0x33, 0x4b, 0xc6, 0xd0 // sbc le r4 r6 r3 LSR r11
};
const byte kInstruction_sbc_cs_r2_r6_r1_ROR_r5[] = {
0x71, 0x25, 0xc6, 0x20 // sbc cs r2 r6 r1 ROR r5
};
const byte kInstruction_sbc_ne_r10_r9_r10_ROR_r4[] = {
0x7a, 0xa4, 0xc9, 0x10 // sbc ne r10 r9 r10 ROR r4
};
const byte kInstruction_sbc_pl_r7_r9_r11_LSR_r14[] = {
0x3b, 0x7e, 0xc9, 0x50 // sbc pl r7 r9 r11 LSR r14
};
const byte kInstruction_sbc_pl_r11_r8_r3_ASR_r5[] = {
0x53, 0xb5, 0xc8, 0x50 // sbc pl r11 r8 r3 ASR r5
};
const byte kInstruction_sbc_le_r10_r4_r10_ROR_r8[] = {
0x7a, 0xa8, 0xc4, 0xd0 // sbc le r10 r4 r10 ROR r8
};
const byte kInstruction_sbc_ne_r8_r14_r8_LSL_r5[] = {
0x18, 0x85, 0xce, 0x10 // sbc ne r8 r14 r8 LSL r5
};
const byte kInstruction_sbc_eq_r12_r5_r2_LSL_r11[] = {
0x12, 0xcb, 0xc5, 0x00 // sbc eq r12 r5 r2 LSL r11
};
const byte kInstruction_sbc_pl_r9_r9_r8_ASR_r2[] = {
0x58, 0x92, 0xc9, 0x50 // sbc pl r9 r9 r8 ASR r2
};
const byte kInstruction_sbc_hi_r8_r12_r3_LSL_r5[] = {
0x13, 0x85, 0xcc, 0x80 // sbc hi r8 r12 r3 LSL r5
};
const byte kInstruction_sbc_eq_r6_r5_r9_LSL_r3[] = {
0x19, 0x63, 0xc5, 0x00 // sbc eq r6 r5 r9 LSL r3
};
const byte kInstruction_sbc_lt_r5_r1_r9_LSR_r6[] = {
0x39, 0x56, 0xc1, 0xb0 // sbc lt r5 r1 r9 LSR r6
};
const byte kInstruction_sbc_hi_r9_r9_r0_LSL_r5[] = {
0x10, 0x95, 0xc9, 0x80 // sbc hi r9 r9 r0 LSL r5
};
const byte kInstruction_sbc_cs_r6_r6_r5_LSL_r8[] = {
0x15, 0x68, 0xc6, 0x20 // sbc cs r6 r6 r5 LSL r8
};
const byte kInstruction_sbc_cs_r0_r1_r6_LSR_r12[] = {
0x36, 0x0c, 0xc1, 0x20 // sbc cs r0 r1 r6 LSR r12
};
const byte kInstruction_sbc_cc_r4_r6_r13_ASR_r6[] = {
0x5d, 0x46, 0xc6, 0x30 // sbc cc r4 r6 r13 ASR r6
};
const byte kInstruction_sbc_hi_r11_r8_r10_LSR_r5[] = {
0x3a, 0xb5, 0xc8, 0x80 // sbc hi r11 r8 r10 LSR r5
};
const byte kInstruction_sbc_ls_r8_r1_r14_ROR_r14[] = {
0x7e, 0x8e, 0xc1, 0x90 // sbc ls r8 r1 r14 ROR r14
};
const byte kInstruction_sbc_pl_r8_r2_r12_ASR_r7[] = {
0x5c, 0x87, 0xc2, 0x50 // sbc pl r8 r2 r12 ASR r7
};
const byte kInstruction_sbc_gt_r14_r7_r5_ROR_r11[] = {
0x75, 0xeb, 0xc7, 0xc0 // sbc gt r14 r7 r5 ROR r11
};
const byte kInstruction_sbc_eq_r3_r6_r13_ROR_r0[] = {
0x7d, 0x30, 0xc6, 0x00 // sbc eq r3 r6 r13 ROR r0
};
const byte kInstruction_sbc_le_r4_r8_r8_ROR_r11[] = {
0x78, 0x4b, 0xc8, 0xd0 // sbc le r4 r8 r8 ROR r11
};
const byte kInstruction_sbc_ge_r2_r7_r5_ASR_r6[] = {
0x55, 0x26, 0xc7, 0xa0 // sbc ge r2 r7 r5 ASR r6
};
const byte kInstruction_sbc_cc_r8_r12_r5_LSL_r11[] = {
0x15, 0x8b, 0xcc, 0x30 // sbc cc r8 r12 r5 LSL r11
};
const byte kInstruction_sbc_vc_r11_r10_r3_ROR_r5[] = {
0x73, 0xb5, 0xca, 0x70 // sbc vc r11 r10 r3 ROR r5
};
const byte kInstruction_sbc_vc_r11_r9_r11_LSL_r6[] = {
0x1b, 0xb6, 0xc9, 0x70 // sbc vc r11 r9 r11 LSL r6
};
const byte kInstruction_sbc_lt_r6_r5_r0_ROR_r9[] = {
0x70, 0x69, 0xc5, 0xb0 // sbc lt r6 r5 r0 ROR r9
};
const byte kInstruction_sbc_cs_r13_r7_r11_ASR_r9[] = {
0x5b, 0xd9, 0xc7, 0x20 // sbc cs r13 r7 r11 ASR r9
};
const byte kInstruction_sbc_cs_r9_r7_r9_ROR_r11[] = {
0x79, 0x9b, 0xc7, 0x20 // sbc cs r9 r7 r9 ROR r11
};
const byte kInstruction_sbc_ls_r14_r3_r2_ASR_r11[] = {
0x52, 0xeb, 0xc3, 0x90 // sbc ls r14 r3 r2 ASR r11
};
const byte kInstruction_sbc_vc_r0_r1_r1_LSR_r0[] = {
0x31, 0x00, 0xc1, 0x70 // sbc vc r0 r1 r1 LSR r0
};
const byte kInstruction_sbc_mi_r10_r8_r8_LSR_r13[] = {
0x38, 0xad, 0xc8, 0x40 // sbc mi r10 r8 r8 LSR r13
};
const byte kInstruction_sbc_pl_r8_r14_r3_LSL_r8[] = {
0x13, 0x88, 0xce, 0x50 // sbc pl r8 r14 r3 LSL r8
};
const byte kInstruction_sbc_ne_r6_r4_r1_LSL_r12[] = {
0x11, 0x6c, 0xc4, 0x10 // sbc ne r6 r4 r1 LSL r12
};
const byte kInstruction_sbc_lt_r2_r2_r7_ROR_r0[] = {
0x77, 0x20, 0xc2, 0xb0 // sbc lt r2 r2 r7 ROR r0
};
const byte kInstruction_sbc_lt_r2_r4_r13_ASR_r5[] = {
0x5d, 0x25, 0xc4, 0xb0 // sbc lt r2 r4 r13 ASR r5
};
const byte kInstruction_sbc_eq_r8_r1_r2_ROR_r13[] = {
0x72, 0x8d, 0xc1, 0x00 // sbc eq r8 r1 r2 ROR r13
};
const byte kInstruction_sbc_lt_r1_r8_r10_LSR_r7[] = {
0x3a, 0x17, 0xc8, 0xb0 // sbc lt r1 r8 r10 LSR r7
};
const byte kInstruction_sbc_cs_r7_r5_r9_LSL_r9[] = {
0x19, 0x79, 0xc5, 0x20 // sbc cs r7 r5 r9 LSL r9
};
const byte kInstruction_sbc_mi_r8_r0_r6_LSL_r8[] = {
0x16, 0x88, 0xc0, 0x40 // sbc mi r8 r0 r6 LSL r8
};
const byte kInstruction_sbc_cs_r7_r12_r3_ROR_r6[] = {
0x73, 0x76, 0xcc, 0x20 // sbc cs r7 r12 r3 ROR r6
};
const byte kInstruction_sbc_vs_r13_r8_r13_LSR_r4[] = {
0x3d, 0xd4, 0xc8, 0x60 // sbc vs r13 r8 r13 LSR r4
};
const byte kInstruction_sbc_cc_r4_r13_r7_ROR_r11[] = {
0x77, 0x4b, 0xcd, 0x30 // sbc cc r4 r13 r7 ROR r11
};
const byte kInstruction_sbc_ge_r10_r5_r9_LSR_r13[] = {
0x39, 0xad, 0xc5, 0xa0 // sbc ge r10 r5 r9 LSR r13
};
const byte kInstruction_sbc_cc_r0_r5_r9_ASR_r4[] = {
0x59, 0x04, 0xc5, 0x30 // sbc cc r0 r5 r9 ASR r4
};
const byte kInstruction_sbc_cc_r1_r5_r8_LSR_r12[] = {
0x38, 0x1c, 0xc5, 0x30 // sbc cc r1 r5 r8 LSR r12
};
const byte kInstruction_sbc_ls_r12_r3_r5_LSL_r6[] = {
0x15, 0xc6, 0xc3, 0x90 // sbc ls r12 r3 r5 LSL r6
};
const byte kInstruction_sbc_cs_r10_r0_r4_ASR_r7[] = {
0x54, 0xa7, 0xc0, 0x20 // sbc cs r10 r0 r4 ASR r7
};
const byte kInstruction_sbc_ge_r10_r13_r14_ROR_r6[] = {
0x7e, 0xa6, 0xcd, 0xa0 // sbc ge r10 r13 r14 ROR r6
};
const byte kInstruction_sbc_al_r9_r0_r9_ROR_r3[] = {
0x79, 0x93, 0xc0, 0xe0 // sbc al r9 r0 r9 ROR r3
};
const byte kInstruction_sbc_vs_r4_r5_r12_ASR_r6[] = {
0x5c, 0x46, 0xc5, 0x60 // sbc vs r4 r5 r12 ASR r6
};
const byte kInstruction_sbc_lt_r4_r1_r14_LSL_r12[] = {
0x1e, 0x4c, 0xc1, 0xb0 // sbc lt r4 r1 r14 LSL r12
};
const byte kInstruction_sbc_cs_r14_r11_r8_ROR_r4[] = {
0x78, 0xe4, 0xcb, 0x20 // sbc cs r14 r11 r8 ROR r4
};
const byte kInstruction_sbc_hi_r12_r0_r14_LSR_r11[] = {
0x3e, 0xcb, 0xc0, 0x80 // sbc hi r12 r0 r14 LSR r11
};
const byte kInstruction_sbc_le_r8_r6_r4_ASR_r7[] = {
0x54, 0x87, 0xc6, 0xd0 // sbc le r8 r6 r4 ASR r7
};
const byte kInstruction_sbc_mi_r13_r4_r14_LSR_r10[] = {
0x3e, 0xda, 0xc4, 0x40 // sbc mi r13 r4 r14 LSR r10
};
const byte kInstruction_sbc_vs_r11_r10_r5_LSL_r10[] = {
0x15, 0xba, 0xca, 0x60 // sbc vs r11 r10 r5 LSL r10
};
const byte kInstruction_sbc_cc_r4_r0_r5_LSR_r2[] = {
0x35, 0x42, 0xc0, 0x30 // sbc cc r4 r0 r5 LSR r2
};
const byte kInstruction_sbc_pl_r9_r14_r0_LSL_r3[] = {
0x10, 0x93, 0xce, 0x50 // sbc pl r9 r14 r0 LSL r3
};
const byte kInstruction_sbc_vc_r7_r2_r14_ASR_r1[] = {
0x5e, 0x71, 0xc2, 0x70 // sbc vc r7 r2 r14 ASR r1
};
const byte kInstruction_sbc_gt_r4_r14_r1_ROR_r10[] = {
0x71, 0x4a, 0xce, 0xc0 // sbc gt r4 r14 r1 ROR r10
};
const byte kInstruction_sbc_lt_r6_r4_r10_LSL_r7[] = {
0x1a, 0x67, 0xc4, 0xb0 // sbc lt r6 r4 r10 LSL r7
};
const byte kInstruction_sbc_hi_r1_r14_r5_LSL_r12[] = {
0x15, 0x1c, 0xce, 0x80 // sbc hi r1 r14 r5 LSL r12
};
const byte kInstruction_sbc_cc_r14_r12_r4_ASR_r14[] = {
0x54, 0xee, 0xcc, 0x30 // sbc cc r14 r12 r4 ASR r14
};
const byte kInstruction_sbc_cc_r0_r8_r5_ROR_r8[] = {
0x75, 0x08, 0xc8, 0x30 // sbc cc r0 r8 r5 ROR r8
};
const byte kInstruction_sbc_gt_r9_r9_r0_ASR_r4[] = {
0x50, 0x94, 0xc9, 0xc0 // sbc gt r9 r9 r0 ASR r4
};
const byte kInstruction_sbc_mi_r8_r11_r12_ASR_r4[] = {
0x5c, 0x84, 0xcb, 0x40 // sbc mi r8 r11 r12 ASR r4
};
const byte kInstruction_sbc_vs_r0_r12_r0_LSR_r11[] = {
0x30, 0x0b, 0xcc, 0x60 // sbc vs r0 r12 r0 LSR r11
};
const byte kInstruction_sbc_ge_r0_r9_r1_ASR_r0[] = {
0x51, 0x00, 0xc9, 0xa0 // sbc ge r0 r9 r1 ASR r0
};
const byte kInstruction_sbc_al_r10_r11_r5_LSR_r4[] = {
0x35, 0xa4, 0xcb, 0xe0 // sbc al r10 r11 r5 LSR r4
};
const byte kInstruction_sbc_eq_r0_r6_r8_LSR_r10[] = {
0x38, 0x0a, 0xc6, 0x00 // sbc eq r0 r6 r8 LSR r10
};
const byte kInstruction_sbc_cc_r13_r12_r14_ROR_r9[] = {
0x7e, 0xd9, 0xcc, 0x30 // sbc cc r13 r12 r14 ROR r9
};
const byte kInstruction_sbc_ls_r4_r11_r0_LSL_r14[] = {
0x10, 0x4e, 0xcb, 0x90 // sbc ls r4 r11 r0 LSL r14
};
const byte kInstruction_sbc_hi_r1_r6_r12_LSR_r13[] = {
0x3c, 0x1d, 0xc6, 0x80 // sbc hi r1 r6 r12 LSR r13
};
const byte kInstruction_sbc_cs_r7_r11_r1_ASR_r5[] = {
0x51, 0x75, 0xcb, 0x20 // sbc cs r7 r11 r1 ASR r5
};
const byte kInstruction_sbc_cc_r7_r5_r4_ASR_r11[] = {
0x54, 0x7b, 0xc5, 0x30 // sbc cc r7 r5 r4 ASR r11
};
const byte kInstruction_sbc_hi_r7_r2_r5_ROR_r5[] = {
0x75, 0x75, 0xc2, 0x80 // sbc hi r7 r2 r5 ROR r5
};
const byte kInstruction_sbc_vc_r11_r9_r7_LSL_r14[] = {
0x17, 0xbe, 0xc9, 0x70 // sbc vc r11 r9 r7 LSL r14
};
const byte kInstruction_sbc_le_r12_r1_r3_ROR_r7[] = {
0x73, 0xc7, 0xc1, 0xd0 // sbc le r12 r1 r3 ROR r7
};
const byte kInstruction_sbc_al_r8_r14_r0_ASR_r12[] = {
0x50, 0x8c, 0xce, 0xe0 // sbc al r8 r14 r0 ASR r12
};
const byte kInstruction_sbc_vc_r14_r3_r0_ROR_r1[] = {
0x70, 0xe1, 0xc3, 0x70 // sbc vc r14 r3 r0 ROR r1
};
const byte kInstruction_sbc_pl_r10_r8_r3_ROR_r4[] = {
0x73, 0xa4, 0xc8, 0x50 // sbc pl r10 r8 r3 ROR r4
};
const byte kInstruction_sbc_al_r9_r14_r12_LSL_r4[] = {
0x1c, 0x94, 0xce, 0xe0 // sbc al r9 r14 r12 LSL r4
};
const byte kInstruction_sbc_vs_r8_r3_r14_ASR_r7[] = {
0x5e, 0x87, 0xc3, 0x60 // sbc vs r8 r3 r14 ASR r7
};
const byte kInstruction_sbc_hi_r4_r8_r13_LSL_r1[] = {
0x1d, 0x41, 0xc8, 0x80 // sbc hi r4 r8 r13 LSL r1
};
const byte kInstruction_sbc_al_r6_r11_r11_LSL_r14[] = {
0x1b, 0x6e, 0xcb, 0xe0 // sbc al r6 r11 r11 LSL r14
};
const byte kInstruction_sbc_al_r7_r2_r4_LSR_r1[] = {
0x34, 0x71, 0xc2, 0xe0 // sbc al r7 r2 r4 LSR r1
};
const byte kInstruction_sbc_vc_r5_r10_r3_ASR_r8[] = {
0x53, 0x58, 0xca, 0x70 // sbc vc r5 r10 r3 ASR r8
};
const byte kInstruction_sbc_cc_r3_r10_r9_ROR_r11[] = {
0x79, 0x3b, 0xca, 0x30 // sbc cc r3 r10 r9 ROR r11
};
const byte kInstruction_sbc_eq_r11_r9_r8_LSL_r2[] = {
0x18, 0xb2, 0xc9, 0x00 // sbc eq r11 r9 r8 LSL r2
};
const byte kInstruction_sbc_mi_r6_r9_r5_ASR_r12[] = {
0x55, 0x6c, 0xc9, 0x40 // sbc mi r6 r9 r5 ASR r12
};
const byte kInstruction_sbc_hi_r6_r6_r0_ASR_r9[] = {
0x50, 0x69, 0xc6, 0x80 // sbc hi r6 r6 r0 ASR r9
};
const byte kInstruction_sbc_ge_r12_r13_r1_LSL_r9[] = {
0x11, 0xc9, 0xcd, 0xa0 // sbc ge r12 r13 r1 LSL r9
};
const byte kInstruction_sbc_le_r4_r9_r14_ASR_r2[] = {
0x5e, 0x42, 0xc9, 0xd0 // sbc le r4 r9 r14 ASR r2
};
const byte kInstruction_sbc_gt_r5_r3_r9_ROR_r5[] = {
0x79, 0x55, 0xc3, 0xc0 // sbc gt r5 r3 r9 ROR r5
};
const byte kInstruction_sbc_al_r14_r5_r13_ROR_r7[] = {
0x7d, 0xe7, 0xc5, 0xe0 // sbc al r14 r5 r13 ROR r7
};
const byte kInstruction_sbc_lt_r2_r1_r14_ASR_r8[] = {
0x5e, 0x28, 0xc1, 0xb0 // sbc lt r2 r1 r14 ASR r8
};
const byte kInstruction_sbc_al_r12_r7_r8_LSL_r11[] = {
0x18, 0xcb, 0xc7, 0xe0 // sbc al r12 r7 r8 LSL r11
};
const byte kInstruction_sbc_ne_r4_r12_r14_LSL_r1[] = {
0x1e, 0x41, 0xcc, 0x10 // sbc ne r4 r12 r14 LSL r1
};
const byte kInstruction_sbc_vs_r7_r14_r4_LSL_r6[] = {
0x14, 0x76, 0xce, 0x60 // sbc vs r7 r14 r4 LSL r6
};
const byte kInstruction_sbc_ge_r12_r5_r11_ASR_r4[] = {
0x5b, 0xc4, 0xc5, 0xa0 // sbc ge r12 r5 r11 ASR r4
};
const byte kInstruction_sbc_gt_r4_r10_r6_LSR_r6[] = {
0x36, 0x46, 0xca, 0xc0 // sbc gt r4 r10 r6 LSR r6
};
const byte kInstruction_sbc_cc_r14_r8_r14_LSR_r8[] = {
0x3e, 0xe8, 0xc8, 0x30 // sbc cc r14 r8 r14 LSR r8
};
const byte kInstruction_sbc_al_r1_r14_r11_LSR_r7[] = {
0x3b, 0x17, 0xce, 0xe0 // sbc al r1 r14 r11 LSR r7
};
const byte kInstruction_sbc_pl_r13_r6_r5_ASR_r14[] = {
0x55, 0xde, 0xc6, 0x50 // sbc pl r13 r6 r5 ASR r14
};
const byte kInstruction_sbc_cc_r10_r6_r9_ROR_r13[] = {
0x79, 0xad, 0xc6, 0x30 // sbc cc r10 r6 r9 ROR r13
};
const byte kInstruction_sbc_ne_r0_r4_r7_ROR_r13[] = {
0x77, 0x0d, 0xc4, 0x10 // sbc ne r0 r4 r7 ROR r13
};
const byte kInstruction_sbc_vc_r12_r0_r14_LSL_r13[] = {
0x1e, 0xcd, 0xc0, 0x70 // sbc vc r12 r0 r14 LSL r13
};
const byte kInstruction_sbc_al_r10_r13_r13_ROR_r5[] = {
0x7d, 0xa5, 0xcd, 0xe0 // sbc al r10 r13 r13 ROR r5
};
const byte kInstruction_sbc_cs_r10_r3_r0_ROR_r7[] = {
0x70, 0xa7, 0xc3, 0x20 // sbc cs r10 r3 r0 ROR r7
};
const byte kInstruction_sbc_ge_r10_r14_r14_ROR_r6[] = {
0x7e, 0xa6, 0xce, 0xa0 // sbc ge r10 r14 r14 ROR r6
};
const byte kInstruction_sbc_pl_r0_r10_r10_LSL_r4[] = {
0x1a, 0x04, 0xca, 0x50 // sbc pl r0 r10 r10 LSL r4
};
const byte kInstruction_sbc_vs_r1_r2_r7_ASR_r6[] = {
0x57, 0x16, 0xc2, 0x60 // sbc vs r1 r2 r7 ASR r6
};
const byte kInstruction_sbc_cs_r9_r11_r9_LSL_r9[] = {
0x19, 0x99, 0xcb, 0x20 // sbc cs r9 r11 r9 LSL r9
};
const byte kInstruction_sbc_eq_r10_r8_r4_LSL_r6[] = {
0x14, 0xa6, 0xc8, 0x00 // sbc eq r10 r8 r4 LSL r6
};
const byte kInstruction_sbc_vc_r8_r5_r12_LSL_r8[] = {
0x1c, 0x88, 0xc5, 0x70 // sbc vc r8 r5 r12 LSL r8
};
const byte kInstruction_sbc_pl_r1_r13_r11_LSL_r8[] = {
0x1b, 0x18, 0xcd, 0x50 // sbc pl r1 r13 r11 LSL r8
};
const byte kInstruction_sbc_le_r9_r10_r5_ROR_r4[] = {
0x75, 0x94, 0xca, 0xd0 // sbc le r9 r10 r5 ROR r4
};
const byte kInstruction_sbc_vs_r8_r3_r0_ASR_r11[] = {
0x50, 0x8b, 0xc3, 0x60 // sbc vs r8 r3 r0 ASR r11
};
const byte kInstruction_sbc_hi_r12_r0_r13_LSL_r2[] = {
0x1d, 0xc2, 0xc0, 0x80 // sbc hi r12 r0 r13 LSL r2
};
const byte kInstruction_sbc_lt_r4_r2_r8_LSL_r5[] = {
0x18, 0x45, 0xc2, 0xb0 // sbc lt r4 r2 r8 LSL r5
};
const byte kInstruction_sbc_ge_r9_r4_r13_LSL_r13[] = {
0x1d, 0x9d, 0xc4, 0xa0 // sbc ge r9 r4 r13 LSL r13
};
const byte kInstruction_sbc_ge_r0_r2_r1_ROR_r8[] = {
0x71, 0x08, 0xc2, 0xa0 // sbc ge r0 r2 r1 ROR r8
};
const byte kInstruction_sbc_le_r6_r13_r9_LSR_r0[] = {
0x39, 0x60, 0xcd, 0xd0 // sbc le r6 r13 r9 LSR r0
};
const byte kInstruction_sbc_ls_r13_r7_r4_ASR_r3[] = {
0x54, 0xd3, 0xc7, 0x90 // sbc ls r13 r7 r4 ASR r3
};
const byte kInstruction_sbc_vc_r8_r13_r6_LSR_r14[] = {
0x36, 0x8e, 0xcd, 0x70 // sbc vc r8 r13 r6 LSR r14
};
const byte kInstruction_sbc_pl_r10_r5_r3_LSR_r9[] = {
0x33, 0xa9, 0xc5, 0x50 // sbc pl r10 r5 r3 LSR r9
};
const byte kInstruction_sbc_al_r6_r3_r14_LSR_r7[] = {
0x3e, 0x67, 0xc3, 0xe0 // sbc al r6 r3 r14 LSR r7
};
const byte kInstruction_sbc_cc_r3_r5_r3_ROR_r10[] = {
0x73, 0x3a, 0xc5, 0x30 // sbc cc r3 r5 r3 ROR r10
};
const byte kInstruction_sbc_cs_r4_r11_r2_LSR_r10[] = {
0x32, 0x4a, 0xcb, 0x20 // sbc cs r4 r11 r2 LSR r10
};
const byte kInstruction_sbc_lt_r6_r10_r5_ASR_r8[] = {
0x55, 0x68, 0xca, 0xb0 // sbc lt r6 r10 r5 ASR r8
};
const byte kInstruction_sbc_ge_r0_r13_r10_ASR_r8[] = {
0x5a, 0x08, 0xcd, 0xa0 // sbc ge r0 r13 r10 ASR r8
};
const byte kInstruction_sbc_cs_r8_r8_r0_LSL_r9[] = {
0x10, 0x89, 0xc8, 0x20 // sbc cs r8 r8 r0 LSL r9
};
const byte kInstruction_sbc_gt_r1_r1_r1_ASR_r2[] = {
0x51, 0x12, 0xc1, 0xc0 // sbc gt r1 r1 r1 ASR r2
};
const byte kInstruction_sbc_al_r5_r0_r14_ROR_r3[] = {
0x7e, 0x53, 0xc0, 0xe0 // sbc al r5 r0 r14 ROR r3
};
const byte kInstruction_sbc_mi_r3_r9_r14_LSL_r9[] = {
0x1e, 0x39, 0xc9, 0x40 // sbc mi r3 r9 r14 LSL r9
};
const byte kInstruction_sbc_ls_r9_r6_r5_LSL_r9[] = {
0x15, 0x99, 0xc6, 0x90 // sbc ls r9 r6 r5 LSL r9
};
const byte kInstruction_sbc_lt_r13_r3_r1_LSL_r13[] = {
0x11, 0xdd, 0xc3, 0xb0 // sbc lt r13 r3 r1 LSL r13
};
const byte kInstruction_sbc_lt_r9_r14_r3_ASR_r3[] = {
0x53, 0x93, 0xce, 0xb0 // sbc lt r9 r14 r3 ASR r3
};
const byte kInstruction_sbc_cc_r5_r4_r1_LSR_r0[] = {
0x31, 0x50, 0xc4, 0x30 // sbc cc r5 r4 r1 LSR r0
};
const byte kInstruction_sbc_cs_r9_r7_r8_ASR_r0[] = {
0x58, 0x90, 0xc7, 0x20 // sbc cs r9 r7 r8 ASR r0
};
const byte kInstruction_sbc_ge_r8_r6_r14_ROR_r7[] = {
0x7e, 0x87, 0xc6, 0xa0 // sbc ge r8 r6 r14 ROR r7
};
const byte kInstruction_sbc_le_r14_r8_r12_LSL_r0[] = {
0x1c, 0xe0, 0xc8, 0xd0 // sbc le r14 r8 r12 LSL r0
};
const byte kInstruction_sbc_mi_r0_r13_r14_ASR_r3[] = {
0x5e, 0x03, 0xcd, 0x40 // sbc mi r0 r13 r14 ASR r3
};
const byte kInstruction_sbc_cs_r7_r4_r9_ROR_r8[] = {
0x79, 0x78, 0xc4, 0x20 // sbc cs r7 r4 r9 ROR r8
};
const byte kInstruction_sbc_ne_r4_r6_r11_ROR_r2[] = {
0x7b, 0x42, 0xc6, 0x10 // sbc ne r4 r6 r11 ROR r2
};
const byte kInstruction_sbc_gt_r8_r8_r9_ROR_r12[] = {
0x79, 0x8c, 0xc8, 0xc0 // sbc gt r8 r8 r9 ROR r12
};
const byte kInstruction_sbc_hi_r1_r2_r0_LSR_r13[] = {
0x30, 0x1d, 0xc2, 0x80 // sbc hi r1 r2 r0 LSR r13
};
const byte kInstruction_sbc_ge_r14_r12_r6_ASR_r5[] = {
0x56, 0xe5, 0xcc, 0xa0 // sbc ge r14 r12 r6 ASR r5
};
const byte kInstruction_sbc_ge_r5_r4_r7_LSR_r14[] = {
0x37, 0x5e, 0xc4, 0xa0 // sbc ge r5 r4 r7 LSR r14
};
const byte kInstruction_sbc_cc_r13_r11_r10_LSR_r2[] = {
0x3a, 0xd2, 0xcb, 0x30 // sbc cc r13 r11 r10 LSR r2
};
const byte kInstruction_sbc_mi_r3_r9_r14_LSR_r14[] = {
0x3e, 0x3e, 0xc9, 0x40 // sbc mi r3 r9 r14 LSR r14
};
const byte kInstruction_sbc_ne_r10_r3_r4_LSR_r3[] = {
0x34, 0xa3, 0xc3, 0x10 // sbc ne r10 r3 r4 LSR r3
};
const byte kInstruction_sbc_ls_r14_r9_r6_LSL_r9[] = {
0x16, 0xe9, 0xc9, 0x90 // sbc ls r14 r9 r6 LSL r9
};
const byte kInstruction_sbc_ls_r8_r2_r8_ROR_r7[] = {
0x78, 0x87, 0xc2, 0x90 // sbc ls r8 r2 r8 ROR r7
};
const byte kInstruction_sbc_ne_r2_r6_r3_ROR_r3[] = {
0x73, 0x23, 0xc6, 0x10 // sbc ne r2 r6 r3 ROR r3
};
const byte kInstruction_sbc_mi_r12_r3_r11_ASR_r11[] = {
0x5b, 0xcb, 0xc3, 0x40 // sbc mi r12 r3 r11 ASR r11
};
const byte kInstruction_sbc_le_r7_r10_r11_LSL_r9[] = {
0x1b, 0x79, 0xca, 0xd0 // sbc le r7 r10 r11 LSL r9
};
const byte kInstruction_sbc_al_r1_r2_r10_ROR_r8[] = {
0x7a, 0x18, 0xc2, 0xe0 // sbc al r1 r2 r10 ROR r8
};
const byte kInstruction_sbc_cc_r7_r9_r14_LSL_r7[] = {
0x1e, 0x77, 0xc9, 0x30 // sbc cc r7 r9 r14 LSL r7
};
const byte kInstruction_sbc_cc_r9_r3_r5_LSL_r8[] = {
0x15, 0x98, 0xc3, 0x30 // sbc cc r9 r3 r5 LSL r8
};
const byte kInstruction_sbc_hi_r8_r3_r8_ROR_r2[] = {
0x78, 0x82, 0xc3, 0x80 // sbc hi r8 r3 r8 ROR r2
};
const byte kInstruction_sbc_pl_r10_r13_r14_LSR_r10[] = {
0x3e, 0xaa, 0xcd, 0x50 // sbc pl r10 r13 r14 LSR r10
};
const byte kInstruction_sbc_lt_r13_r4_r13_LSR_r12[] = {
0x3d, 0xdc, 0xc4, 0xb0 // sbc lt r13 r4 r13 LSR r12
};
const byte kInstruction_sbc_ls_r12_r14_r11_LSR_r13[] = {
0x3b, 0xcd, 0xce, 0x90 // sbc ls r12 r14 r11 LSR r13
};
const byte kInstruction_sbc_vs_r11_r10_r10_ASR_r2[] = {
0x5a, 0xb2, 0xca, 0x60 // sbc vs r11 r10 r10 ASR r2
};
const byte kInstruction_sbc_cc_r5_r8_r13_LSL_r10[] = {
0x1d, 0x5a, 0xc8, 0x30 // sbc cc r5 r8 r13 LSL r10
};
const byte kInstruction_sbc_cs_r7_r4_r11_LSR_r14[] = {
0x3b, 0x7e, 0xc4, 0x20 // sbc cs r7 r4 r11 LSR r14
};
const byte kInstruction_sbc_lt_r1_r12_r7_ASR_r11[] = {
0x57, 0x1b, 0xcc, 0xb0 // sbc lt r1 r12 r7 ASR r11
};
const byte kInstruction_sbc_vc_r11_r4_r4_LSL_r10[] = {
0x14, 0xba, 0xc4, 0x70 // sbc vc r11 r4 r4 LSL r10
};
const byte kInstruction_sbc_vc_r7_r4_r6_LSR_r7[] = {
0x36, 0x77, 0xc4, 0x70 // sbc vc r7 r4 r6 LSR r7
};
const byte kInstruction_sbc_vc_r0_r3_r0_ASR_r14[] = {
0x50, 0x0e, 0xc3, 0x70 // sbc vc r0 r3 r0 ASR r14
};
const byte kInstruction_sbc_mi_r11_r8_r13_ASR_r8[] = {
0x5d, 0xb8, 0xc8, 0x40 // sbc mi r11 r8 r13 ASR r8
};
const byte kInstruction_sbc_gt_r13_r14_r6_LSL_r11[] = {
0x16, 0xdb, 0xce, 0xc0 // sbc gt r13 r14 r6 LSL r11
};
const byte kInstruction_sbc_cs_r3_r2_r6_LSL_r8[] = {
0x16, 0x38, 0xc2, 0x20 // sbc cs r3 r2 r6 LSL r8
};
const byte kInstruction_sbc_ne_r7_r5_r5_LSL_r8[] = {
0x15, 0x78, 0xc5, 0x10 // sbc ne r7 r5 r5 LSL r8
};
const byte kInstruction_sbc_lt_r0_r12_r6_LSR_r0[] = {
0x36, 0x00, 0xcc, 0xb0 // sbc lt r0 r12 r6 LSR r0
};
const byte kInstruction_sbc_ls_r11_r9_r12_ROR_r2[] = {
0x7c, 0xb2, 0xc9, 0x90 // sbc ls r11 r9 r12 ROR r2
};
const byte kInstruction_sbc_ls_r6_r0_r8_LSR_r4[] = {
0x38, 0x64, 0xc0, 0x90 // sbc ls r6 r0 r8 LSR r4
};
const byte kInstruction_sbc_lt_r6_r7_r0_ROR_r13[] = {
0x70, 0x6d, 0xc7, 0xb0 // sbc lt r6 r7 r0 ROR r13
};
const byte kInstruction_sbc_gt_r14_r4_r1_LSL_r8[] = {
0x11, 0xe8, 0xc4, 0xc0 // sbc gt r14 r4 r1 LSL r8
};
const byte kInstruction_sbc_al_r14_r5_r6_LSL_r7[] = {
0x16, 0xe7, 0xc5, 0xe0 // sbc al r14 r5 r6 LSL r7
};
const byte kInstruction_sbc_ge_r9_r6_r4_LSR_r8[] = {
0x34, 0x98, 0xc6, 0xa0 // sbc ge r9 r6 r4 LSR r8
};
const byte kInstruction_sbc_lt_r2_r14_r13_ROR_r3[] = {
0x7d, 0x23, 0xce, 0xb0 // sbc lt r2 r14 r13 ROR r3
};
const byte kInstruction_sbc_al_r11_r1_r13_LSR_r9[] = {
0x3d, 0xb9, 0xc1, 0xe0 // sbc al r11 r1 r13 LSR r9
};
const byte kInstruction_sbc_vs_r8_r2_r5_LSL_r11[] = {
0x15, 0x8b, 0xc2, 0x60 // sbc vs r8 r2 r5 LSL r11
};
const byte kInstruction_sbc_pl_r8_r14_r8_LSL_r7[] = {
0x18, 0x87, 0xce, 0x50 // sbc pl r8 r14 r8 LSL r7
};
const byte kInstruction_sbc_cs_r10_r5_r5_ASR_r4[] = {
0x55, 0xa4, 0xc5, 0x20 // sbc cs r10 r5 r5 ASR r4
};
const byte kInstruction_sbc_eq_r12_r14_r9_LSR_r11[] = {
0x39, 0xcb, 0xce, 0x00 // sbc eq r12 r14 r9 LSR r11
};
const byte kInstruction_sbc_lt_r1_r3_r3_LSL_r1[] = {
0x13, 0x11, 0xc3, 0xb0 // sbc lt r1 r3 r3 LSL r1
};
const byte kInstruction_sbc_le_r4_r13_r4_ASR_r8[] = {
0x54, 0x48, 0xcd, 0xd0 // sbc le r4 r13 r4 ASR r8
};
const byte kInstruction_sbc_ne_r5_r4_r2_LSL_r8[] = {
0x12, 0x58, 0xc4, 0x10 // sbc ne r5 r4 r2 LSL r8
};
const byte kInstruction_sbc_le_r3_r14_r13_LSR_r1[] = {
0x3d, 0x31, 0xce, 0xd0 // sbc le r3 r14 r13 LSR r1
};
const byte kInstruction_sbc_cc_r6_r3_r5_LSL_r1[] = {
0x15, 0x61, 0xc3, 0x30 // sbc cc r6 r3 r5 LSL r1
};
const byte kInstruction_sbc_lt_r9_r6_r11_LSR_r14[] = {
0x3b, 0x9e, 0xc6, 0xb0 // sbc lt r9 r6 r11 LSR r14
};
const byte kInstruction_sbc_cc_r13_r8_r10_ROR_r1[] = {
0x7a, 0xd1, 0xc8, 0x30 // sbc cc r13 r8 r10 ROR r1
};
const byte kInstruction_sbc_lt_r7_r10_r11_LSR_r2[] = {
0x3b, 0x72, 0xca, 0xb0 // sbc lt r7 r10 r11 LSR r2
};
const byte kInstruction_sbc_pl_r0_r9_r5_LSR_r8[] = {
0x35, 0x08, 0xc9, 0x50 // sbc pl r0 r9 r5 LSR r8
};
const byte kInstruction_sbc_eq_r8_r9_r11_LSR_r13[] = {
0x3b, 0x8d, 0xc9, 0x00 // sbc eq r8 r9 r11 LSR r13
};
const byte kInstruction_sbc_hi_r10_r1_r9_ROR_r12[] = {
0x79, 0xac, 0xc1, 0x80 // sbc hi r10 r1 r9 ROR r12
};
const byte kInstruction_sbc_pl_r13_r1_r14_LSL_r14[] = {
0x1e, 0xde, 0xc1, 0x50 // sbc pl r13 r1 r14 LSL r14
};
const byte kInstruction_sbc_eq_r13_r3_r7_LSR_r13[] = {
0x37, 0xdd, 0xc3, 0x00 // sbc eq r13 r3 r7 LSR r13
};
const byte kInstruction_sbc_eq_r3_r6_r6_ASR_r14[] = {
0x56, 0x3e, 0xc6, 0x00 // sbc eq r3 r6 r6 ASR r14
};
const byte kInstruction_sbc_gt_r5_r4_r8_ROR_r13[] = {
0x78, 0x5d, 0xc4, 0xc0 // sbc gt r5 r4 r8 ROR r13
};
const byte kInstruction_sbc_al_r9_r7_r0_ROR_r3[] = {
0x70, 0x93, 0xc7, 0xe0 // sbc al r9 r7 r0 ROR r3
};
const byte kInstruction_sbc_mi_r13_r11_r3_LSL_r1[] = {
0x13, 0xd1, 0xcb, 0x40 // sbc mi r13 r11 r3 LSL r1
};
const byte kInstruction_sbc_ls_r11_r14_r6_LSL_r14[] = {
0x16, 0xbe, 0xce, 0x90 // sbc ls r11 r14 r6 LSL r14
};
const byte kInstruction_sbc_al_r14_r3_r7_LSL_r9[] = {
0x17, 0xe9, 0xc3, 0xe0 // sbc al r14 r3 r7 LSL r9
};
const byte kInstruction_sbc_cs_r14_r2_r14_LSL_r13[] = {
0x1e, 0xed, 0xc2, 0x20 // sbc cs r14 r2 r14 LSL r13
};
const byte kInstruction_sbc_ls_r11_r10_r6_ASR_r11[] = {
0x56, 0xbb, 0xca, 0x90 // sbc ls r11 r10 r6 ASR r11
};
const byte kInstruction_sbc_pl_r13_r4_r2_LSL_r4[] = {
0x12, 0xd4, 0xc4, 0x50 // sbc pl r13 r4 r2 LSL r4
};
const byte kInstruction_sbc_mi_r8_r10_r5_ASR_r0[] = {
0x55, 0x80, 0xca, 0x40 // sbc mi r8 r10 r5 ASR r0
};
const byte kInstruction_sbc_cs_r2_r1_r6_ASR_r4[] = {
0x56, 0x24, 0xc1, 0x20 // sbc cs r2 r1 r6 ASR r4
};
const byte kInstruction_sbc_cc_r0_r11_r8_LSR_r14[] = {
0x38, 0x0e, 0xcb, 0x30 // sbc cc r0 r11 r8 LSR r14
};
const byte kInstruction_sbc_ge_r5_r4_r6_ROR_r1[] = {
0x76, 0x51, 0xc4, 0xa0 // sbc ge r5 r4 r6 ROR r1
};
const byte kInstruction_sbc_cs_r0_r14_r3_LSR_r11[] = {
0x33, 0x0b, 0xce, 0x20 // sbc cs r0 r14 r3 LSR r11
};
const byte kInstruction_sbc_ge_r9_r4_r10_LSR_r13[] = {
0x3a, 0x9d, 0xc4, 0xa0 // sbc ge r9 r4 r10 LSR r13
};
const byte kInstruction_sbc_ne_r11_r0_r9_LSL_r8[] = {
0x19, 0xb8, 0xc0, 0x10 // sbc ne r11 r0 r9 LSL r8
};
const byte kInstruction_sbc_vs_r4_r1_r0_LSL_r8[] = {
0x10, 0x48, 0xc1, 0x60 // sbc vs r4 r1 r0 LSL r8
};
const byte kInstruction_sbc_le_r5_r5_r4_ROR_r10[] = {
0x74, 0x5a, 0xc5, 0xd0 // sbc le r5 r5 r4 ROR r10
};
const byte kInstruction_sbc_al_r9_r5_r0_ROR_r6[] = {
0x70, 0x96, 0xc5, 0xe0 // sbc al r9 r5 r0 ROR r6
};
const byte kInstruction_sbc_hi_r6_r6_r9_LSR_r12[] = {
0x39, 0x6c, 0xc6, 0x80 // sbc hi r6 r6 r9 LSR r12
};
const byte kInstruction_sbc_lt_r1_r4_r9_ROR_r4[] = {
0x79, 0x14, 0xc4, 0xb0 // sbc lt r1 r4 r9 ROR r4
};
const byte kInstruction_sbc_vc_r4_r7_r0_ROR_r11[] = {
0x70, 0x4b, 0xc7, 0x70 // sbc vc r4 r7 r0 ROR r11
};
const byte kInstruction_sbc_gt_r1_r4_r2_ROR_r8[] = {
0x72, 0x18, 0xc4, 0xc0 // sbc gt r1 r4 r2 ROR r8
};
const byte kInstruction_sbc_ne_r4_r5_r9_LSL_r6[] = {
0x19, 0x46, 0xc5, 0x10 // sbc ne r4 r5 r9 LSL r6
};
const byte kInstruction_sbc_gt_r3_r4_r10_LSR_r5[] = {
0x3a, 0x35, 0xc4, 0xc0 // sbc gt r3 r4 r10 LSR r5
};
const byte kInstruction_sbc_al_r7_r9_r2_ROR_r2[] = {
0x72, 0x72, 0xc9, 0xe0 // sbc al r7 r9 r2 ROR r2
};
const byte kInstruction_sbc_le_r3_r8_r2_LSL_r2[] = {
0x12, 0x32, 0xc8, 0xd0 // sbc le r3 r8 r2 LSL r2
};
const byte kInstruction_sbc_hi_r3_r8_r0_LSL_r1[] = {
0x10, 0x31, 0xc8, 0x80 // sbc hi r3 r8 r0 LSL r1
};
const byte kInstruction_sbc_ge_r11_r4_r4_LSL_r14[] = {
0x14, 0xbe, 0xc4, 0xa0 // sbc ge r11 r4 r4 LSL r14
};
const byte kInstruction_sbc_mi_r8_r14_r1_LSR_r13[] = {
0x31, 0x8d, 0xce, 0x40 // sbc mi r8 r14 r1 LSR r13
};
const byte kInstruction_sbc_pl_r6_r1_r10_LSL_r0[] = {
0x1a, 0x60, 0xc1, 0x50 // sbc pl r6 r1 r10 LSL r0
};
const byte kInstruction_sbc_eq_r11_r7_r13_LSL_r0[] = {
0x1d, 0xb0, 0xc7, 0x00 // sbc eq r11 r7 r13 LSL r0
};
const byte kInstruction_sbc_cc_r4_r9_r11_LSR_r1[] = {
0x3b, 0x41, 0xc9, 0x30 // sbc cc r4 r9 r11 LSR r1
};
const byte kInstruction_sbc_cc_r8_r2_r3_LSR_r8[] = {
0x33, 0x88, 0xc2, 0x30 // sbc cc r8 r2 r3 LSR r8
};
const byte kInstruction_sbc_ne_r5_r1_r14_LSL_r12[] = {
0x1e, 0x5c, 0xc1, 0x10 // sbc ne r5 r1 r14 LSL r12
};
const byte kInstruction_sbc_le_r13_r5_r2_ASR_r1[] = {
0x52, 0xd1, 0xc5, 0xd0 // sbc le r13 r5 r2 ASR r1
};
const byte kInstruction_sbc_al_r0_r5_r0_LSL_r4[] = {
0x10, 0x04, 0xc5, 0xe0 // sbc al r0 r5 r0 LSL r4
};
const byte kInstruction_sbc_mi_r3_r1_r4_LSR_r3[] = {
0x34, 0x33, 0xc1, 0x40 // sbc mi r3 r1 r4 LSR r3
};
const byte kInstruction_sbc_cs_r3_r7_r0_ROR_r8[] = {
0x70, 0x38, 0xc7, 0x20 // sbc cs r3 r7 r0 ROR r8
};
const byte kInstruction_sbc_cs_r11_r14_r4_LSR_r13[] = {
0x34, 0xbd, 0xce, 0x20 // sbc cs r11 r14 r4 LSR r13
};
const byte kInstruction_sbc_vs_r11_r10_r8_ASR_r3[] = {
0x58, 0xb3, 0xca, 0x60 // sbc vs r11 r10 r8 ASR r3
};
const byte kInstruction_sbc_gt_r10_r8_r9_LSL_r13[] = {
0x19, 0xad, 0xc8, 0xc0 // sbc gt r10 r8 r9 LSL r13
};
const byte kInstruction_sbc_eq_r10_r1_r8_ASR_r9[] = {
0x58, 0xa9, 0xc1, 0x00 // sbc eq r10 r1 r8 ASR r9
};
const byte kInstruction_sbc_al_r2_r1_r10_ASR_r8[] = {
0x5a, 0x28, 0xc1, 0xe0 // sbc al r2 r1 r10 ASR r8
};
const byte kInstruction_sbc_al_r7_r1_r7_ROR_r11[] = {
0x77, 0x7b, 0xc1, 0xe0 // sbc al r7 r1 r7 ROR r11
};
const byte kInstruction_sbc_cs_r0_r5_r6_ASR_r1[] = {
0x56, 0x01, 0xc5, 0x20 // sbc cs r0 r5 r6 ASR r1
};
const byte kInstruction_sbc_lt_r12_r11_r10_LSR_r14[] = {
0x3a, 0xce, 0xcb, 0xb0 // sbc lt r12 r11 r10 LSR r14
};
const byte kInstruction_sbc_pl_r13_r7_r5_LSL_r2[] = {
0x15, 0xd2, 0xc7, 0x50 // sbc pl r13 r7 r5 LSL r2
};
const byte kInstruction_sbc_ne_r2_r0_r12_LSL_r11[] = {
0x1c, 0x2b, 0xc0, 0x10 // sbc ne r2 r0 r12 LSL r11
};
const byte kInstruction_sbc_ls_r14_r9_r12_ROR_r6[] = {
0x7c, 0xe6, 0xc9, 0x90 // sbc ls r14 r9 r12 ROR r6
};
const byte kInstruction_sbc_cc_r9_r2_r8_ASR_r3[] = {
0x58, 0x93, 0xc2, 0x30 // sbc cc r9 r2 r8 ASR r3
};
const byte kInstruction_sbc_pl_r12_r11_r0_ASR_r7[] = {
0x50, 0xc7, 0xcb, 0x50 // sbc pl r12 r11 r0 ASR r7
};
const byte kInstruction_sbc_vs_r12_r2_r3_ROR_r1[] = {
0x73, 0xc1, 0xc2, 0x60 // sbc vs r12 r2 r3 ROR r1
};
const byte kInstruction_sbc_al_r3_r1_r8_LSL_r4[] = {
0x18, 0x34, 0xc1, 0xe0 // sbc al r3 r1 r8 LSL r4
};
const byte kInstruction_sbc_mi_r7_r9_r13_ASR_r5[] = {
0x5d, 0x75, 0xc9, 0x40 // sbc mi r7 r9 r13 ASR r5
};
const byte kInstruction_sbc_vs_r13_r4_r10_ROR_r9[] = {
0x7a, 0xd9, 0xc4, 0x60 // sbc vs r13 r4 r10 ROR r9
};
const byte kInstruction_sbc_eq_r8_r2_r3_LSR_r2[] = {
0x33, 0x82, 0xc2, 0x00 // sbc eq r8 r2 r3 LSR r2
};
const byte kInstruction_sbc_cs_r0_r3_r11_LSR_r7[] = {
0x3b, 0x07, 0xc3, 0x20 // sbc cs r0 r3 r11 LSR r7
};
const byte kInstruction_sbc_pl_r2_r10_r9_ASR_r13[] = {
0x59, 0x2d, 0xca, 0x50 // sbc pl r2 r10 r9 ASR r13
};
const byte kInstruction_sbc_eq_r14_r0_r7_ASR_r0[] = {
0x57, 0xe0, 0xc0, 0x00 // sbc eq r14 r0 r7 ASR r0
};
const byte kInstruction_sbc_lt_r12_r11_r7_ROR_r7[] = {
0x77, 0xc7, 0xcb, 0xb0 // sbc lt r12 r11 r7 ROR r7
};
const byte kInstruction_sbc_eq_r4_r10_r1_LSL_r2[] = {
0x11, 0x42, 0xca, 0x00 // sbc eq r4 r10 r1 LSL r2
};
const byte kInstruction_sbc_al_r7_r14_r12_ASR_r6[] = {
0x5c, 0x76, 0xce, 0xe0 // sbc al r7 r14 r12 ASR r6
};
const byte kInstruction_sbc_al_r2_r5_r13_ASR_r1[] = {
0x5d, 0x21, 0xc5, 0xe0 // sbc al r2 r5 r13 ASR r1
};
const byte kInstruction_sbc_hi_r0_r3_r14_LSL_r11[] = {
0x1e, 0x0b, 0xc3, 0x80 // sbc hi r0 r3 r14 LSL r11
};
const byte kInstruction_sbc_vs_r5_r6_r9_LSR_r13[] = {
0x39, 0x5d, 0xc6, 0x60 // sbc vs r5 r6 r9 LSR r13
};
const byte kInstruction_sbc_hi_r14_r0_r14_ROR_r14[] = {
0x7e, 0xee, 0xc0, 0x80 // sbc hi r14 r0 r14 ROR r14
};
const byte kInstruction_sbc_eq_r9_r3_r13_ROR_r9[] = {
0x7d, 0x99, 0xc3, 0x00 // sbc eq r9 r3 r13 ROR r9
};
const byte kInstruction_sbc_hi_r6_r8_r1_ASR_r14[] = {
0x51, 0x6e, 0xc8, 0x80 // sbc hi r6 r8 r1 ASR r14
};
const byte kInstruction_sbc_vs_r13_r2_r8_LSR_r7[] = {
0x38, 0xd7, 0xc2, 0x60 // sbc vs r13 r2 r8 LSR r7
};
const byte kInstruction_sbc_cc_r13_r0_r8_LSR_r7[] = {
0x38, 0xd7, 0xc0, 0x30 // sbc cc r13 r0 r8 LSR r7
};
const byte kInstruction_sbc_le_r12_r0_r11_ASR_r9[] = {
0x5b, 0xc9, 0xc0, 0xd0 // sbc le r12 r0 r11 ASR r9
};
const byte kInstruction_sbc_le_r8_r8_r1_LSR_r6[] = {
0x31, 0x86, 0xc8, 0xd0 // sbc le r8 r8 r1 LSR r6
};
const byte kInstruction_sbc_cs_r5_r14_r7_ASR_r3[] = {
0x57, 0x53, 0xce, 0x20 // sbc cs r5 r14 r7 ASR r3
};
const byte kInstruction_sbc_eq_r13_r13_r10_ROR_r12[] = {
0x7a, 0xdc, 0xcd, 0x00 // sbc eq r13 r13 r10 ROR r12
};
const byte kInstruction_sbc_lt_r4_r7_r7_LSR_r5[] = {
0x37, 0x45, 0xc7, 0xb0 // sbc lt r4 r7 r7 LSR r5
};
const byte kInstruction_sbc_le_r6_r13_r10_LSR_r2[] = {
0x3a, 0x62, 0xcd, 0xd0 // sbc le r6 r13 r10 LSR r2
};
const byte kInstruction_sbc_eq_r10_r13_r10_ASR_r8[] = {
0x5a, 0xa8, 0xcd, 0x00 // sbc eq r10 r13 r10 ASR r8
};
const byte kInstruction_sbc_ne_r6_r5_r12_LSR_r12[] = {
0x3c, 0x6c, 0xc5, 0x10 // sbc ne r6 r5 r12 LSR r12
};
const byte kInstruction_sbc_vc_r10_r8_r10_ROR_r8[] = {
0x7a, 0xa8, 0xc8, 0x70 // sbc vc r10 r8 r10 ROR r8
};
const byte kInstruction_sbc_gt_r10_r1_r8_LSR_r1[] = {
0x38, 0xa1, 0xc1, 0xc0 // sbc gt r10 r1 r8 LSR r1
};
const byte kInstruction_sbc_pl_r5_r12_r9_LSR_r13[] = {
0x39, 0x5d, 0xcc, 0x50 // sbc pl r5 r12 r9 LSR r13
};
const byte kInstruction_sbc_gt_r10_r6_r4_ROR_r12[] = {
0x74, 0xac, 0xc6, 0xc0 // sbc gt r10 r6 r4 ROR r12
};
const byte kInstruction_sbc_cs_r14_r10_r10_ASR_r6[] = {
0x5a, 0xe6, 0xca, 0x20 // sbc cs r14 r10 r10 ASR r6
};
const byte kInstruction_sbc_le_r6_r8_r2_ROR_r7[] = {
0x72, 0x67, 0xc8, 0xd0 // sbc le r6 r8 r2 ROR r7
};
const byte kInstruction_sbc_le_r13_r12_r0_ROR_r14[] = {
0x70, 0xde, 0xcc, 0xd0 // sbc le r13 r12 r0 ROR r14
};
const byte kInstruction_sbc_le_r7_r6_r0_ASR_r10[] = {
0x50, 0x7a, 0xc6, 0xd0 // sbc le r7 r6 r0 ASR r10
};
const byte kInstruction_sbc_cs_r10_r4_r1_ASR_r10[] = {
0x51, 0xaa, 0xc4, 0x20 // sbc cs r10 r4 r1 ASR r10
};
const byte kInstruction_sbc_ne_r12_r9_r11_ASR_r6[] = {
0x5b, 0xc6, 0xc9, 0x10 // sbc ne r12 r9 r11 ASR r6
};
const byte kInstruction_sbc_vs_r9_r14_r6_ASR_r12[] = {
0x56, 0x9c, 0xce, 0x60 // sbc vs r9 r14 r6 ASR r12
};
const byte kInstruction_sbc_mi_r1_r8_r0_ASR_r7[] = {
0x50, 0x17, 0xc8, 0x40 // sbc mi r1 r8 r0 ASR r7
};
const byte kInstruction_sbc_gt_r11_r2_r3_ROR_r11[] = {
0x73, 0xbb, 0xc2, 0xc0 // sbc gt r11 r2 r3 ROR r11
};
const byte kInstruction_sbc_cs_r3_r1_r12_LSR_r0[] = {
0x3c, 0x30, 0xc1, 0x20 // sbc cs r3 r1 r12 LSR r0
};
const byte kInstruction_sbc_hi_r12_r14_r11_LSL_r2[] = {
0x1b, 0xc2, 0xce, 0x80 // sbc hi r12 r14 r11 LSL r2
};
const byte kInstruction_sbc_mi_r10_r11_r14_LSL_r10[] = {
0x1e, 0xaa, 0xcb, 0x40 // sbc mi r10 r11 r14 LSL r10
};
const byte kInstruction_sbc_al_r11_r6_r13_ASR_r2[] = {
0x5d, 0xb2, 0xc6, 0xe0 // sbc al r11 r6 r13 ASR r2
};
const byte kInstruction_sbc_gt_r2_r14_r3_ROR_r6[] = {
0x73, 0x26, 0xce, 0xc0 // sbc gt r2 r14 r3 ROR r6
};
const byte kInstruction_sbc_hi_r1_r10_r6_LSR_r6[] = {
0x36, 0x16, 0xca, 0x80 // sbc hi r1 r10 r6 LSR r6
};
const byte kInstruction_sbc_gt_r2_r8_r3_LSL_r6[] = {
0x13, 0x26, 0xc8, 0xc0 // sbc gt r2 r8 r3 LSL r6
};
const byte kInstruction_sbc_ls_r13_r4_r12_ROR_r13[] = {
0x7c, 0xdd, 0xc4, 0x90 // sbc ls r13 r4 r12 ROR r13
};
const byte kInstruction_sbc_vs_r13_r11_r7_ROR_r8[] = {
0x77, 0xd8, 0xcb, 0x60 // sbc vs r13 r11 r7 ROR r8
};
const byte kInstruction_sbc_hi_r5_r12_r14_LSR_r3[] = {
0x3e, 0x53, 0xcc, 0x80 // sbc hi r5 r12 r14 LSR r3
};
const byte kInstruction_sbc_cs_r14_r8_r3_ROR_r13[] = {
0x73, 0xed, 0xc8, 0x20 // sbc cs r14 r8 r3 ROR r13
};
const byte kInstruction_sbc_cs_r9_r10_r0_LSL_r10[] = {
0x10, 0x9a, 0xca, 0x20 // sbc cs r9 r10 r0 LSL r10
};
const byte kInstruction_sbc_lt_r0_r13_r12_ASR_r5[] = {
0x5c, 0x05, 0xcd, 0xb0 // sbc lt r0 r13 r12 ASR r5
};
const byte kInstruction_sbc_cs_r4_r5_r7_ROR_r7[] = {
0x77, 0x47, 0xc5, 0x20 // sbc cs r4 r5 r7 ROR r7
};
const byte kInstruction_sbc_lt_r0_r14_r7_LSR_r7[] = {
0x37, 0x07, 0xce, 0xb0 // sbc lt r0 r14 r7 LSR r7
};
const byte kInstruction_sbc_hi_r10_r5_r3_LSL_r10[] = {
0x13, 0xaa, 0xc5, 0x80 // sbc hi r10 r5 r3 LSL r10
};
const byte kInstruction_sbc_ls_r6_r2_r4_ROR_r0[] = {
0x74, 0x60, 0xc2, 0x90 // sbc ls r6 r2 r4 ROR r0
};
const byte kInstruction_sbc_hi_r9_r7_r7_ASR_r10[] = {
0x57, 0x9a, 0xc7, 0x80 // sbc hi r9 r7 r7 ASR r10
};
const byte kInstruction_sbc_cc_r0_r9_r4_LSR_r2[] = {
0x34, 0x02, 0xc9, 0x30 // sbc cc r0 r9 r4 LSR r2
};
const byte kInstruction_sbc_le_r3_r14_r2_ASR_r0[] = {
0x52, 0x30, 0xce, 0xd0 // sbc le r3 r14 r2 ASR r0
};
const byte kInstruction_sbc_pl_r2_r8_r7_LSL_r13[] = {
0x17, 0x2d, 0xc8, 0x50 // sbc pl r2 r8 r7 LSL r13
};
const byte kInstruction_sbc_al_r10_r1_r9_LSR_r6[] = {
0x39, 0xa6, 0xc1, 0xe0 // sbc al r10 r1 r9 LSR r6
};
const byte kInstruction_sbc_vs_r1_r6_r14_ASR_r14[] = {
0x5e, 0x1e, 0xc6, 0x60 // sbc vs r1 r6 r14 ASR r14
};
const byte kInstruction_sbc_lt_r3_r3_r13_LSR_r0[] = {
0x3d, 0x30, 0xc3, 0xb0 // sbc lt r3 r3 r13 LSR r0
};
const byte kInstruction_sbc_le_r9_r3_r2_ASR_r11[] = {
0x52, 0x9b, 0xc3, 0xd0 // sbc le r9 r3 r2 ASR r11
};
const byte kInstruction_sbc_mi_r4_r14_r6_LSL_r11[] = {
0x16, 0x4b, 0xce, 0x40 // sbc mi r4 r14 r6 LSL r11
};
const byte kInstruction_sbc_ne_r7_r5_r14_ASR_r9[] = {
0x5e, 0x79, 0xc5, 0x10 // sbc ne r7 r5 r14 ASR r9
};
const byte kInstruction_sbc_cs_r11_r11_r13_LSR_r11[] = {
0x3d, 0xbb, 0xcb, 0x20 // sbc cs r11 r11 r13 LSR r11
};
const byte kInstruction_sbc_lt_r12_r9_r5_LSR_r9[] = {
0x35, 0xc9, 0xc9, 0xb0 // sbc lt r12 r9 r5 LSR r9
};
const byte kInstruction_sbc_hi_r13_r1_r10_LSL_r4[] = {
0x1a, 0xd4, 0xc1, 0x80 // sbc hi r13 r1 r10 LSL r4
};
const byte kInstruction_sbc_mi_r14_r6_r8_ASR_r14[] = {
0x58, 0xee, 0xc6, 0x40 // sbc mi r14 r6 r8 ASR r14
};
const byte kInstruction_sbc_vc_r3_r2_r6_ASR_r3[] = {
0x56, 0x33, 0xc2, 0x70 // sbc vc r3 r2 r6 ASR r3
};
const byte kInstruction_sbc_ne_r13_r14_r0_ASR_r2[] = {
0x50, 0xd2, 0xce, 0x10 // sbc ne r13 r14 r0 ASR r2
};
const byte kInstruction_sbc_gt_r2_r14_r5_ROR_r1[] = {
0x75, 0x21, 0xce, 0xc0 // sbc gt r2 r14 r5 ROR r1
};
const byte kInstruction_sbc_ls_r7_r7_r9_LSR_r10[] = {
0x39, 0x7a, 0xc7, 0x90 // sbc ls r7 r7 r9 LSR r10
};
const byte kInstruction_sbc_gt_r2_r12_r8_ASR_r5[] = {
0x58, 0x25, 0xcc, 0xc0 // sbc gt r2 r12 r8 ASR r5
};
const byte kInstruction_sbc_lt_r13_r2_r11_ROR_r6[] = {
0x7b, 0xd6, 0xc2, 0xb0 // sbc lt r13 r2 r11 ROR r6
};
const byte kInstruction_sbc_cc_r2_r13_r13_ASR_r1[] = {
0x5d, 0x21, 0xcd, 0x30 // sbc cc r2 r13 r13 ASR r1
};
const byte kInstruction_sbc_vs_r0_r6_r14_ROR_r3[] = {
0x7e, 0x03, 0xc6, 0x60 // sbc vs r0 r6 r14 ROR r3
};
const byte kInstruction_sbc_vs_r2_r13_r8_LSL_r9[] = {
0x18, 0x29, 0xcd, 0x60 // sbc vs r2 r13 r8 LSL r9
};
const byte kInstruction_sbc_pl_r2_r12_r12_ROR_r6[] = {
0x7c, 0x26, 0xcc, 0x50 // sbc pl r2 r12 r12 ROR r6
};
const byte kInstruction_sbc_vc_r4_r0_r12_ASR_r13[] = {
0x5c, 0x4d, 0xc0, 0x70 // sbc vc r4 r0 r12 ASR r13
};
const byte kInstruction_sbc_mi_r8_r12_r7_ASR_r7[] = {
0x57, 0x87, 0xcc, 0x40 // sbc mi r8 r12 r7 ASR r7
};
const byte kInstruction_sbc_al_r13_r5_r0_LSL_r5[] = {
0x10, 0xd5, 0xc5, 0xe0 // sbc al r13 r5 r0 LSL r5
};
const byte kInstruction_sbc_le_r9_r1_r12_LSR_r8[] = {
0x3c, 0x98, 0xc1, 0xd0 // sbc le r9 r1 r12 LSR r8
};
const byte kInstruction_sbc_vs_r5_r10_r13_ROR_r1[] = {
0x7d, 0x51, 0xca, 0x60 // sbc vs r5 r10 r13 ROR r1
};
const byte kInstruction_sbc_vs_r8_r5_r0_LSR_r11[] = {
0x30, 0x8b, 0xc5, 0x60 // sbc vs r8 r5 r0 LSR r11
};
const byte kInstruction_sbc_ne_r7_r2_r0_LSL_r4[] = {
0x10, 0x74, 0xc2, 0x10 // sbc ne r7 r2 r0 LSL r4
};
const byte kInstruction_sbc_lt_r6_r6_r9_LSL_r10[] = {
0x19, 0x6a, 0xc6, 0xb0 // sbc lt r6 r6 r9 LSL r10
};
const byte kInstruction_sbc_cs_r13_r3_r4_ROR_r12[] = {
0x74, 0xdc, 0xc3, 0x20 // sbc cs r13 r3 r4 ROR r12
};
const byte kInstruction_sbc_ne_r11_r11_r0_LSL_r7[] = {
0x10, 0xb7, 0xcb, 0x10 // sbc ne r11 r11 r0 LSL r7
};
const byte kInstruction_sbc_pl_r3_r14_r12_LSR_r13[] = {
0x3c, 0x3d, 0xce, 0x50 // sbc pl r3 r14 r12 LSR r13
};
const byte kInstruction_sbc_al_r2_r14_r3_LSL_r11[] = {
0x13, 0x2b, 0xce, 0xe0 // sbc al r2 r14 r3 LSL r11
};
const byte kInstruction_sbc_vc_r4_r6_r3_LSR_r7[] = {
0x33, 0x47, 0xc6, 0x70 // sbc vc r4 r6 r3 LSR r7
};
const byte kInstruction_sbc_ls_r6_r2_r1_LSR_r6[] = {
0x31, 0x66, 0xc2, 0x90 // sbc ls r6 r2 r1 LSR r6
};
const byte kInstruction_sbc_le_r0_r2_r5_ASR_r3[] = {
0x55, 0x03, 0xc2, 0xd0 // sbc le r0 r2 r5 ASR r3
};
const byte kInstruction_sbc_ge_r12_r9_r12_ROR_r13[] = {
0x7c, 0xcd, 0xc9, 0xa0 // sbc ge r12 r9 r12 ROR r13
};
const byte kInstruction_sbc_cc_r10_r5_r3_ROR_r12[] = {
0x73, 0xac, 0xc5, 0x30 // sbc cc r10 r5 r3 ROR r12
};
const byte kInstruction_sbc_mi_r14_r0_r10_ASR_r4[] = {
0x5a, 0xe4, 0xc0, 0x40 // sbc mi r14 r0 r10 ASR r4
};
const byte kInstruction_sbc_al_r12_r0_r3_ROR_r13[] = {
0x73, 0xcd, 0xc0, 0xe0 // sbc al r12 r0 r3 ROR r13
};
const byte kInstruction_sbc_hi_r1_r8_r13_ASR_r2[] = {
0x5d, 0x12, 0xc8, 0x80 // sbc hi r1 r8 r13 ASR r2
};
const byte kInstruction_sbc_ls_r7_r9_r9_ASR_r2[] = {
0x59, 0x72, 0xc9, 0x90 // sbc ls r7 r9 r9 ASR r2
};
const byte kInstruction_sbc_ls_r9_r13_r6_ROR_r11[] = {
0x76, 0x9b, 0xcd, 0x90 // sbc ls r9 r13 r6 ROR r11
};
const byte kInstruction_sbc_pl_r11_r12_r14_LSL_r14[] = {
0x1e, 0xbe, 0xcc, 0x50 // sbc pl r11 r12 r14 LSL r14
};
const byte kInstruction_sbc_eq_r1_r3_r10_ASR_r9[] = {
0x5a, 0x19, 0xc3, 0x00 // sbc eq r1 r3 r10 ASR r9
};
const byte kInstruction_sbc_al_r1_r6_r6_LSL_r9[] = {
0x16, 0x19, 0xc6, 0xe0 // sbc al r1 r6 r6 LSL r9
};
const byte kInstruction_sbc_ne_r4_r14_r7_ROR_r12[] = {
0x77, 0x4c, 0xce, 0x10 // sbc ne r4 r14 r7 ROR r12
};
const byte kInstruction_sbc_vc_r2_r13_r1_ROR_r7[] = {
0x71, 0x27, 0xcd, 0x70 // sbc vc r2 r13 r1 ROR r7
};
const byte kInstruction_sbc_cs_r13_r12_r8_LSR_r11[] = {
0x38, 0xdb, 0xcc, 0x20 // sbc cs r13 r12 r8 LSR r11
};
const byte kInstruction_sbc_le_r10_r14_r12_LSL_r4[] = {
0x1c, 0xa4, 0xce, 0xd0 // sbc le r10 r14 r12 LSL r4
};
const byte kInstruction_sbc_cs_r14_r9_r4_ROR_r13[] = {
0x74, 0xed, 0xc9, 0x20 // sbc cs r14 r9 r4 ROR r13
};
const byte kInstruction_sbc_ge_r10_r12_r8_ASR_r14[] = {
0x58, 0xae, 0xcc, 0xa0 // sbc ge r10 r12 r8 ASR r14
};
const byte kInstruction_sbc_cs_r14_r10_r3_LSL_r13[] = {
0x13, 0xed, 0xca, 0x20 // sbc cs r14 r10 r3 LSL r13
};
const byte kInstruction_sbc_lt_r4_r3_r10_LSR_r2[] = {
0x3a, 0x42, 0xc3, 0xb0 // sbc lt r4 r3 r10 LSR r2
};
const byte kInstruction_sbc_ls_r13_r12_r8_ASR_r14[] = {
0x58, 0xde, 0xcc, 0x90 // sbc ls r13 r12 r8 ASR r14
};
const byte kInstruction_sbc_ge_r3_r2_r0_ASR_r8[] = {
0x50, 0x38, 0xc2, 0xa0 // sbc ge r3 r2 r0 ASR r8
};
const byte kInstruction_sbc_vs_r3_r7_r1_LSL_r0[] = {
0x11, 0x30, 0xc7, 0x60 // sbc vs r3 r7 r1 LSL r0
};
const byte kInstruction_sbc_lt_r5_r13_r7_LSR_r7[] = {
0x37, 0x57, 0xcd, 0xb0 // sbc lt r5 r13 r7 LSR r7
};
const byte kInstruction_sbc_ls_r8_r4_r3_ROR_r14[] = {
0x73, 0x8e, 0xc4, 0x90 // sbc ls r8 r4 r3 ROR r14
};
const byte kInstruction_sbc_vc_r5_r4_r13_LSL_r12[] = {
0x1d, 0x5c, 0xc4, 0x70 // sbc vc r5 r4 r13 LSL r12
};
const byte kInstruction_sbc_pl_r6_r10_r11_LSR_r2[] = {
0x3b, 0x62, 0xca, 0x50 // sbc pl r6 r10 r11 LSR r2
};
const byte kInstruction_sbc_ne_r4_r0_r6_ASR_r10[] = {
0x56, 0x4a, 0xc0, 0x10 // sbc ne r4 r0 r6 ASR r10
};
const byte kInstruction_sbc_vc_r2_r6_r7_LSR_r4[] = {
0x37, 0x24, 0xc6, 0x70 // sbc vc r2 r6 r7 LSR r4
};
const byte kInstruction_sbc_pl_r4_r12_r1_ROR_r14[] = {
0x71, 0x4e, 0xcc, 0x50 // sbc pl r4 r12 r1 ROR r14
};
const byte kInstruction_sbc_cs_r13_r1_r10_LSL_r12[] = {
0x1a, 0xdc, 0xc1, 0x20 // sbc cs r13 r1 r10 LSL r12
};
const byte kInstruction_sbc_al_r7_r12_r7_LSL_r10[] = {
0x17, 0x7a, 0xcc, 0xe0 // sbc al r7 r12 r7 LSL r10
};
const byte kInstruction_sbc_ge_r1_r9_r13_LSR_r8[] = {
0x3d, 0x18, 0xc9, 0xa0 // sbc ge r1 r9 r13 LSR r8
};
const byte kInstruction_sbc_eq_r12_r5_r11_ASR_r2[] = {
0x5b, 0xc2, 0xc5, 0x00 // sbc eq r12 r5 r11 ASR r2
};
const byte kInstruction_sbc_ls_r7_r9_r3_ASR_r14[] = {
0x53, 0x7e, 0xc9, 0x90 // sbc ls r7 r9 r3 ASR r14
};
const byte kInstruction_sbc_pl_r5_r10_r3_LSL_r12[] = {
0x13, 0x5c, 0xca, 0x50 // sbc pl r5 r10 r3 LSL r12
};
const byte kInstruction_sbc_vs_r5_r14_r11_ASR_r13[] = {
0x5b, 0x5d, 0xce, 0x60 // sbc vs r5 r14 r11 ASR r13
};
const byte kInstruction_sbc_al_r9_r2_r8_LSR_r10[] = {
0x38, 0x9a, 0xc2, 0xe0 // sbc al r9 r2 r8 LSR r10
};
const byte kInstruction_sbc_cc_r11_r12_r6_ROR_r11[] = {
0x76, 0xbb, 0xcc, 0x30 // sbc cc r11 r12 r6 ROR r11
};
const byte kInstruction_sbc_ge_r10_r3_r1_LSR_r5[] = {
0x31, 0xa5, 0xc3, 0xa0 // sbc ge r10 r3 r1 LSR r5
};
const byte kInstruction_sbc_lt_r13_r4_r7_ROR_r0[] = {
0x77, 0xd0, 0xc4, 0xb0 // sbc lt r13 r4 r7 ROR r0
};
const byte kInstruction_sbc_ne_r2_r12_r12_LSR_r0[] = {
0x3c, 0x20, 0xcc, 0x10 // sbc ne r2 r12 r12 LSR r0
};
const byte kInstruction_sbc_gt_r2_r10_r14_ASR_r10[] = {
0x5e, 0x2a, 0xca, 0xc0 // sbc gt r2 r10 r14 ASR r10
};
const byte kInstruction_sbc_cc_r5_r6_r10_ASR_r11[] = {
0x5a, 0x5b, 0xc6, 0x30 // sbc cc r5 r6 r10 ASR r11
};
const byte kInstruction_sbc_hi_r8_r13_r1_ROR_r9[] = {
0x71, 0x89, 0xcd, 0x80 // sbc hi r8 r13 r1 ROR r9
};
const byte kInstruction_sbc_cc_r3_r1_r14_LSR_r3[] = {
0x3e, 0x33, 0xc1, 0x30 // sbc cc r3 r1 r14 LSR r3
};
const byte kInstruction_sbc_lt_r11_r9_r8_ASR_r13[] = {
0x58, 0xbd, 0xc9, 0xb0 // sbc lt r11 r9 r8 ASR r13
};
const byte kInstruction_sbc_mi_r0_r3_r13_ASR_r5[] = {
0x5d, 0x05, 0xc3, 0x40 // sbc mi r0 r3 r13 ASR r5
};
const byte kInstruction_sbc_vc_r7_r6_r10_ASR_r6[] = {
0x5a, 0x76, 0xc6, 0x70 // sbc vc r7 r6 r10 ASR r6
};
const byte kInstruction_sbc_mi_r2_r6_r4_LSL_r9[] = {
0x14, 0x29, 0xc6, 0x40 // sbc mi r2 r6 r4 LSL r9
};
const byte kInstruction_sbc_ne_r12_r9_r4_ROR_r6[] = {
0x74, 0xc6, 0xc9, 0x10 // sbc ne r12 r9 r4 ROR r6
};
const byte kInstruction_sbc_hi_r4_r3_r0_ROR_r4[] = {
0x70, 0x44, 0xc3, 0x80 // sbc hi r4 r3 r0 ROR r4
};
const byte kInstruction_sbc_gt_r9_r2_r11_LSL_r13[] = {
0x1b, 0x9d, 0xc2, 0xc0 // sbc gt r9 r2 r11 LSL r13
};
const byte kInstruction_sbc_eq_r14_r4_r3_LSL_r10[] = {
0x13, 0xea, 0xc4, 0x00 // sbc eq r14 r4 r3 LSL r10
};
const byte kInstruction_sbc_le_r8_r2_r12_LSL_r10[] = {
0x1c, 0x8a, 0xc2, 0xd0 // sbc le r8 r2 r12 LSL r10
};
const byte kInstruction_sbc_ls_r8_r0_r1_ASR_r8[] = {
0x51, 0x88, 0xc0, 0x90 // sbc ls r8 r0 r1 ASR r8
};
const byte kInstruction_sbc_cc_r13_r9_r7_LSR_r3[] = {
0x37, 0xd3, 0xc9, 0x30 // sbc cc r13 r9 r7 LSR r3
};
const byte kInstruction_sbc_gt_r6_r0_r7_ROR_r9[] = {
0x77, 0x69, 0xc0, 0xc0 // sbc gt r6 r0 r7 ROR r9
};
const byte kInstruction_sbc_hi_r14_r12_r6_LSR_r12[] = {
0x36, 0xec, 0xcc, 0x80 // sbc hi r14 r12 r6 LSR r12
};
const byte kInstruction_sbc_cs_r3_r7_r10_LSR_r8[] = {
0x3a, 0x38, 0xc7, 0x20 // sbc cs r3 r7 r10 LSR r8
};
const byte kInstruction_sbc_le_r7_r7_r7_LSL_r11[] = {
0x17, 0x7b, 0xc7, 0xd0 // sbc le r7 r7 r7 LSL r11
};
const byte kInstruction_sbc_le_r11_r11_r14_ASR_r3[] = {
0x5e, 0xb3, 0xcb, 0xd0 // sbc le r11 r11 r14 ASR r3
};
const byte kInstruction_sbc_vc_r13_r5_r6_LSL_r13[] = {
0x16, 0xdd, 0xc5, 0x70 // sbc vc r13 r5 r6 LSL r13
};
const byte kInstruction_sbc_cc_r12_r3_r12_LSL_r8[] = {
0x1c, 0xc8, 0xc3, 0x30 // sbc cc r12 r3 r12 LSL r8
};
const byte kInstruction_sbc_gt_r4_r14_r12_ASR_r11[] = {
0x5c, 0x4b, 0xce, 0xc0 // sbc gt r4 r14 r12 ASR r11
};
const byte kInstruction_sbc_cs_r9_r6_r7_LSL_r10[] = {
0x17, 0x9a, 0xc6, 0x20 // sbc cs r9 r6 r7 LSL r10
};
const byte kInstruction_sbc_ge_r9_r5_r3_ROR_r5[] = {
0x73, 0x95, 0xc5, 0xa0 // sbc ge r9 r5 r3 ROR r5
};
const byte kInstruction_sbc_vc_r4_r5_r14_LSR_r4[] = {
0x3e, 0x44, 0xc5, 0x70 // sbc vc r4 r5 r14 LSR r4
};
const byte kInstruction_sbc_ne_r13_r12_r2_ASR_r14[] = {
0x52, 0xde, 0xcc, 0x10 // sbc ne r13 r12 r2 ASR r14
};
const byte kInstruction_sbc_gt_r2_r9_r11_LSR_r13[] = {
0x3b, 0x2d, 0xc9, 0xc0 // sbc gt r2 r9 r11 LSR r13
};
const byte kInstruction_sbc_mi_r10_r11_r8_LSR_r1[] = {
0x38, 0xa1, 0xcb, 0x40 // sbc mi r10 r11 r8 LSR r1
};
const byte kInstruction_sbc_hi_r6_r8_r1_ASR_r6[] = {
0x51, 0x66, 0xc8, 0x80 // sbc hi r6 r8 r1 ASR r6
};
const byte kInstruction_sbc_eq_r10_r12_r5_ROR_r11[] = {
0x75, 0xab, 0xcc, 0x00 // sbc eq r10 r12 r5 ROR r11
};
const byte kInstruction_sbc_mi_r9_r6_r4_LSL_r1[] = {
0x14, 0x91, 0xc6, 0x40 // sbc mi r9 r6 r4 LSL r1
};
const byte kInstruction_sbc_vc_r14_r6_r0_ROR_r7[] = {
0x70, 0xe7, 0xc6, 0x70 // sbc vc r14 r6 r0 ROR r7
};
const byte kInstruction_sbc_mi_r10_r3_r12_LSL_r2[] = {
0x1c, 0xa2, 0xc3, 0x40 // sbc mi r10 r3 r12 LSL r2
};
const byte kInstruction_sbc_pl_r9_r6_r9_LSR_r14[] = {
0x39, 0x9e, 0xc6, 0x50 // sbc pl r9 r6 r9 LSR r14
};
const byte kInstruction_sbc_al_r10_r5_r10_ROR_r1[] = {
0x7a, 0xa1, 0xc5, 0xe0 // sbc al r10 r5 r10 ROR r1
};
const byte kInstruction_sbc_ne_r9_r6_r2_ASR_r3[] = {
0x52, 0x93, 0xc6, 0x10 // sbc ne r9 r6 r2 ASR r3
};
const byte kInstruction_sbc_hi_r4_r9_r4_LSL_r6[] = {
0x14, 0x46, 0xc9, 0x80 // sbc hi r4 r9 r4 LSL r6
};
const byte kInstruction_sbc_vs_r1_r9_r7_ASR_r7[] = {
0x57, 0x17, 0xc9, 0x60 // sbc vs r1 r9 r7 ASR r7
};
const byte kInstruction_sbc_ne_r10_r13_r9_ASR_r14[] = {
0x59, 0xae, 0xcd, 0x10 // sbc ne r10 r13 r9 ASR r14
};
const byte kInstruction_sbc_gt_r11_r13_r12_ASR_r12[] = {
0x5c, 0xbc, 0xcd, 0xc0 // sbc gt r11 r13 r12 ASR r12
};
const byte kInstruction_sbc_lt_r3_r5_r0_LSR_r10[] = {
0x30, 0x3a, 0xc5, 0xb0 // sbc lt r3 r5 r0 LSR r10
};
const byte kInstruction_sbc_gt_r4_r8_r13_ROR_r7[] = {
0x7d, 0x47, 0xc8, 0xc0 // sbc gt r4 r8 r13 ROR r7
};
const byte kInstruction_sbc_ls_r14_r14_r0_ASR_r3[] = {
0x50, 0xe3, 0xce, 0x90 // sbc ls r14 r14 r0 ASR r3
};
const byte kInstruction_sbc_vc_r2_r7_r9_ASR_r5[] = {
0x59, 0x25, 0xc7, 0x70 // sbc vc r2 r7 r9 ASR r5
};
const byte kInstruction_sbc_mi_r9_r3_r10_LSR_r10[] = {
0x3a, 0x9a, 0xc3, 0x40 // sbc mi r9 r3 r10 LSR r10
};
const byte kInstruction_sbc_gt_r11_r10_r3_ASR_r11[] = {
0x53, 0xbb, 0xca, 0xc0 // sbc gt r11 r10 r3 ASR r11
};
const byte kInstruction_sbc_cc_r3_r14_r2_ROR_r12[] = {
0x72, 0x3c, 0xce, 0x30 // sbc cc r3 r14 r2 ROR r12
};
const byte kInstruction_sbc_ls_r3_r5_r14_ROR_r12[] = {
0x7e, 0x3c, 0xc5, 0x90 // sbc ls r3 r5 r14 ROR r12
};
const byte kInstruction_sbc_al_r6_r0_r11_ASR_r0[] = {
0x5b, 0x60, 0xc0, 0xe0 // sbc al r6 r0 r11 ASR r0
};
const byte kInstruction_sbc_al_r14_r12_r13_LSL_r8[] = {
0x1d, 0xe8, 0xcc, 0xe0 // sbc al r14 r12 r13 LSL r8
};
const byte kInstruction_sbc_cs_r12_r9_r14_ROR_r4[] = {
0x7e, 0xc4, 0xc9, 0x20 // sbc cs r12 r9 r14 ROR r4
};
const byte kInstruction_sbc_vs_r4_r9_r6_LSL_r10[] = {
0x16, 0x4a, 0xc9, 0x60 // sbc vs r4 r9 r6 LSL r10
};
const byte kInstruction_sbc_eq_r6_r1_r4_ASR_r6[] = {
0x54, 0x66, 0xc1, 0x00 // sbc eq r6 r1 r4 ASR r6
};
const byte kInstruction_sbc_ge_r6_r11_r2_LSR_r10[] = {
0x32, 0x6a, 0xcb, 0xa0 // sbc ge r6 r11 r2 LSR r10
};
const byte kInstruction_sbc_cc_r10_r14_r4_LSR_r0[] = {
0x34, 0xa0, 0xce, 0x30 // sbc cc r10 r14 r4 LSR r0
};
const byte kInstruction_sbc_ge_r0_r12_r1_ROR_r5[] = {
0x71, 0x05, 0xcc, 0xa0 // sbc ge r0 r12 r1 ROR r5
};
const byte kInstruction_sbc_ls_r1_r13_r10_ASR_r5[] = {
0x5a, 0x15, 0xcd, 0x90 // sbc ls r1 r13 r10 ASR r5
};
const byte kInstruction_sbc_cc_r9_r8_r5_ASR_r5[] = {
0x55, 0x95, 0xc8, 0x30 // sbc cc r9 r8 r5 ASR r5
};
const byte kInstruction_sbc_ls_r6_r5_r1_LSL_r11[] = {
0x11, 0x6b, 0xc5, 0x90 // sbc ls r6 r5 r1 LSL r11
};
const byte kInstruction_sbc_ne_r2_r12_r1_ROR_r10[] = {
0x71, 0x2a, 0xcc, 0x10 // sbc ne r2 r12 r1 ROR r10
};
const byte kInstruction_sbc_cc_r2_r9_r9_LSR_r1[] = {
0x39, 0x21, 0xc9, 0x30 // sbc cc r2 r9 r9 LSR r1
};
const byte kInstruction_sbc_ne_r1_r8_r1_ASR_r14[] = {
0x51, 0x1e, 0xc8, 0x10 // sbc ne r1 r8 r1 ASR r14
};
const byte kInstruction_sbc_lt_r9_r2_r1_LSR_r10[] = {
0x31, 0x9a, 0xc2, 0xb0 // sbc lt r9 r2 r1 LSR r10
};
const byte kInstruction_sbc_cc_r14_r11_r9_ROR_r6[] = {
0x79, 0xe6, 0xcb, 0x30 // sbc cc r14 r11 r9 ROR r6
};
const byte kInstruction_sbc_eq_r3_r12_r13_ASR_r0[] = {
0x5d, 0x30, 0xcc, 0x00 // sbc eq r3 r12 r13 ASR r0
};
const byte kInstruction_sbc_le_r6_r6_r6_ASR_r2[] = {
0x56, 0x62, 0xc6, 0xd0 // sbc le r6 r6 r6 ASR r2
};
const byte kInstruction_sbc_mi_r11_r14_r4_ASR_r1[] = {
0x54, 0xb1, 0xce, 0x40 // sbc mi r11 r14 r4 ASR r1
};
const byte kInstruction_sbc_ls_r5_r9_r10_LSL_r9[] = {
0x1a, 0x59, 0xc9, 0x90 // sbc ls r5 r9 r10 LSL r9
};
const byte kInstruction_sbc_vc_r12_r9_r3_LSR_r10[] = {
0x33, 0xca, 0xc9, 0x70 // sbc vc r12 r9 r3 LSR r10
};
const byte kInstruction_sbc_lt_r12_r0_r4_ASR_r0[] = {
0x54, 0xc0, 0xc0, 0xb0 // sbc lt r12 r0 r4 ASR r0
};
const byte kInstruction_sbc_mi_r0_r10_r6_ROR_r9[] = {
0x76, 0x09, 0xca, 0x40 // sbc mi r0 r10 r6 ROR r9
};
const byte kInstruction_sbc_hi_r7_r10_r1_LSL_r7[] = {
0x11, 0x77, 0xca, 0x80 // sbc hi r7 r10 r1 LSL r7
};
const byte kInstruction_sbc_ls_r2_r0_r14_ROR_r5[] = {
0x7e, 0x25, 0xc0, 0x90 // sbc ls r2 r0 r14 ROR r5
};
const byte kInstruction_sbc_cs_r12_r14_r12_LSR_r10[] = {
0x3c, 0xca, 0xce, 0x20 // sbc cs r12 r14 r12 LSR r10
};
const byte kInstruction_sbc_le_r9_r0_r6_ROR_r2[] = {
0x76, 0x92, 0xc0, 0xd0 // sbc le r9 r0 r6 ROR r2
};
const byte kInstruction_sbc_cc_r3_r10_r4_LSR_r12[] = {
0x34, 0x3c, 0xca, 0x30 // sbc cc r3 r10 r4 LSR r12
};
const byte kInstruction_sbc_mi_r4_r5_r2_ASR_r14[] = {
0x52, 0x4e, 0xc5, 0x40 // sbc mi r4 r5 r2 ASR r14
};
const byte kInstruction_sbc_vc_r12_r8_r10_ROR_r14[] = {
0x7a, 0xce, 0xc8, 0x70 // sbc vc r12 r8 r10 ROR r14
};
const byte kInstruction_sbc_al_r5_r14_r4_ASR_r10[] = {
0x54, 0x5a, 0xce, 0xe0 // sbc al r5 r14 r4 ASR r10
};
const byte kInstruction_sbc_ls_r13_r8_r3_ASR_r1[] = {
0x53, 0xd1, 0xc8, 0x90 // sbc ls r13 r8 r3 ASR r1
};
const byte kInstruction_sbc_le_r10_r1_r2_LSR_r4[] = {
0x32, 0xa4, 0xc1, 0xd0 // sbc le r10 r1 r2 LSR r4
};
const byte kInstruction_sbc_ne_r0_r2_r10_ROR_r7[] = {
0x7a, 0x07, 0xc2, 0x10 // sbc ne r0 r2 r10 ROR r7
};
const byte kInstruction_sbc_vs_r11_r13_r11_LSR_r12[] = {
0x3b, 0xbc, 0xcd, 0x60 // sbc vs r11 r13 r11 LSR r12
};
const byte kInstruction_sbc_vs_r10_r10_r8_ROR_r8[] = {
0x78, 0xa8, 0xca, 0x60 // sbc vs r10 r10 r8 ROR r8
};
const byte kInstruction_sbc_ne_r7_r2_r9_LSL_r11[] = {
0x19, 0x7b, 0xc2, 0x10 // sbc ne r7 r2 r9 LSL r11
};
const byte kInstruction_sbc_mi_r5_r12_r11_ASR_r5[] = {
0x5b, 0x55, 0xcc, 0x40 // sbc mi r5 r12 r11 ASR r5
};
const byte kInstruction_sbc_le_r1_r10_r5_ROR_r5[] = {
0x75, 0x15, 0xca, 0xd0 // sbc le r1 r10 r5 ROR r5
};
const byte kInstruction_sbc_cc_r3_r14_r3_ASR_r6[] = {
0x53, 0x36, 0xce, 0x30 // sbc cc r3 r14 r3 ASR r6
};
const byte kInstruction_sbc_vc_r4_r4_r0_ROR_r2[] = {
0x70, 0x42, 0xc4, 0x70 // sbc vc r4 r4 r0 ROR r2
};
const byte kInstruction_sbc_le_r3_r4_r12_ROR_r14[] = {
0x7c, 0x3e, 0xc4, 0xd0 // sbc le r3 r4 r12 ROR r14
};
const byte kInstruction_sbc_al_r3_r7_r14_LSL_r11[] = {
0x1e, 0x3b, 0xc7, 0xe0 // sbc al r3 r7 r14 LSL r11
};
const byte kInstruction_sbc_vc_r8_r11_r0_LSL_r11[] = {
0x10, 0x8b, 0xcb, 0x70 // sbc vc r8 r11 r0 LSL r11
};
const byte kInstruction_sbc_vs_r12_r9_r14_LSR_r2[] = {
0x3e, 0xc2, 0xc9, 0x60 // sbc vs r12 r9 r14 LSR r2
};
const byte kInstruction_sbc_hi_r3_r5_r5_ROR_r6[] = {
0x75, 0x36, 0xc5, 0x80 // sbc hi r3 r5 r5 ROR r6
};
const byte kInstruction_sbc_cs_r9_r3_r13_ASR_r7[] = {
0x5d, 0x97, 0xc3, 0x20 // sbc cs r9 r3 r13 ASR r7
};
const byte kInstruction_sbc_eq_r14_r3_r6_LSR_r5[] = {
0x36, 0xe5, 0xc3, 0x00 // sbc eq r14 r3 r6 LSR r5
};
const byte kInstruction_sbc_lt_r8_r3_r4_LSR_r13[] = {
0x34, 0x8d, 0xc3, 0xb0 // sbc lt r8 r3 r4 LSR r13
};
const byte kInstruction_sbc_vc_r7_r4_r12_ROR_r6[] = {
0x7c, 0x76, 0xc4, 0x70 // sbc vc r7 r4 r12 ROR r6
};
const byte kInstruction_sbc_vs_r5_r3_r3_ASR_r1[] = {
0x53, 0x51, 0xc3, 0x60 // sbc vs r5 r3 r3 ASR r1
};
const byte kInstruction_sbc_le_r5_r6_r1_ROR_r7[] = {
0x71, 0x57, 0xc6, 0xd0 // sbc le r5 r6 r1 ROR r7
};
const byte kInstruction_sbc_ge_r11_r5_r11_LSL_r12[] = {
0x1b, 0xbc, 0xc5, 0xa0 // sbc ge r11 r5 r11 LSL r12
};
const byte kInstruction_sbc_lt_r0_r3_r7_ASR_r14[] = {
0x57, 0x0e, 0xc3, 0xb0 // sbc lt r0 r3 r7 ASR r14
};
const byte kInstruction_sbc_cs_r9_r2_r10_LSL_r1[] = {
0x1a, 0x91, 0xc2, 0x20 // sbc cs r9 r2 r10 LSL r1
};
const byte kInstruction_sbc_cs_r6_r8_r6_ASR_r1[] = {
0x56, 0x61, 0xc8, 0x20 // sbc cs r6 r8 r6 ASR r1
};
const byte kInstruction_sbc_lt_r0_r11_r14_ASR_r5[] = {
0x5e, 0x05, 0xcb, 0xb0 // sbc lt r0 r11 r14 ASR r5
};
const byte kInstruction_sbc_ge_r11_r11_r2_ASR_r3[] = {
0x52, 0xb3, 0xcb, 0xa0 // sbc ge r11 r11 r2 ASR r3
};
const byte kInstruction_sbc_lt_r0_r0_r14_LSL_r2[] = {
0x1e, 0x02, 0xc0, 0xb0 // sbc lt r0 r0 r14 LSL r2
};
const byte kInstruction_sbc_cs_r8_r9_r11_ROR_r8[] = {
0x7b, 0x88, 0xc9, 0x20 // sbc cs r8 r9 r11 ROR r8
};
const byte kInstruction_sbc_pl_r9_r5_r12_ASR_r14[] = {
0x5c, 0x9e, 0xc5, 0x50 // sbc pl r9 r5 r12 ASR r14
};
const byte kInstruction_sbc_eq_r13_r11_r1_LSR_r1[] = {
0x31, 0xd1, 0xcb, 0x00 // sbc eq r13 r11 r1 LSR r1
};
const byte kInstruction_sbc_ne_r1_r0_r13_ROR_r0[] = {
0x7d, 0x10, 0xc0, 0x10 // sbc ne r1 r0 r13 ROR r0
};
const byte kInstruction_sbc_hi_r6_r5_r9_LSR_r10[] = {
0x39, 0x6a, 0xc5, 0x80 // sbc hi r6 r5 r9 LSR r10
};
const byte kInstruction_sbc_lt_r4_r7_r7_ASR_r9[] = {
0x57, 0x49, 0xc7, 0xb0 // sbc lt r4 r7 r7 ASR r9
};
const byte kInstruction_sbc_ls_r13_r13_r5_LSR_r1[] = {
0x35, 0xd1, 0xcd, 0x90 // sbc ls r13 r13 r5 LSR r1
};
const byte kInstruction_sbc_cs_r12_r1_r6_LSR_r14[] = {
0x36, 0xce, 0xc1, 0x20 // sbc cs r12 r1 r6 LSR r14
};
const byte kInstruction_sbc_hi_r11_r0_r5_LSR_r3[] = {
0x35, 0xb3, 0xc0, 0x80 // sbc hi r11 r0 r5 LSR r3
};
const byte kInstruction_sbc_ne_r5_r2_r14_LSR_r1[] = {
0x3e, 0x51, 0xc2, 0x10 // sbc ne r5 r2 r14 LSR r1
};
const byte kInstruction_sbc_le_r6_r12_r9_LSR_r5[] = {
0x39, 0x65, 0xcc, 0xd0 // sbc le r6 r12 r9 LSR r5
};
const byte kInstruction_sbc_cs_r1_r11_r1_LSL_r2[] = {
0x11, 0x12, 0xcb, 0x20 // sbc cs r1 r11 r1 LSL r2
};
const byte kInstruction_sbc_al_r14_r10_r8_ASR_r4[] = {
0x58, 0xe4, 0xca, 0xe0 // sbc al r14 r10 r8 ASR r4
};
const byte kInstruction_sbc_al_r11_r10_r8_LSL_r6[] = {
0x18, 0xb6, 0xca, 0xe0 // sbc al r11 r10 r8 LSL r6
};
const byte kInstruction_sbc_vs_r1_r2_r1_LSL_r11[] = {
0x11, 0x1b, 0xc2, 0x60 // sbc vs r1 r2 r1 LSL r11
};
const byte kInstruction_sbc_cs_r10_r14_r14_LSL_r0[] = {
0x1e, 0xa0, 0xce, 0x20 // sbc cs r10 r14 r14 LSL r0
};
const byte kInstruction_sbc_pl_r0_r1_r14_ROR_r10[] = {
0x7e, 0x0a, 0xc1, 0x50 // sbc pl r0 r1 r14 ROR r10
};
const byte kInstruction_sbc_pl_r3_r7_r5_LSR_r1[] = {
0x35, 0x31, 0xc7, 0x50 // sbc pl r3 r7 r5 LSR r1
};
const byte kInstruction_sbc_gt_r2_r14_r10_LSL_r6[] = {
0x1a, 0x26, 0xce, 0xc0 // sbc gt r2 r14 r10 LSL r6
};
const byte kInstruction_sbc_le_r7_r7_r8_ROR_r0[] = {
0x78, 0x70, 0xc7, 0xd0 // sbc le r7 r7 r8 ROR r0
};
const byte kInstruction_sbc_cs_r7_r9_r8_LSL_r14[] = {
0x18, 0x7e, 0xc9, 0x20 // sbc cs r7 r9 r8 LSL r14
};
const byte kInstruction_sbc_cs_r11_r4_r3_LSR_r10[] = {
0x33, 0xba, 0xc4, 0x20 // sbc cs r11 r4 r3 LSR r10
};
const byte kInstruction_sbc_cc_r9_r1_r12_ROR_r4[] = {
0x7c, 0x94, 0xc1, 0x30 // sbc cc r9 r1 r12 ROR r4
};
const byte kInstruction_sbc_hi_r10_r0_r10_LSL_r8[] = {
0x1a, 0xa8, 0xc0, 0x80 // sbc hi r10 r0 r10 LSL r8
};
const byte kInstruction_sbc_eq_r14_r1_r0_LSL_r11[] = {
0x10, 0xeb, 0xc1, 0x00 // sbc eq r14 r1 r0 LSL r11
};
const byte kInstruction_sbc_mi_r9_r11_r5_ROR_r5[] = {
0x75, 0x95, 0xcb, 0x40 // sbc mi r9 r11 r5 ROR r5
};
const byte kInstruction_sbc_le_r5_r9_r2_LSL_r1[] = {
0x12, 0x51, 0xc9, 0xd0 // sbc le r5 r9 r2 LSL r1
};
const byte kInstruction_sbc_pl_r7_r7_r8_ASR_r13[] = {
0x58, 0x7d, 0xc7, 0x50 // sbc pl r7 r7 r8 ASR r13
};
const byte kInstruction_sbc_gt_r14_r13_r10_ASR_r11[] = {
0x5a, 0xeb, 0xcd, 0xc0 // sbc gt r14 r13 r10 ASR r11
};
const byte kInstruction_sbc_cs_r4_r6_r5_LSR_r7[] = {
0x35, 0x47, 0xc6, 0x20 // sbc cs r4 r6 r5 LSR r7
};
const byte kInstruction_sbc_lt_r2_r7_r7_LSL_r6[] = {
0x17, 0x26, 0xc7, 0xb0 // sbc lt r2 r7 r7 LSL r6
};
const byte kInstruction_sbc_al_r4_r5_r2_ROR_r5[] = {
0x72, 0x45, 0xc5, 0xe0 // sbc al r4 r5 r2 ROR r5
};
const byte kInstruction_sbc_cc_r6_r2_r9_ROR_r7[] = {
0x79, 0x67, 0xc2, 0x30 // sbc cc r6 r2 r9 ROR r7
};
const byte kInstruction_sbc_pl_r4_r0_r0_LSR_r11[] = {
0x30, 0x4b, 0xc0, 0x50 // sbc pl r4 r0 r0 LSR r11
};
const byte kInstruction_sbc_pl_r6_r10_r12_LSL_r11[] = {
0x1c, 0x6b, 0xca, 0x50 // sbc pl r6 r10 r12 LSL r11
};
const byte kInstruction_sbc_al_r0_r14_r1_LSR_r6[] = {
0x31, 0x06, 0xce, 0xe0 // sbc al r0 r14 r1 LSR r6
};
const byte kInstruction_sbc_cs_r7_r9_r13_LSR_r1[] = {
0x3d, 0x71, 0xc9, 0x20 // sbc cs r7 r9 r13 LSR r1
};
const byte kInstruction_sbc_al_r4_r2_r10_ROR_r3[] = {
0x7a, 0x43, 0xc2, 0xe0 // sbc al r4 r2 r10 ROR r3
};
const byte kInstruction_sbc_gt_r12_r4_r14_ROR_r7[] = {
0x7e, 0xc7, 0xc4, 0xc0 // sbc gt r12 r4 r14 ROR r7
};
const byte kInstruction_sbc_cs_r11_r0_r14_ASR_r7[] = {
0x5e, 0xb7, 0xc0, 0x20 // sbc cs r11 r0 r14 ASR r7
};
const byte kInstruction_sbc_pl_r0_r2_r4_ASR_r14[] = {
0x54, 0x0e, 0xc2, 0x50 // sbc pl r0 r2 r4 ASR r14
};
const byte kInstruction_sbc_mi_r14_r4_r9_LSR_r5[] = {
0x39, 0xe5, 0xc4, 0x40 // sbc mi r14 r4 r9 LSR r5
};
const byte kInstruction_sbc_ge_r13_r0_r1_ROR_r5[] = {
0x71, 0xd5, 0xc0, 0xa0 // sbc ge r13 r0 r1 ROR r5
};
const byte kInstruction_sbc_eq_r12_r14_r0_LSL_r11[] = {
0x10, 0xcb, 0xce, 0x00 // sbc eq r12 r14 r0 LSL r11
};
const byte kInstruction_sbc_ge_r6_r4_r10_ROR_r13[] = {
0x7a, 0x6d, 0xc4, 0xa0 // sbc ge r6 r4 r10 ROR r13
};
const byte kInstruction_sbc_lt_r3_r7_r2_ASR_r5[] = {
0x52, 0x35, 0xc7, 0xb0 // sbc lt r3 r7 r2 ASR r5
};
const byte kInstruction_sbc_al_r9_r0_r12_ROR_r0[] = {
0x7c, 0x90, 0xc0, 0xe0 // sbc al r9 r0 r12 ROR r0
};
const byte kInstruction_sbc_le_r1_r9_r7_LSL_r12[] = {
0x17, 0x1c, 0xc9, 0xd0 // sbc le r1 r9 r7 LSL r12
};
const byte kInstruction_sbc_lt_r14_r7_r4_ASR_r7[] = {
0x54, 0xe7, 0xc7, 0xb0 // sbc lt r14 r7 r4 ASR r7
};
const byte kInstruction_sbc_ne_r4_r6_r9_LSR_r8[] = {
0x39, 0x48, 0xc6, 0x10 // sbc ne r4 r6 r9 LSR r8
};
const byte kInstruction_sbc_cc_r0_r5_r1_ASR_r6[] = {
0x51, 0x06, 0xc5, 0x30 // sbc cc r0 r5 r1 ASR r6
};
const byte kInstruction_sbc_cc_r2_r13_r2_ROR_r6[] = {
0x72, 0x26, 0xcd, 0x30 // sbc cc r2 r13 r2 ROR r6
};
const byte kInstruction_sbc_ge_r10_r0_r9_ROR_r6[] = {
0x79, 0xa6, 0xc0, 0xa0 // sbc ge r10 r0 r9 ROR r6
};
const byte kInstruction_sbc_gt_r8_r1_r11_LSR_r0[] = {
0x3b, 0x80, 0xc1, 0xc0 // sbc gt r8 r1 r11 LSR r0
};
const byte kInstruction_sbc_al_r14_r0_r9_LSL_r0[] = {
0x19, 0xe0, 0xc0, 0xe0 // sbc al r14 r0 r9 LSL r0
};
const byte kInstruction_sbc_hi_r12_r3_r12_ROR_r9[] = {
0x7c, 0xc9, 0xc3, 0x80 // sbc hi r12 r3 r12 ROR r9
};
const byte kInstruction_sbc_eq_r4_r12_r3_LSL_r2[] = {
0x13, 0x42, 0xcc, 0x00 // sbc eq r4 r12 r3 LSL r2
};
const byte kInstruction_sbc_ne_r5_r3_r4_LSL_r4[] = {
0x14, 0x54, 0xc3, 0x10 // sbc ne r5 r3 r4 LSL r4
};
const byte kInstruction_sbc_vc_r8_r6_r10_LSL_r11[] = {
0x1a, 0x8b, 0xc6, 0x70 // sbc vc r8 r6 r10 LSL r11
};
const byte kInstruction_sbc_lt_r0_r1_r4_ASR_r3[] = {
0x54, 0x03, 0xc1, 0xb0 // sbc lt r0 r1 r4 ASR r3
};
const byte kInstruction_sbc_le_r14_r4_r1_ROR_r7[] = {
0x71, 0xe7, 0xc4, 0xd0 // sbc le r14 r4 r1 ROR r7
};
const byte kInstruction_sbc_al_r12_r12_r5_LSL_r2[] = {
0x15, 0xc2, 0xcc, 0xe0 // sbc al r12 r12 r5 LSL r2
};
const byte kInstruction_sbc_eq_r10_r3_r10_ROR_r13[] = {
0x7a, 0xad, 0xc3, 0x00 // sbc eq r10 r3 r10 ROR r13
};
const byte kInstruction_sbc_ne_r7_r10_r1_LSR_r14[] = {
0x31, 0x7e, 0xca, 0x10 // sbc ne r7 r10 r1 LSR r14
};
const byte kInstruction_sbc_lt_r10_r4_r10_LSR_r5[] = {
0x3a, 0xa5, 0xc4, 0xb0 // sbc lt r10 r4 r10 LSR r5
};
const byte kInstruction_sbc_pl_r0_r14_r0_LSL_r2[] = {
0x10, 0x02, 0xce, 0x50 // sbc pl r0 r14 r0 LSL r2
};
const byte kInstruction_sbc_gt_r7_r4_r11_LSL_r3[] = {
0x1b, 0x73, 0xc4, 0xc0 // sbc gt r7 r4 r11 LSL r3
};
const byte kInstruction_sbc_cs_r8_r2_r1_LSR_r8[] = {
0x31, 0x88, 0xc2, 0x20 // sbc cs r8 r2 r1 LSR r8
};
const byte kInstruction_sbc_pl_r9_r11_r4_ASR_r7[] = {
0x54, 0x97, 0xcb, 0x50 // sbc pl r9 r11 r4 ASR r7
};
const byte kInstruction_sbc_cc_r9_r5_r12_ROR_r4[] = {
0x7c, 0x94, 0xc5, 0x30 // sbc cc r9 r5 r12 ROR r4
};
const byte kInstruction_sbc_vc_r0_r11_r3_LSR_r12[] = {
0x33, 0x0c, 0xcb, 0x70 // sbc vc r0 r11 r3 LSR r12
};
const byte kInstruction_sbc_gt_r6_r2_r4_LSR_r4[] = {
0x34, 0x64, 0xc2, 0xc0 // sbc gt r6 r2 r4 LSR r4
};
const byte kInstruction_sbc_lt_r4_r2_r0_LSL_r12[] = {
0x10, 0x4c, 0xc2, 0xb0 // sbc lt r4 r2 r0 LSL r12
};
const byte kInstruction_sbc_le_r9_r4_r13_ROR_r5[] = {
0x7d, 0x95, 0xc4, 0xd0 // sbc le r9 r4 r13 ROR r5
};
const byte kInstruction_sbc_vs_r9_r3_r8_LSR_r8[] = {
0x38, 0x98, 0xc3, 0x60 // sbc vs r9 r3 r8 LSR r8
};
const byte kInstruction_sbc_ne_r3_r8_r14_ROR_r8[] = {
0x7e, 0x38, 0xc8, 0x10 // sbc ne r3 r8 r14 ROR r8
};
const byte kInstruction_sbc_vc_r12_r13_r4_LSR_r9[] = {
0x34, 0xc9, 0xcd, 0x70 // sbc vc r12 r13 r4 LSR r9
};
const byte kInstruction_sbc_cc_r14_r0_r8_LSL_r1[] = {
0x18, 0xe1, 0xc0, 0x30 // sbc cc r14 r0 r8 LSL r1
};
const byte kInstruction_sbc_hi_r6_r3_r5_ASR_r9[] = {
0x55, 0x69, 0xc3, 0x80 // sbc hi r6 r3 r5 ASR r9
};
const byte kInstruction_sbc_ne_r14_r4_r3_LSL_r8[] = {
0x13, 0xe8, 0xc4, 0x10 // sbc ne r14 r4 r3 LSL r8
};
const byte kInstruction_sbc_ge_r1_r10_r13_LSR_r4[] = {
0x3d, 0x14, 0xca, 0xa0 // sbc ge r1 r10 r13 LSR r4
};
const byte kInstruction_sbc_vc_r12_r7_r6_ROR_r3[] = {
0x76, 0xc3, 0xc7, 0x70 // sbc vc r12 r7 r6 ROR r3
};
const byte kInstruction_sbc_gt_r0_r6_r7_ROR_r2[] = {
0x77, 0x02, 0xc6, 0xc0 // sbc gt r0 r6 r7 ROR r2
};
const byte kInstruction_sbc_al_r4_r6_r9_LSL_r0[] = {
0x19, 0x40, 0xc6, 0xe0 // sbc al r4 r6 r9 LSL r0
};
const byte kInstruction_sbc_ls_r1_r3_r11_LSR_r11[] = {
0x3b, 0x1b, 0xc3, 0x90 // sbc ls r1 r3 r11 LSR r11
};
const byte kInstruction_sbc_lt_r3_r11_r1_LSR_r14[] = {
0x31, 0x3e, 0xcb, 0xb0 // sbc lt r3 r11 r1 LSR r14
};
const byte kInstruction_sbc_vc_r6_r13_r7_ROR_r11[] = {
0x77, 0x6b, 0xcd, 0x70 // sbc vc r6 r13 r7 ROR r11
};
const byte kInstruction_sbc_vc_r5_r14_r13_ROR_r13[] = {
0x7d, 0x5d, 0xce, 0x70 // sbc vc r5 r14 r13 ROR r13
};
const byte kInstruction_sbc_vc_r1_r4_r11_LSL_r1[] = {
0x1b, 0x11, 0xc4, 0x70 // sbc vc r1 r4 r11 LSL r1
};
const byte kInstruction_sbc_ls_r7_r3_r5_LSR_r6[] = {
0x35, 0x76, 0xc3, 0x90 // sbc ls r7 r3 r5 LSR r6
};
const byte kInstruction_sbc_vc_r13_r8_r3_ASR_r4[] = {
0x53, 0xd4, 0xc8, 0x70 // sbc vc r13 r8 r3 ASR r4
};
const byte kInstruction_sbc_ls_r2_r3_r10_ROR_r11[] = {
0x7a, 0x2b, 0xc3, 0x90 // sbc ls r2 r3 r10 ROR r11
};
const byte kInstruction_sbc_ge_r6_r1_r12_ASR_r11[] = {
0x5c, 0x6b, 0xc1, 0xa0 // sbc ge r6 r1 r12 ASR r11
};
const byte kInstruction_sbc_lt_r3_r1_r1_ASR_r14[] = {
0x51, 0x3e, 0xc1, 0xb0 // sbc lt r3 r1 r1 ASR r14
};
const byte kInstruction_sbc_hi_r2_r7_r14_LSL_r12[] = {
0x1e, 0x2c, 0xc7, 0x80 // sbc hi r2 r7 r14 LSL r12
};
const byte kInstruction_sbc_ge_r13_r10_r10_LSL_r14[] = {
0x1a, 0xde, 0xca, 0xa0 // sbc ge r13 r10 r10 LSL r14
};
const byte kInstruction_sbc_le_r0_r1_r3_LSR_r3[] = {
0x33, 0x03, 0xc1, 0xd0 // sbc le r0 r1 r3 LSR r3
};
const byte kInstruction_sbc_vs_r10_r7_r7_LSR_r6[] = {
0x37, 0xa6, 0xc7, 0x60 // sbc vs r10 r7 r7 LSR r6
};
const byte kInstruction_sbc_al_r6_r3_r6_LSL_r7[] = {
0x16, 0x67, 0xc3, 0xe0 // sbc al r6 r3 r6 LSL r7
};
const byte kInstruction_sbc_ne_r3_r8_r14_ASR_r1[] = {
0x5e, 0x31, 0xc8, 0x10 // sbc ne r3 r8 r14 ASR r1
};
const byte kInstruction_sbc_cc_r4_r10_r4_LSR_r9[] = {
0x34, 0x49, 0xca, 0x30 // sbc cc r4 r10 r4 LSR r9
};
const byte kInstruction_sbc_cs_r4_r1_r5_LSR_r10[] = {
0x35, 0x4a, 0xc1, 0x20 // sbc cs r4 r1 r5 LSR r10
};
const byte kInstruction_sbc_eq_r7_r6_r1_LSL_r4[] = {
0x11, 0x74, 0xc6, 0x00 // sbc eq r7 r6 r1 LSL r4
};
const byte kInstruction_sbc_hi_r3_r7_r1_LSL_r5[] = {
0x11, 0x35, 0xc7, 0x80 // sbc hi r3 r7 r1 LSL r5
};
const byte kInstruction_sbc_al_r6_r11_r8_LSR_r12[] = {
0x38, 0x6c, 0xcb, 0xe0 // sbc al r6 r11 r8 LSR r12
};
const byte kInstruction_sbc_ls_r2_r5_r0_LSR_r5[] = {
0x30, 0x25, 0xc5, 0x90 // sbc ls r2 r5 r0 LSR r5
};
const byte kInstruction_sbc_pl_r4_r5_r13_LSL_r9[] = {
0x1d, 0x49, 0xc5, 0x50 // sbc pl r4 r5 r13 LSL r9
};
const byte kInstruction_sbc_lt_r13_r12_r0_ASR_r8[] = {
0x50, 0xd8, 0xcc, 0xb0 // sbc lt r13 r12 r0 ASR r8
};
const byte kInstruction_sbc_cc_r11_r5_r0_LSL_r12[] = {
0x10, 0xbc, 0xc5, 0x30 // sbc cc r11 r5 r0 LSL r12
};
const byte kInstruction_sbc_ne_r6_r2_r2_ROR_r0[] = {
0x72, 0x60, 0xc2, 0x10 // sbc ne r6 r2 r2 ROR r0
};
const byte kInstruction_sbc_ne_r9_r13_r12_ASR_r6[] = {
0x5c, 0x96, 0xcd, 0x10 // sbc ne r9 r13 r12 ASR r6
};
const byte kInstruction_sbc_cs_r8_r6_r10_ROR_r10[] = {
0x7a, 0x8a, 0xc6, 0x20 // sbc cs r8 r6 r10 ROR r10
};
const byte kInstruction_sbc_vs_r10_r6_r1_LSL_r6[] = {
0x11, 0xa6, 0xc6, 0x60 // sbc vs r10 r6 r1 LSL r6
};
const byte kInstruction_sbc_vc_r12_r0_r4_ASR_r10[] = {
0x54, 0xca, 0xc0, 0x70 // sbc vc r12 r0 r4 ASR r10
};
const byte kInstruction_sbc_cs_r10_r2_r11_ROR_r8[] = {
0x7b, 0xa8, 0xc2, 0x20 // sbc cs r10 r2 r11 ROR r8
};
const byte kInstruction_sbc_ne_r0_r9_r14_ASR_r14[] = {
0x5e, 0x0e, 0xc9, 0x10 // sbc ne r0 r9 r14 ASR r14
};
const byte kInstruction_sbc_eq_r0_r10_r1_ASR_r8[] = {
0x51, 0x08, 0xca, 0x00 // sbc eq r0 r10 r1 ASR r8
};
const byte kInstruction_sbc_gt_r0_r11_r3_LSR_r0[] = {
0x33, 0x00, 0xcb, 0xc0 // sbc gt r0 r11 r3 LSR r0
};
const byte kInstruction_sbc_al_r5_r11_r6_ROR_r14[] = {
0x76, 0x5e, 0xcb, 0xe0 // sbc al r5 r11 r6 ROR r14
};
const byte kInstruction_sbc_ls_r2_r11_r11_ROR_r2[] = {
0x7b, 0x22, 0xcb, 0x90 // sbc ls r2 r11 r11 ROR r2
};
const byte kInstruction_sbc_cs_r2_r11_r6_ROR_r11[] = {
0x76, 0x2b, 0xcb, 0x20 // sbc cs r2 r11 r6 ROR r11
};
const byte kInstruction_sbc_cs_r4_r9_r11_ASR_r5[] = {
0x5b, 0x45, 0xc9, 0x20 // sbc cs r4 r9 r11 ASR r5
};
const byte kInstruction_sbc_ls_r5_r0_r2_ASR_r3[] = {
0x52, 0x53, 0xc0, 0x90 // sbc ls r5 r0 r2 ASR r3
};
const byte kInstruction_sbc_cc_r14_r1_r13_LSR_r2[] = {
0x3d, 0xe2, 0xc1, 0x30 // sbc cc r14 r1 r13 LSR r2
};
const byte kInstruction_sbc_lt_r4_r5_r6_ASR_r0[] = {
0x56, 0x40, 0xc5, 0xb0 // sbc lt r4 r5 r6 ASR r0
};
const byte kInstruction_sbc_vc_r0_r12_r6_ASR_r6[] = {
0x56, 0x06, 0xcc, 0x70 // sbc vc r0 r12 r6 ASR r6
};
const byte kInstruction_sbc_pl_r3_r10_r4_LSR_r8[] = {
0x34, 0x38, 0xca, 0x50 // sbc pl r3 r10 r4 LSR r8
};
const byte kInstruction_sbc_cc_r10_r5_r10_ASR_r10[] = {
0x5a, 0xaa, 0xc5, 0x30 // sbc cc r10 r5 r10 ASR r10
};
const byte kInstruction_sbc_pl_r2_r14_r1_ASR_r10[] = {
0x51, 0x2a, 0xce, 0x50 // sbc pl r2 r14 r1 ASR r10
};
const byte kInstruction_sbc_eq_r12_r13_r8_ROR_r12[] = {
0x78, 0xcc, 0xcd, 0x00 // sbc eq r12 r13 r8 ROR r12
};
const byte kInstruction_sbc_gt_r9_r8_r2_LSL_r2[] = {
0x12, 0x92, 0xc8, 0xc0 // sbc gt r9 r8 r2 LSL r2
};
const byte kInstruction_sbc_al_r13_r10_r10_LSL_r9[] = {
0x1a, 0xd9, 0xca, 0xe0 // sbc al r13 r10 r10 LSL r9
};
const byte kInstruction_sbc_eq_r8_r8_r6_ROR_r14[] = {
0x76, 0x8e, 0xc8, 0x00 // sbc eq r8 r8 r6 ROR r14
};
const byte kInstruction_sbc_le_r14_r12_r4_ASR_r13[] = {
0x54, 0xed, 0xcc, 0xd0 // sbc le r14 r12 r4 ASR r13
};
const byte kInstruction_sbc_cc_r3_r6_r12_LSR_r2[] = {
0x3c, 0x32, 0xc6, 0x30 // sbc cc r3 r6 r12 LSR r2
};
const byte kInstruction_sbc_ls_r5_r14_r10_LSL_r6[] = {
0x1a, 0x56, 0xce, 0x90 // sbc ls r5 r14 r10 LSL r6
};
const byte kInstruction_sbc_hi_r12_r2_r1_ROR_r3[] = {
0x71, 0xc3, 0xc2, 0x80 // sbc hi r12 r2 r1 ROR r3
};
const byte kInstruction_sbc_vc_r7_r13_r1_LSL_r12[] = {
0x11, 0x7c, 0xcd, 0x70 // sbc vc r7 r13 r1 LSL r12
};
const byte kInstruction_sbc_cc_r0_r3_r13_LSL_r9[] = {
0x1d, 0x09, 0xc3, 0x30 // sbc cc r0 r3 r13 LSL r9
};
const byte kInstruction_sbc_hi_r0_r11_r5_LSL_r11[] = {
0x15, 0x0b, 0xcb, 0x80 // sbc hi r0 r11 r5 LSL r11
};
const byte kInstruction_sbc_ge_r9_r6_r14_LSR_r14[] = {
0x3e, 0x9e, 0xc6, 0xa0 // sbc ge r9 r6 r14 LSR r14
};
const byte kInstruction_sbc_vc_r2_r5_r2_ROR_r12[] = {
0x72, 0x2c, 0xc5, 0x70 // sbc vc r2 r5 r2 ROR r12
};
const byte kInstruction_sbc_mi_r9_r6_r9_ASR_r13[] = {
0x59, 0x9d, 0xc6, 0x40 // sbc mi r9 r6 r9 ASR r13
};
const byte kInstruction_sbc_pl_r1_r3_r10_ASR_r2[] = {
0x5a, 0x12, 0xc3, 0x50 // sbc pl r1 r3 r10 ASR r2
};
const byte kInstruction_sbc_le_r10_r9_r7_LSL_r4[] = {
0x17, 0xa4, 0xc9, 0xd0 // sbc le r10 r9 r7 LSL r4
};
const byte kInstruction_sbc_hi_r7_r4_r10_LSR_r6[] = {
0x3a, 0x76, 0xc4, 0x80 // sbc hi r7 r4 r10 LSR r6
};
const byte kInstruction_sbc_cc_r6_r8_r13_LSR_r3[] = {
0x3d, 0x63, 0xc8, 0x30 // sbc cc r6 r8 r13 LSR r3
};
const byte kInstruction_sbc_cs_r4_r9_r6_ASR_r0[] = {
0x56, 0x40, 0xc9, 0x20 // sbc cs r4 r9 r6 ASR r0
};
const byte kInstruction_sbc_ls_r0_r2_r4_ASR_r8[] = {
0x54, 0x08, 0xc2, 0x90 // sbc ls r0 r2 r4 ASR r8
};
const byte kInstruction_sbc_hi_r11_r5_r11_LSR_r1[] = {
0x3b, 0xb1, 0xc5, 0x80 // sbc hi r11 r5 r11 LSR r1
};
const byte kInstruction_sbc_vc_r0_r3_r6_LSR_r7[] = {
0x36, 0x07, 0xc3, 0x70 // sbc vc r0 r3 r6 LSR r7
};
const byte kInstruction_sbc_cs_r13_r10_r8_LSL_r6[] = {
0x18, 0xd6, 0xca, 0x20 // sbc cs r13 r10 r8 LSL r6
};
const byte kInstruction_sbc_al_r12_r12_r10_ASR_r13[] = {
0x5a, 0xcd, 0xcc, 0xe0 // sbc al r12 r12 r10 ASR r13
};
const byte kInstruction_sbc_ge_r7_r7_r2_ASR_r8[] = {
0x52, 0x78, 0xc7, 0xa0 // sbc ge r7 r7 r2 ASR r8
};
const byte kInstruction_sbc_ne_r10_r7_r6_LSL_r14[] = {
0x16, 0xae, 0xc7, 0x10 // sbc ne r10 r7 r6 LSL r14
};
const byte kInstruction_sbc_cs_r9_r9_r14_ROR_r0[] = {
0x7e, 0x90, 0xc9, 0x20 // sbc cs r9 r9 r14 ROR r0
};
const byte kInstruction_sbc_lt_r3_r12_r0_ASR_r12[] = {
0x50, 0x3c, 0xcc, 0xb0 // sbc lt r3 r12 r0 ASR r12
};
const byte kInstruction_sbc_ne_r6_r9_r3_ASR_r11[] = {
0x53, 0x6b, 0xc9, 0x10 // sbc ne r6 r9 r3 ASR r11
};
const byte kInstruction_sbc_vc_r4_r7_r7_ASR_r7[] = {
0x57, 0x47, 0xc7, 0x70 // sbc vc r4 r7 r7 ASR r7
};
const byte kInstruction_sbc_ne_r0_r9_r5_LSR_r14[] = {
0x35, 0x0e, 0xc9, 0x10 // sbc ne r0 r9 r5 LSR r14
};
const byte kInstruction_sbc_hi_r8_r13_r1_ROR_r0[] = {
0x71, 0x80, 0xcd, 0x80 // sbc hi r8 r13 r1 ROR r0
};
const byte kInstruction_sbc_cc_r6_r1_r7_ROR_r5[] = {
0x77, 0x65, 0xc1, 0x30 // sbc cc r6 r1 r7 ROR r5
};
const byte kInstruction_sbc_vc_r7_r13_r2_LSL_r4[] = {
0x12, 0x74, 0xcd, 0x70 // sbc vc r7 r13 r2 LSL r4
};
const byte kInstruction_sbc_al_r4_r2_r3_ROR_r10[] = {
0x73, 0x4a, 0xc2, 0xe0 // sbc al r4 r2 r3 ROR r10
};
const byte kInstruction_sbc_ls_r0_r7_r3_LSR_r12[] = {
0x33, 0x0c, 0xc7, 0x90 // sbc ls r0 r7 r3 LSR r12
};
const byte kInstruction_sbc_ls_r5_r8_r8_ASR_r13[] = {
0x58, 0x5d, 0xc8, 0x90 // sbc ls r5 r8 r8 ASR r13
};
const byte kInstruction_sbc_gt_r0_r6_r12_ASR_r14[] = {
0x5c, 0x0e, 0xc6, 0xc0 // sbc gt r0 r6 r12 ASR r14
};
const byte kInstruction_sbc_vs_r7_r13_r14_LSR_r11[] = {
0x3e, 0x7b, 0xcd, 0x60 // sbc vs r7 r13 r14 LSR r11
};
const byte kInstruction_sbc_mi_r12_r9_r11_LSL_r13[] = {
0x1b, 0xcd, 0xc9, 0x40 // sbc mi r12 r9 r11 LSL r13
};
const byte kInstruction_sbc_ge_r0_r0_r7_ROR_r13[] = {
0x77, 0x0d, 0xc0, 0xa0 // sbc ge r0 r0 r7 ROR r13
};
const byte kInstruction_sbc_hi_r14_r12_r6_LSR_r8[] = {
0x36, 0xe8, 0xcc, 0x80 // sbc hi r14 r12 r6 LSR r8
};
const byte kInstruction_sbc_cs_r0_r3_r6_LSL_r6[] = {
0x16, 0x06, 0xc3, 0x20 // sbc cs r0 r3 r6 LSL r6
};
const byte kInstruction_sbc_al_r6_r9_r4_ASR_r3[] = {
0x54, 0x63, 0xc9, 0xe0 // sbc al r6 r9 r4 ASR r3
};
const byte kInstruction_sbc_ls_r5_r6_r1_LSR_r3[] = {
0x31, 0x53, 0xc6, 0x90 // sbc ls r5 r6 r1 LSR r3
};
const byte kInstruction_sbc_ls_r3_r6_r14_ROR_r7[] = {
0x7e, 0x37, 0xc6, 0x90 // sbc ls r3 r6 r14 ROR r7
};
const byte kInstruction_sbc_le_r10_r5_r1_ASR_r12[] = {
0x51, 0xac, 0xc5, 0xd0 // sbc le r10 r5 r1 ASR r12
};
const byte kInstruction_sbc_hi_r3_r6_r10_ASR_r5[] = {
0x5a, 0x35, 0xc6, 0x80 // sbc hi r3 r6 r10 ASR r5
};
const byte kInstruction_sbc_mi_r9_r3_r5_ROR_r8[] = {
0x75, 0x98, 0xc3, 0x40 // sbc mi r9 r3 r5 ROR r8
};
const byte kInstruction_sbc_hi_r10_r13_r8_ROR_r11[] = {
0x78, 0xab, 0xcd, 0x80 // sbc hi r10 r13 r8 ROR r11
};
const byte kInstruction_sbc_al_r11_r14_r2_ROR_r1[] = {
0x72, 0xb1, 0xce, 0xe0 // sbc al r11 r14 r2 ROR r1
};
const byte kInstruction_sbc_gt_r12_r8_r0_ROR_r11[] = {
0x70, 0xcb, 0xc8, 0xc0 // sbc gt r12 r8 r0 ROR r11
};
const byte kInstruction_sbc_vc_r1_r0_r1_ROR_r9[] = {
0x71, 0x19, 0xc0, 0x70 // sbc vc r1 r0 r1 ROR r9
};
const byte kInstruction_sbc_mi_r6_r6_r3_ASR_r5[] = {
0x53, 0x65, 0xc6, 0x40 // sbc mi r6 r6 r3 ASR r5
};
const byte kInstruction_sbc_ge_r12_r12_r4_ROR_r9[] = {
0x74, 0xc9, 0xcc, 0xa0 // sbc ge r12 r12 r4 ROR r9
};
const byte kInstruction_sbc_ls_r4_r6_r9_ASR_r6[] = {
0x59, 0x46, 0xc6, 0x90 // sbc ls r4 r6 r9 ASR r6
};
const byte kInstruction_sbc_pl_r11_r3_r4_LSR_r9[] = {
0x34, 0xb9, 0xc3, 0x50 // sbc pl r11 r3 r4 LSR r9
};
const byte kInstruction_sbc_hi_r0_r2_r2_ROR_r7[] = {
0x72, 0x07, 0xc2, 0x80 // sbc hi r0 r2 r2 ROR r7
};
const byte kInstruction_sbc_pl_r3_r12_r0_ASR_r2[] = {
0x50, 0x32, 0xcc, 0x50 // sbc pl r3 r12 r0 ASR r2
};
const byte kInstruction_sbc_ne_r6_r0_r9_LSL_r4[] = {
0x19, 0x64, 0xc0, 0x10 // sbc ne r6 r0 r9 LSL r4
};
const byte kInstruction_sbc_vc_r1_r2_r6_ROR_r13[] = {
0x76, 0x1d, 0xc2, 0x70 // sbc vc r1 r2 r6 ROR r13
};
const byte kInstruction_sbc_ge_r9_r1_r12_LSL_r14[] = {
0x1c, 0x9e, 0xc1, 0xa0 // sbc ge r9 r1 r12 LSL r14
};
const byte kInstruction_sbc_pl_r13_r9_r6_ROR_r14[] = {
0x76, 0xde, 0xc9, 0x50 // sbc pl r13 r9 r6 ROR r14
};
const byte kInstruction_sbc_gt_r0_r13_r13_LSL_r9[] = {
0x1d, 0x09, 0xcd, 0xc0 // sbc gt r0 r13 r13 LSL r9
};
const byte kInstruction_sbc_mi_r13_r5_r5_ASR_r8[] = {
0x55, 0xd8, 0xc5, 0x40 // sbc mi r13 r5 r5 ASR r8
};
const byte kInstruction_sbc_gt_r1_r4_r0_LSL_r6[] = {
0x10, 0x16, 0xc4, 0xc0 // sbc gt r1 r4 r0 LSL r6
};
const byte kInstruction_sbc_ls_r5_r4_r7_ROR_r4[] = {
0x77, 0x54, 0xc4, 0x90 // sbc ls r5 r4 r7 ROR r4
};
const byte kInstruction_sbc_vc_r8_r8_r0_ROR_r9[] = {
0x70, 0x89, 0xc8, 0x70 // sbc vc r8 r8 r0 ROR r9
};
const byte kInstruction_sbc_mi_r12_r12_r10_ROR_r8[] = {
0x7a, 0xc8, 0xcc, 0x40 // sbc mi r12 r12 r10 ROR r8
};
const byte kInstruction_sbc_hi_r6_r6_r6_LSL_r2[] = {
0x16, 0x62, 0xc6, 0x80 // sbc hi r6 r6 r6 LSL r2
};
const byte kInstruction_sbc_le_r7_r10_r14_LSL_r1[] = {
0x1e, 0x71, 0xca, 0xd0 // sbc le r7 r10 r14 LSL r1
};
const byte kInstruction_sbc_ne_r13_r10_r6_ASR_r9[] = {
0x56, 0xd9, 0xca, 0x10 // sbc ne r13 r10 r6 ASR r9
};
const byte kInstruction_sbc_ne_r8_r8_r2_LSR_r13[] = {
0x32, 0x8d, 0xc8, 0x10 // sbc ne r8 r8 r2 LSR r13
};
const byte kInstruction_sbc_mi_r0_r10_r14_ROR_r12[] = {
0x7e, 0x0c, 0xca, 0x40 // sbc mi r0 r10 r14 ROR r12
};
const byte kInstruction_sbc_cc_r11_r14_r4_LSL_r5[] = {
0x14, 0xb5, 0xce, 0x30 // sbc cc r11 r14 r4 LSL r5
};
const byte kInstruction_sbc_cc_r3_r6_r3_ROR_r4[] = {
0x73, 0x34, 0xc6, 0x30 // sbc cc r3 r6 r3 ROR r4
};
const byte kInstruction_sbc_mi_r11_r1_r7_LSR_r7[] = {
0x37, 0xb7, 0xc1, 0x40 // sbc mi r11 r1 r7 LSR r7
};
const byte kInstruction_sbc_vs_r12_r2_r2_LSL_r12[] = {
0x12, 0xcc, 0xc2, 0x60 // sbc vs r12 r2 r2 LSL r12
};
const byte kInstruction_sbc_pl_r2_r2_r6_LSR_r0[] = {
0x36, 0x20, 0xc2, 0x50 // sbc pl r2 r2 r6 LSR r0
};
const byte kInstruction_sbc_gt_r11_r12_r7_LSR_r12[] = {
0x37, 0xbc, 0xcc, 0xc0 // sbc gt r11 r12 r7 LSR r12
};
const byte kInstruction_sbc_al_r13_r4_r4_ASR_r12[] = {
0x54, 0xdc, 0xc4, 0xe0 // sbc al r13 r4 r4 ASR r12
};
const byte kInstruction_sbc_le_r9_r1_r9_ROR_r1[] = {
0x79, 0x91, 0xc1, 0xd0 // sbc le r9 r1 r9 ROR r1
};
const byte kInstruction_sbc_le_r1_r12_r8_ASR_r14[] = {
0x58, 0x1e, 0xcc, 0xd0 // sbc le r1 r12 r8 ASR r14
};
const byte kInstruction_sbc_cs_r1_r0_r7_ROR_r13[] = {
0x77, 0x1d, 0xc0, 0x20 // sbc cs r1 r0 r7 ROR r13
};
const byte kInstruction_sbc_le_r0_r7_r7_ROR_r5[] = {
0x77, 0x05, 0xc7, 0xd0 // sbc le r0 r7 r7 ROR r5
};
const byte kInstruction_sbc_hi_r6_r5_r7_ROR_r4[] = {
0x77, 0x64, 0xc5, 0x80 // sbc hi r6 r5 r7 ROR r4
};
const byte kInstruction_sbc_eq_r6_r14_r13_ASR_r1[] = {
0x5d, 0x61, 0xce, 0x00 // sbc eq r6 r14 r13 ASR r1
};
const byte kInstruction_sbc_lt_r1_r14_r13_LSR_r13[] = {
0x3d, 0x1d, 0xce, 0xb0 // sbc lt r1 r14 r13 LSR r13
};
const byte kInstruction_sbc_vs_r13_r1_r2_ROR_r6[] = {
0x72, 0xd6, 0xc1, 0x60 // sbc vs r13 r1 r2 ROR r6
};
const byte kInstruction_sbc_gt_r11_r7_r8_ASR_r3[] = {
0x58, 0xb3, 0xc7, 0xc0 // sbc gt r11 r7 r8 ASR r3
};
const byte kInstruction_sbc_hi_r9_r5_r8_ASR_r8[] = {
0x58, 0x98, 0xc5, 0x80 // sbc hi r9 r5 r8 ASR r8
};
const byte kInstruction_sbc_lt_r10_r9_r5_LSL_r8[] = {
0x15, 0xa8, 0xc9, 0xb0 // sbc lt r10 r9 r5 LSL r8
};
const byte kInstruction_sbc_vs_r6_r1_r2_LSL_r4[] = {
0x12, 0x64, 0xc1, 0x60 // sbc vs r6 r1 r2 LSL r4
};
const byte kInstruction_sbc_pl_r13_r4_r10_LSR_r12[] = {
0x3a, 0xdc, 0xc4, 0x50 // sbc pl r13 r4 r10 LSR r12
};
const byte kInstruction_sbc_cs_r9_r8_r8_LSL_r6[] = {
0x18, 0x96, 0xc8, 0x20 // sbc cs r9 r8 r8 LSL r6
};
const byte kInstruction_sbc_ne_r1_r7_r0_ASR_r2[] = {
0x50, 0x12, 0xc7, 0x10 // sbc ne r1 r7 r0 ASR r2
};
const byte kInstruction_sbc_cc_r6_r3_r9_ASR_r3[] = {
0x59, 0x63, 0xc3, 0x30 // sbc cc r6 r3 r9 ASR r3
};
const byte kInstruction_sbc_hi_r13_r14_r7_ROR_r13[] = {
0x77, 0xdd, 0xce, 0x80 // sbc hi r13 r14 r7 ROR r13
};
const byte kInstruction_sbc_vc_r7_r11_r0_LSR_r8[] = {
0x30, 0x78, 0xcb, 0x70 // sbc vc r7 r11 r0 LSR r8
};
const byte kInstruction_sbc_al_r3_r2_r7_LSL_r12[] = {
0x17, 0x3c, 0xc2, 0xe0 // sbc al r3 r2 r7 LSL r12
};
const byte kInstruction_sbc_lt_r0_r5_r5_LSR_r1[] = {
0x35, 0x01, 0xc5, 0xb0 // sbc lt r0 r5 r5 LSR r1
};
const byte kInstruction_sbc_ge_r10_r10_r4_ROR_r11[] = {
0x74, 0xab, 0xca, 0xa0 // sbc ge r10 r10 r4 ROR r11
};
const byte kInstruction_sbc_ne_r13_r9_r1_ROR_r12[] = {
0x71, 0xdc, 0xc9, 0x10 // sbc ne r13 r9 r1 ROR r12
};
const byte kInstruction_sbc_eq_r6_r6_r2_ROR_r3[] = {
0x72, 0x63, 0xc6, 0x00 // sbc eq r6 r6 r2 ROR r3
};
const byte kInstruction_sbc_gt_r0_r4_r1_ROR_r5[] = {
0x71, 0x05, 0xc4, 0xc0 // sbc gt r0 r4 r1 ROR r5
};
const byte kInstruction_sbc_lt_r5_r8_r0_ROR_r0[] = {
0x70, 0x50, 0xc8, 0xb0 // sbc lt r5 r8 r0 ROR r0
};
const byte kInstruction_sbc_cs_r5_r13_r2_LSR_r8[] = {
0x32, 0x58, 0xcd, 0x20 // sbc cs r5 r13 r2 LSR r8
};
const byte kInstruction_sbc_le_r7_r13_r2_LSL_r7[] = {
0x12, 0x77, 0xcd, 0xd0 // sbc le r7 r13 r2 LSL r7
};
const byte kInstruction_sbc_gt_r7_r1_r3_LSL_r1[] = {
0x13, 0x71, 0xc1, 0xc0 // sbc gt r7 r1 r3 LSL r1
};
const byte kInstruction_sbc_vc_r4_r13_r10_ROR_r8[] = {
0x7a, 0x48, 0xcd, 0x70 // sbc vc r4 r13 r10 ROR r8
};
const byte kInstruction_sbc_eq_r2_r8_r11_ROR_r4[] = {
0x7b, 0x24, 0xc8, 0x00 // sbc eq r2 r8 r11 ROR r4
};
const byte kInstruction_sbc_le_r10_r1_r6_LSR_r9[] = {
0x36, 0xa9, 0xc1, 0xd0 // sbc le r10 r1 r6 LSR r9
};
const byte kInstruction_sbc_ge_r5_r1_r9_ASR_r10[] = {
0x59, 0x5a, 0xc1, 0xa0 // sbc ge r5 r1 r9 ASR r10
};
const byte kInstruction_sbc_al_r1_r5_r5_LSR_r7[] = {
0x35, 0x17, 0xc5, 0xe0 // sbc al r1 r5 r5 LSR r7
};
const byte kInstruction_sbc_cs_r2_r13_r5_LSR_r8[] = {
0x35, 0x28, 0xcd, 0x20 // sbc cs r2 r13 r5 LSR r8
};
const byte kInstruction_sbc_le_r6_r6_r3_ROR_r3[] = {
0x73, 0x63, 0xc6, 0xd0 // sbc le r6 r6 r3 ROR r3
};
const byte kInstruction_sbc_le_r5_r1_r7_ROR_r12[] = {
0x77, 0x5c, 0xc1, 0xd0 // sbc le r5 r1 r7 ROR r12
};
const byte kInstruction_sbc_cc_r9_r3_r9_ASR_r4[] = {
0x59, 0x94, 0xc3, 0x30 // sbc cc r9 r3 r9 ASR r4
};
const byte kInstruction_sbc_mi_r6_r2_r9_LSL_r5[] = {
0x19, 0x65, 0xc2, 0x40 // sbc mi r6 r2 r9 LSL r5
};
const byte kInstruction_sbc_cc_r5_r0_r4_ASR_r12[] = {
0x54, 0x5c, 0xc0, 0x30 // sbc cc r5 r0 r4 ASR r12
};
const byte kInstruction_sbc_vc_r8_r13_r12_LSL_r11[] = {
0x1c, 0x8b, 0xcd, 0x70 // sbc vc r8 r13 r12 LSL r11
};
const byte kInstruction_sbc_lt_r7_r14_r9_LSR_r11[] = {
0x39, 0x7b, 0xce, 0xb0 // sbc lt r7 r14 r9 LSR r11
};
const byte kInstruction_sbc_cs_r1_r5_r3_ASR_r1[] = {
0x53, 0x11, 0xc5, 0x20 // sbc cs r1 r5 r3 ASR r1
};
const byte kInstruction_sbc_lt_r14_r11_r6_ASR_r9[] = {
0x56, 0xe9, 0xcb, 0xb0 // sbc lt r14 r11 r6 ASR r9
};
const byte kInstruction_sbc_gt_r10_r5_r13_LSR_r3[] = {
0x3d, 0xa3, 0xc5, 0xc0 // sbc gt r10 r5 r13 LSR r3
};
const byte kInstruction_sbc_cc_r6_r4_r12_LSL_r4[] = {
0x1c, 0x64, 0xc4, 0x30 // sbc cc r6 r4 r12 LSL r4
};
const byte kInstruction_sbc_ne_r2_r12_r10_ROR_r11[] = {
0x7a, 0x2b, 0xcc, 0x10 // sbc ne r2 r12 r10 ROR r11
};
const byte kInstruction_sbc_eq_r8_r0_r6_ASR_r10[] = {
0x56, 0x8a, 0xc0, 0x00 // sbc eq r8 r0 r6 ASR r10
};
const byte kInstruction_sbc_cc_r14_r3_r14_LSR_r7[] = {
0x3e, 0xe7, 0xc3, 0x30 // sbc cc r14 r3 r14 LSR r7
};
const byte kInstruction_sbc_lt_r1_r10_r1_ASR_r13[] = {
0x51, 0x1d, 0xca, 0xb0 // sbc lt r1 r10 r1 ASR r13
};
const byte kInstruction_sbc_cc_r14_r3_r0_LSL_r12[] = {
0x10, 0xec, 0xc3, 0x30 // sbc cc r14 r3 r0 LSL r12
};
const byte kInstruction_sbc_vs_r8_r10_r7_LSL_r2[] = {
0x17, 0x82, 0xca, 0x60 // sbc vs r8 r10 r7 LSL r2
};
const byte kInstruction_sbc_ls_r5_r6_r3_ASR_r2[] = {
0x53, 0x52, 0xc6, 0x90 // sbc ls r5 r6 r3 ASR r2
};
const byte kInstruction_sbc_vc_r11_r5_r13_LSL_r10[] = {
0x1d, 0xba, 0xc5, 0x70 // sbc vc r11 r5 r13 LSL r10
};
const byte kInstruction_sbc_hi_r2_r10_r7_LSR_r0[] = {
0x37, 0x20, 0xca, 0x80 // sbc hi r2 r10 r7 LSR r0
};
const byte kInstruction_sbc_ne_r5_r6_r8_ASR_r4[] = {
0x58, 0x54, 0xc6, 0x10 // sbc ne r5 r6 r8 ASR r4
};
const byte kInstruction_sbc_cs_r3_r12_r8_ASR_r5[] = {
0x58, 0x35, 0xcc, 0x20 // sbc cs r3 r12 r8 ASR r5
};
const byte kInstruction_sbc_ge_r3_r4_r4_LSR_r0[] = {
0x34, 0x30, 0xc4, 0xa0 // sbc ge r3 r4 r4 LSR r0
};
const byte kInstruction_sbc_ge_r13_r13_r6_ROR_r13[] = {
0x76, 0xdd, 0xcd, 0xa0 // sbc ge r13 r13 r6 ROR r13
};
const byte kInstruction_sbc_eq_r4_r9_r0_LSL_r9[] = {
0x10, 0x49, 0xc9, 0x00 // sbc eq r4 r9 r0 LSL r9
};
const byte kInstruction_sbc_le_r7_r3_r1_ROR_r8[] = {
0x71, 0x78, 0xc3, 0xd0 // sbc le r7 r3 r1 ROR r8
};
const byte kInstruction_sbc_gt_r9_r2_r5_LSL_r4[] = {
0x15, 0x94, 0xc2, 0xc0 // sbc gt r9 r2 r5 LSL r4
};
const byte kInstruction_sbc_gt_r10_r12_r9_ROR_r12[] = {
0x79, 0xac, 0xcc, 0xc0 // sbc gt r10 r12 r9 ROR r12
};
const byte kInstruction_sbc_hi_r4_r9_r6_LSR_r14[] = {
0x36, 0x4e, 0xc9, 0x80 // sbc hi r4 r9 r6 LSR r14
};
const byte kInstruction_sbc_pl_r1_r10_r9_LSR_r8[] = {
0x39, 0x18, 0xca, 0x50 // sbc pl r1 r10 r9 LSR r8
};
const byte kInstruction_sbc_mi_r0_r11_r2_ROR_r13[] = {
0x72, 0x0d, 0xcb, 0x40 // sbc mi r0 r11 r2 ROR r13
};
const byte kInstruction_sbc_ge_r14_r5_r4_ASR_r2[] = {
0x54, 0xe2, 0xc5, 0xa0 // sbc ge r14 r5 r4 ASR r2
};
const byte kInstruction_sbc_vc_r7_r8_r9_ROR_r10[] = {
0x79, 0x7a, 0xc8, 0x70 // sbc vc r7 r8 r9 ROR r10
};
const byte kInstruction_sbc_cs_r3_r1_r0_ROR_r7[] = {
0x70, 0x37, 0xc1, 0x20 // sbc cs r3 r1 r0 ROR r7
};
const byte kInstruction_sbc_hi_r9_r11_r4_ASR_r14[] = {
0x54, 0x9e, 0xcb, 0x80 // sbc hi r9 r11 r4 ASR r14
};
const byte kInstruction_sbc_mi_r3_r8_r6_LSR_r12[] = {
0x36, 0x3c, 0xc8, 0x40 // sbc mi r3 r8 r6 LSR r12
};
const byte kInstruction_sbc_vc_r5_r5_r6_LSL_r1[] = {
0x16, 0x51, 0xc5, 0x70 // sbc vc r5 r5 r6 LSL r1
};
const byte kInstruction_sbc_mi_r4_r8_r1_ASR_r3[] = {
0x51, 0x43, 0xc8, 0x40 // sbc mi r4 r8 r1 ASR r3
};
const byte kInstruction_sbc_le_r6_r0_r0_LSL_r0[] = {
0x10, 0x60, 0xc0, 0xd0 // sbc le r6 r0 r0 LSL r0
};
const byte kInstruction_sbc_hi_r8_r11_r8_LSL_r14[] = {
0x18, 0x8e, 0xcb, 0x80 // sbc hi r8 r11 r8 LSL r14
};
const byte kInstruction_sbc_gt_r14_r8_r12_ASR_r13[] = {
0x5c, 0xed, 0xc8, 0xc0 // sbc gt r14 r8 r12 ASR r13
};
const byte kInstruction_sbc_ge_r7_r7_r4_ROR_r7[] = {
0x74, 0x77, 0xc7, 0xa0 // sbc ge r7 r7 r4 ROR r7
};
const byte kInstruction_sbc_eq_r11_r4_r13_LSL_r3[] = {
0x1d, 0xb3, 0xc4, 0x00 // sbc eq r11 r4 r13 LSL r3
};
const byte kInstruction_sbc_eq_r3_r6_r6_LSL_r10[] = {
0x16, 0x3a, 0xc6, 0x00 // sbc eq r3 r6 r6 LSL r10
};
const byte kInstruction_sbc_al_r3_r10_r11_ROR_r12[] = {
0x7b, 0x3c, 0xca, 0xe0 // sbc al r3 r10 r11 ROR r12
};
const byte kInstruction_sbc_pl_r13_r7_r8_LSL_r13[] = {
0x18, 0xdd, 0xc7, 0x50 // sbc pl r13 r7 r8 LSL r13
};
const byte kInstruction_sbc_pl_r9_r2_r11_LSR_r2[] = {
0x3b, 0x92, 0xc2, 0x50 // sbc pl r9 r2 r11 LSR r2
};
const byte kInstruction_sbc_al_r3_r12_r8_LSR_r2[] = {
0x38, 0x32, 0xcc, 0xe0 // sbc al r3 r12 r8 LSR r2
};
const byte kInstruction_sbc_ne_r4_r14_r6_ROR_r0[] = {
0x76, 0x40, 0xce, 0x10 // sbc ne r4 r14 r6 ROR r0
};
const byte kInstruction_sbc_cs_r6_r14_r13_ASR_r3[] = {
0x5d, 0x63, 0xce, 0x20 // sbc cs r6 r14 r13 ASR r3
};
const byte kInstruction_sbc_pl_r10_r6_r8_LSR_r7[] = {
0x38, 0xa7, 0xc6, 0x50 // sbc pl r10 r6 r8 LSR r7
};
const byte kInstruction_sbc_ls_r10_r1_r12_ROR_r6[] = {
0x7c, 0xa6, 0xc1, 0x90 // sbc ls r10 r1 r12 ROR r6
};
const byte kInstruction_sbc_eq_r12_r0_r1_LSL_r9[] = {
0x11, 0xc9, 0xc0, 0x00 // sbc eq r12 r0 r1 LSL r9
};
const byte kInstruction_sbc_hi_r11_r14_r8_ROR_r6[] = {
0x78, 0xb6, 0xce, 0x80 // sbc hi r11 r14 r8 ROR r6
};
const byte kInstruction_sbc_vc_r9_r2_r5_LSL_r6[] = {
0x15, 0x96, 0xc2, 0x70 // sbc vc r9 r2 r5 LSL r6
};
const byte kInstruction_sbc_ne_r11_r8_r5_LSR_r11[] = {
0x35, 0xbb, 0xc8, 0x10 // sbc ne r11 r8 r5 LSR r11
};
const byte kInstruction_sbc_mi_r1_r12_r3_ASR_r5[] = {
0x53, 0x15, 0xcc, 0x40 // sbc mi r1 r12 r3 ASR r5
};
const byte kInstruction_sbc_pl_r14_r7_r1_ASR_r12[] = {
0x51, 0xec, 0xc7, 0x50 // sbc pl r14 r7 r1 ASR r12
};
const byte kInstruction_sbc_pl_r9_r4_r1_ASR_r1[] = {
0x51, 0x91, 0xc4, 0x50 // sbc pl r9 r4 r1 ASR r1
};
const byte kInstruction_sbc_ls_r11_r0_r5_ROR_r14[] = {
0x75, 0xbe, 0xc0, 0x90 // sbc ls r11 r0 r5 ROR r14
};
const byte kInstruction_sbc_lt_r13_r10_r14_ROR_r13[] = {
0x7e, 0xdd, 0xca, 0xb0 // sbc lt r13 r10 r14 ROR r13
};
const byte kInstruction_sbc_gt_r3_r14_r10_LSR_r4[] = {
0x3a, 0x34, 0xce, 0xc0 // sbc gt r3 r14 r10 LSR r4
};
const byte kInstruction_sbc_cc_r1_r0_r5_ROR_r7[] = {
0x75, 0x17, 0xc0, 0x30 // sbc cc r1 r0 r5 ROR r7
};
const byte kInstruction_sbc_hi_r2_r14_r0_LSR_r14[] = {
0x30, 0x2e, 0xce, 0x80 // sbc hi r2 r14 r0 LSR r14
};
const byte kInstruction_sbc_pl_r3_r7_r2_ASR_r9[] = {
0x52, 0x39, 0xc7, 0x50 // sbc pl r3 r7 r2 ASR r9
};
const byte kInstruction_sbc_eq_r7_r5_r0_ROR_r6[] = {
0x70, 0x76, 0xc5, 0x00 // sbc eq r7 r5 r0 ROR r6
};
const byte kInstruction_sbc_mi_r14_r9_r14_LSR_r5[] = {
0x3e, 0xe5, 0xc9, 0x40 // sbc mi r14 r9 r14 LSR r5
};
const byte kInstruction_sbc_mi_r6_r1_r1_LSL_r12[] = {
0x11, 0x6c, 0xc1, 0x40 // sbc mi r6 r1 r1 LSL r12
};
const byte kInstruction_sbc_ge_r12_r0_r8_LSR_r0[] = {
0x38, 0xc0, 0xc0, 0xa0 // sbc ge r12 r0 r8 LSR r0
};
const byte kInstruction_sbc_cc_r13_r8_r3_ROR_r7[] = {
0x73, 0xd7, 0xc8, 0x30 // sbc cc r13 r8 r3 ROR r7
};
const byte kInstruction_sbc_vs_r7_r9_r4_LSL_r11[] = {
0x14, 0x7b, 0xc9, 0x60 // sbc vs r7 r9 r4 LSL r11
};
const byte kInstruction_sbc_ge_r9_r10_r9_LSR_r5[] = {
0x39, 0x95, 0xca, 0xa0 // sbc ge r9 r10 r9 LSR r5
};
const byte kInstruction_sbc_ls_r5_r3_r0_LSR_r7[] = {
0x30, 0x57, 0xc3, 0x90 // sbc ls r5 r3 r0 LSR r7
};
const byte kInstruction_sbc_eq_r0_r6_r1_LSL_r11[] = {
0x11, 0x0b, 0xc6, 0x00 // sbc eq r0 r6 r1 LSL r11
};
const byte kInstruction_sbc_ge_r9_r7_r0_ROR_r11[] = {
0x70, 0x9b, 0xc7, 0xa0 // sbc ge r9 r7 r0 ROR r11
};
const byte kInstruction_sbc_mi_r4_r2_r3_LSL_r12[] = {
0x13, 0x4c, 0xc2, 0x40 // sbc mi r4 r2 r3 LSL r12
};
const byte kInstruction_sbc_hi_r7_r5_r0_ASR_r5[] = {
0x50, 0x75, 0xc5, 0x80 // sbc hi r7 r5 r0 ASR r5
};
const byte kInstruction_sbc_cc_r7_r13_r7_LSL_r14[] = {
0x17, 0x7e, 0xcd, 0x30 // sbc cc r7 r13 r7 LSL r14
};
const byte kInstruction_sbc_ne_r2_r11_r2_LSL_r14[] = {
0x12, 0x2e, 0xcb, 0x10 // sbc ne r2 r11 r2 LSL r14
};
const byte kInstruction_sbc_cc_r7_r5_r3_LSR_r11[] = {
0x33, 0x7b, 0xc5, 0x30 // sbc cc r7 r5 r3 LSR r11
};
const byte kInstruction_sbc_ge_r12_r0_r12_ASR_r10[] = {
0x5c, 0xca, 0xc0, 0xa0 // sbc ge r12 r0 r12 ASR r10
};
const byte kInstruction_sbc_al_r11_r0_r2_LSR_r11[] = {
0x32, 0xbb, 0xc0, 0xe0 // sbc al r11 r0 r2 LSR r11
};
const byte kInstruction_sbc_cc_r1_r12_r1_ROR_r1[] = {
0x71, 0x11, 0xcc, 0x30 // sbc cc r1 r12 r1 ROR r1
};
const byte kInstruction_sbc_ls_r5_r9_r6_ASR_r4[] = {
0x56, 0x54, 0xc9, 0x90 // sbc ls r5 r9 r6 ASR r4
};
const byte kInstruction_sbc_ne_r5_r13_r2_ROR_r12[] = {
0x72, 0x5c, 0xcd, 0x10 // sbc ne r5 r13 r2 ROR r12
};
const byte kInstruction_sbc_ge_r9_r10_r12_ROR_r10[] = {
0x7c, 0x9a, 0xca, 0xa0 // sbc ge r9 r10 r12 ROR r10
};
const byte kInstruction_sbc_cc_r10_r1_r8_LSR_r12[] = {
0x38, 0xac, 0xc1, 0x30 // sbc cc r10 r1 r8 LSR r12
};
const byte kInstruction_sbc_le_r9_r6_r11_ROR_r3[] = {
0x7b, 0x93, 0xc6, 0xd0 // sbc le r9 r6 r11 ROR r3
};
const byte kInstruction_sbc_le_r9_r9_r13_ASR_r5[] = {
0x5d, 0x95, 0xc9, 0xd0 // sbc le r9 r9 r13 ASR r5
};
const byte kInstruction_sbc_ge_r1_r12_r11_LSL_r12[] = {
0x1b, 0x1c, 0xcc, 0xa0 // sbc ge r1 r12 r11 LSL r12
};
const byte kInstruction_sbc_vs_r11_r4_r6_LSL_r10[] = {
0x16, 0xba, 0xc4, 0x60 // sbc vs r11 r4 r6 LSL r10
};
const byte kInstruction_sbc_vs_r3_r3_r1_ROR_r2[] = {
0x71, 0x32, 0xc3, 0x60 // sbc vs r3 r3 r1 ROR r2
};
const byte kInstruction_sbc_ne_r12_r8_r12_ASR_r11[] = {
0x5c, 0xcb, 0xc8, 0x10 // sbc ne r12 r8 r12 ASR r11
};
const byte kInstruction_sbc_pl_r4_r8_r1_ROR_r8[] = {
0x71, 0x48, 0xc8, 0x50 // sbc pl r4 r8 r1 ROR r8
};
const byte kInstruction_sbc_gt_r3_r11_r13_ROR_r9[] = {
0x7d, 0x39, 0xcb, 0xc0 // sbc gt r3 r11 r13 ROR r9
};
const byte kInstruction_sbc_pl_r6_r0_r3_LSR_r9[] = {
0x33, 0x69, 0xc0, 0x50 // sbc pl r6 r0 r3 LSR r9
};
const byte kInstruction_sbc_ne_r5_r7_r9_LSL_r10[] = {
0x19, 0x5a, 0xc7, 0x10 // sbc ne r5 r7 r9 LSL r10
};
const byte kInstruction_sbc_lt_r1_r12_r12_LSR_r8[] = {
0x3c, 0x18, 0xcc, 0xb0 // sbc lt r1 r12 r12 LSR r8
};
const byte kInstruction_sbc_cc_r2_r0_r0_ROR_r5[] = {
0x70, 0x25, 0xc0, 0x30 // sbc cc r2 r0 r0 ROR r5
};
const byte kInstruction_sbc_vc_r7_r11_r8_LSR_r14[] = {
0x38, 0x7e, 0xcb, 0x70 // sbc vc r7 r11 r8 LSR r14
};
const byte kInstruction_sbc_ge_r0_r11_r6_ROR_r10[] = {
0x76, 0x0a, 0xcb, 0xa0 // sbc ge r0 r11 r6 ROR r10
};
const byte kInstruction_sbc_vs_r0_r9_r1_LSR_r0[] = {
0x31, 0x00, 0xc9, 0x60 // sbc vs r0 r9 r1 LSR r0
};
const byte kInstruction_sbc_gt_r13_r7_r11_LSR_r1[] = {
0x3b, 0xd1, 0xc7, 0xc0 // sbc gt r13 r7 r11 LSR r1
};
const byte kInstruction_sbc_eq_r9_r10_r2_ROR_r12[] = {
0x72, 0x9c, 0xca, 0x00 // sbc eq r9 r10 r2 ROR r12
};
const byte kInstruction_sbc_eq_r0_r4_r0_LSR_r3[] = {
0x30, 0x03, 0xc4, 0x00 // sbc eq r0 r4 r0 LSR r3
};
const byte kInstruction_sbc_cs_r14_r2_r9_ASR_r12[] = {
0x59, 0xec, 0xc2, 0x20 // sbc cs r14 r2 r9 ASR r12
};
const byte kInstruction_sbc_lt_r9_r4_r9_ASR_r8[] = {
0x59, 0x98, 0xc4, 0xb0 // sbc lt r9 r4 r9 ASR r8
};
const byte kInstruction_sbc_vs_r6_r12_r3_LSL_r11[] = {
0x13, 0x6b, 0xcc, 0x60 // sbc vs r6 r12 r3 LSL r11
};
const byte kInstruction_sbc_ge_r9_r14_r10_ROR_r0[] = {
0x7a, 0x90, 0xce, 0xa0 // sbc ge r9 r14 r10 ROR r0
};
const byte kInstruction_sbc_pl_r10_r2_r5_LSL_r12[] = {
0x15, 0xac, 0xc2, 0x50 // sbc pl r10 r2 r5 LSL r12
};
const byte kInstruction_sbc_al_r8_r0_r6_ROR_r6[] = {
0x76, 0x86, 0xc0, 0xe0 // sbc al r8 r0 r6 ROR r6
};
const byte kInstruction_sbc_le_r9_r7_r7_LSR_r11[] = {
0x37, 0x9b, 0xc7, 0xd0 // sbc le r9 r7 r7 LSR r11
};
const byte kInstruction_sbc_vc_r3_r4_r5_LSR_r1[] = {
0x35, 0x31, 0xc4, 0x70 // sbc vc r3 r4 r5 LSR r1
};
const byte kInstruction_sbc_cc_r13_r1_r4_LSR_r11[] = {
0x34, 0xdb, 0xc1, 0x30 // sbc cc r13 r1 r4 LSR r11
};
const byte kInstruction_sbc_vc_r13_r4_r0_LSL_r10[] = {
0x10, 0xda, 0xc4, 0x70 // sbc vc r13 r4 r0 LSL r10
};
const byte kInstruction_sbc_vc_r5_r0_r1_LSR_r1[] = {
0x31, 0x51, 0xc0, 0x70 // sbc vc r5 r0 r1 LSR r1
};
const byte kInstruction_sbc_ls_r5_r11_r1_ASR_r9[] = {
0x51, 0x59, 0xcb, 0x90 // sbc ls r5 r11 r1 ASR r9
};
const byte kInstruction_sbc_vs_r3_r2_r8_ASR_r1[] = {
0x58, 0x31, 0xc2, 0x60 // sbc vs r3 r2 r8 ASR r1
};
const byte kInstruction_sbc_hi_r8_r4_r6_ASR_r4[] = {
0x56, 0x84, 0xc4, 0x80 // sbc hi r8 r4 r6 ASR r4
};
const byte kInstruction_sbc_mi_r11_r12_r14_ASR_r13[] = {
0x5e, 0xbd, 0xcc, 0x40 // sbc mi r11 r12 r14 ASR r13
};
const byte kInstruction_sbc_gt_r7_r12_r12_LSL_r14[] = {
0x1c, 0x7e, 0xcc, 0xc0 // sbc gt r7 r12 r12 LSL r14
};
const byte kInstruction_sbc_ge_r11_r4_r9_LSR_r7[] = {
0x39, 0xb7, 0xc4, 0xa0 // sbc ge r11 r4 r9 LSR r7
};
const byte kInstruction_sbc_vs_r0_r4_r10_LSL_r2[] = {
0x1a, 0x02, 0xc4, 0x60 // sbc vs r0 r4 r10 LSL r2
};
const byte kInstruction_sbc_pl_r6_r4_r13_ASR_r0[] = {
0x5d, 0x60, 0xc4, 0x50 // sbc pl r6 r4 r13 ASR r0
};
const byte kInstruction_sbc_eq_r2_r3_r11_ROR_r1[] = {
0x7b, 0x21, 0xc3, 0x00 // sbc eq r2 r3 r11 ROR r1
};
const byte kInstruction_sbc_vs_r10_r9_r0_LSL_r4[] = {
0x10, 0xa4, 0xc9, 0x60 // sbc vs r10 r9 r0 LSL r4
};
const byte kInstruction_sbc_cs_r0_r7_r10_LSL_r0[] = {
0x1a, 0x00, 0xc7, 0x20 // sbc cs r0 r7 r10 LSL r0
};
const byte kInstruction_sbc_eq_r11_r2_r3_ASR_r13[] = {
0x53, 0xbd, 0xc2, 0x00 // sbc eq r11 r2 r3 ASR r13
};
const byte kInstruction_sbc_eq_r14_r3_r7_ASR_r14[] = {
0x57, 0xee, 0xc3, 0x00 // sbc eq r14 r3 r7 ASR r14
};
const byte kInstruction_sbc_gt_r0_r2_r0_LSL_r12[] = {
0x10, 0x0c, 0xc2, 0xc0 // sbc gt r0 r2 r0 LSL r12
};
const byte kInstruction_sbc_mi_r0_r12_r6_LSR_r13[] = {
0x36, 0x0d, 0xcc, 0x40 // sbc mi r0 r12 r6 LSR r13
};
const byte kInstruction_sbc_gt_r4_r4_r9_LSR_r12[] = {
0x39, 0x4c, 0xc4, 0xc0 // sbc gt r4 r4 r9 LSR r12
};
const byte kInstruction_sbc_vc_r6_r7_r10_ROR_r2[] = {
0x7a, 0x62, 0xc7, 0x70 // sbc vc r6 r7 r10 ROR r2
};
const byte kInstruction_sbc_lt_r10_r8_r13_ROR_r13[] = {
0x7d, 0xad, 0xc8, 0xb0 // sbc lt r10 r8 r13 ROR r13
};
const byte kInstruction_sbc_lt_r13_r10_r4_ROR_r0[] = {
0x74, 0xd0, 0xca, 0xb0 // sbc lt r13 r10 r4 ROR r0
};
const byte kInstruction_sbc_pl_r1_r6_r0_LSR_r12[] = {
0x30, 0x1c, 0xc6, 0x50 // sbc pl r1 r6 r0 LSR r12
};
const byte kInstruction_sbc_ge_r14_r7_r1_LSR_r8[] = {
0x31, 0xe8, 0xc7, 0xa0 // sbc ge r14 r7 r1 LSR r8
};
const byte kInstruction_sbc_cc_r8_r13_r6_LSL_r13[] = {
0x16, 0x8d, 0xcd, 0x30 // sbc cc r8 r13 r6 LSL r13
};
const byte kInstruction_sbc_gt_r13_r4_r7_LSR_r2[] = {
0x37, 0xd2, 0xc4, 0xc0 // sbc gt r13 r4 r7 LSR r2
};
const byte kInstruction_sbc_eq_r11_r3_r5_LSR_r3[] = {
0x35, 0xb3, 0xc3, 0x00 // sbc eq r11 r3 r5 LSR r3
};
const byte kInstruction_sbc_vc_r8_r11_r2_ROR_r7[] = {
0x72, 0x87, 0xcb, 0x70 // sbc vc r8 r11 r2 ROR r7
};
const byte kInstruction_sbc_vc_r11_r2_r0_LSL_r2[] = {
0x10, 0xb2, 0xc2, 0x70 // sbc vc r11 r2 r0 LSL r2
};
const byte kInstruction_sbc_cs_r9_r11_r11_LSL_r11[] = {
0x1b, 0x9b, 0xcb, 0x20 // sbc cs r9 r11 r11 LSL r11
};
const byte kInstruction_sbc_ge_r14_r4_r12_LSL_r11[] = {
0x1c, 0xeb, 0xc4, 0xa0 // sbc ge r14 r4 r12 LSL r11
};
const byte kInstruction_sbc_vs_r4_r10_r3_LSL_r1[] = {
0x13, 0x41, 0xca, 0x60 // sbc vs r4 r10 r3 LSL r1
};
const byte kInstruction_sbc_mi_r13_r1_r8_LSR_r2[] = {
0x38, 0xd2, 0xc1, 0x40 // sbc mi r13 r1 r8 LSR r2
};
const byte kInstruction_sbc_le_r3_r13_r13_LSL_r8[] = {
0x1d, 0x38, 0xcd, 0xd0 // sbc le r3 r13 r13 LSL r8
};
const byte kInstruction_sbc_mi_r9_r12_r8_LSR_r14[] = {
0x38, 0x9e, 0xcc, 0x40 // sbc mi r9 r12 r8 LSR r14
};
const byte kInstruction_sbc_pl_r7_r11_r10_ASR_r2[] = {
0x5a, 0x72, 0xcb, 0x50 // sbc pl r7 r11 r10 ASR r2
};
const byte kInstruction_sbc_lt_r12_r2_r9_ASR_r5[] = {
0x59, 0xc5, 0xc2, 0xb0 // sbc lt r12 r2 r9 ASR r5
};
const byte kInstruction_sbc_gt_r13_r0_r5_LSL_r2[] = {
0x15, 0xd2, 0xc0, 0xc0 // sbc gt r13 r0 r5 LSL r2
};
const byte kInstruction_sbc_le_r5_r10_r9_ROR_r0[] = {
0x79, 0x50, 0xca, 0xd0 // sbc le r5 r10 r9 ROR r0
};
const byte kInstruction_sbc_lt_r6_r1_r4_ASR_r11[] = {
0x54, 0x6b, 0xc1, 0xb0 // sbc lt r6 r1 r4 ASR r11
};
const byte kInstruction_sbc_pl_r11_r5_r14_LSR_r4[] = {
0x3e, 0xb4, 0xc5, 0x50 // sbc pl r11 r5 r14 LSR r4
};
const byte kInstruction_sbc_eq_r9_r0_r6_ROR_r9[] = {
0x76, 0x99, 0xc0, 0x00 // sbc eq r9 r0 r6 ROR r9
};
const byte kInstruction_sbc_mi_r3_r11_r2_ASR_r4[] = {
0x52, 0x34, 0xcb, 0x40 // sbc mi r3 r11 r2 ASR r4
};
const byte kInstruction_sbc_pl_r13_r8_r0_ROR_r6[] = {
0x70, 0xd6, 0xc8, 0x50 // sbc pl r13 r8 r0 ROR r6
};
const byte kInstruction_sbc_vc_r8_r2_r6_ASR_r4[] = {
0x56, 0x84, 0xc2, 0x70 // sbc vc r8 r2 r6 ASR r4
};
const byte kInstruction_sbc_ge_r1_r0_r4_ASR_r1[] = {
0x54, 0x11, 0xc0, 0xa0 // sbc ge r1 r0 r4 ASR r1
};
const byte kInstruction_sbc_vc_r2_r4_r13_LSL_r13[] = {
0x1d, 0x2d, 0xc4, 0x70 // sbc vc r2 r4 r13 LSL r13
};
const byte kInstruction_sbc_lt_r4_r3_r5_ASR_r11[] = {
0x55, 0x4b, 0xc3, 0xb0 // sbc lt r4 r3 r5 ASR r11
};
const byte kInstruction_sbc_pl_r5_r12_r3_LSL_r4[] = {
0x13, 0x54, 0xcc, 0x50 // sbc pl r5 r12 r3 LSL r4
};
const byte kInstruction_sbc_pl_r14_r6_r6_LSR_r10[] = {
0x36, 0xea, 0xc6, 0x50 // sbc pl r14 r6 r6 LSR r10
};
const byte kInstruction_sbc_gt_r14_r13_r3_LSL_r9[] = {
0x13, 0xe9, 0xcd, 0xc0 // sbc gt r14 r13 r3 LSL r9
};
const byte kInstruction_sbc_pl_r10_r9_r4_LSL_r3[] = {
0x14, 0xa3, 0xc9, 0x50 // sbc pl r10 r9 r4 LSL r3
};
const byte kInstruction_sbc_al_r10_r8_r4_ROR_r1[] = {
0x74, 0xa1, 0xc8, 0xe0 // sbc al r10 r8 r4 ROR r1
};
const byte kInstruction_sbc_pl_r14_r9_r11_ASR_r13[] = {
0x5b, 0xed, 0xc9, 0x50 // sbc pl r14 r9 r11 ASR r13
};
const byte kInstruction_sbc_cc_r8_r1_r4_ROR_r12[] = {
0x74, 0x8c, 0xc1, 0x30 // sbc cc r8 r1 r4 ROR r12
};
const byte kInstruction_sbc_vs_r5_r14_r7_LSR_r0[] = {
0x37, 0x50, 0xce, 0x60 // sbc vs r5 r14 r7 LSR r0
};
const byte kInstruction_sbc_gt_r1_r10_r13_ROR_r9[] = {
0x7d, 0x19, 0xca, 0xc0 // sbc gt r1 r10 r13 ROR r9
};
const byte kInstruction_sbc_mi_r8_r14_r9_LSR_r5[] = {
0x39, 0x85, 0xce, 0x40 // sbc mi r8 r14 r9 LSR r5
};
const byte kInstruction_sbc_ge_r12_r10_r7_ROR_r2[] = {
0x77, 0xc2, 0xca, 0xa0 // sbc ge r12 r10 r7 ROR r2
};
const byte kInstruction_sbc_al_r11_r8_r1_LSR_r10[] = {
0x31, 0xba, 0xc8, 0xe0 // sbc al r11 r8 r1 LSR r10
};
const byte kInstruction_sbc_al_r7_r13_r11_LSL_r14[] = {
0x1b, 0x7e, 0xcd, 0xe0 // sbc al r7 r13 r11 LSL r14
};
const byte kInstruction_sbc_vc_r13_r11_r11_ASR_r9[] = {
0x5b, 0xd9, 0xcb, 0x70 // sbc vc r13 r11 r11 ASR r9
};
const byte kInstruction_sbc_gt_r10_r5_r11_LSR_r14[] = {
0x3b, 0xae, 0xc5, 0xc0 // sbc gt r10 r5 r11 LSR r14
};
const byte kInstruction_sbc_vc_r10_r11_r7_ROR_r3[] = {
0x77, 0xa3, 0xcb, 0x70 // sbc vc r10 r11 r7 ROR r3
};
const byte kInstruction_sbc_le_r10_r2_r7_LSL_r6[] = {
0x17, 0xa6, 0xc2, 0xd0 // sbc le r10 r2 r7 LSL r6
};
const byte kInstruction_sbc_al_r1_r3_r6_ASR_r5[] = {
0x56, 0x15, 0xc3, 0xe0 // sbc al r1 r3 r6 ASR r5
};
const byte kInstruction_sbc_cs_r14_r9_r7_LSL_r12[] = {
0x17, 0xec, 0xc9, 0x20 // sbc cs r14 r9 r7 LSL r12
};
const byte kInstruction_sbc_ls_r10_r1_r4_LSL_r4[] = {
0x14, 0xa4, 0xc1, 0x90 // sbc ls r10 r1 r4 LSL r4
};
const byte kInstruction_sbc_vs_r2_r5_r4_ROR_r3[] = {
0x74, 0x23, 0xc5, 0x60 // sbc vs r2 r5 r4 ROR r3
};
const byte kInstruction_sbc_vs_r1_r7_r10_ASR_r0[] = {
0x5a, 0x10, 0xc7, 0x60 // sbc vs r1 r7 r10 ASR r0
};
const byte kInstruction_sbc_cs_r10_r12_r0_LSR_r4[] = {
0x30, 0xa4, 0xcc, 0x20 // sbc cs r10 r12 r0 LSR r4
};
const byte kInstruction_sbc_vs_r8_r8_r1_LSR_r13[] = {
0x31, 0x8d, 0xc8, 0x60 // sbc vs r8 r8 r1 LSR r13
};
const byte kInstruction_sbc_mi_r14_r5_r9_LSR_r7[] = {
0x39, 0xe7, 0xc5, 0x40 // sbc mi r14 r5 r9 LSR r7
};
const byte kInstruction_sbc_vs_r6_r6_r14_ASR_r8[] = {
0x5e, 0x68, 0xc6, 0x60 // sbc vs r6 r6 r14 ASR r8
};
const byte kInstruction_sbc_vc_r0_r1_r14_ROR_r0[] = {
0x7e, 0x00, 0xc1, 0x70 // sbc vc r0 r1 r14 ROR r0
};
const byte kInstruction_sbc_ls_r9_r3_r11_ASR_r3[] = {
0x5b, 0x93, 0xc3, 0x90 // sbc ls r9 r3 r11 ASR r3
};
const byte kInstruction_sbc_ls_r1_r12_r1_ASR_r6[] = {
0x51, 0x16, 0xcc, 0x90 // sbc ls r1 r12 r1 ASR r6
};
const byte kInstruction_sbc_hi_r6_r10_r0_ASR_r2[] = {
0x50, 0x62, 0xca, 0x80 // sbc hi r6 r10 r0 ASR r2
};
const byte kInstruction_sbc_vc_r6_r14_r7_ASR_r1[] = {
0x57, 0x61, 0xce, 0x70 // sbc vc r6 r14 r7 ASR r1
};
const byte kInstruction_sbc_eq_r14_r11_r10_LSL_r13[] = {
0x1a, 0xed, 0xcb, 0x00 // sbc eq r14 r11 r10 LSL r13
};
const byte kInstruction_sbc_ge_r6_r12_r5_LSR_r9[] = {
0x35, 0x69, 0xcc, 0xa0 // sbc ge r6 r12 r5 LSR r9
};
const byte kInstruction_sbc_mi_r1_r5_r0_ROR_r9[] = {
0x70, 0x19, 0xc5, 0x40 // sbc mi r1 r5 r0 ROR r9
};
const byte kInstruction_sbc_al_r7_r8_r2_ROR_r4[] = {
0x72, 0x74, 0xc8, 0xe0 // sbc al r7 r8 r2 ROR r4
};
const byte kInstruction_sbc_hi_r8_r1_r5_ASR_r10[] = {
0x55, 0x8a, 0xc1, 0x80 // sbc hi r8 r1 r5 ASR r10
};
const byte kInstruction_sbc_ne_r14_r5_r0_LSR_r7[] = {
0x30, 0xe7, 0xc5, 0x10 // sbc ne r14 r5 r0 LSR r7
};
const byte kInstruction_sbc_vc_r3_r13_r9_LSL_r9[] = {
0x19, 0x39, 0xcd, 0x70 // sbc vc r3 r13 r9 LSL r9
};
const byte kInstruction_sbc_vs_r2_r2_r7_LSL_r5[] = {
0x17, 0x25, 0xc2, 0x60 // sbc vs r2 r2 r7 LSL r5
};
const byte kInstruction_sbc_vc_r7_r3_r6_ASR_r6[] = {
0x56, 0x76, 0xc3, 0x70 // sbc vc r7 r3 r6 ASR r6
};
const byte kInstruction_sbc_eq_r2_r5_r8_ROR_r1[] = {
0x78, 0x21, 0xc5, 0x00 // sbc eq r2 r5 r8 ROR r1
};
const byte kInstruction_sbc_eq_r0_r0_r10_ROR_r3[] = {
0x7a, 0x03, 0xc0, 0x00 // sbc eq r0 r0 r10 ROR r3
};
const byte kInstruction_sbc_lt_r6_r1_r0_ROR_r9[] = {
0x70, 0x69, 0xc1, 0xb0 // sbc lt r6 r1 r0 ROR r9
};
const byte kInstruction_sbc_ls_r7_r7_r12_LSR_r5[] = {
0x3c, 0x75, 0xc7, 0x90 // sbc ls r7 r7 r12 LSR r5
};
const byte kInstruction_sbc_vs_r0_r9_r7_ROR_r14[] = {
0x77, 0x0e, 0xc9, 0x60 // sbc vs r0 r9 r7 ROR r14
};
const byte kInstruction_sbc_al_r0_r8_r2_ROR_r2[] = {
0x72, 0x02, 0xc8, 0xe0 // sbc al r0 r8 r2 ROR r2
};
const byte kInstruction_sbc_vc_r1_r14_r14_LSL_r11[] = {
0x1e, 0x1b, 0xce, 0x70 // sbc vc r1 r14 r14 LSL r11
};
const byte kInstruction_sbc_ge_r9_r14_r10_ASR_r11[] = {
0x5a, 0x9b, 0xce, 0xa0 // sbc ge r9 r14 r10 ASR r11
};
const byte kInstruction_sbc_vs_r0_r3_r9_LSL_r4[] = {
0x19, 0x04, 0xc3, 0x60 // sbc vs r0 r3 r9 LSL r4
};
const byte kInstruction_sbc_pl_r14_r13_r7_LSR_r14[] = {
0x37, 0xee, 0xcd, 0x50 // sbc pl r14 r13 r7 LSR r14
};
const byte kInstruction_sbc_le_r2_r4_r6_LSR_r3[] = {
0x36, 0x23, 0xc4, 0xd0 // sbc le r2 r4 r6 LSR r3
};
const byte kInstruction_sbc_vc_r7_r14_r6_LSR_r10[] = {
0x36, 0x7a, 0xce, 0x70 // sbc vc r7 r14 r6 LSR r10
};
const byte kInstruction_sbc_mi_r13_r11_r14_ASR_r7[] = {
0x5e, 0xd7, 0xcb, 0x40 // sbc mi r13 r11 r14 ASR r7
};
const TestResult kReferencesbc[] = {
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r10_r8_LSL_r0),
kInstruction_sbc_mi_r8_r10_r8_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r11_r4_r13_ROR_r8),
kInstruction_sbc_cc_r11_r4_r13_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r11_r3_ROR_r4),
kInstruction_sbc_al_r13_r11_r3_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r5_r4_LSR_r11),
kInstruction_sbc_gt_r11_r5_r4_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r12_r0_r8_ROR_r13),
kInstruction_sbc_vs_r12_r0_r8_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r12_r5_LSL_r5),
kInstruction_sbc_pl_r10_r12_r5_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r10_r2_r2_LSL_r9),
kInstruction_sbc_ls_r10_r2_r2_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r7_r9_LSR_r7),
kInstruction_sbc_eq_r12_r7_r9_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r13_r0_ROR_r11),
kInstruction_sbc_mi_r3_r13_r0_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r9_r0_r9_ASR_r12),
kInstruction_sbc_lt_r9_r0_r9_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r12_r8_r14_ROR_r1),
kInstruction_sbc_le_r12_r8_r14_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r7_r1_r14_LSL_r0),
kInstruction_sbc_cc_r7_r1_r14_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r11_r13_r3_ROR_r6),
kInstruction_sbc_le_r11_r13_r3_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r5_r8_r9_ASR_r14),
kInstruction_sbc_al_r5_r8_r9_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r2_r7_ASR_r13),
kInstruction_sbc_hi_r1_r2_r7_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r8_r7_LSR_r12),
kInstruction_sbc_al_r13_r8_r7_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r3_r6_r4_ASR_r4),
kInstruction_sbc_vc_r3_r6_r4_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r4_r6_LSL_r5),
kInstruction_sbc_lt_r12_r4_r6_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r5_r11_ROR_r8),
kInstruction_sbc_ls_r13_r5_r11_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r10_r11_LSL_r9),
kInstruction_sbc_vc_r11_r10_r11_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r14_r10_LSR_r4),
kInstruction_sbc_al_r13_r14_r10_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r13_r6_ASR_r12),
kInstruction_sbc_ge_r12_r13_r6_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r14_r6_r12_ROR_r0),
kInstruction_sbc_ne_r14_r6_r12_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r14_r14_ASR_r13),
kInstruction_sbc_ls_r13_r14_r14_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r10_r13_r7_ROR_r8),
kInstruction_sbc_lt_r10_r13_r7_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r8_r8_r9_ASR_r0),
kInstruction_sbc_lt_r8_r8_r9_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r5_r4_LSR_r8),
kInstruction_sbc_ne_r7_r5_r4_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r11_r5_r1_LSL_r13),
kInstruction_sbc_mi_r11_r5_r1_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r14_r1_r2_LSL_r1),
kInstruction_sbc_ge_r14_r1_r2_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r6_r11_r4_ASR_r11),
kInstruction_sbc_ls_r6_r11_r4_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r11_r12_r4_LSR_r13),
kInstruction_sbc_hi_r11_r12_r4_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r3_r0_LSL_r7),
kInstruction_sbc_le_r9_r3_r0_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r8_r7_r4_ASR_r3),
kInstruction_sbc_ls_r8_r7_r4_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r13_r11_LSL_r7),
kInstruction_sbc_pl_r9_r13_r11_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r7_r11_ASR_r3),
kInstruction_sbc_eq_r12_r7_r11_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r9_r13_ROR_r10),
kInstruction_sbc_mi_r3_r9_r13_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r8_r10_ROR_r10),
kInstruction_sbc_mi_r14_r8_r10_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r5_r3_r5_LSL_r1),
kInstruction_sbc_lt_r5_r3_r5_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r12_r6_r1_LSL_r7),
kInstruction_sbc_ne_r12_r6_r1_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r6_r5_ASR_r1),
kInstruction_sbc_lt_r3_r6_r5_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r14_r0_r0_LSR_r11),
kInstruction_sbc_lt_r14_r0_r0_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r10_r4_LSL_r14),
kInstruction_sbc_eq_r11_r10_r4_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r14_r11_LSL_r9),
kInstruction_sbc_lt_r2_r14_r11_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r6_r14_ASR_r11),
kInstruction_sbc_mi_r0_r6_r14_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r4_r6_r3_LSR_r11),
kInstruction_sbc_le_r4_r6_r3_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r2_r6_r1_ROR_r5),
kInstruction_sbc_cs_r2_r6_r1_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r10_r9_r10_ROR_r4),
kInstruction_sbc_ne_r10_r9_r10_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r7_r9_r11_LSR_r14),
kInstruction_sbc_pl_r7_r9_r11_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r11_r8_r3_ASR_r5),
kInstruction_sbc_pl_r11_r8_r3_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r4_r10_ROR_r8),
kInstruction_sbc_le_r10_r4_r10_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r8_r14_r8_LSL_r5),
kInstruction_sbc_ne_r8_r14_r8_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r5_r2_LSL_r11),
kInstruction_sbc_eq_r12_r5_r2_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r9_r8_ASR_r2),
kInstruction_sbc_pl_r9_r9_r8_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r12_r3_LSL_r5),
kInstruction_sbc_hi_r8_r12_r3_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r6_r5_r9_LSL_r3),
kInstruction_sbc_eq_r6_r5_r9_LSL_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r5_r1_r9_LSR_r6),
kInstruction_sbc_lt_r5_r1_r9_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r9_r9_r0_LSL_r5),
kInstruction_sbc_hi_r9_r9_r0_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r6_r6_r5_LSL_r8),
kInstruction_sbc_cs_r6_r6_r5_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r1_r6_LSR_r12),
kInstruction_sbc_cs_r0_r1_r6_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r4_r6_r13_ASR_r6),
kInstruction_sbc_cc_r4_r6_r13_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r11_r8_r10_LSR_r5),
kInstruction_sbc_hi_r11_r8_r10_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r8_r1_r14_ROR_r14),
kInstruction_sbc_ls_r8_r1_r14_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r8_r2_r12_ASR_r7),
kInstruction_sbc_pl_r8_r2_r12_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r14_r7_r5_ROR_r11),
kInstruction_sbc_gt_r14_r7_r5_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r3_r6_r13_ROR_r0),
kInstruction_sbc_eq_r3_r6_r13_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r4_r8_r8_ROR_r11),
kInstruction_sbc_le_r4_r8_r8_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r2_r7_r5_ASR_r6),
kInstruction_sbc_ge_r2_r7_r5_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r8_r12_r5_LSL_r11),
kInstruction_sbc_cc_r8_r12_r5_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r10_r3_ROR_r5),
kInstruction_sbc_vc_r11_r10_r3_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r9_r11_LSL_r6),
kInstruction_sbc_vc_r11_r9_r11_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r5_r0_ROR_r9),
kInstruction_sbc_lt_r6_r5_r0_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r13_r7_r11_ASR_r9),
kInstruction_sbc_cs_r13_r7_r11_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r7_r9_ROR_r11),
kInstruction_sbc_cs_r9_r7_r9_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r14_r3_r2_ASR_r11),
kInstruction_sbc_ls_r14_r3_r2_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r1_r1_LSR_r0),
kInstruction_sbc_vc_r0_r1_r1_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r10_r8_r8_LSR_r13),
kInstruction_sbc_mi_r10_r8_r8_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r8_r14_r3_LSL_r8),
kInstruction_sbc_pl_r8_r14_r3_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r6_r4_r1_LSL_r12),
kInstruction_sbc_ne_r6_r4_r1_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r2_r7_ROR_r0),
kInstruction_sbc_lt_r2_r2_r7_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r4_r13_ASR_r5),
kInstruction_sbc_lt_r2_r4_r13_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r8_r1_r2_ROR_r13),
kInstruction_sbc_eq_r8_r1_r2_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r8_r10_LSR_r7),
kInstruction_sbc_lt_r1_r8_r10_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r5_r9_LSL_r9),
kInstruction_sbc_cs_r7_r5_r9_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r0_r6_LSL_r8),
kInstruction_sbc_mi_r8_r0_r6_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r12_r3_ROR_r6),
kInstruction_sbc_cs_r7_r12_r3_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r13_r8_r13_LSR_r4),
kInstruction_sbc_vs_r13_r8_r13_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r4_r13_r7_ROR_r11),
kInstruction_sbc_cc_r4_r13_r7_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r5_r9_LSR_r13),
kInstruction_sbc_ge_r10_r5_r9_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r5_r9_ASR_r4),
kInstruction_sbc_cc_r0_r5_r9_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r1_r5_r8_LSR_r12),
kInstruction_sbc_cc_r1_r5_r8_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r12_r3_r5_LSL_r6),
kInstruction_sbc_ls_r12_r3_r5_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r0_r4_ASR_r7),
kInstruction_sbc_cs_r10_r0_r4_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r13_r14_ROR_r6),
kInstruction_sbc_ge_r10_r13_r14_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r0_r9_ROR_r3),
kInstruction_sbc_al_r9_r0_r9_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r4_r5_r12_ASR_r6),
kInstruction_sbc_vs_r4_r5_r12_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r1_r14_LSL_r12),
kInstruction_sbc_lt_r4_r1_r14_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r11_r8_ROR_r4),
kInstruction_sbc_cs_r14_r11_r8_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r12_r0_r14_LSR_r11),
kInstruction_sbc_hi_r12_r0_r14_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r8_r6_r4_ASR_r7),
kInstruction_sbc_le_r8_r6_r4_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r13_r4_r14_LSR_r10),
kInstruction_sbc_mi_r13_r4_r14_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r11_r10_r5_LSL_r10),
kInstruction_sbc_vs_r11_r10_r5_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r4_r0_r5_LSR_r2),
kInstruction_sbc_cc_r4_r0_r5_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r14_r0_LSL_r3),
kInstruction_sbc_pl_r9_r14_r0_LSL_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r2_r14_ASR_r1),
kInstruction_sbc_vc_r7_r2_r14_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r4_r14_r1_ROR_r10),
kInstruction_sbc_gt_r4_r14_r1_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r4_r10_LSL_r7),
kInstruction_sbc_lt_r6_r4_r10_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r14_r5_LSL_r12),
kInstruction_sbc_hi_r1_r14_r5_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r12_r4_ASR_r14),
kInstruction_sbc_cc_r14_r12_r4_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r8_r5_ROR_r8),
kInstruction_sbc_cc_r0_r8_r5_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r9_r9_r0_ASR_r4),
kInstruction_sbc_gt_r9_r9_r0_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r11_r12_ASR_r4),
kInstruction_sbc_mi_r8_r11_r12_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r12_r0_LSR_r11),
kInstruction_sbc_vs_r0_r12_r0_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r9_r1_ASR_r0),
kInstruction_sbc_ge_r0_r9_r1_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r10_r11_r5_LSR_r4),
kInstruction_sbc_al_r10_r11_r5_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r0_r6_r8_LSR_r10),
kInstruction_sbc_eq_r0_r6_r8_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r12_r14_ROR_r9),
kInstruction_sbc_cc_r13_r12_r14_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r4_r11_r0_LSL_r14),
kInstruction_sbc_ls_r4_r11_r0_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r6_r12_LSR_r13),
kInstruction_sbc_hi_r1_r6_r12_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r11_r1_ASR_r5),
kInstruction_sbc_cs_r7_r11_r1_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r7_r5_r4_ASR_r11),
kInstruction_sbc_cc_r7_r5_r4_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r7_r2_r5_ROR_r5),
kInstruction_sbc_hi_r7_r2_r5_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r9_r7_LSL_r14),
kInstruction_sbc_vc_r11_r9_r7_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r12_r1_r3_ROR_r7),
kInstruction_sbc_le_r12_r1_r3_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r8_r14_r0_ASR_r12),
kInstruction_sbc_al_r8_r14_r0_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r14_r3_r0_ROR_r1),
kInstruction_sbc_vc_r14_r3_r0_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r8_r3_ROR_r4),
kInstruction_sbc_pl_r10_r8_r3_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r14_r12_LSL_r4),
kInstruction_sbc_al_r9_r14_r12_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r3_r14_ASR_r7),
kInstruction_sbc_vs_r8_r3_r14_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r4_r8_r13_LSL_r1),
kInstruction_sbc_hi_r4_r8_r13_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r11_r11_LSL_r14),
kInstruction_sbc_al_r6_r11_r11_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r2_r4_LSR_r1),
kInstruction_sbc_al_r7_r2_r4_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r5_r10_r3_ASR_r8),
kInstruction_sbc_vc_r5_r10_r3_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r10_r9_ROR_r11),
kInstruction_sbc_cc_r3_r10_r9_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r9_r8_LSL_r2),
kInstruction_sbc_eq_r11_r9_r8_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r6_r9_r5_ASR_r12),
kInstruction_sbc_mi_r6_r9_r5_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r6_r0_ASR_r9),
kInstruction_sbc_hi_r6_r6_r0_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r13_r1_LSL_r9),
kInstruction_sbc_ge_r12_r13_r1_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r4_r9_r14_ASR_r2),
kInstruction_sbc_le_r4_r9_r14_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r5_r3_r9_ROR_r5),
kInstruction_sbc_gt_r5_r3_r9_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r5_r13_ROR_r7),
kInstruction_sbc_al_r14_r5_r13_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r1_r14_ASR_r8),
kInstruction_sbc_lt_r2_r1_r14_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r12_r7_r8_LSL_r11),
kInstruction_sbc_al_r12_r7_r8_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r12_r14_LSL_r1),
kInstruction_sbc_ne_r4_r12_r14_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r7_r14_r4_LSL_r6),
kInstruction_sbc_vs_r7_r14_r4_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r5_r11_ASR_r4),
kInstruction_sbc_ge_r12_r5_r11_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r4_r10_r6_LSR_r6),
kInstruction_sbc_gt_r4_r10_r6_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r8_r14_LSR_r8),
kInstruction_sbc_cc_r14_r8_r14_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r1_r14_r11_LSR_r7),
kInstruction_sbc_al_r1_r14_r11_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r6_r5_ASR_r14),
kInstruction_sbc_pl_r13_r6_r5_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r10_r6_r9_ROR_r13),
kInstruction_sbc_cc_r10_r6_r9_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r0_r4_r7_ROR_r13),
kInstruction_sbc_ne_r0_r4_r7_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r0_r14_LSL_r13),
kInstruction_sbc_vc_r12_r0_r14_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r10_r13_r13_ROR_r5),
kInstruction_sbc_al_r10_r13_r13_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r3_r0_ROR_r7),
kInstruction_sbc_cs_r10_r3_r0_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r14_r14_ROR_r6),
kInstruction_sbc_ge_r10_r14_r14_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r0_r10_r10_LSL_r4),
kInstruction_sbc_pl_r0_r10_r10_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r1_r2_r7_ASR_r6),
kInstruction_sbc_vs_r1_r2_r7_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r11_r9_LSL_r9),
kInstruction_sbc_cs_r9_r11_r9_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r10_r8_r4_LSL_r6),
kInstruction_sbc_eq_r10_r8_r4_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r5_r12_LSL_r8),
kInstruction_sbc_vc_r8_r5_r12_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r1_r13_r11_LSL_r8),
kInstruction_sbc_pl_r1_r13_r11_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r10_r5_ROR_r4),
kInstruction_sbc_le_r9_r10_r5_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r3_r0_ASR_r11),
kInstruction_sbc_vs_r8_r3_r0_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r12_r0_r13_LSL_r2),
kInstruction_sbc_hi_r12_r0_r13_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r2_r8_LSL_r5),
kInstruction_sbc_lt_r4_r2_r8_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r4_r13_LSL_r13),
kInstruction_sbc_ge_r9_r4_r13_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r2_r1_ROR_r8),
kInstruction_sbc_ge_r0_r2_r1_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r13_r9_LSR_r0),
kInstruction_sbc_le_r6_r13_r9_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r7_r4_ASR_r3),
kInstruction_sbc_ls_r13_r7_r4_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r13_r6_LSR_r14),
kInstruction_sbc_vc_r8_r13_r6_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r5_r3_LSR_r9),
kInstruction_sbc_pl_r10_r5_r3_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r3_r14_LSR_r7),
kInstruction_sbc_al_r6_r3_r14_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r5_r3_ROR_r10),
kInstruction_sbc_cc_r3_r5_r3_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r11_r2_LSR_r10),
kInstruction_sbc_cs_r4_r11_r2_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r10_r5_ASR_r8),
kInstruction_sbc_lt_r6_r10_r5_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r13_r10_ASR_r8),
kInstruction_sbc_ge_r0_r13_r10_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r8_r8_r0_LSL_r9),
kInstruction_sbc_cs_r8_r8_r0_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r1_r1_r1_ASR_r2),
kInstruction_sbc_gt_r1_r1_r1_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r5_r0_r14_ROR_r3),
kInstruction_sbc_al_r5_r0_r14_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r9_r14_LSL_r9),
kInstruction_sbc_mi_r3_r9_r14_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r9_r6_r5_LSL_r9),
kInstruction_sbc_ls_r9_r6_r5_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r3_r1_LSL_r13),
kInstruction_sbc_lt_r13_r3_r1_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r9_r14_r3_ASR_r3),
kInstruction_sbc_lt_r9_r14_r3_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r5_r4_r1_LSR_r0),
kInstruction_sbc_cc_r5_r4_r1_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r7_r8_ASR_r0),
kInstruction_sbc_cs_r9_r7_r8_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r8_r6_r14_ROR_r7),
kInstruction_sbc_ge_r8_r6_r14_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r14_r8_r12_LSL_r0),
kInstruction_sbc_le_r14_r8_r12_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r13_r14_ASR_r3),
kInstruction_sbc_mi_r0_r13_r14_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r4_r9_ROR_r8),
kInstruction_sbc_cs_r7_r4_r9_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r6_r11_ROR_r2),
kInstruction_sbc_ne_r4_r6_r11_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r8_r8_r9_ROR_r12),
kInstruction_sbc_gt_r8_r8_r9_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r2_r0_LSR_r13),
kInstruction_sbc_hi_r1_r2_r0_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r14_r12_r6_ASR_r5),
kInstruction_sbc_ge_r14_r12_r6_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r5_r4_r7_LSR_r14),
kInstruction_sbc_ge_r5_r4_r7_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r11_r10_LSR_r2),
kInstruction_sbc_cc_r13_r11_r10_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r9_r14_LSR_r14),
kInstruction_sbc_mi_r3_r9_r14_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r10_r3_r4_LSR_r3),
kInstruction_sbc_ne_r10_r3_r4_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r14_r9_r6_LSL_r9),
kInstruction_sbc_ls_r14_r9_r6_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r8_r2_r8_ROR_r7),
kInstruction_sbc_ls_r8_r2_r8_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r6_r3_ROR_r3),
kInstruction_sbc_ne_r2_r6_r3_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r12_r3_r11_ASR_r11),
kInstruction_sbc_mi_r12_r3_r11_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r10_r11_LSL_r9),
kInstruction_sbc_le_r7_r10_r11_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r1_r2_r10_ROR_r8),
kInstruction_sbc_al_r1_r2_r10_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r7_r9_r14_LSL_r7),
kInstruction_sbc_cc_r7_r9_r14_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r3_r5_LSL_r8),
kInstruction_sbc_cc_r9_r3_r5_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r3_r8_ROR_r2),
kInstruction_sbc_hi_r8_r3_r8_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r13_r14_LSR_r10),
kInstruction_sbc_pl_r10_r13_r14_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r4_r13_LSR_r12),
kInstruction_sbc_lt_r13_r4_r13_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r12_r14_r11_LSR_r13),
kInstruction_sbc_ls_r12_r14_r11_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r11_r10_r10_ASR_r2),
kInstruction_sbc_vs_r11_r10_r10_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r5_r8_r13_LSL_r10),
kInstruction_sbc_cc_r5_r8_r13_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r4_r11_LSR_r14),
kInstruction_sbc_cs_r7_r4_r11_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r12_r7_ASR_r11),
kInstruction_sbc_lt_r1_r12_r7_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r4_r4_LSL_r10),
kInstruction_sbc_vc_r11_r4_r4_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r4_r6_LSR_r7),
kInstruction_sbc_vc_r7_r4_r6_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r3_r0_ASR_r14),
kInstruction_sbc_vc_r0_r3_r0_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r11_r8_r13_ASR_r8),
kInstruction_sbc_mi_r11_r8_r13_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r13_r14_r6_LSL_r11),
kInstruction_sbc_gt_r13_r14_r6_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r2_r6_LSL_r8),
kInstruction_sbc_cs_r3_r2_r6_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r5_r5_LSL_r8),
kInstruction_sbc_ne_r7_r5_r5_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r12_r6_LSR_r0),
kInstruction_sbc_lt_r0_r12_r6_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r11_r9_r12_ROR_r2),
kInstruction_sbc_ls_r11_r9_r12_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r6_r0_r8_LSR_r4),
kInstruction_sbc_ls_r6_r0_r8_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r7_r0_ROR_r13),
kInstruction_sbc_lt_r6_r7_r0_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r14_r4_r1_LSL_r8),
kInstruction_sbc_gt_r14_r4_r1_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r5_r6_LSL_r7),
kInstruction_sbc_al_r14_r5_r6_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r6_r4_LSR_r8),
kInstruction_sbc_ge_r9_r6_r4_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r14_r13_ROR_r3),
kInstruction_sbc_lt_r2_r14_r13_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r1_r13_LSR_r9),
kInstruction_sbc_al_r11_r1_r13_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r2_r5_LSL_r11),
kInstruction_sbc_vs_r8_r2_r5_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r8_r14_r8_LSL_r7),
kInstruction_sbc_pl_r8_r14_r8_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r5_r5_ASR_r4),
kInstruction_sbc_cs_r10_r5_r5_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r14_r9_LSR_r11),
kInstruction_sbc_eq_r12_r14_r9_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r3_r3_LSL_r1),
kInstruction_sbc_lt_r1_r3_r3_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r4_r13_r4_ASR_r8),
kInstruction_sbc_le_r4_r13_r4_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r4_r2_LSL_r8),
kInstruction_sbc_ne_r5_r4_r2_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r3_r14_r13_LSR_r1),
kInstruction_sbc_le_r3_r14_r13_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r3_r5_LSL_r1),
kInstruction_sbc_cc_r6_r3_r5_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r9_r6_r11_LSR_r14),
kInstruction_sbc_lt_r9_r6_r11_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r8_r10_ROR_r1),
kInstruction_sbc_cc_r13_r8_r10_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r7_r10_r11_LSR_r2),
kInstruction_sbc_lt_r7_r10_r11_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r0_r9_r5_LSR_r8),
kInstruction_sbc_pl_r0_r9_r5_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r8_r9_r11_LSR_r13),
kInstruction_sbc_eq_r8_r9_r11_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r10_r1_r9_ROR_r12),
kInstruction_sbc_hi_r10_r1_r9_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r1_r14_LSL_r14),
kInstruction_sbc_pl_r13_r1_r14_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r13_r3_r7_LSR_r13),
kInstruction_sbc_eq_r13_r3_r7_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r3_r6_r6_ASR_r14),
kInstruction_sbc_eq_r3_r6_r6_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r5_r4_r8_ROR_r13),
kInstruction_sbc_gt_r5_r4_r8_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r7_r0_ROR_r3),
kInstruction_sbc_al_r9_r7_r0_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r13_r11_r3_LSL_r1),
kInstruction_sbc_mi_r13_r11_r3_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r11_r14_r6_LSL_r14),
kInstruction_sbc_ls_r11_r14_r6_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r3_r7_LSL_r9),
kInstruction_sbc_al_r14_r3_r7_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r2_r14_LSL_r13),
kInstruction_sbc_cs_r14_r2_r14_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r11_r10_r6_ASR_r11),
kInstruction_sbc_ls_r11_r10_r6_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r4_r2_LSL_r4),
kInstruction_sbc_pl_r13_r4_r2_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r10_r5_ASR_r0),
kInstruction_sbc_mi_r8_r10_r5_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r2_r1_r6_ASR_r4),
kInstruction_sbc_cs_r2_r1_r6_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r11_r8_LSR_r14),
kInstruction_sbc_cc_r0_r11_r8_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r5_r4_r6_ROR_r1),
kInstruction_sbc_ge_r5_r4_r6_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r14_r3_LSR_r11),
kInstruction_sbc_cs_r0_r14_r3_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r4_r10_LSR_r13),
kInstruction_sbc_ge_r9_r4_r10_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r11_r0_r9_LSL_r8),
kInstruction_sbc_ne_r11_r0_r9_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r4_r1_r0_LSL_r8),
kInstruction_sbc_vs_r4_r1_r0_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r5_r5_r4_ROR_r10),
kInstruction_sbc_le_r5_r5_r4_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r5_r0_ROR_r6),
kInstruction_sbc_al_r9_r5_r0_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r6_r9_LSR_r12),
kInstruction_sbc_hi_r6_r6_r9_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r4_r9_ROR_r4),
kInstruction_sbc_lt_r1_r4_r9_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r7_r0_ROR_r11),
kInstruction_sbc_vc_r4_r7_r0_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r1_r4_r2_ROR_r8),
kInstruction_sbc_gt_r1_r4_r2_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r5_r9_LSL_r6),
kInstruction_sbc_ne_r4_r5_r9_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r3_r4_r10_LSR_r5),
kInstruction_sbc_gt_r3_r4_r10_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r9_r2_ROR_r2),
kInstruction_sbc_al_r7_r9_r2_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r3_r8_r2_LSL_r2),
kInstruction_sbc_le_r3_r8_r2_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r3_r8_r0_LSL_r1),
kInstruction_sbc_hi_r3_r8_r0_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r11_r4_r4_LSL_r14),
kInstruction_sbc_ge_r11_r4_r4_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r14_r1_LSR_r13),
kInstruction_sbc_mi_r8_r14_r1_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r6_r1_r10_LSL_r0),
kInstruction_sbc_pl_r6_r1_r10_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r7_r13_LSL_r0),
kInstruction_sbc_eq_r11_r7_r13_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r4_r9_r11_LSR_r1),
kInstruction_sbc_cc_r4_r9_r11_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r8_r2_r3_LSR_r8),
kInstruction_sbc_cc_r8_r2_r3_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r1_r14_LSL_r12),
kInstruction_sbc_ne_r5_r1_r14_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r13_r5_r2_ASR_r1),
kInstruction_sbc_le_r13_r5_r2_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r0_r5_r0_LSL_r4),
kInstruction_sbc_al_r0_r5_r0_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r1_r4_LSR_r3),
kInstruction_sbc_mi_r3_r1_r4_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r7_r0_ROR_r8),
kInstruction_sbc_cs_r3_r7_r0_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r11_r14_r4_LSR_r13),
kInstruction_sbc_cs_r11_r14_r4_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r11_r10_r8_ASR_r3),
kInstruction_sbc_vs_r11_r10_r8_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r8_r9_LSL_r13),
kInstruction_sbc_gt_r10_r8_r9_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r10_r1_r8_ASR_r9),
kInstruction_sbc_eq_r10_r1_r8_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r2_r1_r10_ASR_r8),
kInstruction_sbc_al_r2_r1_r10_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r1_r7_ROR_r11),
kInstruction_sbc_al_r7_r1_r7_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r5_r6_ASR_r1),
kInstruction_sbc_cs_r0_r5_r6_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r11_r10_LSR_r14),
kInstruction_sbc_lt_r12_r11_r10_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r7_r5_LSL_r2),
kInstruction_sbc_pl_r13_r7_r5_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r0_r12_LSL_r11),
kInstruction_sbc_ne_r2_r0_r12_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r14_r9_r12_ROR_r6),
kInstruction_sbc_ls_r14_r9_r12_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r2_r8_ASR_r3),
kInstruction_sbc_cc_r9_r2_r8_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r12_r11_r0_ASR_r7),
kInstruction_sbc_pl_r12_r11_r0_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r12_r2_r3_ROR_r1),
kInstruction_sbc_vs_r12_r2_r3_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r3_r1_r8_LSL_r4),
kInstruction_sbc_al_r3_r1_r8_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r7_r9_r13_ASR_r5),
kInstruction_sbc_mi_r7_r9_r13_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r13_r4_r10_ROR_r9),
kInstruction_sbc_vs_r13_r4_r10_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r8_r2_r3_LSR_r2),
kInstruction_sbc_eq_r8_r2_r3_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r3_r11_LSR_r7),
kInstruction_sbc_cs_r0_r3_r11_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r2_r10_r9_ASR_r13),
kInstruction_sbc_pl_r2_r10_r9_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r0_r7_ASR_r0),
kInstruction_sbc_eq_r14_r0_r7_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r11_r7_ROR_r7),
kInstruction_sbc_lt_r12_r11_r7_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r4_r10_r1_LSL_r2),
kInstruction_sbc_eq_r4_r10_r1_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r14_r12_ASR_r6),
kInstruction_sbc_al_r7_r14_r12_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r2_r5_r13_ASR_r1),
kInstruction_sbc_al_r2_r5_r13_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r0_r3_r14_LSL_r11),
kInstruction_sbc_hi_r0_r3_r14_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r5_r6_r9_LSR_r13),
kInstruction_sbc_vs_r5_r6_r9_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r14_r0_r14_ROR_r14),
kInstruction_sbc_hi_r14_r0_r14_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r9_r3_r13_ROR_r9),
kInstruction_sbc_eq_r9_r3_r13_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r8_r1_ASR_r14),
kInstruction_sbc_hi_r6_r8_r1_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r13_r2_r8_LSR_r7),
kInstruction_sbc_vs_r13_r2_r8_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r0_r8_LSR_r7),
kInstruction_sbc_cc_r13_r0_r8_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r12_r0_r11_ASR_r9),
kInstruction_sbc_le_r12_r0_r11_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r8_r8_r1_LSR_r6),
kInstruction_sbc_le_r8_r8_r1_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r5_r14_r7_ASR_r3),
kInstruction_sbc_cs_r5_r14_r7_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r13_r13_r10_ROR_r12),
kInstruction_sbc_eq_r13_r13_r10_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r7_r7_LSR_r5),
kInstruction_sbc_lt_r4_r7_r7_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r13_r10_LSR_r2),
kInstruction_sbc_le_r6_r13_r10_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r10_r13_r10_ASR_r8),
kInstruction_sbc_eq_r10_r13_r10_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r6_r5_r12_LSR_r12),
kInstruction_sbc_ne_r6_r5_r12_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r10_r8_r10_ROR_r8),
kInstruction_sbc_vc_r10_r8_r10_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r1_r8_LSR_r1),
kInstruction_sbc_gt_r10_r1_r8_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r5_r12_r9_LSR_r13),
kInstruction_sbc_pl_r5_r12_r9_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r6_r4_ROR_r12),
kInstruction_sbc_gt_r10_r6_r4_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r10_r10_ASR_r6),
kInstruction_sbc_cs_r14_r10_r10_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r8_r2_ROR_r7),
kInstruction_sbc_le_r6_r8_r2_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r13_r12_r0_ROR_r14),
kInstruction_sbc_le_r13_r12_r0_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r6_r0_ASR_r10),
kInstruction_sbc_le_r7_r6_r0_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r4_r1_ASR_r10),
kInstruction_sbc_cs_r10_r4_r1_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r12_r9_r11_ASR_r6),
kInstruction_sbc_ne_r12_r9_r11_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r9_r14_r6_ASR_r12),
kInstruction_sbc_vs_r9_r14_r6_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r1_r8_r0_ASR_r7),
kInstruction_sbc_mi_r1_r8_r0_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r2_r3_ROR_r11),
kInstruction_sbc_gt_r11_r2_r3_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r1_r12_LSR_r0),
kInstruction_sbc_cs_r3_r1_r12_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r12_r14_r11_LSL_r2),
kInstruction_sbc_hi_r12_r14_r11_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r10_r11_r14_LSL_r10),
kInstruction_sbc_mi_r10_r11_r14_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r6_r13_ASR_r2),
kInstruction_sbc_al_r11_r6_r13_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r14_r3_ROR_r6),
kInstruction_sbc_gt_r2_r14_r3_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r10_r6_LSR_r6),
kInstruction_sbc_hi_r1_r10_r6_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r8_r3_LSL_r6),
kInstruction_sbc_gt_r2_r8_r3_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r4_r12_ROR_r13),
kInstruction_sbc_ls_r13_r4_r12_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r13_r11_r7_ROR_r8),
kInstruction_sbc_vs_r13_r11_r7_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r5_r12_r14_LSR_r3),
kInstruction_sbc_hi_r5_r12_r14_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r8_r3_ROR_r13),
kInstruction_sbc_cs_r14_r8_r3_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r10_r0_LSL_r10),
kInstruction_sbc_cs_r9_r10_r0_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r13_r12_ASR_r5),
kInstruction_sbc_lt_r0_r13_r12_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r5_r7_ROR_r7),
kInstruction_sbc_cs_r4_r5_r7_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r14_r7_LSR_r7),
kInstruction_sbc_lt_r0_r14_r7_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r10_r5_r3_LSL_r10),
kInstruction_sbc_hi_r10_r5_r3_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r6_r2_r4_ROR_r0),
kInstruction_sbc_ls_r6_r2_r4_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r9_r7_r7_ASR_r10),
kInstruction_sbc_hi_r9_r7_r7_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r9_r4_LSR_r2),
kInstruction_sbc_cc_r0_r9_r4_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r3_r14_r2_ASR_r0),
kInstruction_sbc_le_r3_r14_r2_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r2_r8_r7_LSL_r13),
kInstruction_sbc_pl_r2_r8_r7_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r10_r1_r9_LSR_r6),
kInstruction_sbc_al_r10_r1_r9_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r1_r6_r14_ASR_r14),
kInstruction_sbc_vs_r1_r6_r14_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r3_r13_LSR_r0),
kInstruction_sbc_lt_r3_r3_r13_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r3_r2_ASR_r11),
kInstruction_sbc_le_r9_r3_r2_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r4_r14_r6_LSL_r11),
kInstruction_sbc_mi_r4_r14_r6_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r5_r14_ASR_r9),
kInstruction_sbc_ne_r7_r5_r14_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r11_r11_r13_LSR_r11),
kInstruction_sbc_cs_r11_r11_r13_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r9_r5_LSR_r9),
kInstruction_sbc_lt_r12_r9_r5_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r13_r1_r10_LSL_r4),
kInstruction_sbc_hi_r13_r1_r10_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r6_r8_ASR_r14),
kInstruction_sbc_mi_r14_r6_r8_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r3_r2_r6_ASR_r3),
kInstruction_sbc_vc_r3_r2_r6_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r13_r14_r0_ASR_r2),
kInstruction_sbc_ne_r13_r14_r0_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r14_r5_ROR_r1),
kInstruction_sbc_gt_r2_r14_r5_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r7_r7_r9_LSR_r10),
kInstruction_sbc_ls_r7_r7_r9_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r12_r8_ASR_r5),
kInstruction_sbc_gt_r2_r12_r8_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r2_r11_ROR_r6),
kInstruction_sbc_lt_r13_r2_r11_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r2_r13_r13_ASR_r1),
kInstruction_sbc_cc_r2_r13_r13_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r6_r14_ROR_r3),
kInstruction_sbc_vs_r0_r6_r14_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r2_r13_r8_LSL_r9),
kInstruction_sbc_vs_r2_r13_r8_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r2_r12_r12_ROR_r6),
kInstruction_sbc_pl_r2_r12_r12_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r0_r12_ASR_r13),
kInstruction_sbc_vc_r4_r0_r12_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r12_r7_ASR_r7),
kInstruction_sbc_mi_r8_r12_r7_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r5_r0_LSL_r5),
kInstruction_sbc_al_r13_r5_r0_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r1_r12_LSR_r8),
kInstruction_sbc_le_r9_r1_r12_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r5_r10_r13_ROR_r1),
kInstruction_sbc_vs_r5_r10_r13_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r5_r0_LSR_r11),
kInstruction_sbc_vs_r8_r5_r0_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r2_r0_LSL_r4),
kInstruction_sbc_ne_r7_r2_r0_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r6_r9_LSL_r10),
kInstruction_sbc_lt_r6_r6_r9_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r13_r3_r4_ROR_r12),
kInstruction_sbc_cs_r13_r3_r4_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r11_r11_r0_LSL_r7),
kInstruction_sbc_ne_r11_r11_r0_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r3_r14_r12_LSR_r13),
kInstruction_sbc_pl_r3_r14_r12_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r2_r14_r3_LSL_r11),
kInstruction_sbc_al_r2_r14_r3_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r6_r3_LSR_r7),
kInstruction_sbc_vc_r4_r6_r3_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r6_r2_r1_LSR_r6),
kInstruction_sbc_ls_r6_r2_r1_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r0_r2_r5_ASR_r3),
kInstruction_sbc_le_r0_r2_r5_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r9_r12_ROR_r13),
kInstruction_sbc_ge_r12_r9_r12_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r10_r5_r3_ROR_r12),
kInstruction_sbc_cc_r10_r5_r3_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r0_r10_ASR_r4),
kInstruction_sbc_mi_r14_r0_r10_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r12_r0_r3_ROR_r13),
kInstruction_sbc_al_r12_r0_r3_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r1_r8_r13_ASR_r2),
kInstruction_sbc_hi_r1_r8_r13_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r7_r9_r9_ASR_r2),
kInstruction_sbc_ls_r7_r9_r9_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r9_r13_r6_ROR_r11),
kInstruction_sbc_ls_r9_r13_r6_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r11_r12_r14_LSL_r14),
kInstruction_sbc_pl_r11_r12_r14_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r1_r3_r10_ASR_r9),
kInstruction_sbc_eq_r1_r3_r10_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r1_r6_r6_LSL_r9),
kInstruction_sbc_al_r1_r6_r6_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r14_r7_ROR_r12),
kInstruction_sbc_ne_r4_r14_r7_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r2_r13_r1_ROR_r7),
kInstruction_sbc_vc_r2_r13_r1_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r13_r12_r8_LSR_r11),
kInstruction_sbc_cs_r13_r12_r8_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r14_r12_LSL_r4),
kInstruction_sbc_le_r10_r14_r12_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r9_r4_ROR_r13),
kInstruction_sbc_cs_r14_r9_r4_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r12_r8_ASR_r14),
kInstruction_sbc_ge_r10_r12_r8_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r10_r3_LSL_r13),
kInstruction_sbc_cs_r14_r10_r3_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r3_r10_LSR_r2),
kInstruction_sbc_lt_r4_r3_r10_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r12_r8_ASR_r14),
kInstruction_sbc_ls_r13_r12_r8_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r3_r2_r0_ASR_r8),
kInstruction_sbc_ge_r3_r2_r0_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r3_r7_r1_LSL_r0),
kInstruction_sbc_vs_r3_r7_r1_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r5_r13_r7_LSR_r7),
kInstruction_sbc_lt_r5_r13_r7_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r8_r4_r3_ROR_r14),
kInstruction_sbc_ls_r8_r4_r3_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r5_r4_r13_LSL_r12),
kInstruction_sbc_vc_r5_r4_r13_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r6_r10_r11_LSR_r2),
kInstruction_sbc_pl_r6_r10_r11_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r0_r6_ASR_r10),
kInstruction_sbc_ne_r4_r0_r6_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r2_r6_r7_LSR_r4),
kInstruction_sbc_vc_r2_r6_r7_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r4_r12_r1_ROR_r14),
kInstruction_sbc_pl_r4_r12_r1_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r13_r1_r10_LSL_r12),
kInstruction_sbc_cs_r13_r1_r10_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r12_r7_LSL_r10),
kInstruction_sbc_al_r7_r12_r7_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r1_r9_r13_LSR_r8),
kInstruction_sbc_ge_r1_r9_r13_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r5_r11_ASR_r2),
kInstruction_sbc_eq_r12_r5_r11_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r7_r9_r3_ASR_r14),
kInstruction_sbc_ls_r7_r9_r3_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r5_r10_r3_LSL_r12),
kInstruction_sbc_pl_r5_r10_r3_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r5_r14_r11_ASR_r13),
kInstruction_sbc_vs_r5_r14_r11_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r2_r8_LSR_r10),
kInstruction_sbc_al_r9_r2_r8_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r11_r12_r6_ROR_r11),
kInstruction_sbc_cc_r11_r12_r6_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r3_r1_LSR_r5),
kInstruction_sbc_ge_r10_r3_r1_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r4_r7_ROR_r0),
kInstruction_sbc_lt_r13_r4_r7_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r12_r12_LSR_r0),
kInstruction_sbc_ne_r2_r12_r12_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r10_r14_ASR_r10),
kInstruction_sbc_gt_r2_r10_r14_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r5_r6_r10_ASR_r11),
kInstruction_sbc_cc_r5_r6_r10_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r13_r1_ROR_r9),
kInstruction_sbc_hi_r8_r13_r1_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r1_r14_LSR_r3),
kInstruction_sbc_cc_r3_r1_r14_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r11_r9_r8_ASR_r13),
kInstruction_sbc_lt_r11_r9_r8_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r3_r13_ASR_r5),
kInstruction_sbc_mi_r0_r3_r13_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r6_r10_ASR_r6),
kInstruction_sbc_vc_r7_r6_r10_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r2_r6_r4_LSL_r9),
kInstruction_sbc_mi_r2_r6_r4_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r12_r9_r4_ROR_r6),
kInstruction_sbc_ne_r12_r9_r4_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r4_r3_r0_ROR_r4),
kInstruction_sbc_hi_r4_r3_r0_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r9_r2_r11_LSL_r13),
kInstruction_sbc_gt_r9_r2_r11_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r4_r3_LSL_r10),
kInstruction_sbc_eq_r14_r4_r3_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r8_r2_r12_LSL_r10),
kInstruction_sbc_le_r8_r2_r12_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r8_r0_r1_ASR_r8),
kInstruction_sbc_ls_r8_r0_r1_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r9_r7_LSR_r3),
kInstruction_sbc_cc_r13_r9_r7_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r6_r0_r7_ROR_r9),
kInstruction_sbc_gt_r6_r0_r7_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r14_r12_r6_LSR_r12),
kInstruction_sbc_hi_r14_r12_r6_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r7_r10_LSR_r8),
kInstruction_sbc_cs_r3_r7_r10_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r7_r7_LSL_r11),
kInstruction_sbc_le_r7_r7_r7_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r11_r11_r14_ASR_r3),
kInstruction_sbc_le_r11_r11_r14_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r13_r5_r6_LSL_r13),
kInstruction_sbc_vc_r13_r5_r6_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r12_r3_r12_LSL_r8),
kInstruction_sbc_cc_r12_r3_r12_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r4_r14_r12_ASR_r11),
kInstruction_sbc_gt_r4_r14_r12_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r6_r7_LSL_r10),
kInstruction_sbc_cs_r9_r6_r7_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r5_r3_ROR_r5),
kInstruction_sbc_ge_r9_r5_r3_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r5_r14_LSR_r4),
kInstruction_sbc_vc_r4_r5_r14_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r13_r12_r2_ASR_r14),
kInstruction_sbc_ne_r13_r12_r2_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r9_r11_LSR_r13),
kInstruction_sbc_gt_r2_r9_r11_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r10_r11_r8_LSR_r1),
kInstruction_sbc_mi_r10_r11_r8_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r8_r1_ASR_r6),
kInstruction_sbc_hi_r6_r8_r1_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r10_r12_r5_ROR_r11),
kInstruction_sbc_eq_r10_r12_r5_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r6_r4_LSL_r1),
kInstruction_sbc_mi_r9_r6_r4_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r14_r6_r0_ROR_r7),
kInstruction_sbc_vc_r14_r6_r0_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r10_r3_r12_LSL_r2),
kInstruction_sbc_mi_r10_r3_r12_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r6_r9_LSR_r14),
kInstruction_sbc_pl_r9_r6_r9_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r10_r5_r10_ROR_r1),
kInstruction_sbc_al_r10_r5_r10_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r9_r6_r2_ASR_r3),
kInstruction_sbc_ne_r9_r6_r2_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r4_r9_r4_LSL_r6),
kInstruction_sbc_hi_r4_r9_r4_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r1_r9_r7_ASR_r7),
kInstruction_sbc_vs_r1_r9_r7_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r10_r13_r9_ASR_r14),
kInstruction_sbc_ne_r10_r13_r9_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r13_r12_ASR_r12),
kInstruction_sbc_gt_r11_r13_r12_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r5_r0_LSR_r10),
kInstruction_sbc_lt_r3_r5_r0_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r4_r8_r13_ROR_r7),
kInstruction_sbc_gt_r4_r8_r13_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r14_r14_r0_ASR_r3),
kInstruction_sbc_ls_r14_r14_r0_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r2_r7_r9_ASR_r5),
kInstruction_sbc_vc_r2_r7_r9_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r3_r10_LSR_r10),
kInstruction_sbc_mi_r9_r3_r10_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r10_r3_ASR_r11),
kInstruction_sbc_gt_r11_r10_r3_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r14_r2_ROR_r12),
kInstruction_sbc_cc_r3_r14_r2_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r3_r5_r14_ROR_r12),
kInstruction_sbc_ls_r3_r5_r14_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r0_r11_ASR_r0),
kInstruction_sbc_al_r6_r0_r11_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r12_r13_LSL_r8),
kInstruction_sbc_al_r14_r12_r13_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r12_r9_r14_ROR_r4),
kInstruction_sbc_cs_r12_r9_r14_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r4_r9_r6_LSL_r10),
kInstruction_sbc_vs_r4_r9_r6_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r6_r1_r4_ASR_r6),
kInstruction_sbc_eq_r6_r1_r4_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r6_r11_r2_LSR_r10),
kInstruction_sbc_ge_r6_r11_r2_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r10_r14_r4_LSR_r0),
kInstruction_sbc_cc_r10_r14_r4_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r12_r1_ROR_r5),
kInstruction_sbc_ge_r0_r12_r1_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r1_r13_r10_ASR_r5),
kInstruction_sbc_ls_r1_r13_r10_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r8_r5_ASR_r5),
kInstruction_sbc_cc_r9_r8_r5_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r6_r5_r1_LSL_r11),
kInstruction_sbc_ls_r6_r5_r1_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r12_r1_ROR_r10),
kInstruction_sbc_ne_r2_r12_r1_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r2_r9_r9_LSR_r1),
kInstruction_sbc_cc_r2_r9_r9_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r1_r8_r1_ASR_r14),
kInstruction_sbc_ne_r1_r8_r1_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r9_r2_r1_LSR_r10),
kInstruction_sbc_lt_r9_r2_r1_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r11_r9_ROR_r6),
kInstruction_sbc_cc_r14_r11_r9_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r3_r12_r13_ASR_r0),
kInstruction_sbc_eq_r3_r12_r13_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r6_r6_ASR_r2),
kInstruction_sbc_le_r6_r6_r6_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r11_r14_r4_ASR_r1),
kInstruction_sbc_mi_r11_r14_r4_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r9_r10_LSL_r9),
kInstruction_sbc_ls_r5_r9_r10_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r9_r3_LSR_r10),
kInstruction_sbc_vc_r12_r9_r3_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r0_r4_ASR_r0),
kInstruction_sbc_lt_r12_r0_r4_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r10_r6_ROR_r9),
kInstruction_sbc_mi_r0_r10_r6_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r7_r10_r1_LSL_r7),
kInstruction_sbc_hi_r7_r10_r1_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r2_r0_r14_ROR_r5),
kInstruction_sbc_ls_r2_r0_r14_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r12_r14_r12_LSR_r10),
kInstruction_sbc_cs_r12_r14_r12_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r0_r6_ROR_r2),
kInstruction_sbc_le_r9_r0_r6_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r10_r4_LSR_r12),
kInstruction_sbc_cc_r3_r10_r4_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r4_r5_r2_ASR_r14),
kInstruction_sbc_mi_r4_r5_r2_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r8_r10_ROR_r14),
kInstruction_sbc_vc_r12_r8_r10_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r5_r14_r4_ASR_r10),
kInstruction_sbc_al_r5_r14_r4_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r8_r3_ASR_r1),
kInstruction_sbc_ls_r13_r8_r3_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r1_r2_LSR_r4),
kInstruction_sbc_le_r10_r1_r2_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r0_r2_r10_ROR_r7),
kInstruction_sbc_ne_r0_r2_r10_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r11_r13_r11_LSR_r12),
kInstruction_sbc_vs_r11_r13_r11_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r10_r10_r8_ROR_r8),
kInstruction_sbc_vs_r10_r10_r8_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r2_r9_LSL_r11),
kInstruction_sbc_ne_r7_r2_r9_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r5_r12_r11_ASR_r5),
kInstruction_sbc_mi_r5_r12_r11_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r1_r10_r5_ROR_r5),
kInstruction_sbc_le_r1_r10_r5_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r14_r3_ASR_r6),
kInstruction_sbc_cc_r3_r14_r3_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r4_r0_ROR_r2),
kInstruction_sbc_vc_r4_r4_r0_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r3_r4_r12_ROR_r14),
kInstruction_sbc_le_r3_r4_r12_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r3_r7_r14_LSL_r11),
kInstruction_sbc_al_r3_r7_r14_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r11_r0_LSL_r11),
kInstruction_sbc_vc_r8_r11_r0_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r12_r9_r14_LSR_r2),
kInstruction_sbc_vs_r12_r9_r14_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r3_r5_r5_ROR_r6),
kInstruction_sbc_hi_r3_r5_r5_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r3_r13_ASR_r7),
kInstruction_sbc_cs_r9_r3_r13_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r3_r6_LSR_r5),
kInstruction_sbc_eq_r14_r3_r6_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r8_r3_r4_LSR_r13),
kInstruction_sbc_lt_r8_r3_r4_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r4_r12_ROR_r6),
kInstruction_sbc_vc_r7_r4_r12_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r5_r3_r3_ASR_r1),
kInstruction_sbc_vs_r5_r3_r3_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r5_r6_r1_ROR_r7),
kInstruction_sbc_le_r5_r6_r1_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r11_r5_r11_LSL_r12),
kInstruction_sbc_ge_r11_r5_r11_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r3_r7_ASR_r14),
kInstruction_sbc_lt_r0_r3_r7_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r2_r10_LSL_r1),
kInstruction_sbc_cs_r9_r2_r10_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r6_r8_r6_ASR_r1),
kInstruction_sbc_cs_r6_r8_r6_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r11_r14_ASR_r5),
kInstruction_sbc_lt_r0_r11_r14_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r11_r11_r2_ASR_r3),
kInstruction_sbc_ge_r11_r11_r2_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r0_r14_LSL_r2),
kInstruction_sbc_lt_r0_r0_r14_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r8_r9_r11_ROR_r8),
kInstruction_sbc_cs_r8_r9_r11_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r5_r12_ASR_r14),
kInstruction_sbc_pl_r9_r5_r12_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r13_r11_r1_LSR_r1),
kInstruction_sbc_eq_r13_r11_r1_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r1_r0_r13_ROR_r0),
kInstruction_sbc_ne_r1_r0_r13_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r5_r9_LSR_r10),
kInstruction_sbc_hi_r6_r5_r9_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r7_r7_ASR_r9),
kInstruction_sbc_lt_r4_r7_r7_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r13_r13_r5_LSR_r1),
kInstruction_sbc_ls_r13_r13_r5_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r12_r1_r6_LSR_r14),
kInstruction_sbc_cs_r12_r1_r6_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r11_r0_r5_LSR_r3),
kInstruction_sbc_hi_r11_r0_r5_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r2_r14_LSR_r1),
kInstruction_sbc_ne_r5_r2_r14_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r12_r9_LSR_r5),
kInstruction_sbc_le_r6_r12_r9_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r1_r11_r1_LSL_r2),
kInstruction_sbc_cs_r1_r11_r1_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r10_r8_ASR_r4),
kInstruction_sbc_al_r14_r10_r8_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r10_r8_LSL_r6),
kInstruction_sbc_al_r11_r10_r8_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r1_r2_r1_LSL_r11),
kInstruction_sbc_vs_r1_r2_r1_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r14_r14_LSL_r0),
kInstruction_sbc_cs_r10_r14_r14_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r0_r1_r14_ROR_r10),
kInstruction_sbc_pl_r0_r1_r14_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r3_r7_r5_LSR_r1),
kInstruction_sbc_pl_r3_r7_r5_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r2_r14_r10_LSL_r6),
kInstruction_sbc_gt_r2_r14_r10_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r7_r8_ROR_r0),
kInstruction_sbc_le_r7_r7_r8_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r9_r8_LSL_r14),
kInstruction_sbc_cs_r7_r9_r8_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r11_r4_r3_LSR_r10),
kInstruction_sbc_cs_r11_r4_r3_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r1_r12_ROR_r4),
kInstruction_sbc_cc_r9_r1_r12_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r10_r0_r10_LSL_r8),
kInstruction_sbc_hi_r10_r0_r10_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r1_r0_LSL_r11),
kInstruction_sbc_eq_r14_r1_r0_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r11_r5_ROR_r5),
kInstruction_sbc_mi_r9_r11_r5_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r5_r9_r2_LSL_r1),
kInstruction_sbc_le_r5_r9_r2_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r7_r7_r8_ASR_r13),
kInstruction_sbc_pl_r7_r7_r8_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r14_r13_r10_ASR_r11),
kInstruction_sbc_gt_r14_r13_r10_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r6_r5_LSR_r7),
kInstruction_sbc_cs_r4_r6_r5_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r2_r7_r7_LSL_r6),
kInstruction_sbc_lt_r2_r7_r7_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r4_r5_r2_ROR_r5),
kInstruction_sbc_al_r4_r5_r2_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r2_r9_ROR_r7),
kInstruction_sbc_cc_r6_r2_r9_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r4_r0_r0_LSR_r11),
kInstruction_sbc_pl_r4_r0_r0_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r6_r10_r12_LSL_r11),
kInstruction_sbc_pl_r6_r10_r12_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r0_r14_r1_LSR_r6),
kInstruction_sbc_al_r0_r14_r1_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r7_r9_r13_LSR_r1),
kInstruction_sbc_cs_r7_r9_r13_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r4_r2_r10_ROR_r3),
kInstruction_sbc_al_r4_r2_r10_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r12_r4_r14_ROR_r7),
kInstruction_sbc_gt_r12_r4_r14_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r11_r0_r14_ASR_r7),
kInstruction_sbc_cs_r11_r0_r14_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r0_r2_r4_ASR_r14),
kInstruction_sbc_pl_r0_r2_r4_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r4_r9_LSR_r5),
kInstruction_sbc_mi_r14_r4_r9_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r13_r0_r1_ROR_r5),
kInstruction_sbc_ge_r13_r0_r1_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r14_r0_LSL_r11),
kInstruction_sbc_eq_r12_r14_r0_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r6_r4_r10_ROR_r13),
kInstruction_sbc_ge_r6_r4_r10_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r7_r2_ASR_r5),
kInstruction_sbc_lt_r3_r7_r2_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r9_r0_r12_ROR_r0),
kInstruction_sbc_al_r9_r0_r12_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r1_r9_r7_LSL_r12),
kInstruction_sbc_le_r1_r9_r7_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r14_r7_r4_ASR_r7),
kInstruction_sbc_lt_r14_r7_r4_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r6_r9_LSR_r8),
kInstruction_sbc_ne_r4_r6_r9_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r5_r1_ASR_r6),
kInstruction_sbc_cc_r0_r5_r1_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r2_r13_r2_ROR_r6),
kInstruction_sbc_cc_r2_r13_r2_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r0_r9_ROR_r6),
kInstruction_sbc_ge_r10_r0_r9_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r8_r1_r11_LSR_r0),
kInstruction_sbc_gt_r8_r1_r11_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r14_r0_r9_LSL_r0),
kInstruction_sbc_al_r14_r0_r9_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r12_r3_r12_ROR_r9),
kInstruction_sbc_hi_r12_r3_r12_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r4_r12_r3_LSL_r2),
kInstruction_sbc_eq_r4_r12_r3_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r3_r4_LSL_r4),
kInstruction_sbc_ne_r5_r3_r4_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r6_r10_LSL_r11),
kInstruction_sbc_vc_r8_r6_r10_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r1_r4_ASR_r3),
kInstruction_sbc_lt_r0_r1_r4_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r14_r4_r1_ROR_r7),
kInstruction_sbc_le_r14_r4_r1_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r12_r12_r5_LSL_r2),
kInstruction_sbc_al_r12_r12_r5_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r10_r3_r10_ROR_r13),
kInstruction_sbc_eq_r10_r3_r10_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r7_r10_r1_LSR_r14),
kInstruction_sbc_ne_r7_r10_r1_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r10_r4_r10_LSR_r5),
kInstruction_sbc_lt_r10_r4_r10_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r0_r14_r0_LSL_r2),
kInstruction_sbc_pl_r0_r14_r0_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r7_r4_r11_LSL_r3),
kInstruction_sbc_gt_r7_r4_r11_LSL_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r8_r2_r1_LSR_r8),
kInstruction_sbc_cs_r8_r2_r1_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r11_r4_ASR_r7),
kInstruction_sbc_pl_r9_r11_r4_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r5_r12_ROR_r4),
kInstruction_sbc_cc_r9_r5_r12_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r11_r3_LSR_r12),
kInstruction_sbc_vc_r0_r11_r3_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r6_r2_r4_LSR_r4),
kInstruction_sbc_gt_r6_r2_r4_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r2_r0_LSL_r12),
kInstruction_sbc_lt_r4_r2_r0_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r4_r13_ROR_r5),
kInstruction_sbc_le_r9_r4_r13_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r9_r3_r8_LSR_r8),
kInstruction_sbc_vs_r9_r3_r8_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r3_r8_r14_ROR_r8),
kInstruction_sbc_ne_r3_r8_r14_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r13_r4_LSR_r9),
kInstruction_sbc_vc_r12_r13_r4_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r0_r8_LSL_r1),
kInstruction_sbc_cc_r14_r0_r8_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r3_r5_ASR_r9),
kInstruction_sbc_hi_r6_r3_r5_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r14_r4_r3_LSL_r8),
kInstruction_sbc_ne_r14_r4_r3_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r1_r10_r13_LSR_r4),
kInstruction_sbc_ge_r1_r10_r13_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r7_r6_ROR_r3),
kInstruction_sbc_vc_r12_r7_r6_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r6_r7_ROR_r2),
kInstruction_sbc_gt_r0_r6_r7_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r4_r6_r9_LSL_r0),
kInstruction_sbc_al_r4_r6_r9_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r1_r3_r11_LSR_r11),
kInstruction_sbc_ls_r1_r3_r11_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r11_r1_LSR_r14),
kInstruction_sbc_lt_r3_r11_r1_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r6_r13_r7_ROR_r11),
kInstruction_sbc_vc_r6_r13_r7_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r5_r14_r13_ROR_r13),
kInstruction_sbc_vc_r5_r14_r13_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r1_r4_r11_LSL_r1),
kInstruction_sbc_vc_r1_r4_r11_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r7_r3_r5_LSR_r6),
kInstruction_sbc_ls_r7_r3_r5_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r13_r8_r3_ASR_r4),
kInstruction_sbc_vc_r13_r8_r3_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r2_r3_r10_ROR_r11),
kInstruction_sbc_ls_r2_r3_r10_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r6_r1_r12_ASR_r11),
kInstruction_sbc_ge_r6_r1_r12_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r1_r1_ASR_r14),
kInstruction_sbc_lt_r3_r1_r1_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r2_r7_r14_LSL_r12),
kInstruction_sbc_hi_r2_r7_r14_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r13_r10_r10_LSL_r14),
kInstruction_sbc_ge_r13_r10_r10_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r0_r1_r3_LSR_r3),
kInstruction_sbc_le_r0_r1_r3_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r10_r7_r7_LSR_r6),
kInstruction_sbc_vs_r10_r7_r7_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r3_r6_LSL_r7),
kInstruction_sbc_al_r6_r3_r6_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r3_r8_r14_ASR_r1),
kInstruction_sbc_ne_r3_r8_r14_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r4_r10_r4_LSR_r9),
kInstruction_sbc_cc_r4_r10_r4_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r1_r5_LSR_r10),
kInstruction_sbc_cs_r4_r1_r5_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r7_r6_r1_LSL_r4),
kInstruction_sbc_eq_r7_r6_r1_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r3_r7_r1_LSL_r5),
kInstruction_sbc_hi_r3_r7_r1_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r11_r8_LSR_r12),
kInstruction_sbc_al_r6_r11_r8_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r2_r5_r0_LSR_r5),
kInstruction_sbc_ls_r2_r5_r0_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r4_r5_r13_LSL_r9),
kInstruction_sbc_pl_r4_r5_r13_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r12_r0_ASR_r8),
kInstruction_sbc_lt_r13_r12_r0_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r11_r5_r0_LSL_r12),
kInstruction_sbc_cc_r11_r5_r0_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r6_r2_r2_ROR_r0),
kInstruction_sbc_ne_r6_r2_r2_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r9_r13_r12_ASR_r6),
kInstruction_sbc_ne_r9_r13_r12_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r8_r6_r10_ROR_r10),
kInstruction_sbc_cs_r8_r6_r10_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r10_r6_r1_LSL_r6),
kInstruction_sbc_vs_r10_r6_r1_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r12_r0_r4_ASR_r10),
kInstruction_sbc_vc_r12_r0_r4_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r2_r11_ROR_r8),
kInstruction_sbc_cs_r10_r2_r11_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r0_r9_r14_ASR_r14),
kInstruction_sbc_ne_r0_r9_r14_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r0_r10_r1_ASR_r8),
kInstruction_sbc_eq_r0_r10_r1_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r11_r3_LSR_r0),
kInstruction_sbc_gt_r0_r11_r3_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r5_r11_r6_ROR_r14),
kInstruction_sbc_al_r5_r11_r6_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r2_r11_r11_ROR_r2),
kInstruction_sbc_ls_r2_r11_r11_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r2_r11_r6_ROR_r11),
kInstruction_sbc_cs_r2_r11_r6_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r9_r11_ASR_r5),
kInstruction_sbc_cs_r4_r9_r11_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r0_r2_ASR_r3),
kInstruction_sbc_ls_r5_r0_r2_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r1_r13_LSR_r2),
kInstruction_sbc_cc_r14_r1_r13_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r5_r6_ASR_r0),
kInstruction_sbc_lt_r4_r5_r6_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r12_r6_ASR_r6),
kInstruction_sbc_vc_r0_r12_r6_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r3_r10_r4_LSR_r8),
kInstruction_sbc_pl_r3_r10_r4_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r10_r5_r10_ASR_r10),
kInstruction_sbc_cc_r10_r5_r10_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r2_r14_r1_ASR_r10),
kInstruction_sbc_pl_r2_r14_r1_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r13_r8_ROR_r12),
kInstruction_sbc_eq_r12_r13_r8_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r9_r8_r2_LSL_r2),
kInstruction_sbc_gt_r9_r8_r2_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r10_r10_LSL_r9),
kInstruction_sbc_al_r13_r10_r10_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r8_r8_r6_ROR_r14),
kInstruction_sbc_eq_r8_r8_r6_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r14_r12_r4_ASR_r13),
kInstruction_sbc_le_r14_r12_r4_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r6_r12_LSR_r2),
kInstruction_sbc_cc_r3_r6_r12_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r14_r10_LSL_r6),
kInstruction_sbc_ls_r5_r14_r10_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r12_r2_r1_ROR_r3),
kInstruction_sbc_hi_r12_r2_r1_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r13_r1_LSL_r12),
kInstruction_sbc_vc_r7_r13_r1_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r0_r3_r13_LSL_r9),
kInstruction_sbc_cc_r0_r3_r13_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r0_r11_r5_LSL_r11),
kInstruction_sbc_hi_r0_r11_r5_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r6_r14_LSR_r14),
kInstruction_sbc_ge_r9_r6_r14_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r2_r5_r2_ROR_r12),
kInstruction_sbc_vc_r2_r5_r2_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r6_r9_ASR_r13),
kInstruction_sbc_mi_r9_r6_r9_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r1_r3_r10_ASR_r2),
kInstruction_sbc_pl_r1_r3_r10_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r9_r7_LSL_r4),
kInstruction_sbc_le_r10_r9_r7_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r7_r4_r10_LSR_r6),
kInstruction_sbc_hi_r7_r4_r10_LSR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r8_r13_LSR_r3),
kInstruction_sbc_cc_r6_r8_r13_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r4_r9_r6_ASR_r0),
kInstruction_sbc_cs_r4_r9_r6_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r0_r2_r4_ASR_r8),
kInstruction_sbc_ls_r0_r2_r4_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r11_r5_r11_LSR_r1),
kInstruction_sbc_hi_r11_r5_r11_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r3_r6_LSR_r7),
kInstruction_sbc_vc_r0_r3_r6_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r13_r10_r8_LSL_r6),
kInstruction_sbc_cs_r13_r10_r8_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r12_r12_r10_ASR_r13),
kInstruction_sbc_al_r12_r12_r10_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r7_r7_r2_ASR_r8),
kInstruction_sbc_ge_r7_r7_r2_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r10_r7_r6_LSL_r14),
kInstruction_sbc_ne_r10_r7_r6_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r9_r14_ROR_r0),
kInstruction_sbc_cs_r9_r9_r14_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r3_r12_r0_ASR_r12),
kInstruction_sbc_lt_r3_r12_r0_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r6_r9_r3_ASR_r11),
kInstruction_sbc_ne_r6_r9_r3_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r7_r7_ASR_r7),
kInstruction_sbc_vc_r4_r7_r7_ASR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r0_r9_r5_LSR_r14),
kInstruction_sbc_ne_r0_r9_r5_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r13_r1_ROR_r0),
kInstruction_sbc_hi_r8_r13_r1_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r1_r7_ROR_r5),
kInstruction_sbc_cc_r6_r1_r7_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r13_r2_LSL_r4),
kInstruction_sbc_vc_r7_r13_r2_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r4_r2_r3_ROR_r10),
kInstruction_sbc_al_r4_r2_r3_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r0_r7_r3_LSR_r12),
kInstruction_sbc_ls_r0_r7_r3_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r8_r8_ASR_r13),
kInstruction_sbc_ls_r5_r8_r8_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r6_r12_ASR_r14),
kInstruction_sbc_gt_r0_r6_r12_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r7_r13_r14_LSR_r11),
kInstruction_sbc_vs_r7_r13_r14_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r12_r9_r11_LSL_r13),
kInstruction_sbc_mi_r12_r9_r11_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r0_r7_ROR_r13),
kInstruction_sbc_ge_r0_r0_r7_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r14_r12_r6_LSR_r8),
kInstruction_sbc_hi_r14_r12_r6_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r3_r6_LSL_r6),
kInstruction_sbc_cs_r0_r3_r6_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r6_r9_r4_ASR_r3),
kInstruction_sbc_al_r6_r9_r4_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r6_r1_LSR_r3),
kInstruction_sbc_ls_r5_r6_r1_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r3_r6_r14_ROR_r7),
kInstruction_sbc_ls_r3_r6_r14_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r5_r1_ASR_r12),
kInstruction_sbc_le_r10_r5_r1_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r3_r6_r10_ASR_r5),
kInstruction_sbc_hi_r3_r6_r10_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r3_r5_ROR_r8),
kInstruction_sbc_mi_r9_r3_r5_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r10_r13_r8_ROR_r11),
kInstruction_sbc_hi_r10_r13_r8_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r14_r2_ROR_r1),
kInstruction_sbc_al_r11_r14_r2_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r12_r8_r0_ROR_r11),
kInstruction_sbc_gt_r12_r8_r0_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r1_r0_r1_ROR_r9),
kInstruction_sbc_vc_r1_r0_r1_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r6_r6_r3_ASR_r5),
kInstruction_sbc_mi_r6_r6_r3_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r12_r4_ROR_r9),
kInstruction_sbc_ge_r12_r12_r4_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r4_r6_r9_ASR_r6),
kInstruction_sbc_ls_r4_r6_r9_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r11_r3_r4_LSR_r9),
kInstruction_sbc_pl_r11_r3_r4_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r0_r2_r2_ROR_r7),
kInstruction_sbc_hi_r0_r2_r2_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r3_r12_r0_ASR_r2),
kInstruction_sbc_pl_r3_r12_r0_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r6_r0_r9_LSL_r4),
kInstruction_sbc_ne_r6_r0_r9_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r1_r2_r6_ROR_r13),
kInstruction_sbc_vc_r1_r2_r6_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r1_r12_LSL_r14),
kInstruction_sbc_ge_r9_r1_r12_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r9_r6_ROR_r14),
kInstruction_sbc_pl_r13_r9_r6_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r13_r13_LSL_r9),
kInstruction_sbc_gt_r0_r13_r13_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r13_r5_r5_ASR_r8),
kInstruction_sbc_mi_r13_r5_r5_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r1_r4_r0_LSL_r6),
kInstruction_sbc_gt_r1_r4_r0_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r4_r7_ROR_r4),
kInstruction_sbc_ls_r5_r4_r7_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r8_r0_ROR_r9),
kInstruction_sbc_vc_r8_r8_r0_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r12_r12_r10_ROR_r8),
kInstruction_sbc_mi_r12_r12_r10_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r6_r6_LSL_r2),
kInstruction_sbc_hi_r6_r6_r6_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r10_r14_LSL_r1),
kInstruction_sbc_le_r7_r10_r14_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r13_r10_r6_ASR_r9),
kInstruction_sbc_ne_r13_r10_r6_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r8_r8_r2_LSR_r13),
kInstruction_sbc_ne_r8_r8_r2_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r10_r14_ROR_r12),
kInstruction_sbc_mi_r0_r10_r14_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r11_r14_r4_LSL_r5),
kInstruction_sbc_cc_r11_r14_r4_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r3_r6_r3_ROR_r4),
kInstruction_sbc_cc_r3_r6_r3_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r11_r1_r7_LSR_r7),
kInstruction_sbc_mi_r11_r1_r7_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r12_r2_r2_LSL_r12),
kInstruction_sbc_vs_r12_r2_r2_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r2_r2_r6_LSR_r0),
kInstruction_sbc_pl_r2_r2_r6_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r12_r7_LSR_r12),
kInstruction_sbc_gt_r11_r12_r7_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r13_r4_r4_ASR_r12),
kInstruction_sbc_al_r13_r4_r4_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r1_r9_ROR_r1),
kInstruction_sbc_le_r9_r1_r9_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r1_r12_r8_ASR_r14),
kInstruction_sbc_le_r1_r12_r8_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r1_r0_r7_ROR_r13),
kInstruction_sbc_cs_r1_r0_r7_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r0_r7_r7_ROR_r5),
kInstruction_sbc_le_r0_r7_r7_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r5_r7_ROR_r4),
kInstruction_sbc_hi_r6_r5_r7_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r6_r14_r13_ASR_r1),
kInstruction_sbc_eq_r6_r14_r13_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r14_r13_LSR_r13),
kInstruction_sbc_lt_r1_r14_r13_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r13_r1_r2_ROR_r6),
kInstruction_sbc_vs_r13_r1_r2_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r11_r7_r8_ASR_r3),
kInstruction_sbc_gt_r11_r7_r8_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r9_r5_r8_ASR_r8),
kInstruction_sbc_hi_r9_r5_r8_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r10_r9_r5_LSL_r8),
kInstruction_sbc_lt_r10_r9_r5_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r6_r1_r2_LSL_r4),
kInstruction_sbc_vs_r6_r1_r2_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r4_r10_LSR_r12),
kInstruction_sbc_pl_r13_r4_r10_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r8_r8_LSL_r6),
kInstruction_sbc_cs_r9_r8_r8_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r1_r7_r0_ASR_r2),
kInstruction_sbc_ne_r1_r7_r0_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r3_r9_ASR_r3),
kInstruction_sbc_cc_r6_r3_r9_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r13_r14_r7_ROR_r13),
kInstruction_sbc_hi_r13_r14_r7_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r11_r0_LSR_r8),
kInstruction_sbc_vc_r7_r11_r0_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r3_r2_r7_LSL_r12),
kInstruction_sbc_al_r3_r2_r7_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r0_r5_r5_LSR_r1),
kInstruction_sbc_lt_r0_r5_r5_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r10_r10_r4_ROR_r11),
kInstruction_sbc_ge_r10_r10_r4_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r13_r9_r1_ROR_r12),
kInstruction_sbc_ne_r13_r9_r1_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r6_r6_r2_ROR_r3),
kInstruction_sbc_eq_r6_r6_r2_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r4_r1_ROR_r5),
kInstruction_sbc_gt_r0_r4_r1_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r5_r8_r0_ROR_r0),
kInstruction_sbc_lt_r5_r8_r0_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r5_r13_r2_LSR_r8),
kInstruction_sbc_cs_r5_r13_r2_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r13_r2_LSL_r7),
kInstruction_sbc_le_r7_r13_r2_LSL_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r7_r1_r3_LSL_r1),
kInstruction_sbc_gt_r7_r1_r3_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r4_r13_r10_ROR_r8),
kInstruction_sbc_vc_r4_r13_r10_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r2_r8_r11_ROR_r4),
kInstruction_sbc_eq_r2_r8_r11_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r1_r6_LSR_r9),
kInstruction_sbc_le_r10_r1_r6_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r5_r1_r9_ASR_r10),
kInstruction_sbc_ge_r5_r1_r9_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r1_r5_r5_LSR_r7),
kInstruction_sbc_al_r1_r5_r5_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r2_r13_r5_LSR_r8),
kInstruction_sbc_cs_r2_r13_r5_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r6_r3_ROR_r3),
kInstruction_sbc_le_r6_r6_r3_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r5_r1_r7_ROR_r12),
kInstruction_sbc_le_r5_r1_r7_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r9_r3_r9_ASR_r4),
kInstruction_sbc_cc_r9_r3_r9_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r6_r2_r9_LSL_r5),
kInstruction_sbc_mi_r6_r2_r9_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r5_r0_r4_ASR_r12),
kInstruction_sbc_cc_r5_r0_r4_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r13_r12_LSL_r11),
kInstruction_sbc_vc_r8_r13_r12_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r7_r14_r9_LSR_r11),
kInstruction_sbc_lt_r7_r14_r9_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r1_r5_r3_ASR_r1),
kInstruction_sbc_cs_r1_r5_r3_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r14_r11_r6_ASR_r9),
kInstruction_sbc_lt_r14_r11_r6_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r5_r13_LSR_r3),
kInstruction_sbc_gt_r10_r5_r13_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r6_r4_r12_LSL_r4),
kInstruction_sbc_cc_r6_r4_r12_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r12_r10_ROR_r11),
kInstruction_sbc_ne_r2_r12_r10_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r8_r0_r6_ASR_r10),
kInstruction_sbc_eq_r8_r0_r6_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r3_r14_LSR_r7),
kInstruction_sbc_cc_r14_r3_r14_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r10_r1_ASR_r13),
kInstruction_sbc_lt_r1_r10_r1_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r14_r3_r0_LSL_r12),
kInstruction_sbc_cc_r14_r3_r0_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r10_r7_LSL_r2),
kInstruction_sbc_vs_r8_r10_r7_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r6_r3_ASR_r2),
kInstruction_sbc_ls_r5_r6_r3_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r5_r13_LSL_r10),
kInstruction_sbc_vc_r11_r5_r13_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r2_r10_r7_LSR_r0),
kInstruction_sbc_hi_r2_r10_r7_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r6_r8_ASR_r4),
kInstruction_sbc_ne_r5_r6_r8_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r12_r8_ASR_r5),
kInstruction_sbc_cs_r3_r12_r8_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r3_r4_r4_LSR_r0),
kInstruction_sbc_ge_r3_r4_r4_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r13_r13_r6_ROR_r13),
kInstruction_sbc_ge_r13_r13_r6_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r4_r9_r0_LSL_r9),
kInstruction_sbc_eq_r4_r9_r0_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r7_r3_r1_ROR_r8),
kInstruction_sbc_le_r7_r3_r1_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r9_r2_r5_LSL_r4),
kInstruction_sbc_gt_r9_r2_r5_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r12_r9_ROR_r12),
kInstruction_sbc_gt_r10_r12_r9_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r4_r9_r6_LSR_r14),
kInstruction_sbc_hi_r4_r9_r6_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r1_r10_r9_LSR_r8),
kInstruction_sbc_pl_r1_r10_r9_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r11_r2_ROR_r13),
kInstruction_sbc_mi_r0_r11_r2_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r14_r5_r4_ASR_r2),
kInstruction_sbc_ge_r14_r5_r4_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r8_r9_ROR_r10),
kInstruction_sbc_vc_r7_r8_r9_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r3_r1_r0_ROR_r7),
kInstruction_sbc_cs_r3_r1_r0_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r9_r11_r4_ASR_r14),
kInstruction_sbc_hi_r9_r11_r4_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r8_r6_LSR_r12),
kInstruction_sbc_mi_r3_r8_r6_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r5_r5_r6_LSL_r1),
kInstruction_sbc_vc_r5_r5_r6_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r4_r8_r1_ASR_r3),
kInstruction_sbc_mi_r4_r8_r1_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r6_r0_r0_LSL_r0),
kInstruction_sbc_le_r6_r0_r0_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r11_r8_LSL_r14),
kInstruction_sbc_hi_r8_r11_r8_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r14_r8_r12_ASR_r13),
kInstruction_sbc_gt_r14_r8_r12_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r7_r7_r4_ROR_r7),
kInstruction_sbc_ge_r7_r7_r4_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r4_r13_LSL_r3),
kInstruction_sbc_eq_r11_r4_r13_LSL_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r3_r6_r6_LSL_r10),
kInstruction_sbc_eq_r3_r6_r6_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r3_r10_r11_ROR_r12),
kInstruction_sbc_al_r3_r10_r11_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r7_r8_LSL_r13),
kInstruction_sbc_pl_r13_r7_r8_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r2_r11_LSR_r2),
kInstruction_sbc_pl_r9_r2_r11_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r3_r12_r8_LSR_r2),
kInstruction_sbc_al_r3_r12_r8_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r4_r14_r6_ROR_r0),
kInstruction_sbc_ne_r4_r14_r6_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r6_r14_r13_ASR_r3),
kInstruction_sbc_cs_r6_r14_r13_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r6_r8_LSR_r7),
kInstruction_sbc_pl_r10_r6_r8_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r10_r1_r12_ROR_r6),
kInstruction_sbc_ls_r10_r1_r12_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r12_r0_r1_LSL_r9),
kInstruction_sbc_eq_r12_r0_r1_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r11_r14_r8_ROR_r6),
kInstruction_sbc_hi_r11_r14_r8_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r9_r2_r5_LSL_r6),
kInstruction_sbc_vc_r9_r2_r5_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r11_r8_r5_LSR_r11),
kInstruction_sbc_ne_r11_r8_r5_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r1_r12_r3_ASR_r5),
kInstruction_sbc_mi_r1_r12_r3_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r14_r7_r1_ASR_r12),
kInstruction_sbc_pl_r14_r7_r1_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r9_r4_r1_ASR_r1),
kInstruction_sbc_pl_r9_r4_r1_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r11_r0_r5_ROR_r14),
kInstruction_sbc_ls_r11_r0_r5_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r10_r14_ROR_r13),
kInstruction_sbc_lt_r13_r10_r14_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r3_r14_r10_LSR_r4),
kInstruction_sbc_gt_r3_r14_r10_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r1_r0_r5_ROR_r7),
kInstruction_sbc_cc_r1_r0_r5_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r2_r14_r0_LSR_r14),
kInstruction_sbc_hi_r2_r14_r0_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r3_r7_r2_ASR_r9),
kInstruction_sbc_pl_r3_r7_r2_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r7_r5_r0_ROR_r6),
kInstruction_sbc_eq_r7_r5_r0_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r9_r14_LSR_r5),
kInstruction_sbc_mi_r14_r9_r14_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r6_r1_r1_LSL_r12),
kInstruction_sbc_mi_r6_r1_r1_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r0_r8_LSR_r0),
kInstruction_sbc_ge_r12_r0_r8_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r8_r3_ROR_r7),
kInstruction_sbc_cc_r13_r8_r3_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r7_r9_r4_LSL_r11),
kInstruction_sbc_vs_r7_r9_r4_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r10_r9_LSR_r5),
kInstruction_sbc_ge_r9_r10_r9_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r3_r0_LSR_r7),
kInstruction_sbc_ls_r5_r3_r0_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r0_r6_r1_LSL_r11),
kInstruction_sbc_eq_r0_r6_r1_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r7_r0_ROR_r11),
kInstruction_sbc_ge_r9_r7_r0_ROR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r4_r2_r3_LSL_r12),
kInstruction_sbc_mi_r4_r2_r3_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r7_r5_r0_ASR_r5),
kInstruction_sbc_hi_r7_r5_r0_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r7_r13_r7_LSL_r14),
kInstruction_sbc_cc_r7_r13_r7_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r2_r11_r2_LSL_r14),
kInstruction_sbc_ne_r2_r11_r2_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r7_r5_r3_LSR_r11),
kInstruction_sbc_cc_r7_r5_r3_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r0_r12_ASR_r10),
kInstruction_sbc_ge_r12_r0_r12_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r0_r2_LSR_r11),
kInstruction_sbc_al_r11_r0_r2_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r1_r12_r1_ROR_r1),
kInstruction_sbc_cc_r1_r12_r1_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r9_r6_ASR_r4),
kInstruction_sbc_ls_r5_r9_r6_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r13_r2_ROR_r12),
kInstruction_sbc_ne_r5_r13_r2_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r10_r12_ROR_r10),
kInstruction_sbc_ge_r9_r10_r12_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r10_r1_r8_LSR_r12),
kInstruction_sbc_cc_r10_r1_r8_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r6_r11_ROR_r3),
kInstruction_sbc_le_r9_r6_r11_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r9_r13_ASR_r5),
kInstruction_sbc_le_r9_r9_r13_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r1_r12_r11_LSL_r12),
kInstruction_sbc_ge_r1_r12_r11_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r11_r4_r6_LSL_r10),
kInstruction_sbc_vs_r11_r4_r6_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r3_r3_r1_ROR_r2),
kInstruction_sbc_vs_r3_r3_r1_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r12_r8_r12_ASR_r11),
kInstruction_sbc_ne_r12_r8_r12_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r4_r8_r1_ROR_r8),
kInstruction_sbc_pl_r4_r8_r1_ROR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r3_r11_r13_ROR_r9),
kInstruction_sbc_gt_r3_r11_r13_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r6_r0_r3_LSR_r9),
kInstruction_sbc_pl_r6_r0_r3_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r5_r7_r9_LSL_r10),
kInstruction_sbc_ne_r5_r7_r9_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r1_r12_r12_LSR_r8),
kInstruction_sbc_lt_r1_r12_r12_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r2_r0_r0_ROR_r5),
kInstruction_sbc_cc_r2_r0_r0_ROR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r11_r8_LSR_r14),
kInstruction_sbc_vc_r7_r11_r8_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r0_r11_r6_ROR_r10),
kInstruction_sbc_ge_r0_r11_r6_ROR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r9_r1_LSR_r0),
kInstruction_sbc_vs_r0_r9_r1_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r13_r7_r11_LSR_r1),
kInstruction_sbc_gt_r13_r7_r11_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r9_r10_r2_ROR_r12),
kInstruction_sbc_eq_r9_r10_r2_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r0_r4_r0_LSR_r3),
kInstruction_sbc_eq_r0_r4_r0_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r2_r9_ASR_r12),
kInstruction_sbc_cs_r14_r2_r9_ASR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r9_r4_r9_ASR_r8),
kInstruction_sbc_lt_r9_r4_r9_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r6_r12_r3_LSL_r11),
kInstruction_sbc_vs_r6_r12_r3_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r14_r10_ROR_r0),
kInstruction_sbc_ge_r9_r14_r10_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r2_r5_LSL_r12),
kInstruction_sbc_pl_r10_r2_r5_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r8_r0_r6_ROR_r6),
kInstruction_sbc_al_r8_r0_r6_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r9_r7_r7_LSR_r11),
kInstruction_sbc_le_r9_r7_r7_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r3_r4_r5_LSR_r1),
kInstruction_sbc_vc_r3_r4_r5_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r13_r1_r4_LSR_r11),
kInstruction_sbc_cc_r13_r1_r4_LSR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r13_r4_r0_LSL_r10),
kInstruction_sbc_vc_r13_r4_r0_LSL_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r5_r0_r1_LSR_r1),
kInstruction_sbc_vc_r5_r0_r1_LSR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r5_r11_r1_ASR_r9),
kInstruction_sbc_ls_r5_r11_r1_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r3_r2_r8_ASR_r1),
kInstruction_sbc_vs_r3_r2_r8_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r4_r6_ASR_r4),
kInstruction_sbc_hi_r8_r4_r6_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r11_r12_r14_ASR_r13),
kInstruction_sbc_mi_r11_r12_r14_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r7_r12_r12_LSL_r14),
kInstruction_sbc_gt_r7_r12_r12_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r11_r4_r9_LSR_r7),
kInstruction_sbc_ge_r11_r4_r9_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r4_r10_LSL_r2),
kInstruction_sbc_vs_r0_r4_r10_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r6_r4_r13_ASR_r0),
kInstruction_sbc_pl_r6_r4_r13_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r2_r3_r11_ROR_r1),
kInstruction_sbc_eq_r2_r3_r11_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r10_r9_r0_LSL_r4),
kInstruction_sbc_vs_r10_r9_r0_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r0_r7_r10_LSL_r0),
kInstruction_sbc_cs_r0_r7_r10_LSL_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r2_r3_ASR_r13),
kInstruction_sbc_eq_r11_r2_r3_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r3_r7_ASR_r14),
kInstruction_sbc_eq_r14_r3_r7_ASR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r0_r2_r0_LSL_r12),
kInstruction_sbc_gt_r0_r2_r0_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r0_r12_r6_LSR_r13),
kInstruction_sbc_mi_r0_r12_r6_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r4_r4_r9_LSR_r12),
kInstruction_sbc_gt_r4_r4_r9_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r6_r7_r10_ROR_r2),
kInstruction_sbc_vc_r6_r7_r10_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r10_r8_r13_ROR_r13),
kInstruction_sbc_lt_r10_r8_r13_ROR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r13_r10_r4_ROR_r0),
kInstruction_sbc_lt_r13_r10_r4_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r1_r6_r0_LSR_r12),
kInstruction_sbc_pl_r1_r6_r0_LSR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r14_r7_r1_LSR_r8),
kInstruction_sbc_ge_r14_r7_r1_LSR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r8_r13_r6_LSL_r13),
kInstruction_sbc_cc_r8_r13_r6_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r13_r4_r7_LSR_r2),
kInstruction_sbc_gt_r13_r4_r7_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r11_r3_r5_LSR_r3),
kInstruction_sbc_eq_r11_r3_r5_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r11_r2_ROR_r7),
kInstruction_sbc_vc_r8_r11_r2_ROR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r11_r2_r0_LSL_r2),
kInstruction_sbc_vc_r11_r2_r0_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r9_r11_r11_LSL_r11),
kInstruction_sbc_cs_r9_r11_r11_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r14_r4_r12_LSL_r11),
kInstruction_sbc_ge_r14_r4_r12_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r4_r10_r3_LSL_r1),
kInstruction_sbc_vs_r4_r10_r3_LSL_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r13_r1_r8_LSR_r2),
kInstruction_sbc_mi_r13_r1_r8_LSR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r3_r13_r13_LSL_r8),
kInstruction_sbc_le_r3_r13_r13_LSL_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r9_r12_r8_LSR_r14),
kInstruction_sbc_mi_r9_r12_r8_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r7_r11_r10_ASR_r2),
kInstruction_sbc_pl_r7_r11_r10_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r12_r2_r9_ASR_r5),
kInstruction_sbc_lt_r12_r2_r9_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r13_r0_r5_LSL_r2),
kInstruction_sbc_gt_r13_r0_r5_LSL_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r5_r10_r9_ROR_r0),
kInstruction_sbc_le_r5_r10_r9_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r1_r4_ASR_r11),
kInstruction_sbc_lt_r6_r1_r4_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r11_r5_r14_LSR_r4),
kInstruction_sbc_pl_r11_r5_r14_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r9_r0_r6_ROR_r9),
kInstruction_sbc_eq_r9_r0_r6_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r3_r11_r2_ASR_r4),
kInstruction_sbc_mi_r3_r11_r2_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r13_r8_r0_ROR_r6),
kInstruction_sbc_pl_r13_r8_r0_ROR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r8_r2_r6_ASR_r4),
kInstruction_sbc_vc_r8_r2_r6_ASR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r1_r0_r4_ASR_r1),
kInstruction_sbc_ge_r1_r0_r4_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r2_r4_r13_LSL_r13),
kInstruction_sbc_vc_r2_r4_r13_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r4_r3_r5_ASR_r11),
kInstruction_sbc_lt_r4_r3_r5_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r5_r12_r3_LSL_r4),
kInstruction_sbc_pl_r5_r12_r3_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r14_r6_r6_LSR_r10),
kInstruction_sbc_pl_r14_r6_r6_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r14_r13_r3_LSL_r9),
kInstruction_sbc_gt_r14_r13_r3_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r10_r9_r4_LSL_r3),
kInstruction_sbc_pl_r10_r9_r4_LSL_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r10_r8_r4_ROR_r1),
kInstruction_sbc_al_r10_r8_r4_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r14_r9_r11_ASR_r13),
kInstruction_sbc_pl_r14_r9_r11_ASR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_cc_r8_r1_r4_ROR_r12),
kInstruction_sbc_cc_r8_r1_r4_ROR_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r5_r14_r7_LSR_r0),
kInstruction_sbc_vs_r5_r14_r7_LSR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r1_r10_r13_ROR_r9),
kInstruction_sbc_gt_r1_r10_r13_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r8_r14_r9_LSR_r5),
kInstruction_sbc_mi_r8_r14_r9_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r12_r10_r7_ROR_r2),
kInstruction_sbc_ge_r12_r10_r7_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r11_r8_r1_LSR_r10),
kInstruction_sbc_al_r11_r8_r1_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r13_r11_LSL_r14),
kInstruction_sbc_al_r7_r13_r11_LSL_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r13_r11_r11_ASR_r9),
kInstruction_sbc_vc_r13_r11_r11_ASR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_gt_r10_r5_r11_LSR_r14),
kInstruction_sbc_gt_r10_r5_r11_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r10_r11_r7_ROR_r3),
kInstruction_sbc_vc_r10_r11_r7_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r10_r2_r7_LSL_r6),
kInstruction_sbc_le_r10_r2_r7_LSL_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r1_r3_r6_ASR_r5),
kInstruction_sbc_al_r1_r3_r6_ASR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r14_r9_r7_LSL_r12),
kInstruction_sbc_cs_r14_r9_r7_LSL_r12,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r10_r1_r4_LSL_r4),
kInstruction_sbc_ls_r10_r1_r4_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r2_r5_r4_ROR_r3),
kInstruction_sbc_vs_r2_r5_r4_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r1_r7_r10_ASR_r0),
kInstruction_sbc_vs_r1_r7_r10_ASR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_cs_r10_r12_r0_LSR_r4),
kInstruction_sbc_cs_r10_r12_r0_LSR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r8_r8_r1_LSR_r13),
kInstruction_sbc_vs_r8_r8_r1_LSR_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r14_r5_r9_LSR_r7),
kInstruction_sbc_mi_r14_r5_r9_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r6_r6_r14_ASR_r8),
kInstruction_sbc_vs_r6_r6_r14_ASR_r8,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r0_r1_r14_ROR_r0),
kInstruction_sbc_vc_r0_r1_r14_ROR_r0,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r9_r3_r11_ASR_r3),
kInstruction_sbc_ls_r9_r3_r11_ASR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r1_r12_r1_ASR_r6),
kInstruction_sbc_ls_r1_r12_r1_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r6_r10_r0_ASR_r2),
kInstruction_sbc_hi_r6_r10_r0_ASR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r6_r14_r7_ASR_r1),
kInstruction_sbc_vc_r6_r14_r7_ASR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r14_r11_r10_LSL_r13),
kInstruction_sbc_eq_r14_r11_r10_LSL_r13,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r6_r12_r5_LSR_r9),
kInstruction_sbc_ge_r6_r12_r5_LSR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r1_r5_r0_ROR_r9),
kInstruction_sbc_mi_r1_r5_r0_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r7_r8_r2_ROR_r4),
kInstruction_sbc_al_r7_r8_r2_ROR_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_hi_r8_r1_r5_ASR_r10),
kInstruction_sbc_hi_r8_r1_r5_ASR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_ne_r14_r5_r0_LSR_r7),
kInstruction_sbc_ne_r14_r5_r0_LSR_r7,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r3_r13_r9_LSL_r9),
kInstruction_sbc_vc_r3_r13_r9_LSL_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r2_r2_r7_LSL_r5),
kInstruction_sbc_vs_r2_r2_r7_LSL_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r3_r6_ASR_r6),
kInstruction_sbc_vc_r7_r3_r6_ASR_r6,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r2_r5_r8_ROR_r1),
kInstruction_sbc_eq_r2_r5_r8_ROR_r1,
},
{
ARRAY_SIZE(kInstruction_sbc_eq_r0_r0_r10_ROR_r3),
kInstruction_sbc_eq_r0_r0_r10_ROR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_lt_r6_r1_r0_ROR_r9),
kInstruction_sbc_lt_r6_r1_r0_ROR_r9,
},
{
ARRAY_SIZE(kInstruction_sbc_ls_r7_r7_r12_LSR_r5),
kInstruction_sbc_ls_r7_r7_r12_LSR_r5,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r9_r7_ROR_r14),
kInstruction_sbc_vs_r0_r9_r7_ROR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_al_r0_r8_r2_ROR_r2),
kInstruction_sbc_al_r0_r8_r2_ROR_r2,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r1_r14_r14_LSL_r11),
kInstruction_sbc_vc_r1_r14_r14_LSL_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_ge_r9_r14_r10_ASR_r11),
kInstruction_sbc_ge_r9_r14_r10_ASR_r11,
},
{
ARRAY_SIZE(kInstruction_sbc_vs_r0_r3_r9_LSL_r4),
kInstruction_sbc_vs_r0_r3_r9_LSL_r4,
},
{
ARRAY_SIZE(kInstruction_sbc_pl_r14_r13_r7_LSR_r14),
kInstruction_sbc_pl_r14_r13_r7_LSR_r14,
},
{
ARRAY_SIZE(kInstruction_sbc_le_r2_r4_r6_LSR_r3),
kInstruction_sbc_le_r2_r4_r6_LSR_r3,
},
{
ARRAY_SIZE(kInstruction_sbc_vc_r7_r14_r6_LSR_r10),
kInstruction_sbc_vc_r7_r14_r6_LSR_r10,
},
{
ARRAY_SIZE(kInstruction_sbc_mi_r13_r11_r14_ASR_r7),
kInstruction_sbc_mi_r13_r11_r14_ASR_r7,
},
};
#endif // VIXL_ASSEMBLER_COND_RD_RN_OPERAND_RM_SHIFT_RS_SBC_A32_H_
| 129,591 |
648 | <filename>spring-rabbit/src/main/java/org/springframework/amqp/rabbit/core/AmqpNackReceivedException.java
/*
* Copyright 2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://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.
*/
package org.springframework.amqp.rabbit.core;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
/**
* An exception thrown when a negative acknowledgement received after publishing a
* message.
*
* @author <NAME>
* @since 2.3.3
*
*/
public class AmqpNackReceivedException extends AmqpException {
private static final long serialVersionUID = 1L;
private final Message failedMessage;
/**
* Create an instance with the provided message and failed message.
* @param message the message.
* @param failedMessage the failed message.
*/
public AmqpNackReceivedException(String message, Message failedMessage) {
super(message);
this.failedMessage = failedMessage;
}
/**
* Return the failed message.
* @return the message.
*/
public Message getFailedMessage() {
return this.failedMessage;
}
}
| 453 |
395 | <reponame>amixuse/Android-Disassembler
package com.kyhsgeekcode.disassembler.Interpreter;
public abstract class Machine {
long[] regs;
public void Execute() {
}
public interface MachineCallback {
}
public class Instruction {
byte[] bytes;
int size;
int id;
}
}
| 127 |
14,668 | <filename>testing/libfuzzer/fuzzers/skia_path_common.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 "testing/libfuzzer/fuzzers/skia_path_common.h"
#include "third_party/skia/include/core/SkPath.h"
// This is needed because SkPath::readFromMemory does not seem to be able to
// be able to handle arbitrary input.
void BuildPath(const uint8_t** data,
size_t* size,
SkPath* path,
int last_verb) {
uint8_t operation;
SkScalar a, b, c, d, e, f;
while (read<uint8_t>(data, size, &operation)) {
switch (operation % (last_verb + 1)) {
case SkPath::Verb::kMove_Verb:
if (!read<SkScalar>(data, size, &a) || !read<SkScalar>(data, size, &b))
return;
path->moveTo(a, b);
break;
case SkPath::Verb::kLine_Verb:
if (!read<SkScalar>(data, size, &a) || !read<SkScalar>(data, size, &b))
return;
path->lineTo(a, b);
break;
case SkPath::Verb::kQuad_Verb:
if (!read<SkScalar>(data, size, &a) ||
!read<SkScalar>(data, size, &b) ||
!read<SkScalar>(data, size, &c) ||
!read<SkScalar>(data, size, &d))
return;
path->quadTo(a, b, c, d);
break;
case SkPath::Verb::kConic_Verb:
if (!read<SkScalar>(data, size, &a) ||
!read<SkScalar>(data, size, &b) ||
!read<SkScalar>(data, size, &c) ||
!read<SkScalar>(data, size, &d) ||
!read<SkScalar>(data, size, &e))
return;
path->conicTo(a, b, c, d, e);
break;
case SkPath::Verb::kCubic_Verb:
if (!read<SkScalar>(data, size, &a) ||
!read<SkScalar>(data, size, &b) ||
!read<SkScalar>(data, size, &c) ||
!read<SkScalar>(data, size, &d) ||
!read<SkScalar>(data, size, &e) ||
!read<SkScalar>(data, size, &f))
return;
path->cubicTo(a, b, c, d, e, f);
break;
case SkPath::Verb::kClose_Verb:
path->close();
break;
case SkPath::Verb::kDone_Verb:
// In this case, simply exit.
return;
}
}
}
| 1,173 |
419 | <filename>Resources/Services/Export/Placeholder/ScribanRenderingEngine/RenderingObjects/ScribanExportDialog.en.json<gh_stars>100-1000
{
"PlaceholderDesc_InitialFunction": "Initial function of the dialog.",
"PlaceholderDesc_AdditionalFunctions": "Additional functions of the dialog. Can be iterated using <i>for</i>.",
"PlaceholderDesc_AllFunctions": "All functions of the dialog. Can be iterated using <i>for</i>."
} | 136 |
316 | #include "dg/llvm/ControlDependence/ControlDependence.h"
#include "dg/llvm/DataDependence/DataDependence.h"
#include "dg/llvm/SystemDependenceGraph/SystemDependenceGraph.h"
#include "dg/util/debug.h"
namespace dg {
namespace llvmdg {
///
// Fill in dependence edges into SDG
struct SDGDependenciesBuilder {
llvmdg::SystemDependenceGraph &_sdg;
dda::LLVMDataDependenceAnalysis *DDA;
LLVMControlDependenceAnalysis *CDA;
SDGDependenciesBuilder(llvmdg::SystemDependenceGraph &g,
dda::LLVMDataDependenceAnalysis *dda,
LLVMControlDependenceAnalysis *cda)
: _sdg(g), DDA(dda), CDA(cda) {}
void addUseDependencies(sdg::DGElement *nd, llvm::Instruction &I) {
for (auto &op : I.operands()) {
auto *val = &*op;
if (llvm::isa<llvm::ConstantExpr>(val)) {
val = val->stripPointerCasts();
} else if (llvm::isa<llvm::BasicBlock>(val) ||
llvm::isa<llvm::ConstantInt>(val)) {
// we do not add use edges to basic blocks
// FIXME: but maybe we could? The implementation could be then
// clearer...
continue;
}
auto *opnd = _sdg.getNode(val);
if (!opnd) {
if (auto *fun = llvm::dyn_cast<llvm::Function>(val)) {
llvm::errs() << "[SDG error] Do not have fun as operand: "
<< fun->getName() << "\n";
continue;
}
llvm::errs() << "[SDG error] Do not have operand node:\n";
llvm::errs() << *val << "\n";
abort();
}
assert(opnd && "Do not have operand node");
assert(sdg::DGNode::get(nd) && "Wrong type of node");
if (auto *arg = sdg::DGArgumentPair::get(opnd)) {
sdg::DGNode::get(nd)->addUses(arg->getInputArgument());
} else {
auto *opnode = sdg::DGNode::get(opnd);
assert(opnode && "Wrong type of node");
sdg::DGNode::get(nd)->addUses(*opnode);
}
}
}
// elem is CD on 'on'
void addControlDep(sdg::DepDGElement *elem, const llvm::Value *on) {
if (const auto *depB = llvm::dyn_cast<llvm::BasicBlock>(on)) {
auto *depblock = _sdg.getBBlock(depB);
assert(depblock && "Do not have the block");
elem->addControlDep(*depblock);
} else {
auto *depnd = sdg::DepDGElement::get(_sdg.getNode(on));
assert(depnd && "Do not have the node");
if (auto *C = sdg::DGNodeCall::get(depnd)) {
// this is 'noret' dependence (we have no other control deps for
// calls)
auto *noret = C->getParameters().getNoReturn();
if (!noret)
noret = &C->getParameters().createNoReturn();
elem->addControlDep(*noret);
// add CD to all formal norets
for (auto *calledF : C->getCallees()) {
auto *fnoret = calledF->getParameters().getNoReturn();
if (!fnoret)
fnoret = &calledF->getParameters().createNoReturn();
noret->addControlDep(*fnoret);
}
} else {
elem->addControlDep(*depnd);
}
}
}
void addControlDependencies(sdg::DepDGElement *elem, llvm::Instruction &I) {
assert(elem);
for (auto *dep : CDA->getDependencies(&I)) {
addControlDep(elem, dep);
}
}
void addControlDependencies(sdg::DGBBlock *block, llvm::BasicBlock &B) {
assert(block);
for (auto *dep : CDA->getDependencies(&B)) {
addControlDep(block, dep);
}
}
void addDataDependencies(sdg::DGElement *nd, llvm::Instruction &I) {
addInterprocDataDependencies(nd, I);
}
void addInterprocDataDependencies(sdg::DGElement *nd,
llvm::Instruction &I) {
if (!DDA->isUse(&I))
return;
for (auto &op : DDA->getLLVMDefinitions(&I)) {
auto *val = &*op;
auto *opnd = _sdg.getNode(val);
if (!opnd) {
llvm::errs() << "[SDG error] Do not have operand node:\n";
llvm::errs() << *val << "\n";
abort();
}
assert(opnd && "Do not have operand node");
assert(sdg::DGNode::get(nd) && "Wrong type of node");
if (auto *arg = sdg::DGArgumentPair::get(opnd)) {
sdg::DGNode::get(nd)->addMemoryDep(arg->getInputArgument());
} else {
auto *opnode = sdg::DGNode::get(opnd);
assert(opnode && "Wrong type of node");
sdg::DGNode::get(nd)->addMemoryDep(*opnode);
}
}
}
void processInstr(llvm::Instruction &I) {
auto *nd = sdg::DepDGElement::get(_sdg.getNode(&I));
assert(nd && "Do not have node");
if (llvm::isa<llvm::DbgInfoIntrinsic>(&I)) {
// FIXME
llvm::errs() << "sdg: Skipping " << I << "\n";
return;
}
// add dependencies
addUseDependencies(nd, I);
addDataDependencies(nd, I);
addControlDependencies(nd, I);
}
void processDG(llvm::Function &F) {
auto *dg = _sdg.getDG(&F);
assert(dg && "Do not have dg");
for (auto &B : F) {
for (auto &I : B) {
processInstr(I);
}
// block-based control dependencies
addControlDependencies(_sdg.getBBlock(&B), B);
}
// add noreturn dependencies
DBG(sdg, "Adding noreturn dependencies to " << F.getName().str());
auto *noret = dg->getParameters().getNoReturn();
if (!noret)
noret = &dg->getParameters().createNoReturn();
for (auto *dep : CDA->getNoReturns(&F)) {
llvm::errs() << "NORET: " << *dep << "\n";
auto *nd = sdg::DepDGElement::get(_sdg.getNode(dep));
assert(nd && "Do not have the node");
if (auto *C = sdg::DGNodeCall::get(nd)) {
// if this is call, add it again to noret node
auto *cnoret = C->getParameters().getNoReturn();
assert(cnoret && "Did not create a noret for a call");
noret->addControlDep(*cnoret);
} else {
noret->addControlDep(*nd);
}
}
}
void processFuns() {
for (auto &F : *_sdg.getModule()) {
if (F.isDeclaration()) {
continue;
}
processDG(F);
}
}
};
void SystemDependenceGraph::buildEdges() {
DBG_SECTION_BEGIN(sdg, "Adding edges into SDG");
SDGDependenciesBuilder builder(*this, _dda, _cda);
builder.processFuns();
DBG_SECTION_END(sdg, "Adding edges into SDG finished");
}
} // namespace llvmdg
} // namespace dg
| 3,741 |
602 | <reponame>CorfuDB/CORFU
package org.corfudb.protocols.wireprotocol.orchestrator;
import javax.annotation.Nonnull;
import static org.corfudb.protocols.wireprotocol.orchestrator.OrchestratorRequestType.FORCE_REMOVE_NODE;
/**
* A request to force remove an endpoint from the cluster.
*
* @author Maithem
*/
public class ForceRemoveNodeRequest extends RemoveNodeRequest {
/**
* Create a force remove request.
* @param endpoint the endpoint to force remove
*/
public ForceRemoveNodeRequest(@Nonnull String endpoint) {
super(endpoint);
}
@Override
public OrchestratorRequestType getType() {
return FORCE_REMOVE_NODE;
}
}
| 245 |
3,507 | package com.bumptech.glide.load.engine.prefill;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
final class PreFillQueue {
private final Map<PreFillType, Integer> bitmapsPerType;
private final List<PreFillType> keyList;
private int bitmapsRemaining;
private int keyIndex;
public PreFillQueue(Map<PreFillType, Integer> bitmapsPerType) {
this.bitmapsPerType = bitmapsPerType;
// We don't particularly care about the initial order.
keyList = new ArrayList<PreFillType>(bitmapsPerType.keySet());
for (Integer count : bitmapsPerType.values()) {
bitmapsRemaining += count;
}
}
public PreFillType remove() {
PreFillType result = keyList.get(keyIndex);
Integer countForResult = bitmapsPerType.get(result);
if (countForResult == 1) {
bitmapsPerType.remove(result);
keyList.remove(keyIndex);
} else {
bitmapsPerType.put(result, countForResult - 1);
}
bitmapsRemaining--;
// Avoid divide by 0.
keyIndex = keyList.isEmpty() ? 0 : (keyIndex + 1) % keyList.size();
return result;
}
public int getSize() {
return bitmapsRemaining;
}
public boolean isEmpty() {
return bitmapsRemaining == 0;
}
}
| 547 |
456 | package com.swingfrog.summer.promise;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class Promise {
private final Integer id;
private volatile boolean running;
private Executor executor;
private Consumer<Throwable> throwableConsumer;
private Runnable stopHook;
private final AtomicInteger executeIndex = new AtomicInteger();
private final List<Runnable> runnableList = new ArrayList<>();
// key, index
private final Map<Object, Integer> markIndexMap = new HashMap<>();
private final PromiseContext context = new PromiseContext(this);
// index, gotoCount
private final Map<Integer, Integer> gotoCountMap = new HashMap<>();
// index, executor
private final Map<Integer, Executor> executorMap = new HashMap<>();
public Promise() {
this(null);
}
public Promise(Integer id) {
this.id = id;
}
void throwError(Throwable throwable) {
if (throwableConsumer != null)
throwableConsumer.accept(throwable);
stop();
}
void next() {
int nextIndex = executeIndex.get();
if (nextIndex >= runnableList.size()) {
stop();
return;
}
if (context.hasWaitFuture())
return;
nextIndex = executeIndex.getAndIncrement();
if (nextIndex >= runnableList.size()) {
stop();
return;
}
Runnable runnable = runnableList.get(nextIndex);
Executor availableExecutor = executorMap.getOrDefault(nextIndex, executor);
if (availableExecutor != null) {
availableExecutor.execute(runnable);
return;
}
runnable.run();
}
void setStopHook(Runnable runnable) {
checkNotRunning();
stopHook = runnable;
}
public static Promise create() {
return new Promise();
}
public Promise then(Consumer<PromiseContext> consumer) {
checkNotRunning();
runnableList.add(() -> {
try {
consumer.accept(context);
next();
} catch (Throwable throwable) {
throwError(throwable);
}
});
return this;
}
public Promise then(Runnable runnable) {
checkNotRunning();
runnableList.add(() -> {
try {
runnable.run();
next();
} catch (Throwable throwable) {
throwError(throwable);
}
});
return this;
}
public Promise then(Consumer<PromiseContext> consumer, Executor executor) {
if (executor == null)
return then(consumer);
int index = runnableList.size();
then(consumer);
executorMap.put(index, executor);
return this;
}
public Promise then(Runnable runnable, Executor executor) {
if (executor == null)
return then(runnable);
int index = runnableList.size();
then(runnable);
executorMap.put(index, executor);
return this;
}
public Promise then(ConsumerTask contextConsumerTask) {
return then(contextConsumerTask.consumer, contextConsumerTask.executor);
}
public Promise then(RunnableTask runnableTask) {
return then(runnableTask.runnable, runnableTask.executor);
}
public Promise setCatch(Consumer<Throwable> consumer) {
checkNotRunning();
throwableConsumer = consumer;
return this;
}
public Promise setExecutor(Executor executor) {
checkNotRunning();
this.executor = executor;
return this;
}
public Promise mark(Object key) {
checkNotRunning();
markIndexMap.put(key, runnableList.size());
return this;
}
// This method is easy to create a dead cycle, use with caution
public Promise gotoMark(Object key) {
checkNotRunning();
runnableList.add(() -> {
Integer index = markIndexMap.get(key);
if (index != null) {
executeIndex.set(index);
}
next();
});
return this;
}
public Promise gotoMark(Object key, int count) {
checkNotRunning();
int currentIndex = runnableList.size();
runnableList.add(() -> {
Integer index = markIndexMap.get(key);
if (index != null) {
int currentCount = gotoCountMap.getOrDefault(currentIndex, 0);
if (currentCount < count) {
executeIndex.set(index);
gotoCountMap.put(currentIndex, currentCount + 1);
}
}
next();
});
return this;
}
public Promise gotoMark(Object key, Predicate<PromiseContext> predicate) {
checkNotRunning();
runnableList.add(() -> {
Integer index = markIndexMap.get(key);
if (index != null && predicate.test(context)) {
executeIndex.set(index);
}
next();
});
return this;
}
public void start() {
checkNotRunning();
executeIndex.set(0);
context.clear();
running = true;
next();
}
public void stop() {
executeIndex.set(0);
context.clear();
running = false;
if (stopHook != null)
stopHook.run();
}
public boolean isRunning() {
return running;
}
public void clearRunnable() {
runnableList.clear();
}
private void checkNotRunning() {
if (running)
throw new UnsupportedOperationException();
}
public static class ConsumerTask {
private final Consumer<PromiseContext> consumer;
private final Executor executor;
public ConsumerTask(Consumer<PromiseContext> consumer, Executor executor) {
this.consumer = consumer;
this.executor = executor;
}
public ConsumerTask(Consumer<PromiseContext> consumer) {
this.consumer = consumer;
this.executor = null;
}
}
public static class RunnableTask {
private final Runnable runnable;
private final Executor executor;
public RunnableTask(Runnable runnable, Executor executor) {
this.runnable = runnable;
this.executor = executor;
}
public RunnableTask(Runnable runnable) {
this.runnable = runnable;
this.executor = null;
}
}
public static ConsumerTask newTask(Consumer<PromiseContext> consumer, Executor executor) {
return new ConsumerTask(consumer, executor);
}
public static RunnableTask newTask(Runnable runnable, Executor executor) {
return new RunnableTask(runnable, executor);
}
public static ConsumerTask newTask(Consumer<PromiseContext> consumer) {
return new ConsumerTask(consumer);
}
public static RunnableTask newTask(Runnable runnable) {
return new RunnableTask(runnable);
}
@Override
public boolean equals(Object o) {
if (id == null)
return super.equals(o);
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Promise promise = (Promise) o;
return Objects.equals(id, promise.id);
}
@Override
public int hashCode() {
if (id == null)
return super.hashCode();
return Objects.hash(id);
}
}
| 3,376 |
643 | <gh_stars>100-1000
// Generated automatically from android.content.pm.PackageManager for testing purposes
package android.content.pm;
import android.content.ComponentName;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.ApkChecksum;
import android.content.pm.ApplicationInfo;
import android.content.pm.ChangedPackages;
import android.content.pm.FeatureInfo;
import android.content.pm.InstallSourceInfo;
import android.content.pm.InstrumentationInfo;
import android.content.pm.ModuleInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageInstaller;
import android.content.pm.PermissionGroupInfo;
import android.content.pm.PermissionInfo;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.content.pm.SharedLibraryInfo;
import android.content.pm.VersionedPackage;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.content.res.XmlResourceParser;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.UserHandle;
import android.util.AndroidException;
import java.security.cert.Certificate;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.function.Consumer;
abstract public class PackageManager
{
public Bundle getSuspendedPackageAppExtras(){ return null; }
public CharSequence getBackgroundPermissionOptionLabel(){ return null; }
public InstallSourceInfo getInstallSourceInfo(String p0){ return null; }
public List<ModuleInfo> getInstalledModules(int p0){ return null; }
public List<PackageManager.Property> queryActivityProperty(String p0){ return null; }
public List<PackageManager.Property> queryApplicationProperty(String p0){ return null; }
public List<PackageManager.Property> queryProviderProperty(String p0){ return null; }
public List<PackageManager.Property> queryReceiverProperty(String p0){ return null; }
public List<PackageManager.Property> queryServiceProperty(String p0){ return null; }
public ModuleInfo getModuleInfo(String p0, int p1){ return null; }
public PackageInfo getPackageArchiveInfo(String p0, int p1){ return null; }
public PackageManager(){}
public PackageManager.Property getProperty(String p0, ComponentName p1){ return null; }
public PackageManager.Property getProperty(String p0, String p1){ return null; }
public Resources getResourcesForApplication(ApplicationInfo p0, Configuration p1){ return null; }
public Set<String> getMimeGroup(String p0){ return null; }
public Set<String> getWhitelistedRestrictedPermissions(String p0, int p1){ return null; }
public abstract ActivityInfo getActivityInfo(ComponentName p0, int p1);
public abstract ActivityInfo getReceiverInfo(ComponentName p0, int p1);
public abstract ApplicationInfo getApplicationInfo(String p0, int p1);
public abstract ChangedPackages getChangedPackages(int p0);
public abstract CharSequence getApplicationLabel(ApplicationInfo p0);
public abstract CharSequence getText(String p0, int p1, ApplicationInfo p2);
public abstract CharSequence getUserBadgedLabel(CharSequence p0, UserHandle p1);
public abstract Drawable getActivityBanner(ComponentName p0);
public abstract Drawable getActivityBanner(Intent p0);
public abstract Drawable getActivityIcon(ComponentName p0);
public abstract Drawable getActivityIcon(Intent p0);
public abstract Drawable getActivityLogo(ComponentName p0);
public abstract Drawable getActivityLogo(Intent p0);
public abstract Drawable getApplicationBanner(ApplicationInfo p0);
public abstract Drawable getApplicationBanner(String p0);
public abstract Drawable getApplicationIcon(ApplicationInfo p0);
public abstract Drawable getApplicationIcon(String p0);
public abstract Drawable getApplicationLogo(ApplicationInfo p0);
public abstract Drawable getApplicationLogo(String p0);
public abstract Drawable getDefaultActivityIcon();
public abstract Drawable getDrawable(String p0, int p1, ApplicationInfo p2);
public abstract Drawable getUserBadgedDrawableForDensity(Drawable p0, UserHandle p1, Rect p2, int p3);
public abstract Drawable getUserBadgedIcon(Drawable p0, UserHandle p1);
public abstract FeatureInfo[] getSystemAvailableFeatures();
public abstract InstrumentationInfo getInstrumentationInfo(ComponentName p0, int p1);
public abstract Intent getLaunchIntentForPackage(String p0);
public abstract Intent getLeanbackLaunchIntentForPackage(String p0);
public abstract List<ApplicationInfo> getInstalledApplications(int p0);
public abstract List<InstrumentationInfo> queryInstrumentation(String p0, int p1);
public abstract List<PackageInfo> getInstalledPackages(int p0);
public abstract List<PackageInfo> getPackagesHoldingPermissions(String[] p0, int p1);
public abstract List<PackageInfo> getPreferredPackages(int p0);
public abstract List<PermissionGroupInfo> getAllPermissionGroups(int p0);
public abstract List<PermissionInfo> queryPermissionsByGroup(String p0, int p1);
public abstract List<ProviderInfo> queryContentProviders(String p0, int p1, int p2);
public abstract List<ResolveInfo> queryBroadcastReceivers(Intent p0, int p1);
public abstract List<ResolveInfo> queryIntentActivities(Intent p0, int p1);
public abstract List<ResolveInfo> queryIntentActivityOptions(ComponentName p0, Intent[] p1, Intent p2, int p3);
public abstract List<ResolveInfo> queryIntentContentProviders(Intent p0, int p1);
public abstract List<ResolveInfo> queryIntentServices(Intent p0, int p1);
public abstract List<SharedLibraryInfo> getSharedLibraries(int p0);
public abstract PackageInfo getPackageInfo(String p0, int p1);
public abstract PackageInfo getPackageInfo(VersionedPackage p0, int p1);
public abstract PackageInstaller getPackageInstaller();
public abstract PermissionGroupInfo getPermissionGroupInfo(String p0, int p1);
public abstract PermissionInfo getPermissionInfo(String p0, int p1);
public abstract ProviderInfo getProviderInfo(ComponentName p0, int p1);
public abstract ProviderInfo resolveContentProvider(String p0, int p1);
public abstract ResolveInfo resolveActivity(Intent p0, int p1);
public abstract ResolveInfo resolveService(Intent p0, int p1);
public abstract Resources getResourcesForActivity(ComponentName p0);
public abstract Resources getResourcesForApplication(ApplicationInfo p0);
public abstract Resources getResourcesForApplication(String p0);
public abstract ServiceInfo getServiceInfo(ComponentName p0, int p1);
public abstract String getInstallerPackageName(String p0);
public abstract String getNameForUid(int p0);
public abstract String[] canonicalToCurrentPackageNames(String[] p0);
public abstract String[] currentToCanonicalPackageNames(String[] p0);
public abstract String[] getPackagesForUid(int p0);
public abstract String[] getSystemSharedLibraryNames();
public abstract XmlResourceParser getXml(String p0, int p1, ApplicationInfo p2);
public abstract boolean addPermission(PermissionInfo p0);
public abstract boolean addPermissionAsync(PermissionInfo p0);
public abstract boolean canRequestPackageInstalls();
public abstract boolean hasSystemFeature(String p0);
public abstract boolean hasSystemFeature(String p0, int p1);
public abstract boolean isInstantApp();
public abstract boolean isInstantApp(String p0);
public abstract boolean isPermissionRevokedByPolicy(String p0, String p1);
public abstract boolean isSafeMode();
public abstract byte[] getInstantAppCookie();
public abstract int checkPermission(String p0, String p1);
public abstract int checkSignatures(String p0, String p1);
public abstract int checkSignatures(int p0, int p1);
public abstract int getApplicationEnabledSetting(String p0);
public abstract int getComponentEnabledSetting(ComponentName p0);
public abstract int getInstantAppCookieMaxBytes();
public abstract int getPackageUid(String p0, int p1);
public abstract int getPreferredActivities(List<IntentFilter> p0, List<ComponentName> p1, String p2);
public abstract int[] getPackageGids(String p0);
public abstract int[] getPackageGids(String p0, int p1);
public abstract void addPackageToPreferred(String p0);
public abstract void addPreferredActivity(IntentFilter p0, int p1, ComponentName[] p2, ComponentName p3);
public abstract void clearInstantAppCookie();
public abstract void clearPackagePreferredActivities(String p0);
public abstract void extendVerificationTimeout(int p0, int p1, long p2);
public abstract void removePackageFromPreferred(String p0);
public abstract void removePermission(String p0);
public abstract void setApplicationCategoryHint(String p0, int p1);
public abstract void setApplicationEnabledSetting(String p0, int p1, int p2);
public abstract void setComponentEnabledSetting(ComponentName p0, int p1, int p2);
public abstract void setInstallerPackageName(String p0, String p1);
public abstract void updateInstantAppCookie(byte[] p0);
public abstract void verifyPendingInstall(int p0, int p1);
public boolean addWhitelistedRestrictedPermission(String p0, String p1, int p2){ return false; }
public boolean getSyntheticAppDetailsActivityEnabled(String p0){ return false; }
public boolean hasSigningCertificate(String p0, byte[] p1, int p2){ return false; }
public boolean hasSigningCertificate(int p0, byte[] p1, int p2){ return false; }
public boolean isAutoRevokeWhitelisted(){ return false; }
public boolean isAutoRevokeWhitelisted(String p0){ return false; }
public boolean isDefaultApplicationIcon(Drawable p0){ return false; }
public boolean isDeviceUpgrading(){ return false; }
public boolean isPackageSuspended(){ return false; }
public boolean isPackageSuspended(String p0){ return false; }
public boolean removeWhitelistedRestrictedPermission(String p0, String p1, int p2){ return false; }
public boolean setAutoRevokeWhitelisted(String p0, boolean p1){ return false; }
public int getTargetSdkVersion(String p0){ return 0; }
public static List<Certificate> TRUST_ALL = null;
public static List<Certificate> TRUST_NONE = null;
public static String EXTRA_VERIFICATION_ID = null;
public static String EXTRA_VERIFICATION_RESULT = null;
public static String FEATURE_ACTIVITIES_ON_SECONDARY_DISPLAYS = null;
public static String FEATURE_APP_WIDGETS = null;
public static String FEATURE_AUDIO_LOW_LATENCY = null;
public static String FEATURE_AUDIO_OUTPUT = null;
public static String FEATURE_AUDIO_PRO = null;
public static String FEATURE_AUTOFILL = null;
public static String FEATURE_AUTOMOTIVE = null;
public static String FEATURE_BACKUP = null;
public static String FEATURE_BLUETOOTH = null;
public static String FEATURE_BLUETOOTH_LE = null;
public static String FEATURE_CAMERA = null;
public static String FEATURE_CAMERA_ANY = null;
public static String FEATURE_CAMERA_AR = null;
public static String FEATURE_CAMERA_AUTOFOCUS = null;
public static String FEATURE_CAMERA_CAPABILITY_MANUAL_POST_PROCESSING = null;
public static String FEATURE_CAMERA_CAPABILITY_MANUAL_SENSOR = null;
public static String FEATURE_CAMERA_CAPABILITY_RAW = null;
public static String FEATURE_CAMERA_CONCURRENT = null;
public static String FEATURE_CAMERA_EXTERNAL = null;
public static String FEATURE_CAMERA_FLASH = null;
public static String FEATURE_CAMERA_FRONT = null;
public static String FEATURE_CAMERA_LEVEL_FULL = null;
public static String FEATURE_CANT_SAVE_STATE = null;
public static String FEATURE_COMPANION_DEVICE_SETUP = null;
public static String FEATURE_CONNECTION_SERVICE = null;
public static String FEATURE_CONSUMER_IR = null;
public static String FEATURE_CONTROLS = null;
public static String FEATURE_DEVICE_ADMIN = null;
public static String FEATURE_EMBEDDED = null;
public static String FEATURE_ETHERNET = null;
public static String FEATURE_FACE = null;
public static String FEATURE_FAKETOUCH = null;
public static String FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT = null;
public static String FEATURE_FAKETOUCH_MULTITOUCH_JAZZHAND = null;
public static String FEATURE_FINGERPRINT = null;
public static String FEATURE_FREEFORM_WINDOW_MANAGEMENT = null;
public static String FEATURE_GAMEPAD = null;
public static String FEATURE_HARDWARE_KEYSTORE = null;
public static String FEATURE_HIFI_SENSORS = null;
public static String FEATURE_HOME_SCREEN = null;
public static String FEATURE_IDENTITY_CREDENTIAL_HARDWARE = null;
public static String FEATURE_IDENTITY_CREDENTIAL_HARDWARE_DIRECT_ACCESS = null;
public static String FEATURE_INPUT_METHODS = null;
public static String FEATURE_IPSEC_TUNNELS = null;
public static String FEATURE_IRIS = null;
public static String FEATURE_KEYSTORE_APP_ATTEST_KEY = null;
public static String FEATURE_KEYSTORE_LIMITED_USE_KEY = null;
public static String FEATURE_KEYSTORE_SINGLE_USE_KEY = null;
public static String FEATURE_LEANBACK = null;
public static String FEATURE_LEANBACK_ONLY = null;
public static String FEATURE_LIVE_TV = null;
public static String FEATURE_LIVE_WALLPAPER = null;
public static String FEATURE_LOCATION = null;
public static String FEATURE_LOCATION_GPS = null;
public static String FEATURE_LOCATION_NETWORK = null;
public static String FEATURE_MANAGED_USERS = null;
public static String FEATURE_MICROPHONE = null;
public static String FEATURE_MIDI = null;
public static String FEATURE_NFC = null;
public static String FEATURE_NFC_BEAM = null;
public static String FEATURE_NFC_HOST_CARD_EMULATION = null;
public static String FEATURE_NFC_HOST_CARD_EMULATION_NFCF = null;
public static String FEATURE_NFC_OFF_HOST_CARD_EMULATION_ESE = null;
public static String FEATURE_NFC_OFF_HOST_CARD_EMULATION_UICC = null;
public static String FEATURE_OPENGLES_DEQP_LEVEL = null;
public static String FEATURE_OPENGLES_EXTENSION_PACK = null;
public static String FEATURE_PC = null;
public static String FEATURE_PICTURE_IN_PICTURE = null;
public static String FEATURE_PRINTING = null;
public static String FEATURE_RAM_LOW = null;
public static String FEATURE_RAM_NORMAL = null;
public static String FEATURE_SCREEN_LANDSCAPE = null;
public static String FEATURE_SCREEN_PORTRAIT = null;
public static String FEATURE_SECURELY_REMOVES_USERS = null;
public static String FEATURE_SECURE_LOCK_SCREEN = null;
public static String FEATURE_SECURITY_MODEL_COMPATIBLE = null;
public static String FEATURE_SENSOR_ACCELEROMETER = null;
public static String FEATURE_SENSOR_AMBIENT_TEMPERATURE = null;
public static String FEATURE_SENSOR_BAROMETER = null;
public static String FEATURE_SENSOR_COMPASS = null;
public static String FEATURE_SENSOR_GYROSCOPE = null;
public static String FEATURE_SENSOR_HEART_RATE = null;
public static String FEATURE_SENSOR_HEART_RATE_ECG = null;
public static String FEATURE_SENSOR_HINGE_ANGLE = null;
public static String FEATURE_SENSOR_LIGHT = null;
public static String FEATURE_SENSOR_PROXIMITY = null;
public static String FEATURE_SENSOR_RELATIVE_HUMIDITY = null;
public static String FEATURE_SENSOR_STEP_COUNTER = null;
public static String FEATURE_SENSOR_STEP_DETECTOR = null;
public static String FEATURE_SE_OMAPI_ESE = null;
public static String FEATURE_SE_OMAPI_SD = null;
public static String FEATURE_SE_OMAPI_UICC = null;
public static String FEATURE_SIP = null;
public static String FEATURE_SIP_VOIP = null;
public static String FEATURE_STRONGBOX_KEYSTORE = null;
public static String FEATURE_TELEPHONY = null;
public static String FEATURE_TELEPHONY_CDMA = null;
public static String FEATURE_TELEPHONY_EUICC = null;
public static String FEATURE_TELEPHONY_GSM = null;
public static String FEATURE_TELEPHONY_IMS = null;
public static String FEATURE_TELEPHONY_MBMS = null;
public static String FEATURE_TELEVISION = null;
public static String FEATURE_TOUCHSCREEN = null;
public static String FEATURE_TOUCHSCREEN_MULTITOUCH = null;
public static String FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT = null;
public static String FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND = null;
public static String FEATURE_USB_ACCESSORY = null;
public static String FEATURE_USB_HOST = null;
public static String FEATURE_VERIFIED_BOOT = null;
public static String FEATURE_VR_HEADTRACKING = null;
public static String FEATURE_VR_MODE = null;
public static String FEATURE_VR_MODE_HIGH_PERFORMANCE = null;
public static String FEATURE_VULKAN_DEQP_LEVEL = null;
public static String FEATURE_VULKAN_HARDWARE_COMPUTE = null;
public static String FEATURE_VULKAN_HARDWARE_LEVEL = null;
public static String FEATURE_VULKAN_HARDWARE_VERSION = null;
public static String FEATURE_WATCH = null;
public static String FEATURE_WEBVIEW = null;
public static String FEATURE_WIFI = null;
public static String FEATURE_WIFI_AWARE = null;
public static String FEATURE_WIFI_DIRECT = null;
public static String FEATURE_WIFI_PASSPOINT = null;
public static String FEATURE_WIFI_RTT = null;
public static String PROPERTY_MEDIA_CAPABILITIES = null;
public static int CERT_INPUT_RAW_X509 = 0;
public static int CERT_INPUT_SHA256 = 0;
public static int COMPONENT_ENABLED_STATE_DEFAULT = 0;
public static int COMPONENT_ENABLED_STATE_DISABLED = 0;
public static int COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED = 0;
public static int COMPONENT_ENABLED_STATE_DISABLED_USER = 0;
public static int COMPONENT_ENABLED_STATE_ENABLED = 0;
public static int DONT_KILL_APP = 0;
public static int FLAG_PERMISSION_WHITELIST_INSTALLER = 0;
public static int FLAG_PERMISSION_WHITELIST_SYSTEM = 0;
public static int FLAG_PERMISSION_WHITELIST_UPGRADE = 0;
public static int GET_ACTIVITIES = 0;
public static int GET_ATTRIBUTIONS = 0;
public static int GET_CONFIGURATIONS = 0;
public static int GET_DISABLED_COMPONENTS = 0;
public static int GET_DISABLED_UNTIL_USED_COMPONENTS = 0;
public static int GET_GIDS = 0;
public static int GET_INSTRUMENTATION = 0;
public static int GET_INTENT_FILTERS = 0;
public static int GET_META_DATA = 0;
public static int GET_PERMISSIONS = 0;
public static int GET_PROVIDERS = 0;
public static int GET_RECEIVERS = 0;
public static int GET_RESOLVED_FILTER = 0;
public static int GET_SERVICES = 0;
public static int GET_SHARED_LIBRARY_FILES = 0;
public static int GET_SIGNATURES = 0;
public static int GET_SIGNING_CERTIFICATES = 0;
public static int GET_UNINSTALLED_PACKAGES = 0;
public static int GET_URI_PERMISSION_PATTERNS = 0;
public static int INSTALL_REASON_DEVICE_RESTORE = 0;
public static int INSTALL_REASON_DEVICE_SETUP = 0;
public static int INSTALL_REASON_POLICY = 0;
public static int INSTALL_REASON_UNKNOWN = 0;
public static int INSTALL_REASON_USER = 0;
public static int INSTALL_SCENARIO_BULK = 0;
public static int INSTALL_SCENARIO_BULK_SECONDARY = 0;
public static int INSTALL_SCENARIO_DEFAULT = 0;
public static int INSTALL_SCENARIO_FAST = 0;
public static int MATCH_ALL = 0;
public static int MATCH_APEX = 0;
public static int MATCH_DEFAULT_ONLY = 0;
public static int MATCH_DIRECT_BOOT_AUTO = 0;
public static int MATCH_DIRECT_BOOT_AWARE = 0;
public static int MATCH_DIRECT_BOOT_UNAWARE = 0;
public static int MATCH_DISABLED_COMPONENTS = 0;
public static int MATCH_DISABLED_UNTIL_USED_COMPONENTS = 0;
public static int MATCH_SYSTEM_ONLY = 0;
public static int MATCH_UNINSTALLED_PACKAGES = 0;
public static int PERMISSION_DENIED = 0;
public static int PERMISSION_GRANTED = 0;
public static int SIGNATURE_FIRST_NOT_SIGNED = 0;
public static int SIGNATURE_MATCH = 0;
public static int SIGNATURE_NEITHER_SIGNED = 0;
public static int SIGNATURE_NO_MATCH = 0;
public static int SIGNATURE_SECOND_NOT_SIGNED = 0;
public static int SIGNATURE_UNKNOWN_PACKAGE = 0;
public static int SYNCHRONOUS = 0;
public static int VERIFICATION_ALLOW = 0;
public static int VERIFICATION_REJECT = 0;
public static int VERSION_CODE_HIGHEST = 0;
public static long MAXIMUM_VERIFICATION_TIMEOUT = 0;
public void getGroupOfPlatformPermission(String p0, Executor p1, Consumer<String> p2){}
public void getPlatformPermissionsForGroup(String p0, Executor p1, Consumer<List<String>> p2){}
public void requestChecksums(String p0, boolean p1, int p2, List<Certificate> p3, PackageManager.OnChecksumsReadyListener p4){}
public void setMimeGroup(String p0, Set<String> p1){}
static public class NameNotFoundException extends AndroidException
{
public NameNotFoundException(){}
public NameNotFoundException(String p0){}
}
static public class Property implements Parcelable
{
public String getClassName(){ return null; }
public String getName(){ return null; }
public String getPackageName(){ return null; }
public String getString(){ return null; }
public boolean getBoolean(){ return false; }
public boolean isBoolean(){ return false; }
public boolean isFloat(){ return false; }
public boolean isInteger(){ return false; }
public boolean isResourceId(){ return false; }
public boolean isString(){ return false; }
public float getFloat(){ return 0; }
public int describeContents(){ return 0; }
public int getInteger(){ return 0; }
public int getResourceId(){ return 0; }
public static Parcelable.Creator<PackageManager.Property> CREATOR = null;
public void writeToParcel(Parcel p0, int p1){}
}
static public interface OnChecksumsReadyListener
{
void onChecksumsReady(List<ApkChecksum> p0);
}
}
| 7,387 |
429 | #pragma once
#include <_cheader.h>
#include <toaru/graphics.h>
_Begin_C_Header
extern int load_sprite_png(sprite_t * sprite, char * filename);
_End_C_Header
| 68 |
751 | int i = 3;
printf(" i: %s \n", i);// __AUTO_GENERATED_PRINT_VAR__
| 33 |
395 | <reponame>Ketler13/antlr4
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
* Use of this file is governed by the BSD 3-clause license that
* can be found in the LICENSE.txt file in the project root.
*/
#pragma once
#include "tree/ErrorNode.h"
#include "tree/TerminalNodeImpl.h"
#include "misc/Interval.h"
#include "support/Any.h"
namespace antlr4 {
namespace tree {
/// <summary>
/// Represents a token that was consumed during resynchronization
/// rather than during a valid match operation. For example,
/// we will create this kind of a node during single token insertion
/// and deletion as well as during "consume until error recovery set"
/// upon no viable alternative exceptions.
/// </summary>
class ANTLR4CPP_PUBLIC ErrorNodeImpl : public virtual TerminalNodeImpl, public virtual ErrorNode {
public:
ErrorNodeImpl(Token *token);
~ErrorNodeImpl() override;
virtual std::any accept(ParseTreeVisitor *visitor) override;
};
} // namespace tree
} // namespace antlr4
| 316 |
9,272 | from .. import authz
from . import v1_core
def get_secret(namespace, name, auth=True):
if auth:
authz.ensure_authorized("get", "", "v1", "secrets", namespace)
return v1_core.read_namespaced_secret(name, namespace)
def create_secret(namespace, secret, auth=True):
if auth:
authz.ensure_authorized("create", "", "v1", "secrets", namespace)
return v1_core.create_namespaced_secret(namespace, secret)
| 163 |
725 | /* Part of SWI-Prolog
Author: <NAME>
E-mail: <EMAIL>
WWW: http://www.swi-prolog.org
Copyright (c) 2005-2020, University of Amsterdam
VU University Amsterdam
CWI, Amsterdam
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "pl-incl.h"
#ifndef O_PLGMP_INCLUDED
#define O_PLGMP_INCLUDED
#if USE_LD_MACROS
#define PL_unify_number(t, n) LDFUNC(PL_unify_number, t, n)
#define PL_put_number(t, n) LDFUNC(PL_put_number, t, n)
#define get_number(w, n) LDFUNC(get_number, w, n)
#define PL_get_number(t, n) LDFUNC(PL_get_number, t, n)
#define put_uint64(at, l, flags) LDFUNC(put_uint64, at, l, flags)
#define put_number(at, n, flags) LDFUNC(put_number, at, n, flags)
#endif /*USE_LD_MACROS*/
#define LDFUNC_DECLARATIONS
int PL_unify_number(term_t t, Number n);
int PL_put_number(term_t t, Number n);
void get_number(word w, Number n);
int PL_get_number(term_t t, Number n);
int PL_get_number(term_t t, Number n);
int put_uint64(Word at, uint64_t l, int flags);
int put_number(Word at, Number n, int flags);
int promoteToFloatNumber(Number n);
int make_same_type_numbers(Number n1, Number n2) WUNUSED;
int promoteNumber(Number n1, numtype type) WUNUSED;
int cmpNumbers(Number n1, Number n2);
void cpNumber(Number to, Number from);
#undef LDFUNC_DECLARATIONS
#ifdef O_GMP
#include <gmp.h>
#define O_MY_GMP_ALLOC 1
#define O_GMP_PRECHECK_ALLOCATIONS 1 /* GMP 4.2.3 uses abort() sometimes */
void initGMP(void);
void cleanupGMP(void);
void get_integer(word w, number *n);
void get_rational(word w, number *n);
Code get_mpz_from_code(Code pc, mpz_t mpz);
Code get_mpq_from_code(Code pc, mpq_t mpq);
int promoteToMPZNumber(number *n);
int promoteToMPQNumber(number *n);
void ensureWritableNumber(Number n);
void clearGMPNumber(Number n);
void addMPZToBuffer(Buffer b, mpz_t mpz);
void addMPQToBuffer(Buffer b, mpq_t mpq);
char * loadMPZFromCharp(const char *data, Word r, Word *store);
char * loadMPQFromCharp(const char *data, Word r, Word *store);
char * skipMPZOnCharp(const char *data);
char * skipMPQOnCharp(const char *data);
int mpz_to_int64(mpz_t mpz, int64_t *i);
int mpz_to_uint64(mpz_t mpz, uint64_t *i);
void mpz_init_set_si64(mpz_t mpz, int64_t i);
double mpX_round(double f);
double mpq_to_double(mpq_t q);
void mpq_set_double(mpq_t q, double f);
#define clearNumber(n) \
do { if ( (n)->type != V_INTEGER ) clearGMPNumber(n); } while(0)
static inline word
mpz_size_stack(int sz)
{ return ((word)sz<<1) & ~(word)MP_RAT_MASK;
}
static inline word
mpq_size_stack(int sz)
{ return ((word)sz<<1) | MP_RAT_MASK;
}
static inline int
mpz_stack_size(word w)
{ return (int)w>>1;
}
static inline int
mpq_stack_size(word w)
{ return (int)w>>1;
}
#else /*O_GMP*/
#define get_integer(w, n) \
do \
{ (n)->type = V_INTEGER; \
(n)->value.i = valInteger(w); \
} while(0)
#define get_rational(w, n) \
get_integer(w, n)
#define clearGMPNumber(n) (void)0
#define clearNumber(n) (void)0
#define ensureWritableNumber(n) (void)0
#define initGMP() (void)0
#endif /*O_GMP*/
/*******************************
* GMP ALLOCATION *
*******************************/
#define FE_NOTSET (-1)
#if O_MY_GMP_ALLOC
typedef struct mp_mem_header
{ struct mp_mem_header *prev;
struct mp_mem_header *next;
struct ar_context *context;
} mp_mem_header;
typedef struct ar_context
{ struct ar_context *parent;
size_t allocated;
int femode;
} ar_context;
#define O_GMP_LEAK_CHECK 0
#if O_GMP_LEAK_CHECK
#define GMP_LEAK_CHECK(g) g
#else
#define GMP_LEAK_CHECK(g)
#endif
#define AR_CTX ar_context __PL_ar_ctx = {0};
#define AR_BEGIN() \
do \
{ __PL_ar_ctx.parent = LD->gmp.context; \
__PL_ar_ctx.femode = FE_NOTSET; \
LD->gmp.context = &__PL_ar_ctx; \
GMP_LEAK_CHECK(__PL_ar_ctx.allocated = LD->gmp.allocated); \
} while(0)
#define AR_END() \
do \
{ LD->gmp.context = __PL_ar_ctx.parent; \
GMP_LEAK_CHECK(if ( __PL_ar_ctx.allocated != LD->gmp.allocated ) \
{ Sdprintf("GMP: lost %ld bytes\n", \
LD->gmp.allocated-__PL_ar_ctx.allocated); \
}) \
} while(0)
#define AR_CLEANUP() \
do \
{ if ( __PL_ar_ctx.femode != FE_NOTSET ) \
fesetround(__PL_ar_ctx.femode); \
mp_cleanup(&__PL_ar_ctx); \
} while(0)
void mp_cleanup(ar_context *ctx);
#else /*O_MY_GMP_ALLOC*/
typedef struct ar_context
{ int femode;
} ar_context;
#define AR_CTX ar_context __PL_ar_ctx = {0};
#define AR_BEGIN() \
do { __PL_ar_ctx.femode = FE_NOTSET; \
} while(0)
#define AR_END() (void)0
#define AR_CLEANUP() \
do \
{ if ( __PL_ar_ctx.femode != FE_NOTSET ) \
fesetround(__PL_ar_ctx.femode); \
} while(0)
#endif /*O_MY_GMP_ALLOC*/
#endif /*O_PLGMP_INCLUDED*/
| 2,593 |
335 | {
"word": "Divergent",
"definitions": [
"Tending to be different or develop in different directions.",
"(of thought) using a variety of premises, especially unfamiliar premises, as bases for inference, and avoiding common limiting assumptions in making deductions.",
"(of a series) increasing indefinitely as more of its terms are added."
],
"parts-of-speech": "Adjective"
} | 124 |
2,144 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.pinot.segment.local.utils.nativefst;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import org.apache.pinot.segment.local.utils.nativefst.builder.FSTBuilder;
import org.apache.pinot.segment.local.utils.nativefst.utils.RegexpMatcher;
import org.roaringbitmap.RoaringBitmapWriter;
import org.roaringbitmap.buffer.MutableRoaringBitmap;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.testng.Assert.assertEquals;
import static org.testng.FileAssert.fail;
/**
* Test utils class
*/
class FSTTestUtils {
private FSTTestUtils() {
}
/*
* Generate a sorted list of random sequences.
*/
public static byte[][] generateRandom(int count, MinMax length, MinMax alphabet) {
byte[][] input = new byte[count][];
Random rnd = new Random();
for (int i = 0; i < count; i++) {
input[i] = randomByteSequence(rnd, length, alphabet);
}
Arrays.sort(input, FSTBuilder.LEXICAL_ORDERING);
return input;
}
/**
* Generate a random string.
*/
private static byte[] randomByteSequence(Random rnd, MinMax length, MinMax alphabet) {
byte[] bytes = new byte[length._min + rnd.nextInt(length.range())];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = (byte) (alphabet._min + rnd.nextInt(alphabet.range()));
}
return bytes;
}
/*
* Check if the DFST is correct with respect to the given input.
*/
public static void checkCorrect(byte[][] input, FST fst) {
// (1) All input sequences are in the right language.
HashSet<ByteBuffer> rl = new HashSet<>();
for (ByteBuffer bb : fst) {
rl.add(ByteBuffer.wrap(Arrays.copyOf(bb.array(), bb.remaining())));
}
HashSet<ByteBuffer> uniqueInput = new HashSet<>();
for (byte[] sequence : input) {
uniqueInput.add(ByteBuffer.wrap(sequence));
}
for (ByteBuffer sequence : uniqueInput) {
if (!rl.remove(sequence)) {
fail("Not present in the right language: " + SerializerTestBase.toString(sequence));
}
}
// (2) No other sequence _other_ than the input is in the right language.
assertEquals(0, rl.size());
}
/**
* Return number of matches for given regex
*/
public static long regexQueryNrHits(String regex, FST fst) {
RoaringBitmapWriter<MutableRoaringBitmap> writer = RoaringBitmapWriter.bufferWriter().get();
RegexpMatcher.regexMatch(regex, fst, writer::add);
return writer.get().getCardinality();
}
/**
* Return all matches for given regex
*/
public static List<Long> regexQueryNrHitsWithResults(String regex, FST fst) {
RoaringBitmapWriter<MutableRoaringBitmap> writer = RoaringBitmapWriter.bufferWriter().get();
RegexpMatcher.regexMatch(regex, fst, writer::add);
MutableRoaringBitmap resultBitMap = writer.get();
List<Long> resultList = new ArrayList<>();
for (int dictId : resultBitMap) {
resultList.add((long) dictId);
}
return resultList;
}
/**
* Return all sequences reachable from a given node, as strings.
*/
public static HashSet<String> suffixes(FST fst, int node) {
HashSet<String> result = new HashSet<>();
for (ByteBuffer bb : fst.getSequences(node)) {
result.add(new String(bb.array(), bb.position(), bb.remaining(), UTF_8));
}
return result;
}
public static byte[][] convertToBytes(String[] strings) {
byte[][] data = new byte[strings.length][];
for (int i = 0; i < strings.length; i++) {
String string = strings[i];
data[i] = string.getBytes(Charset.defaultCharset()); // you can chose charset
}
return data;
}
}
| 1,574 |
533 | <reponame>Shixiaowei02/Anakin
#! /usr/bin/env python
# Copyright (c) 2017, Cuichaowen. All rights reserved.
# -*- coding: utf-8 -*-
import sys
import io
#import bson # this is installed with the pymongo package
#import matplotlib.pyplot as plt
#from skimage.data import imread # or, whatever image library you prefer
#import multiprocessing as mp # will come in handy due to the size of the data
| 159 |
679 | <reponame>Grosskopf/openoffice
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
#include <svx/AccessibleGraphicShape.hxx>
#include <svx/ShapeTypeHandler.hxx>
#include <svx/SvxShapeTypes.hxx>
#include <svx/svdobj.hxx>
#include <svx/svdmodel.hxx>
using namespace ::accessibility;
using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::accessibility;
//===== internal ============================================================
AccessibleGraphicShape::AccessibleGraphicShape (
const AccessibleShapeInfo& rShapeInfo,
const AccessibleShapeTreeInfo& rShapeTreeInfo)
: AccessibleShape (rShapeInfo, rShapeTreeInfo)
{
}
AccessibleGraphicShape::~AccessibleGraphicShape (void)
{
}
//===== XAccessibleImage ====================================================
::rtl::OUString SAL_CALL AccessibleGraphicShape::getAccessibleImageDescription (void)
throw (::com::sun::star::uno::RuntimeException)
{
if(m_pShape)
return m_pShape->GetTitle();
return AccessibleShape::getAccessibleDescription ();
}
sal_Int32 SAL_CALL AccessibleGraphicShape::getAccessibleImageHeight (void)
throw (::com::sun::star::uno::RuntimeException)
{
return AccessibleShape::getSize().Height;
}
sal_Int32 SAL_CALL AccessibleGraphicShape::getAccessibleImageWidth (void)
throw (::com::sun::star::uno::RuntimeException)
{
return AccessibleShape::getSize().Width;
}
//===== XInterface ==========================================================
com::sun::star::uno::Any SAL_CALL
AccessibleGraphicShape::queryInterface (const com::sun::star::uno::Type & rType)
throw (::com::sun::star::uno::RuntimeException)
{
::com::sun::star::uno::Any aReturn = AccessibleShape::queryInterface (rType);
if ( ! aReturn.hasValue())
aReturn = ::cppu::queryInterface (rType,
static_cast<XAccessibleImage*>(this));
return aReturn;
}
void SAL_CALL
AccessibleGraphicShape::acquire (void)
throw ()
{
AccessibleShape::acquire ();
}
void SAL_CALL
AccessibleGraphicShape::release (void)
throw ()
{
AccessibleShape::release ();
}
//===== XServiceInfo ========================================================
::rtl::OUString SAL_CALL
AccessibleGraphicShape::getImplementationName (void)
throw (::com::sun::star::uno::RuntimeException)
{
return ::rtl::OUString(
RTL_CONSTASCII_USTRINGPARAM("AccessibleGraphicShape"));
}
::com::sun::star::uno::Sequence< ::rtl::OUString> SAL_CALL
AccessibleGraphicShape::getSupportedServiceNames (void)
throw (::com::sun::star::uno::RuntimeException)
{
ThrowIfDisposed ();
// Get list of supported service names from base class...
uno::Sequence<OUString> aServiceNames =
AccessibleShape::getSupportedServiceNames();
sal_Int32 nCount (aServiceNames.getLength());
// ...and add additional names.
aServiceNames.realloc (nCount + 1);
static const OUString sAdditionalServiceName (RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.drawing.AccessibleGraphicShape"));
aServiceNames[nCount] = sAdditionalServiceName;
return aServiceNames;
}
//===== XTypeProvider ===================================================
uno::Sequence<uno::Type> SAL_CALL
AccessibleGraphicShape::getTypes (void)
throw (uno::RuntimeException)
{
// Get list of types from the context base implementation...
uno::Sequence<uno::Type> aTypeList (AccessibleShape::getTypes());
// ...and add the additional type for the component.
long nTypeCount = aTypeList.getLength();
aTypeList.realloc (nTypeCount + 1);
const uno::Type aImageType =
::getCppuType((const uno::Reference<XAccessibleImage>*)0);
aTypeList[nTypeCount] = aImageType;
return aTypeList;
}
/// Create the base name of this object, i.e. the name without appended number.
::rtl::OUString
AccessibleGraphicShape::CreateAccessibleBaseName (void)
throw (::com::sun::star::uno::RuntimeException)
{
::rtl::OUString sName;
ShapeTypeId nShapeType = ShapeTypeHandler::Instance().GetTypeId (mxShape);
switch (nShapeType)
{
case DRAWING_GRAPHIC_OBJECT:
sName = ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM("GraphicObjectShape"));
break;
default:
sName = ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM("UnknownAccessibleGraphicShape"));
uno::Reference<drawing::XShapeDescriptor> xDescriptor (mxShape, uno::UNO_QUERY);
if (xDescriptor.is())
sName += ::rtl::OUString (RTL_CONSTASCII_USTRINGPARAM(": "))
+ xDescriptor->getShapeType();
}
return sName;
}
::rtl::OUString
AccessibleGraphicShape::CreateAccessibleDescription (void)
throw (::com::sun::star::uno::RuntimeException)
{
//Solution: Don't use the same information for accessible name and accessible description.
::rtl::OUString sDesc;
if(m_pShape)
sDesc = m_pShape->GetTitle();
if(sDesc.getLength() > 0)
return sDesc;
return CreateAccessibleBaseName();
}
// Return this object's role.
sal_Int16 SAL_CALL AccessibleGraphicShape::getAccessibleRole (void)
throw (::com::sun::star::uno::RuntimeException)
{
sal_Int16 nAccessibleRole = AccessibleRole::SHAPE;
if( m_pShape->GetModel()->GetImageMapForObject(m_pShape) != NULL )
return AccessibleRole::IMAGE_MAP;
else
return AccessibleShape::getAccessibleRole();
return nAccessibleRole;
}
| 2,248 |
2,151 | <gh_stars>1000+
// 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.
#ifndef CONTENT_RENDERER_APPCACHE_APPCACHE_BACKEND_PROXY_H_
#define CONTENT_RENDERER_APPCACHE_APPCACHE_BACKEND_PROXY_H_
#include <stdint.h>
#include <vector>
#include "content/common/appcache.mojom.h"
#include "content/common/appcache_interfaces.h"
#include "ipc/ipc_sender.h"
namespace content {
// Sends appcache related messages to the main process.
class AppCacheBackendProxy : public AppCacheBackend {
public:
AppCacheBackendProxy();
~AppCacheBackendProxy() override;
// AppCacheBackend methods
void RegisterHost(int host_id) override;
void UnregisterHost(int host_id) override;
void SetSpawningHostId(int host_id, int spawning_host_id) override;
void SelectCache(int host_id,
const GURL& document_url,
const int64_t cache_document_was_loaded_from,
const GURL& manifest_url) override;
void SelectCacheForSharedWorker(int host_id, int64_t appcache_id) override;
void MarkAsForeignEntry(int host_id,
const GURL& document_url,
int64_t cache_document_was_loaded_from) override;
AppCacheStatus GetStatus(int host_id) override;
bool StartUpdate(int host_id) override;
bool SwapCache(int host_id) override;
void GetResourceList(
int host_id,
std::vector<AppCacheResourceInfo>* resource_infos) override;
private:
mojom::AppCacheBackend* GetAppCacheBackendPtr();
mojom::AppCacheBackendPtr app_cache_backend_ptr_;
};
} // namespace content
#endif // CONTENT_RENDERER_APPCACHE_APPCACHE_BACKEND_PROXY_H_
| 673 |
1,673 | /*****************************************************************************/
/* */
/* pen.h */
/* */
/* Lightpen API */
/* */
/* */
/* This software is provided "as-is", without any expressed or implied */
/* warranty. In no event will the authors be held liable for any damages */
/* arising from the use of this software. */
/* */
/* Permission is granted to anyone to use this software for any purpose, */
/* including commercial applications, and to alter it and redistribute it */
/* freely, subject to the following restrictions: */
/* */
/* 1. The origin of this software must not be misrepresented; you must not */
/* claim that you wrote the original software. If you use this software */
/* in a product, an acknowledgment in the product documentation would be */
/* appreciated, but is not required. */
/* 2. Altered source versions must be marked plainly as such; and, must not */
/* be misrepresented as being the original software. */
/* 3. This notice may not be removed or altered from any source */
/* distribution. */
/* */
/*****************************************************************************/
#ifndef _PEN_H
#define _PEN_H
/*****************************************************************************/
/* Declarations */
/*****************************************************************************/
/* A program optionally can set this pointer to a function that gives
** a calibration value to a driver. If this pointer isn't NULL,
** then a driver that wants a value can call that function.
** pen_adjuster must be set before the driver is installed.
*/
extern void __fastcall__ (*pen_adjuster) (unsigned char *pValue);
/*****************************************************************************/
/* Functions */
/*****************************************************************************/
void __fastcall__ pen_calibrate (unsigned char *XOffset);
/* Ask the user to help to calibrate a lightpen. Changes the screen!
** A pointer to this function can be put into pen_adjuster.
*/
void __fastcall__ pen_adjust (const char *filename);
/* Get a lightpen calibration value from a file if it exists. Otherwise, call
** pen_calibrate() to create a value; then, write it into a file, so that it
** will be available at the next time that the lightpen is used.
** Might change the screen.
** pen_adjust() is optional; if you want to use its feature,
** then it must be called before a driver is installed.
** Note: This function merely saves the file-name pointer, and sets
** the pen_adjuster pointer. The file will be read only when a driver
** is installed, and only if that driver wants to be calibrated.
*/
/* End of pen.h */
#endif
| 1,624 |
705 | <filename>05_Computer Alghorithm/dixonzhao-cs1c-project05-master/src/lazyTrees/LazySearchTree.java
package lazyTrees;
import java.util.*;
/**
* Implements BST with lazy deletion to keep track of total inventory ("deleted" + non deleted)
* and current inventory (non deleted only).
*
* @author <NAME>, <NAME>
*/
public class LazySearchTree<E extends Comparable< ? super E > >
implements Cloneable
{
protected int mSize;
protected int mSizeHard;
protected LazySTNode mRoot;
protected LazySTNode mRootHard;
boolean checkExist;
/**
* The constructor of BST which initialize the tree
*/
public LazySearchTree() { clear(); }
/**
* check if the tree is empty
* @return
*/
public boolean empty() { return (mSize == 0); }
/**
* check the size of tree without lazy deleted object
* @return
*/
public int size() { return mSize; }
/**
* Check the size of tree with every nodes
* @return
*/
public int sizeHard(){return mSizeHard;};
/**
* clear all data and tree
*/
public void clear() { mSize = 0; mRoot = null; }
/** unused method which prepare for AVL tree
*
* @return
*/
public int showHeight() { return findHeight(mRoot, -1); }
/**
* method which find minium object based on count
* @return
*/
public E findMin()
{
if (mRoot == null)
throw new NoSuchElementException();
return findMin(mRoot).data;
}
/**
* method which find maxium object based on count
* @return
*/
public E findMax() {
if (mRoot == null)
throw new NoSuchElementException();
return findMax(mRoot).data;
}
/**
* method which takes in object and search for same name
* @param x
* @return
*/
public E find( E x )
{
LazySTNode resultNode;
resultNode = find(mRoot, x);
if (resultNode == null)
throw new NoSuchElementException();
return resultNode.data;
}
/**
* method which check if specific object is in list
* @param x
* @return
*/
public boolean contains(E x) { return find(mRoot, x) != null; }
/**
* method which call insert method in helping method
* @param x
* @return
*/
public boolean insert( E x )
{
int oldSize = mSize;
mRoot = insert(mRoot, x);
return (mSize != oldSize);
}
/**
* method which call remove method in helping method
* @param x
* @return
*/
public boolean remove( E x )
{
int oldSize = mSize;
remove(mRoot, x);
return (mSize != oldSize);
}
/**
* method which call traverse method in helping method for every object
* @return
*/
public < F extends Traverser<? super E > >
void traverseHard(F func)
{
traverseHard(func, mRoot);
}
/**
* method which call traverse method in helping method for only exist object
* @return
*/
public < F extends Traverser<? super E > >
void traverseSoft(F func)
{
traverseSoft(func, mRoot);
}
/*
method which gives a hard copy of list
*/
public Object clone() throws CloneNotSupportedException
{
LazySearchTree<E> newObject = (LazySearchTree<E>)super.clone();
newObject.clear(); // can't point to other's data
newObject.mRoot = cloneSubtree(mRoot);
newObject.mSize = mSize;
return newObject;
}
// private helper methods ----------------------------------------
/**
* method which find minium object in list
* @param root
* @return
*/
protected LazySTNode findMin(LazySTNode root )
{
LazySTNode minNode=root;
LazySTNode backUp=root;
boolean checkFirst=false;
if(root.deleted==true) {
for (int i=0; i < 500; i++)
((Item) root.data).incrementCount();
checkFirst=true;
}
if (root == null){
return null;
}
if(root.data instanceof Item) {
// for item class only
if (checkLeft(root) == true) {
if(root.lftChild!=null)
if(((Item) root.data).getCount()> ((Item) findMin(root.lftChild).data).getCount())
minNode = findMin(root.lftChild);
}
if (checkRight(root) == true) {
if(root.rtChild!=null)
if(((Item) root.data).getCount()> ((Item) findMin(root.rtChild).data).getCount())
minNode = findMin(root.rtChild);
}
}
if(checkFirst){
for (int i=0; i < 500; i++)
((Item) root.data).decrementCount();
checkFirst=false;
}
return minNode;
}
/**
* method which find maxium object in list
* @param root
* @return
*/
protected LazySTNode findMax(LazySTNode root )
{
LazySTNode maxNode=root;
if (root == null){
return null;
}
// for item class only
if (checkRight(root) == true) {
if(root.rtChild!=null)
if(((Item) maxNode.data).getCount()< ((Item) findMax(root.rtChild).data).getCount())
maxNode = findMax(root.rtChild);
}
if (checkLeft(root) == true) {
if(root.lftChild!=null)
if(((Item) maxNode.data).getCount()< ((Item) findMax(root.lftChild).data).getCount())
maxNode = findMax(root.lftChild);
}
return maxNode;
// if (root == null){
// return null;
// }
//
// if(checkLeft(root)==true){
// return findMin(root.lftChild);
// }
// if(root.deleted!=true){
// return root;
// }
// if(checkRight(root)==true){
// return findMin(root.rtChild);
// }
//
//
// return null;
//
// if (root == null)
// return null;
// else if(root.deleted==true)
// return findMax(root.rtChild);
// if (root.rtChild == null)
// return root;
// if(root.rtChild.deleted==true && root.rtChild.rtChild==null)
// return root;
// return findMax(root.rtChild);
}
/**
* method which insert object to specific point based on BST rule
* @param root
* @param x
* @return
*/
protected LazySTNode insert(LazySTNode root, E x )
{
int compareResult; // avoid multiple calls to compareTo()
if (root == null)
{
mSize++;
mSizeHard++;
return new LazySTNode(x, null, null);
}
compareResult = x.compareTo(root.data);
if ( compareResult < 0 )
root.lftChild = insert(root.lftChild, x);
else if ( compareResult > 0 )
root.rtChild = insert(root.rtChild, x);
if(compareResult ==0){
if(root.deleted==true){
root.deleted=false;
mSize++;
}
((Item) root.data).incrementCount();
}
return root;
}
/**
* method which remove object with lazy deletion which only mark
* @param root
* @param x
*/
protected void remove(LazySTNode root, E x )
{
int compareResult; // avoid multiple calls to compareTo()
if (root == null)
return;
compareResult = x.compareTo(root.data);
if ( compareResult < 0 )
remove(root.lftChild, x);
else if ( compareResult > 0 )
remove(root.rtChild, x);
// found the node, for Item class Only
if(root.data instanceof Item){
if(compareResult==0)
if(((Item) root.data).getCount()>1){
((Item) root.data).decrementCount();
// root.deleted=true;
return;
} else{
if(((Item) root.data).getCount()==1){
((Item) root.data).decrementCount();
mSize--;
}
mSize--;
root.deleted=true;
}
}
return;
}
/**
* method which check the close left three point of one node if there is data
* @param nodeT
* @return
*/
private boolean checkLeft(LazySTNode nodeT){
checkExist=false;
if(nodeT== null)
return checkExist;
if(nodeT.lftChild!=null){
if(nodeT.lftChild.deleted!=true){
checkExist =true;
return checkExist;
}
if(checkLeft(nodeT.lftChild)==true){
checkExist =true;
return checkExist;
}
if(checkRight(nodeT.lftChild)==true){
checkExist =true;
return checkExist;
}
}
return checkExist;
}
/**
* method which check the close right three point of one node if there is data
* @param nodeT
* @return
*/
private boolean checkRight(LazySTNode nodeT){
checkExist=false;
if(nodeT== null)
return checkExist;
if(nodeT.rtChild!=null){
if(nodeT.rtChild.deleted!=true){
checkExist =true;
return checkExist;
}
if(checkLeft(nodeT.rtChild)==true){
checkExist =true;
return checkExist;
}
if(checkRight(nodeT.rtChild)==true){
checkExist =true;
return checkExist;
}
}
return checkExist;
}
/**
* method which serve as backup for if needs hard delete
* @return
*/
private LazySTNode doRemove(LazySTNode root){
if(root== null){
return null;
}
if(root.deleted==false){
root.lftChild=doRemove(root.lftChild);
root.rtChild=doRemove(root.rtChild);
} else {
if (root.lftChild==null||root.rtChild==null){
root = (root.lftChild!=null) ? root.lftChild : root.rtChild;
root = doRemove(root);
} else {
root.lftChild=null;
findMin(root.rtChild);
if(root.lftChild==null){
root.rtChild=null;
root=doRemove(root);
} else {
root.data= root.lftChild.data;
root.deleted=false;
root.lftChild.deleted = true;
root = doRemove(root);
}
}
}
return root;
}
/**
* method which traverse every object to print out
* @param func
* @param treeNode
* @param <F>
*/
protected <F extends Traverser<? super E>>
void traverseHard(F func, LazySTNode treeNode)
{
if (treeNode == null)
return;
traverseHard(func, treeNode.lftChild);
func.visit(treeNode.data);
traverseHard(func, treeNode.rtChild);
}
/**
* method which traverse every undeleted object to print out
* @param func
* @param treeNode
* @param <F>
*/
protected <F extends Traverser<? super E>>
void traverseSoft(F func, LazySTNode treeNode)
{
if (treeNode == null)
return;
traverseSoft(func, treeNode.lftChild);
if(treeNode.deleted!=true)
func.visit(treeNode.data);
traverseSoft(func, treeNode.rtChild);
}
/**
* method which find the specific object by traverse the tree
* @param root
* @param x
* @return
*/
protected LazySTNode find(LazySTNode root, E x )
{
int compareResult; // avoid multiple calls to compareTo()
if (root == null)
return null;
compareResult = x.compareTo(root.data);
if (compareResult < 0)
return find(root.lftChild, x);
if (compareResult > 0)
return find(root.rtChild, x);
if(root.deleted==true)
return null;
return root; // found
}
/**
* method which gives a hard clone of current tree
* @param root
* @return
*/
protected LazySTNode cloneSubtree(LazySTNode root)
{
LazySTNode newNode;
if (root == null)
return null;
// does not set myRoot which must be done by caller
newNode = new LazySTNode
(
root.data,
cloneSubtree(root.lftChild),
cloneSubtree(root.rtChild)
);
return newNode;
}
/**
* unused method for AVL Trees
* @param treeNode
* @param height
* @return
*/
protected int findHeight(LazySTNode treeNode, int height )
{
int leftHeight, rightHeight;
if (treeNode == null)
return height;
if(treeNode.deleted!=true){
height++;
}else{
if(treeNode.lftChild!=null && treeNode.rtChild!=null){
if(treeNode.rtChild.deleted!=true && treeNode.lftChild.deleted!=true)
height++;
}
}
leftHeight = findHeight(treeNode.lftChild, height);
rightHeight = findHeight(treeNode.rtChild, height);
return (leftHeight > rightHeight)? leftHeight : rightHeight;
}
/**
* inner class for store the Node with left and right node
*/
private class LazySTNode
{
// use public access so the tree or other classes can access members
public LazySTNode lftChild, rtChild;
public E data;
public boolean deleted = false;
public LazySTNode myRoot; // needed to test for certain error
public LazySTNode(E d, LazySTNode lft, LazySTNode rt )
{
lftChild = lft;
rtChild = rt;
data = d;
}
public LazySTNode()
{
this(null, null, null);
}
// function stubs -- for use only with AVL Trees when we extend
public int getHeight() { return 0; }
boolean setHeight(int height) { return true; }
}
}
| 6,141 |
428 | #include "dat.h"
#include "fns.h"
#include "error.h"
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/filio.h>
#include "audio.h"
#include <sys/soundcard.h>
#define Audio_Mic_Val SOUND_MIXER_MIC
#define Audio_Linein_Val SOUND_MIXER_LINE
#define Audio_Speaker_Val SOUND_MIXER_SPEAKER
#define Audio_Headphone_Val SOUND_MIXER_PHONEOUT
#define Audio_Lineout_Val SOUND_MIXER_VOLUME
#define Audio_Pcm_Val AFMT_S16_LE
#define Audio_Ulaw_Val AFMT_MU_LAW
#define Audio_Alaw_Val AFMT_A_LAW
#include "audio-tbls.c"
#define min(a,b) ((a) < (b) ? (a) : (b))
static int debug;
#define AUDIO_FILE_STRING "/dev/dsp"
enum {
A_Pause,
A_UnPause
};
enum {
A_In,
A_Out
};
static QLock inlock;
static QLock outlock;
static int audio_file = -1; /* file in/out */
static int audio_file_in = -1; /* copy of above when opened O_READ/O_RDWR */
static int audio_file_out = -1; /* copy of above when opened O_WRITE/O_RDWR */
static int audio_swap_flag = 0; /* endian swap */
static int audio_in_pause = A_UnPause;
static Audio_t av;
static int mixerleftvol[32];
static int mixerrightvol[32];
static int audio_enforce(Audio_t*);
static int audio_open(void);
static int audio_pause_in(int, int);
static int audio_flush(int, int);
static int audio_pause_out(int);
static int audio_set_blocking(int);
static int audio_set_info(int, Audio_d*, int);
static void audio_swap_endian(char*, int);
void
audio_file_init(void)
{
int i;
static ushort flag = 1;
audio_swap_flag = *((uchar*)&flag) == 0; /* big-endian? */
audio_info_init(&av);
for (i = 0; i < 32; i++)
mixerleftvol[i] = mixerrightvol[i] = 100;
}
void
audio_ctl_init(void)
{
}
void
audio_file_open(Chan *c, int omode)
{
char ebuf[ERRMAX];
if (debug)
print("audio_file_open(0x%.8lux, %d)\n", c, omode);
switch(omode){
case OREAD:
qlock(&inlock);
if(waserror()){
qunlock(&inlock);
nexterror();
}
if(audio_file_in >= 0)
error(Einuse);
if (audio_file < 0)
audio_file = audio_open();
audio_file_in = audio_file;
poperror();
qunlock(&inlock);
break;
case OWRITE:
qlock(&outlock);
if(waserror()){
qunlock(&outlock);
nexterror();
}
if(audio_file_out >= 0)
error(Einuse);
if (audio_file < 0)
audio_file = audio_open();
audio_file_out = audio_file;
poperror();
qunlock(&outlock);
break;
case ORDWR:
qlock(&inlock);
qlock(&outlock);
if(waserror()){
qunlock(&outlock);
qunlock(&inlock);
nexterror();
}
if(audio_file_in >= 0 || audio_file_out >= 0)
error(Einuse);
if (audio_file < 0)
audio_file = audio_open();
audio_file_in = audio_file_out = audio_file;
poperror();
qunlock(&outlock);
qunlock(&inlock);
break;
}
if (debug)
print("audio_file_open: success\nin %d out %d both %d\n",
audio_file_out, audio_file_in, audio_file);
}
void
audio_ctl_open(Chan *c, int omode)
{
USED(c);
USED(omode);
}
void
audio_file_close(Chan *c)
{
switch(c->mode){
case OREAD:
qlock(&inlock);
qlock(&outlock);
if (audio_file_out < 0) {
close(audio_file);
audio_file = -1;
}
qunlock(&outlock);
audio_file_in = -1;
qunlock(&inlock);
break;
case OWRITE:
qlock(&inlock);
qlock(&outlock);
if (audio_file_in < 0) {
close(audio_file);
audio_file = -1;
}
audio_file_out = -1;
qunlock(&outlock);
qunlock(&inlock);
break;
case ORDWR:
qlock(&inlock);
qlock(&outlock);
close(audio_file);
audio_file_in = audio_file_out = audio_file = -1;
qunlock(&outlock);
qunlock(&inlock);
break;
}
}
void
audio_ctl_close(Chan *c)
{
}
long
audio_file_read(Chan *c, void *va, long count, vlong offset)
{
struct timespec time;
long ba, status, chunk, total;
char *pva = (char *) va;
qlock(&inlock);
if(waserror()){
qunlock(&inlock);
nexterror();
}
if(audio_file_in < 0)
error(Eperm);
/* check block alignment */
ba = av.in.bits * av.in.chan / Bits_Per_Byte;
if(count % ba)
error(Ebadarg);
if(! audio_pause_in(audio_file_in, A_UnPause))
error(Eio);
total = 0;
while(total < count) {
chunk = count - total;
osenter();
status = read(audio_file_in, pva + total, chunk);
osleave();
if(status < 0)
error(Eio);
total += status;
}
if(total != count)
error(Eio);
if(audio_swap_flag && av.out.bits == 16)
audio_swap_endian(pva, count);
poperror();
qunlock(&inlock);
return count;
}
long
audio_file_write(Chan *c, void *va, long count, vlong offset)
{
struct timespec time;
long status = -1;
long ba, total, chunk, bufsz;
if (debug > 1)
print("audio_file_write(0x%.8lux, 0x%.8lux, %ld, %uld)\n",
c, va, count, offset);
qlock(&outlock);
if(waserror()){
qunlock(&outlock);
nexterror();
}
if(audio_file_out < 0)
error(Eperm);
/* check block alignment */
ba = av.out.bits * av.out.chan / Bits_Per_Byte;
if(count % ba)
error(Ebadarg);
if(audio_swap_flag && av.out.bits == 16)
audio_swap_endian(va, count);
total = 0;
bufsz = av.out.buf * Audio_Max_Buf / Audio_Max_Val;
if(bufsz == 0)
error(Ebadarg);
while(total < count) {
chunk = min(bufsz, count - total);
osenter();
status = write(audio_file_out, va, chunk);
osleave();
if(status <= 0)
error(Eio);
total += status;
}
poperror();
qunlock(&outlock);
return count;
}
static int
audio_open(void)
{
int fd;
/* open non-blocking in case someone already has it open */
/* otherwise we would block until they close! */
fd = open(AUDIO_FILE_STRING, O_RDWR|O_NONBLOCK);
if(fd < 0)
oserror();
/* change device to be blocking */
if(!audio_set_blocking(fd)) {
if (debug)
print("audio_open: failed to set blocking\n");
close(fd);
error("cannot set blocking mode");
}
if (debug)
print("audio_open: blocking set\n");
/* set audio info */
av.in.flags = ~0;
av.out.flags = 0;
if(! audio_set_info(fd, &av.in, A_In)) {
close(fd);
error(Ebadarg);
}
av.in.flags = 0;
/* tada, we're open, blocking, paused and flushed */
return fd;
}
long
audio_ctl_write(Chan *c, void *va, long count, vlong offset)
{
int fd;
int ff;
Audio_t tmpav = av;
tmpav.in.flags = 0;
tmpav.out.flags = 0;
if (!audioparse(va, count, &tmpav))
error(Ebadarg);
if (!audio_enforce(&tmpav))
error(Ebadarg);
qlock(&inlock);
if (waserror()) {
qunlock(&inlock);
nexterror();
}
if (audio_file_in >= 0 && (tmpav.in.flags & AUDIO_MOD_FLAG)) {
if (!audio_pause_in(audio_file_in, A_Pause))
error(Ebadarg);
if (!audio_flush(audio_file_in, A_In))
error(Ebadarg);
if (!audio_set_info(audio_file_in, &tmpav.in, A_In))
error(Ebadarg);
}
poperror();
qunlock(&inlock);
qlock(&outlock);
if (waserror()) {
qunlock(&outlock);
nexterror();
}
if (audio_file_out >= 0 && (tmpav.out.flags & AUDIO_MOD_FLAG)){
if (!audio_pause_out(audio_file_out))
error(Ebadarg);
if (!audio_set_info(audio_file_out, &tmpav.out, A_Out))
error(Ebadarg);
}
poperror();
qunlock(&outlock);
tmpav.in.flags = 0;
tmpav.out.flags = 0;
av = tmpav;
return count;
}
static int
audio_set_blocking(int fd)
{
int val;
if((val = fcntl(fd, F_GETFL, 0)) == -1)
return 0;
val &= ~O_NONBLOCK;
if(fcntl(fd, F_SETFL, val) < 0)
return 0;
return 1;
}
static int
doioctl(int fd, int ctl, int *info)
{
int status;
osenter();
status = ioctl(fd, ctl, info); /* qlock and load general stuff */
osleave();
if (status < 0)
print("doioctl(0x%.8lux, 0x%.8lux) failed %d\n", ctl, *info, errno);
return status;
}
static int
choosefmt(Audio_d *i)
{
int newbits, newenc;
newbits = i->bits;
newenc = i->enc;
switch (newenc) {
case Audio_Alaw_Val:
if (newbits == 8)
return AFMT_A_LAW;
break;
case Audio_Ulaw_Val:
if (newbits == 8)
return AFMT_MU_LAW;
break;
case Audio_Pcm_Val:
if (newbits == 8)
return AFMT_U8;
else if (newbits == 16)
return AFMT_S16_LE;
break;
}
return -1;
}
static int
audio_set_info(int fd, Audio_d *i, int d)
{
int status;
int unequal_stereo = 0;
if(fd < 0)
return 0;
/* fmt */
if(i->flags & (AUDIO_BITS_FLAG || AUDIO_ENC_FLAG)) {
int oldfmt, newfmt;
oldfmt = AFMT_QUERY;
if (doioctl(fd, SNDCTL_DSP_SETFMT, &oldfmt) < 0)
return 0;
if (debug)
print("audio_set_info: current format 0x%.8lux\n", oldfmt);
newfmt = choosefmt(i);
if (debug)
print("audio_set_info: new format 0x%.8lux\n", newfmt);
if (newfmt == -1 || newfmt != oldfmt && doioctl(fd, SNDCTL_DSP_SETFMT, &newfmt) < 0)
return 0;
}
/* channels */
if(i->flags & AUDIO_CHAN_FLAG) {
int channels = i->chan;
if (debug)
print("audio_set_info: new channels %d\n", channels);
if (doioctl(fd, SNDCTL_DSP_CHANNELS, &channels) < 0
|| channels != i->chan)
return 0;
}
/* sample rate */
if(i->flags & AUDIO_RATE_FLAG) {
int speed = i->rate;
if (debug)
print("audio_set_info: new speed %d\n", speed);
if (doioctl(fd, SNDCTL_DSP_SPEED, &speed) < 0 || speed != i->rate)
return 0;
}
/* dev volume */
if(i->flags & (AUDIO_LEFT_FLAG | AUDIO_VOL_FLAG | AUDIO_RIGHT_FLAG)) {
int val;
if (i->flags & (AUDIO_LEFT_FLAG | AUDIO_VOL_FLAG))
mixerleftvol[i->dev] = (i->left * 100) / Audio_Max_Val;
if (i->flags & (AUDIO_RIGHT_FLAG | AUDIO_VOL_FLAG))
mixerrightvol[i->dev] = (i->right * 100) / Audio_Max_Val;
val = mixerleftvol[i->dev] | (mixerrightvol[i->dev] << 8);
doioctl(fd, MIXER_WRITE(i->dev), &val);
}
if (i->flags & AUDIO_DEV_FLAG) {
}
return 1;
}
void
audio_swap_endian(char *p, int n)
{
int b;
while (n > 1) {
b = p[0];
p[0] = p[1];
p[1] = b;
p += 2;
n -= 2;
}
}
static int
audio_pause_out(int fd)
{
USED(fd);
return 1;
}
static int
audio_pause_in(int fd, int f)
{
USED(fd);
USED(f);
return 1;
}
static int
audio_flush(int fd, int d)
{
int x;
return doioctl(fd, SNDCTL_DSP_SYNC, &x) >= 0;
}
static int
audio_enforce(Audio_t *t)
{
if((t->in.enc == Audio_Ulaw_Val || t->in.enc == Audio_Alaw_Val) &&
(t->in.rate != 8000 || t->in.chan != 1))
return 0;
if((t->out.enc == Audio_Ulaw_Val || t->out.enc == Audio_Alaw_Val) &&
(t->out.rate != 8000 || t->out.chan != 1))
return 0;
return 1;
}
Audio_t*
getaudiodev(void)
{
return &av;
}
| 4,671 |
777 | <filename>content/browser/screen_orientation/screen_orientation.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 CONTENT_BROWSER_SCREEN_ORIENTATION_SCREEN_ORIENTATION_H
#define CONTENT_BROWSER_SCREEN_ORIENTATION_SCREEN_ORIENTATION_H
#include "base/callback.h"
#include "base/memory/weak_ptr.h"
#include "content/public/browser/web_contents_binding_set.h"
#include "content/public/browser/web_contents_observer.h"
#include "device/screen_orientation/public/interfaces/screen_orientation.mojom.h"
namespace content {
class ScreenOrientationProvider;
class WebContents;
class ScreenOrientation : public device::mojom::ScreenOrientation,
public WebContentsObserver {
public:
explicit ScreenOrientation(WebContents* web_contents);
~ScreenOrientation() override;
ScreenOrientationProvider* GetScreenOrientationProvider();
private:
// ScreenOrientation:
void LockOrientation(blink::WebScreenOrientationLockType orientation,
const LockOrientationCallback& callback) override;
void UnlockOrientation() override;
// WebContentsObserver:
void DidNavigateMainFrame(const LoadCommittedDetails& details,
const FrameNavigateParams& params) override;
void NotifyLockResult(device::mojom::ScreenOrientationLockResult result);
std::unique_ptr<ScreenOrientationProvider> provider_;
LockOrientationCallback on_result_callback_;
WebContentsFrameBindingSet<device::mojom::ScreenOrientation> bindings_;
base::WeakPtrFactory<ScreenOrientation> weak_factory_;
};
} // namespace content
#endif // CONTENT_BROWSER_SCREEN_ORIENTATION_SCREEN_ORIENTATION_H
| 599 |
582 | <filename>treelib/exceptions.py
class NodePropertyError(Exception):
"""Basic Node attribute error"""
pass
class NodeIDAbsentError(NodePropertyError):
"""Exception throwed if a node's identifier is unknown"""
pass
class NodePropertyAbsentError(NodePropertyError):
"""Exception throwed if a node's data property is not specified"""
pass
class MultipleRootError(Exception):
"""Exception throwed if more than one root exists in a tree."""
pass
class DuplicatedNodeIdError(Exception):
"""Exception throwed if an identifier already exists in a tree."""
pass
class LinkPastRootNodeError(Exception):
"""
Exception throwed in Tree.link_past_node() if one attempts
to "link past" the root node of a tree.
"""
pass
class InvalidLevelNumber(Exception):
pass
class LoopError(Exception):
"""
Exception thrown if trying to move node B to node A's position
while A is B's ancestor.
"""
pass
| 299 |
1,009 | <filename>src/msqueue.h
/*
* Copyright (c) 2017, Alibaba Group Holding Limited
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Redis nor the names of its contributors may be used
* to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __MSQUEUE_H__
#define __MSQUEUE_H__
#include <pthread.h>
typedef struct queueNode {
struct queueNode *next;
} queueNode;
typedef struct queue {
queueNode *head;
pthread_spinlock_t head_lock;
queueNode *tail;
pthread_spinlock_t tail_lock;
queueNode divider;
} queue;
queue *queueInit(queue *q);
queue *queueCreate();
void queuePush(queue *q, queueNode *node);
queueNode *queuePop(queue *q);
void queueSetHead(queue *q, queueNode *node);
#endif
| 642 |
434 | <reponame>eckserah/nifskope
#include "spellbook.h"
// Brief description is deliberately not autolinked to class Spell
/*! \file moppcode.cpp
* \brief Havok MOPP spells
*
* Note that this code only works on the Windows platform due an external
* dependency on the Havok SDK, with which NifMopp.dll is compiled.
*
* Most classes here inherit from the Spell class.
*/
// Need to include headers before testing this
#ifdef Q_OS_WIN32
// This code is only intended to be run with Win32 platform.
extern "C" void * __stdcall SetDllDirectoryA( const char * lpPathName );
extern "C" void * __stdcall LoadLibraryA( const char * lpModuleName );
extern "C" void * __stdcall GetProcAddress ( void * hModule, const char * lpProcName );
extern "C" void __stdcall FreeLibrary( void * lpModule );
//! Interface to the external MOPP library
class HavokMoppCode
{
private:
typedef int (__stdcall * fnGenerateMoppCode)( int nVerts, Vector3 const * verts, int nTris, Triangle const * tris );
typedef int (__stdcall * fnGenerateMoppCodeWithSubshapes)( int nShapes, int const * shapes, int nVerts, Vector3 const * verts, int nTris, Triangle const * tris );
typedef int (__stdcall * fnRetrieveMoppCode)( int nBuffer, char * buffer );
typedef int (__stdcall * fnRetrieveMoppScale)( float * value );
typedef int (__stdcall * fnRetrieveMoppOrigin)( Vector3 * value );
void * hMoppLib;
fnGenerateMoppCode GenerateMoppCode;
fnRetrieveMoppCode RetrieveMoppCode;
fnRetrieveMoppScale RetrieveMoppScale;
fnRetrieveMoppOrigin RetrieveMoppOrigin;
fnGenerateMoppCodeWithSubshapes GenerateMoppCodeWithSubshapes;
public:
HavokMoppCode() : hMoppLib( 0 ), GenerateMoppCode( 0 ), RetrieveMoppCode( 0 ), RetrieveMoppScale( 0 ),
RetrieveMoppOrigin( 0 ), GenerateMoppCodeWithSubshapes( 0 )
{
}
~HavokMoppCode()
{
if ( hMoppLib )
FreeLibrary( hMoppLib );
}
bool Initialize()
{
if ( !hMoppLib ) {
SetDllDirectoryA( QCoreApplication::applicationDirPath().toLocal8Bit().constData() );
hMoppLib = LoadLibraryA( "NifMopp.dll" );
GenerateMoppCode = (fnGenerateMoppCode)GetProcAddress( hMoppLib, "GenerateMoppCode" );
RetrieveMoppCode = (fnRetrieveMoppCode)GetProcAddress( hMoppLib, "RetrieveMoppCode" );
RetrieveMoppScale = (fnRetrieveMoppScale)GetProcAddress( hMoppLib, "RetrieveMoppScale" );
RetrieveMoppOrigin = (fnRetrieveMoppOrigin)GetProcAddress( hMoppLib, "RetrieveMoppOrigin" );
GenerateMoppCodeWithSubshapes = (fnGenerateMoppCodeWithSubshapes)GetProcAddress( hMoppLib, "GenerateMoppCodeWithSubshapes" );
}
return (GenerateMoppCode && RetrieveMoppCode && RetrieveMoppScale && RetrieveMoppOrigin);
}
QByteArray CalculateMoppCode( QVector<Vector3> const & verts, QVector<Triangle> const & tris, Vector3 * origin, float * scale )
{
QByteArray code;
if ( Initialize() ) {
int len = GenerateMoppCode( verts.size(), &verts[0], tris.size(), &tris[0] );
if ( len > 0 ) {
code.resize( len );
if ( 0 != RetrieveMoppCode( len, code.data() ) ) {
if ( scale )
RetrieveMoppScale( scale );
if ( origin )
RetrieveMoppOrigin( origin );
} else {
code.clear();
}
}
}
return code;
}
QByteArray CalculateMoppCode( QVector<int> const & subShapesVerts,
QVector<Vector3> const & verts,
QVector<Triangle> const & tris,
Vector3 * origin, float * scale )
{
QByteArray code;
if ( Initialize() ) {
int len;
if ( GenerateMoppCodeWithSubshapes )
len = GenerateMoppCodeWithSubshapes( subShapesVerts.size(), &subShapesVerts[0], verts.size(), &verts[0], tris.size(), &tris[0] );
else
len = GenerateMoppCode( verts.size(), &verts[0], tris.size(), &tris[0] );
if ( len > 0 ) {
code.resize( len );
if ( 0 != RetrieveMoppCode( len, code.data() ) ) {
if ( scale )
RetrieveMoppScale( scale );
if ( origin )
RetrieveMoppOrigin( origin );
} else {
code.clear();
}
}
}
return code;
}
}
TheHavokCode;
//! Update Havok MOPP for a given shape
class spMoppCode final : public Spell
{
public:
QString name() const override final { return Spell::tr( "Update MOPP Code" ); }
QString page() const override final { return Spell::tr( "Havok" ); }
bool isApplicable( const NifModel * nif, const QModelIndex & index ) override final
{
if ( nif->getUserVersion() != 10 && nif->getUserVersion() != 11 )
return false;
if ( TheHavokCode.Initialize() ) {
//QModelIndex iData = nif->getBlock( nif->getLink( index, "Data" ) );
if ( nif->isNiBlock( index, "bhkMoppBvTreeShape" ) ) {
return ( nif->checkVersion( 0x14000004, 0x14000005 )
|| nif->checkVersion( 0x14020007, 0x14020007 ) );
}
}
return false;
}
QModelIndex cast( NifModel * nif, const QModelIndex & iBlock ) override final
{
if ( !TheHavokCode.Initialize() ) {
Message::critical( nullptr, Spell::tr( "Unable to locate NifMopp.dll" ) );
return iBlock;
}
QPersistentModelIndex ibhkMoppBvTreeShape = iBlock;
QModelIndex ibhkPackedNiTriStripsShape = nif->getBlock( nif->getLink( ibhkMoppBvTreeShape, "Shape" ) );
if ( !nif->isNiBlock( ibhkPackedNiTriStripsShape, "bhkPackedNiTriStripsShape" ) ) {
Message::warning( nullptr, Spell::tr( "Only bhkPackedNiTriStripsShape is supported at this time." ) );
return iBlock;
}
QModelIndex ihkPackedNiTriStripsData = nif->getBlock( nif->getLink( ibhkPackedNiTriStripsShape, "Data" ) );
if ( !nif->isNiBlock( ihkPackedNiTriStripsData, "hkPackedNiTriStripsData" ) )
return iBlock;
QVector<int> subshapeVerts;
if ( nif->checkVersion( 0x14000004, 0x14000005 ) ) {
int nSubShapes = nif->get<int>( ibhkPackedNiTriStripsShape, "Num Sub Shapes" );
QModelIndex ihkSubShapes = nif->getIndex( ibhkPackedNiTriStripsShape, "Sub Shapes" );
subshapeVerts.resize( nSubShapes );
for ( int t = 0; t < nSubShapes; t++ ) {
subshapeVerts[t] = nif->get<int>( ihkSubShapes.child( t, 0 ), "Num Vertices" );
}
} else if ( nif->checkVersion( 0x14020007, 0x14020007 ) ) {
int nSubShapes = nif->get<int>( ihkPackedNiTriStripsData, "Num Sub Shapes" );
QModelIndex ihkSubShapes = nif->getIndex( ihkPackedNiTriStripsData, "Sub Shapes" );
subshapeVerts.resize( nSubShapes );
for ( int t = 0; t < nSubShapes; t++ ) {
subshapeVerts[t] = nif->get<int>( ihkSubShapes.child( t, 0 ), "Num Vertices" );
}
}
QVector<Vector3> verts = nif->getArray<Vector3>( ihkPackedNiTriStripsData, "Vertices" );
QVector<Triangle> triangles;
int nTriangles = nif->get<int>( ihkPackedNiTriStripsData, "Num Triangles" );
QModelIndex iTriangles = nif->getIndex( ihkPackedNiTriStripsData, "Triangles" );
triangles.resize( nTriangles );
for ( int t = 0; t < nTriangles; t++ ) {
triangles[t] = nif->get<Triangle>( iTriangles.child( t, 0 ), "Triangle" );
}
if ( verts.isEmpty() || triangles.isEmpty() ) {
Message::critical( nullptr, Spell::tr( "Insufficient data to calculate MOPP code" ),
Spell::tr("Vertices: %1, Triangles: %2").arg( !verts.isEmpty() ).arg( !triangles.isEmpty() )
);
return iBlock;
}
Vector3 origin;
float scale;
QByteArray moppcode = TheHavokCode.CalculateMoppCode( subshapeVerts, verts, triangles, &origin, &scale );
if ( moppcode.size() == 0 ) {
Message::critical( nullptr, Spell::tr( "Failed to generate MOPP code" ) );
} else {
QModelIndex iCodeOrigin = nif->getIndex( ibhkMoppBvTreeShape, "Origin" );
nif->set<Vector3>( iCodeOrigin, origin );
QModelIndex iCodeScale = nif->getIndex( ibhkMoppBvTreeShape, "Scale" );
nif->set<float>( iCodeScale, scale );
QModelIndex iCodeSize = nif->getIndex( ibhkMoppBvTreeShape, "MOPP Data Size" );
QModelIndex iCode = nif->getIndex( ibhkMoppBvTreeShape, "MOPP Data" ).child( 0, 0 );
if ( iCodeSize.isValid() && iCode.isValid() ) {
nif->set<int>( iCodeSize, moppcode.size() );
nif->updateArray( iCode );
nif->set<QByteArray>( iCode, moppcode );
}
}
return iBlock;
}
};
REGISTER_SPELL( spMoppCode )
//! Update MOPP code on all shapes in this model
class spAllMoppCodes final : public Spell
{
public:
QString name() const override final { return Spell::tr( "Update All MOPP Code" ); }
QString page() const override final { return Spell::tr( "Batch" ); }
bool isApplicable( const NifModel * nif, const QModelIndex & idx ) override final
{
if ( nif && nif->getUserVersion() != 10 && nif->getUserVersion() != 11 )
return false;
if ( TheHavokCode.Initialize() ) {
if ( nif && !idx.isValid() ) {
return ( nif->checkVersion( 0x14000004, 0x14000005 )
|| nif->checkVersion( 0x14020007, 0x14020007 ) );
}
}
return false;
}
QModelIndex cast( NifModel * nif, const QModelIndex & ) override final
{
QList<QPersistentModelIndex> indices;
spMoppCode TSpacer;
for ( int n = 0; n < nif->getBlockCount(); n++ ) {
QModelIndex idx = nif->getBlock( n );
if ( TSpacer.isApplicable( nif, idx ) )
indices << idx;
}
for ( const QModelIndex& idx : indices ) {
TSpacer.castIfApplicable( nif, idx );
}
return QModelIndex();
}
};
REGISTER_SPELL( spAllMoppCodes )
#endif // Q_OS_WIN32
| 3,748 |
331 | package com.freedom.lauzy.ticktockmusic.contract;
import com.freedom.lauzy.ticktockmusic.base.IBaseView;
import com.freedom.lauzy.ticktockmusic.model.SongEntity;
import java.util.List;
/**
* Desc : 文件夹音乐
* Author : Lauzy
* Date : 2018/3/15
* Blog : http://www.jianshu.com/u/e76853f863a9
* Email : <EMAIL>
*/
public interface FolderSongsContract {
interface Presenter {
void loadFolderSongs(String folderPath);
void deleteSong(int position, SongEntity songEntity);
}
interface View extends IBaseView {
void onLoadFolderSongsSuccess(List<SongEntity> songEntities);
void setEmptyView();
void loadFail(Throwable throwable);
void deleteSongSuccess(int position, SongEntity songEntity);
}
}
| 289 |
355 | <reponame>netdrones/habitat-lab<filename>habitat/tasks/rearrange/obj_loaders.py
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import magnum as mn
import numpy as np
import habitat_sim
from habitat.tasks.rearrange.utils import get_aabb, make_render_only
from habitat_sim.physics import MotionType
def add_obj(name, sim):
if "/BOX_" in name:
size_parts = name.split("/BOX_")[-1]
size_parts = size_parts.split("_")
if len(size_parts) == 1:
size_x = size_y = size_z = float(size_parts[0])
else:
size_x = float(size_parts[0])
size_y = float(size_parts[1])
size_z = float(size_parts[2])
obj_mgr = sim.get_object_template_manager()
template_handle = obj_mgr.get_template_handles("cube")[0]
template = obj_mgr.get_template_by_handle(template_handle)
template.scale = mn.Vector3(size_x, size_y, size_z)
template.force_flat_shading = False
new_template_handle = obj_mgr.register_template(template, "box_new")
obj_id = sim.add_object(new_template_handle)
sim.set_object_motion_type(MotionType.DYNAMIC, obj_id)
return obj_id
PROP_FILE_END = ".object_config.json"
use_name = name + PROP_FILE_END
obj_id = sim.add_object_by_handle(use_name)
return obj_id
def place_viz_objs(name_trans, sim, obj_ids):
viz_obj_ids = []
for i, (_, assoc_obj_idx, trans) in enumerate(name_trans):
if len(obj_ids) == 0:
obj_bb = get_aabb(assoc_obj_idx, sim, False)
obj_mgr = sim.get_object_template_manager()
template = obj_mgr.get_template_by_handle(
obj_mgr.get_template_handles("cubeWireframe")[0]
)
template.scale = (
mn.Vector3(obj_bb.size_x(), obj_bb.size_y(), obj_bb.size_z())
/ 2.0
)
new_template_handle = obj_mgr.register_template(
template, "new_obj_viz"
)
viz_obj_id = sim.add_object(new_template_handle)
else:
viz_obj_id = obj_ids[i]
make_render_only(viz_obj_id, sim)
sim.set_transformation(trans, viz_obj_id)
viz_obj_ids.append(viz_obj_id)
return viz_obj_ids
def load_articulated_objs(name_obj_dat, sim, obj_ids, auto_sleep=True):
"""
Same params as `orp.obj_loaders.load_objs`
"""
art_obj_ids = []
for i, (name, obj_dat) in enumerate(name_obj_dat):
trans = obj_dat[0]
obj_type = obj_dat[1]
motion_type = MotionType.DYNAMIC
if obj_type == -2:
fixed_base = False
else:
fixed_base = True
if len(obj_ids) == 0:
ao_mgr = sim.get_articulated_object_manager()
ao = ao_mgr.add_articulated_object_from_urdf(name, fixed_base)
else:
ao = obj_ids[i]
T = mn.Matrix4(trans)
ao.transformation = T
# TODO: Broken in release.
# if auto_sleep:
# ao.can_sleep = True
ao.motion_type = motion_type
art_obj_ids.append(ao)
if len(obj_ids) != 0:
return obj_ids
return art_obj_ids
def init_art_objs(idx_and_state, sim):
for art_obj_idx, art_state in idx_and_state:
# Need to not sleep so the update actually happens
prev_sleep = sim.get_articulated_object_sleep(art_obj_idx)
sim.set_articulated_object_positions(art_obj_idx, np.array(art_state))
# Default motors for all NONROBOT articulated objects.
for i in range(len(art_state)):
jms = habitat_sim.physics.JointMotorSettings(
0.0, # position_target
0.0, # position_gain
0.0, # velocity_target
0.3, # velocity_gain
1.0, # max_impulse
)
sim.update_joint_motor(art_obj_idx, i, jms)
sim.set_auto_clamp_joint_limits(art_obj_idx, True)
sim.set_articulated_object_sleep(art_obj_idx, prev_sleep)
def load_objs(name_obj_dat, sim, obj_ids, auto_sleep=True):
"""
- name_obj_dat: List[(str, List[
transformation as a 4x4 list of lists of floats,
int representing the motion type
])
"""
static_obj_ids = []
for i, (name, obj_dat) in enumerate(name_obj_dat):
if len(obj_ids) == 0:
obj_id = add_obj(name, sim)
else:
obj_id = obj_ids[i]
trans = obj_dat[0]
obj_type = obj_dat[1]
use_trans = mn.Matrix4(trans)
sim.set_transformation(use_trans, obj_id)
sim.set_linear_velocity(mn.Vector3(0, 0, 0), obj_id)
sim.set_angular_velocity(mn.Vector3(0, 0, 0), obj_id)
sim.set_object_motion_type(MotionType(obj_type), obj_id)
static_obj_ids.append(obj_id)
if len(obj_ids) != 0:
return obj_ids
return static_obj_ids
| 2,485 |
493 | <filename>src/main/java/com/mauersu/util/redis/DefaultValueOperations.java
/*
* Copyright 2011-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.mauersu.util.redis;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.TimeoutUtils;
import org.springframework.data.redis.core.ValueOperations;
/**
* Default implementation of {@link ValueOperations}.
*
* @author <NAME>
* @author <NAME>
* @author <NAME>
*/
class DefaultValueOperations<K, V> extends AbstractOperations<K, V> implements ValueOperations<K, V> {
DefaultValueOperations(RedisTemplate<K, V> template) {
super(template);
}
private volatile int dbIndex;
DefaultValueOperations(RedisTemplate<K, V> template, int dbIndex) {
super(template);
this.dbIndex = dbIndex;
}
public V get(final Object key) {
return execute(new ValueDeserializingRedisCallback(key) {
protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
connection.select(dbIndex);
return connection.get(rawKey);
}
}, true);
}
public V getAndSet(K key, V newValue) {
final byte[] rawValue = rawValue(newValue);
return execute(new ValueDeserializingRedisCallback(key) {
protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
connection.select(dbIndex);
return connection.getSet(rawKey, rawValue);
}
}, true);
}
public Long increment(K key, final long delta) {
final byte[] rawKey = rawKey(key);
return execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.incrBy(rawKey, delta);
}
}, true);
}
public Double increment(K key, final double delta) {
final byte[] rawKey = rawKey(key);
return execute(new RedisCallback<Double>() {
public Double doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.incrBy(rawKey, delta);
}
}, true);
}
public Integer append(K key, String value) {
final byte[] rawKey = rawKey(key);
final byte[] rawString = rawString(value);
return execute(new RedisCallback<Integer>() {
public Integer doInRedis(RedisConnection connection) {
connection.select(dbIndex);
final Long result = connection.append(rawKey, rawString);
return ( result != null ) ? result.intValue() : null;
}
}, true);
}
public String get(K key, final long start, final long end) {
final byte[] rawKey = rawKey(key);
byte[] rawReturn = execute(new RedisCallback<byte[]>() {
public byte[] doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.getRange(rawKey, start, end);
}
}, true);
return deserializeString(rawReturn);
}
public List<V> multiGet(Collection<K> keys) {
if (keys.isEmpty()) {
return Collections.emptyList();
}
final byte[][] rawKeys = new byte[keys.size()][];
int counter = 0;
for (K hashKey : keys) {
rawKeys[counter++] = rawKey(hashKey);
}
List<byte[]> rawValues = execute(new RedisCallback<List<byte[]>>() {
public List<byte[]> doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.mGet(rawKeys);
}
}, true);
return deserializeValues(rawValues);
}
public void multiSet(Map<? extends K, ? extends V> m) {
if (m.isEmpty()) {
return;
}
final Map<byte[], byte[]> rawKeys = new LinkedHashMap<byte[], byte[]>(m.size());
for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
rawKeys.put(rawKey(entry.getKey()), rawValue(entry.getValue()));
}
execute(new RedisCallback<Object>() {
public Object doInRedis(RedisConnection connection) {
connection.select(dbIndex);
connection.mSet(rawKeys);
return null;
}
}, true);
}
public Boolean multiSetIfAbsent(Map<? extends K, ? extends V> m) {
if (m.isEmpty()) {
return true;
}
final Map<byte[], byte[]> rawKeys = new LinkedHashMap<byte[], byte[]>(m.size());
for (Map.Entry<? extends K, ? extends V> entry : m.entrySet()) {
rawKeys.put(rawKey(entry.getKey()), rawValue(entry.getValue()));
}
return execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.mSetNX(rawKeys);
}
}, true);
}
public void set(K key, V value) {
final byte[] rawValue = rawValue(value);
execute(new ValueDeserializingRedisCallback(key) {
protected byte[] inRedis(byte[] rawKey, RedisConnection connection) {
connection.select(dbIndex);
connection.set(rawKey, rawValue);
return null;
}
}, true);
}
public void set(K key, V value, final long timeout, final TimeUnit unit) {
final byte[] rawKey = rawKey(key);
final byte[] rawValue = rawValue(value);
execute(new RedisCallback<Object>() {
public Object doInRedis(RedisConnection connection) throws DataAccessException {
connection.select(dbIndex);
potentiallyUsePsetEx(connection);
return null;
}
public void potentiallyUsePsetEx(RedisConnection connection) {
if (!TimeUnit.MILLISECONDS.equals(unit) || !failsafeInvokePsetEx(connection)) {
connection.select(dbIndex);
connection.setEx(rawKey, TimeoutUtils.toSeconds(timeout, unit), rawValue);
}
}
private boolean failsafeInvokePsetEx(RedisConnection connection) {
boolean failed = false;
try {
connection.select(dbIndex);
connection.pSetEx(rawKey, timeout, rawValue);
} catch (UnsupportedOperationException e) {
// in case the connection does not support pSetEx return false to allow fallback to other operation.
failed = true;
}
return !failed;
}
}, true);
}
public Boolean setIfAbsent(K key, V value) {
final byte[] rawKey = rawKey(key);
final byte[] rawValue = rawValue(value);
return execute(new RedisCallback<Boolean>() {
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
connection.select(dbIndex);
return connection.setNX(rawKey, rawValue);
}
}, true);
}
public void set(K key, final V value, final long offset) {
final byte[] rawKey = rawKey(key);
final byte[] rawValue = rawValue(value);
execute(new RedisCallback<Object>() {
public Object doInRedis(RedisConnection connection) {
connection.select(dbIndex);
connection.setRange(rawKey, rawValue, offset);
return null;
}
}, true);
}
public Long size(K key) {
final byte[] rawKey = rawKey(key);
return execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection connection) {
connection.select(dbIndex);
return connection.strLen(rawKey);
}
}, true);
}
}
| 2,657 |
1,144 | package de.metas.material.dispo.commons.repository.atp;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import de.metas.material.commons.attributes.AttributesKeyMatcher;
import de.metas.material.commons.attributes.AttributesKeyPatternsUtil;
import de.metas.material.commons.attributes.clasifiers.BPartnerClassifier;
import de.metas.material.commons.attributes.clasifiers.ProductClassifier;
import de.metas.material.commons.attributes.clasifiers.WarehouseClassifier;
import lombok.NonNull;
import org.adempiere.exceptions.AdempiereException;
import org.adempiere.warehouse.WarehouseId;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/*
* #%L
* metasfresh-material-dispo-commons
* %%
* Copyright (C) 2019 metas GmbH
* %%
* 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/gpl-2.0.html>.
* #L%
*/
final class AvailableToPromiseResultBuilder
{
public static AvailableToPromiseResultBuilder createEmpty()
{
return new AvailableToPromiseResultBuilder(ImmutableList.of(AvailableToPromiseResultBucket.newAcceptingAny()));
}
@NonNull
public static AvailableToPromiseResultBuilder createEmptyWithPredefinedBuckets(@NonNull final AvailableToPromiseMultiQuery multiQuery)
{
final ImmutableList.Builder<AvailableToPromiseResultBucket> buckets = ImmutableList.builder();
for (final AvailableToPromiseQuery query : multiQuery.getQueries())
{
final List<AttributesKeyMatcher> storageAttributesKeyMatchers = AttributesKeyPatternsUtil.extractAttributesKeyMatchers(query.getStorageAttributesKeyPatterns());
Set<WarehouseId> warehouseIds = query.getWarehouseIds();
if (warehouseIds.isEmpty())
{
warehouseIds = Collections.singleton(null);
}
final BPartnerClassifier bpartner = query.getBpartner();
final List<Integer> productIds = query.getProductIds();
for (final WarehouseId warehouseId : warehouseIds)
{
for (final int productId : productIds)
{
for (final AttributesKeyMatcher storageAttributesKeyMatcher : storageAttributesKeyMatchers)
{
final AvailableToPromiseResultBucket bucket = AvailableToPromiseResultBucket.builder()
.warehouse(WarehouseClassifier.specificOrAny(warehouseId))
.bpartner(bpartner)
.product(ProductClassifier.specific(productId))
.storageAttributesKeyMatcher(storageAttributesKeyMatcher)
.build();
bucket.addDefaultEmptyGroupIfPossible();
buckets.add(bucket);
}
}
}
}
return new AvailableToPromiseResultBuilder(buckets.build());
}
private final ArrayList<AvailableToPromiseResultBucket> buckets;
@VisibleForTesting
AvailableToPromiseResultBuilder(final List<AvailableToPromiseResultBucket> buckets)
{
this.buckets = new ArrayList<>(buckets);
}
public AvailableToPromiseResult build()
{
final ImmutableList<AvailableToPromiseResultGroup> groups = buckets.stream()
.flatMap(AvailableToPromiseResultBucket::buildAndStreamGroups)
.collect(ImmutableList.toImmutableList());
return AvailableToPromiseResult.ofGroups(groups);
}
public void addQtyToAllMatchingGroups(@NonNull final AddToResultGroupRequest request)
{
// note that we might select more quantities than we actually wanted (bc of the way we match attributes in the query using LIKE)
// for that reason, we need to be lenient in case not all quantities can be added to a bucked
buckets.forEach(bucket -> bucket.addQtyToAllMatchingGroups(request));
}
public void addToNewGroupIfFeasible(@NonNull final AddToResultGroupRequest request)
{
boolean addedToAtLeastOneGroup = false;
for (final AvailableToPromiseResultBucket bucket : buckets)
{
if (bucket.addToNewGroupIfFeasible(request))
{
addedToAtLeastOneGroup = true;
break;
}
}
if (!addedToAtLeastOneGroup)
{
final AvailableToPromiseResultBucket bucket = newBucket(request);
if (!bucket.addToNewGroupIfFeasible(request))
{
throw new AdempiereException("Internal error: cannot add " + request + " to newly created bucket: " + bucket);
}
}
}
private AvailableToPromiseResultBucket newBucket(final AddToResultGroupRequest request)
{
final AvailableToPromiseResultBucket bucket = AvailableToPromiseResultBucket.builder()
.warehouse(WarehouseClassifier.specificOrAny(request.getWarehouseId()))
.bpartner(request.getBpartner())
.product(ProductClassifier.specific(request.getProductId().getRepoId()))
.storageAttributesKeyMatcher(AttributesKeyPatternsUtil.matching(request.getStorageAttributesKey()))
.build();
buckets.add(bucket);
return bucket;
}
@VisibleForTesting
ImmutableList<AvailableToPromiseResultBucket> getBuckets()
{
return ImmutableList.copyOf(buckets);
}
}
| 1,751 |
325 | # -*- coding: utf-8 -*-
u"""
Created on 2015-7-13
@author: cheng.li
"""
from PyFin.tests import api
from PyFin.tests import DateUtilities
from PyFin.tests import Env
from PyFin.tests import Math
from PyFin.tests import PricingEngines
from PyFin.tests import Analysis
__all__ = ["api",
"DateUtilities",
"Env",
"Math",
"PricingEngines",
"Analysis"]
| 176 |
1,155 | <filename>deps/boost/libs/mp11/test/mp_quote.cpp
// Copyright 2015, 2017 <NAME>.
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/mp11/utility.hpp>
#include <boost/mp11/detail/config.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <type_traits>
using boost::mp11::mp_invoke;
template<class...> struct X {};
template<template<class...> class F, class... T> using Y = X<F<T>...>;
template<class Q, class... T> using Z = X<mp_invoke<Q, T>...>;
template<class T, class U> struct P {};
template<class T, class U> using first = T;
int main()
{
using boost::mp11::mp_identity_t;
using boost::mp11::mp_quote;
{
using Q = mp_quote<mp_identity_t>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void>, void>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, int[]>, int[]>));
}
{
using Q = mp_quote<mp_identity_t>;
#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
using R1 = Y<Q::fn, void, char, int>;
BOOST_TEST_TRAIT_TRUE((std::is_same<R1, X<void, char, int>>));
#endif
#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 && BOOST_MP11_MSVC >= 1900 )
using R2 = Z<Q, void, char, int>;
BOOST_TEST_TRAIT_TRUE((std::is_same<R2, X<void, char, int>>));
#endif
}
{
using Q = mp_quote<P>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void, void>, P<void, void>>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, char[], int[]>, P<char[], int[]>>));
}
{
using Q = mp_quote<first>;
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void, int>, void>));
BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, char[], int[]>, char[]>));
}
return boost::report_errors();
}
| 889 |
2,346 | /*
* Copyright 2020 <NAME> (<EMAIL>)
*
* 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.
*/
package org.traccar.protocol;
import org.traccar.Protocol;
import org.traccar.StringProtocolEncoder;
import org.traccar.helper.Checksum;
import org.traccar.model.Command;
public class GlobalSatProtocolEncoder extends StringProtocolEncoder {
public GlobalSatProtocolEncoder(Protocol protocol) {
super(protocol);
}
@Override
protected Object encodeCommand(Command command) {
String formattedCommand = null;
switch (command.getType()) {
case Command.TYPE_CUSTOM:
formattedCommand = formatCommand(
command, "GSC,%s,%s", Command.KEY_UNIQUE_ID, Command.KEY_DATA);
break;
case Command.TYPE_ALARM_DISMISS:
formattedCommand = formatCommand(
command, "GSC,%s,Na", Command.KEY_UNIQUE_ID);
break;
case Command.TYPE_OUTPUT_CONTROL:
formattedCommand = formatCommand(
command, "GSC,%s,Lo(%s,%s)", Command.KEY_UNIQUE_ID, Command.KEY_INDEX, Command.KEY_DATA);
break;
default:
break;
}
if (formattedCommand != null) {
return formattedCommand + Checksum.nmea(formattedCommand) + '!';
} else {
return null;
}
}
}
| 805 |
488 | <filename>src/3rdPartyLibraries/qrose/Widgets/QRSeparator_p.h
/***************************************************************************
<NAME>
<EMAIL>
Class: QRSeparator_p
Description:
***************************************************************************/
#ifndef QRSEPARATOR_P_H
#define QRSEPARATOR_P_H
#include <QRSeparator.h>
#include <QRMain.h>
namespace qrs {
class QRSeparator_p {
friend class QRSeparator;
private:
QRSeparator_p(QRSeparator *sep);
void init(QROSE::Orientation orientation);
static QRSeparator_p* getInstance(QRSeparator *sep);
static QRSeparator_p* getInstance(QRSeparator *sep, QROSE::Orientation orientation);
private:
QRSeparator *_sep;
bool _initialised;
};
} // namespace qrs
#endif
| 432 |
1,964 | //
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 <NAME>
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//
#pragma once
#include "extra/fuzzer/fuzzer_input.hpp"
#include <array>
#include <fstream>
#include <iostream>
#include <vector>
std::vector<std::uint8_t> load_input(const char* file)
{
auto fname = std::string{IMMER_OSS_FUZZ_DATA_PATH} + "/" + file;
auto ifs = std::ifstream{fname, std::ios::binary};
ifs.seekg(0, ifs.end);
auto size = ifs.tellg();
ifs.seekg(0, ifs.beg);
auto r = std::vector<std::uint8_t>(size);
ifs.read(reinterpret_cast<char*>(r.data()), size);
return r;
}
| 307 |
408 | <filename>src/main/python/rlbot/matchcomms/common_uses/common_keys.py<gh_stars>100-1000
TARGET_PLAYER_INDEX = 'target_player_index'
| 51 |
335 | <reponame>Safal08/Hacktoberfest-1<filename>M/Mischief_noun.json<gh_stars>100-1000
{
"word": "Mischief",
"definitions": [
"Playful misbehaviour, especially on the part of children.",
"Playfulness that is intended to tease or create trouble.",
"Harm or trouble caused by someone or something.",
"A person responsible for harm or annoyance.",
"A wrong or hardship that a statute is designed to remove or for which the common law affords a remedy."
],
"parts-of-speech": "Noun"
} | 189 |
460 | <gh_stars>100-1000
/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (<EMAIL>)
**
** This file is part of the QtScript module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL-ONLY$
** 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.
**
** If you have questions regarding the use of this file, please contact
** Nokia at <EMAIL>.
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QSCRIPTSTRING_H
#define QSCRIPTSTRING_H
#include <QtCore/qstring.h>
#include <QtCore/qsharedpointer.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Script)
class QScriptStringPrivate;
class Q_SCRIPT_EXPORT QScriptString
{
public:
QScriptString();
QScriptString(const QScriptString &other);
~QScriptString();
QScriptString &operator=(const QScriptString &other);
bool isValid() const;
bool operator==(const QScriptString &other) const;
bool operator!=(const QScriptString &other) const;
quint32 toArrayIndex(bool *ok = 0) const;
QString toString() const;
operator QString() const;
private:
QExplicitlySharedDataPointer<QScriptStringPrivate> d_ptr;
friend class QScriptValue;
Q_DECLARE_PRIVATE(QScriptString)
};
Q_SCRIPT_EXPORT uint qHash(const QScriptString &key);
QT_END_NAMESPACE
QT_END_HEADER
#endif // QSCRIPTSTRING_H
| 673 |
852 | #include "Calibration/EcalTBTools/interface/TB06RecoH2.h"
/*
*/
// FIXME ClassImp (TB06RecoH2)
void TB06RecoH2::reset() {
run = 0;
event = 0;
tableIsMoving = 0;
S6ADC = 0;
MEXTLindex = 0;
MEXTLeta = 0;
MEXTLphi = 0;
MEXTLenergy = 0.;
beamEnergy = 0.;
for (int eta = 0; eta < 7; ++eta)
for (int phi = 0; phi < 7; ++phi)
localMap[eta][phi] = 0.;
S1uncalib_ = 0.;
S25uncalib_ = 0.;
S9uncalib_ = 0.;
S49uncalib_ = 0.;
xECAL = 0.;
yECAL = 0.;
zECAL = 0.;
xHodo = 0.;
yHodo = 0.;
zHodo = 0.;
xSlopeHodo = 0.;
ySlopeHodo = 0.;
xQualityHodo = 0.;
yQualityHodo = 0.;
wcAXo_ = 0;
wcAYo_ = 0;
wcBXo_ = 0;
wcBYo_ = 0;
wcCXo_ = 0;
wcCYo_ = 0;
xwA_ = -999.;
ywA_ = -999.;
xwB_ = -999.;
ywB_ = -999.;
xwC_ = -999.;
ywC_ = -999.;
S1adc_ = 0.;
S2adc_ = 0.;
S3adc_ = 0.;
S4adc_ = 0.;
VM1_ = 0.;
VM2_ = 0.;
VM3_ = 0.;
VM4_ = 0.;
VM5_ = 0.;
VM6_ = 0.;
VM7_ = 0.;
VM8_ = 0.;
VMF_ = 0.;
VMB_ = 0.;
CK1_ = 0.;
CK2_ = 0.;
CK3_ = 0.;
BH1_ = 0.;
BH2_ = 0.;
BH3_ = 0.;
BH4_ = 0.;
TOF1S_ = -999.;
TOF1J_ = -999.;
TOF2S_ = -999.;
TOF2J_ = -999.;
convFactor = 0.;
}
| 669 |
12,278 | // (C) Copyright <NAME> 2006.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_MATH_TOOLS_REMEZ_HPP
#define BOOST_MATH_TOOLS_REMEZ_HPP
#ifdef _MSC_VER
#pragma once
#endif
#include <boost/math/tools/solve.hpp>
#include <boost/math/tools/minima.hpp>
#include <boost/math/tools/roots.hpp>
#include <boost/math/tools/polynomial.hpp>
#include <boost/function/function1.hpp>
#include <boost/scoped_array.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/math/policies/policy.hpp>
namespace boost{ namespace math{ namespace tools{
namespace detail{
//
// The error function: the difference between F(x) and
// the current approximation. This is the function
// for which we must find the extema.
//
template <class T>
struct remez_error_function
{
typedef boost::function1<T, T const &> function_type;
public:
remez_error_function(
function_type f_,
const polynomial<T>& n,
const polynomial<T>& d,
bool rel_err)
: f(f_), numerator(n), denominator(d), rel_error(rel_err) {}
T operator()(const T& z)const
{
T y = f(z);
T abs = y - (numerator.evaluate(z) / denominator.evaluate(z));
T err;
if(rel_error)
{
if(y != 0)
err = abs / fabs(y);
else if(0 == abs)
{
// we must be at a root, or it's not recoverable:
BOOST_ASSERT(0 == abs);
err = 0;
}
else
{
// We have a divide by zero!
// Lets assume that f(x) is zero as a result of
// internal cancellation error that occurs as a result
// of shifting a root at point z to the origin so that
// the approximation can be "pinned" to pass through
// the origin: in that case it really
// won't matter what our approximation calculates here
// as long as it's a small number, return the absolute error:
err = abs;
}
}
else
err = abs;
return err;
}
private:
function_type f;
polynomial<T> numerator;
polynomial<T> denominator;
bool rel_error;
};
//
// This function adapts the error function so that it's minima
// are the extema of the error function. We can find the minima
// with standard techniques.
//
template <class T>
struct remez_max_error_function
{
remez_max_error_function(const remez_error_function<T>& f)
: func(f) {}
T operator()(const T& x)
{
BOOST_MATH_STD_USING
return -fabs(func(x));
}
private:
remez_error_function<T> func;
};
} // detail
template <class T>
class remez_minimax
{
public:
typedef boost::function1<T, T const &> function_type;
typedef boost::numeric::ublas::vector<T> vector_type;
typedef boost::numeric::ublas::matrix<T> matrix_type;
remez_minimax(function_type f, unsigned oN, unsigned oD, T a, T b, bool pin = true, bool rel_err = false, int sk = 0, int bits = 0);
remez_minimax(function_type f, unsigned oN, unsigned oD, T a, T b, bool pin, bool rel_err, int sk, int bits, const vector_type& points);
void reset(unsigned oN, unsigned oD, T a, T b, bool pin = true, bool rel_err = false, int sk = 0, int bits = 0);
void reset(unsigned oN, unsigned oD, T a, T b, bool pin, bool rel_err, int sk, int bits, const vector_type& points);
void set_brake(int b)
{
BOOST_ASSERT(b < 100);
BOOST_ASSERT(b >= 0);
m_brake = b;
}
T iterate();
polynomial<T> denominator()const;
polynomial<T> numerator()const;
vector_type const& chebyshev_points()const
{
return control_points;
}
vector_type const& zero_points()const
{
return zeros;
}
T error_term()const
{
return solution[solution.size() - 1];
}
T max_error()const
{
return m_max_error;
}
T max_change()const
{
return m_max_change;
}
void rotate()
{
--orderN;
++orderD;
}
void rescale(T a, T b)
{
T scale = (b - a) / (max - min);
for(unsigned i = 0; i < control_points.size(); ++i)
{
control_points[i] = (control_points[i] - min) * scale + a;
}
min = a;
max = b;
}
private:
void init_chebyshev();
function_type func; // The function to approximate.
vector_type control_points; // Current control points to be used for the next iteration.
vector_type solution; // Solution from the last iteration contains all unknowns including the error term.
vector_type zeros; // Location of points of zero error from last iteration, plus the two end points.
vector_type maxima; // Location of maxima of the error function, actually contains the control points used for the last iteration.
T m_max_error; // Maximum error found in last approximation.
T m_max_change; // Maximum change in location of control points after last iteration.
unsigned orderN; // Order of the numerator polynomial.
unsigned orderD; // Order of the denominator polynomial.
T min, max; // End points of the range to optimise over.
bool rel_error; // If true optimise for relative not absolute error.
bool pinned; // If true the approximation is "pinned" to go through the origin.
unsigned unknowns; // Total number of unknowns.
int m_precision; // Number of bits precision to which the zeros and maxima are found.
T m_max_change_history[2]; // Past history of changes to control points.
int m_brake; // amount to break by in percentage points.
int m_skew; // amount to skew starting points by in percentage points: -100-100
};
#ifndef BRAKE
#define BRAKE 0
#endif
#ifndef SKEW
#define SKEW 0
#endif
template <class T>
void remez_minimax<T>::init_chebyshev()
{
BOOST_MATH_STD_USING
//
// Fill in the zeros:
//
unsigned terms = pinned ? orderD + orderN : orderD + orderN + 1;
for(unsigned i = 0; i < terms; ++i)
{
T cheb = cos((2 * terms - 1 - 2 * i) * constants::pi<T>() / (2 * terms));
cheb += 1;
cheb /= 2;
if(m_skew != 0)
{
T p = static_cast<T>(200 + m_skew) / 200;
cheb = pow(cheb, p);
}
cheb *= (max - min);
cheb += min;
zeros[i+1] = cheb;
}
zeros[0] = min;
zeros[unknowns] = max;
// perform a regular interpolation fit:
matrix_type A(terms, terms);
vector_type b(terms);
// fill in the y values:
for(unsigned i = 0; i < b.size(); ++i)
{
b[i] = func(zeros[i+1]);
}
// fill in powers of x evaluated at each of the control points:
unsigned offsetN = pinned ? 0 : 1;
unsigned offsetD = offsetN + orderN;
unsigned maxorder = (std::max)(orderN, orderD);
for(unsigned i = 0; i < b.size(); ++i)
{
T x0 = zeros[i+1];
T x = x0;
if(!pinned)
A(i, 0) = 1;
for(unsigned j = 0; j < maxorder; ++j)
{
if(j < orderN)
A(i, j + offsetN) = x;
if(j < orderD)
{
A(i, j + offsetD) = -x * b[i];
}
x *= x0;
}
}
//
// Now go ahead and solve the expression to get our solution:
//
vector_type l_solution = boost::math::tools::solve(A, b);
// need to add a "fake" error term:
l_solution.resize(unknowns);
l_solution[unknowns-1] = 0;
solution = l_solution;
//
// Now find all the extrema of the error function:
//
detail::remez_error_function<T> Err(func, this->numerator(), this->denominator(), rel_error);
detail::remez_max_error_function<T> Ex(Err);
m_max_error = 0;
//int max_err_location = 0;
for(unsigned i = 0; i < unknowns; ++i)
{
std::pair<T, T> r = brent_find_minima(Ex, zeros[i], zeros[i+1], m_precision);
maxima[i] = r.first;
T rel_err = fabs(r.second);
if(rel_err > m_max_error)
{
m_max_error = fabs(r.second);
//max_err_location = i;
}
}
control_points = maxima;
}
template <class T>
void remez_minimax<T>::reset(
unsigned oN,
unsigned oD,
T a,
T b,
bool pin,
bool rel_err,
int sk,
int bits)
{
control_points = vector_type(oN + oD + (pin ? 1 : 2));
solution = control_points;
zeros = vector_type(oN + oD + (pin ? 2 : 3));
maxima = control_points;
orderN = oN;
orderD = oD;
rel_error = rel_err;
pinned = pin;
m_skew = sk;
min = a;
max = b;
m_max_error = 0;
unknowns = orderN + orderD + (pinned ? 1 : 2);
// guess our initial control points:
control_points[0] = min;
control_points[unknowns - 1] = max;
T interval = (max - min) / (unknowns - 1);
T spot = min + interval;
for(unsigned i = 1; i < control_points.size(); ++i)
{
control_points[i] = spot;
spot += interval;
}
solution[unknowns - 1] = 0;
m_max_error = 0;
if(bits == 0)
{
// don't bother about more than float precision:
m_precision = (std::min)(24, (boost::math::policies::digits<T, boost::math::policies::policy<> >() / 2) - 2);
}
else
{
// can't be more accurate than half the bits of T:
m_precision = (std::min)(bits, (boost::math::policies::digits<T, boost::math::policies::policy<> >() / 2) - 2);
}
m_max_change_history[0] = m_max_change_history[1] = 1;
init_chebyshev();
// do one iteration whatever:
//iterate();
}
template <class T>
inline remez_minimax<T>::remez_minimax(
typename remez_minimax<T>::function_type f,
unsigned oN,
unsigned oD,
T a,
T b,
bool pin,
bool rel_err,
int sk,
int bits)
: func(f)
{
m_brake = 0;
reset(oN, oD, a, b, pin, rel_err, sk, bits);
}
template <class T>
void remez_minimax<T>::reset(
unsigned oN,
unsigned oD,
T a,
T b,
bool pin,
bool rel_err,
int sk,
int bits,
const vector_type& points)
{
control_points = vector_type(oN + oD + (pin ? 1 : 2));
solution = control_points;
zeros = vector_type(oN + oD + (pin ? 2 : 3));
maxima = control_points;
orderN = oN;
orderD = oD;
rel_error = rel_err;
pinned = pin;
m_skew = sk;
min = a;
max = b;
m_max_error = 0;
unknowns = orderN + orderD + (pinned ? 1 : 2);
control_points = points;
solution[unknowns - 1] = 0;
m_max_error = 0;
if(bits == 0)
{
// don't bother about more than float precision:
m_precision = (std::min)(24, (boost::math::policies::digits<T, boost::math::policies::policy<> >() / 2) - 2);
}
else
{
// can't be more accurate than half the bits of T:
m_precision = (std::min)(bits, (boost::math::policies::digits<T, boost::math::policies::policy<> >() / 2) - 2);
}
m_max_change_history[0] = m_max_change_history[1] = 1;
// do one iteration whatever:
//iterate();
}
template <class T>
inline remez_minimax<T>::remez_minimax(
typename remez_minimax<T>::function_type f,
unsigned oN,
unsigned oD,
T a,
T b,
bool pin,
bool rel_err,
int sk,
int bits,
const vector_type& points)
: func(f)
{
m_brake = 0;
reset(oN, oD, a, b, pin, rel_err, sk, bits, points);
}
template <class T>
T remez_minimax<T>::iterate()
{
BOOST_MATH_STD_USING
matrix_type A(unknowns, unknowns);
vector_type b(unknowns);
// fill in evaluation of f(x) at each of the control points:
for(unsigned i = 0; i < b.size(); ++i)
{
// take care that none of our control points are at the origin:
if(pinned && (control_points[i] == 0))
{
if(i)
control_points[i] = control_points[i-1] / 3;
else
control_points[i] = control_points[i+1] / 3;
}
b[i] = func(control_points[i]);
}
T err_err;
unsigned convergence_count = 0;
do{
// fill in powers of x evaluated at each of the control points:
int sign = 1;
unsigned offsetN = pinned ? 0 : 1;
unsigned offsetD = offsetN + orderN;
unsigned maxorder = (std::max)(orderN, orderD);
T Elast = solution[unknowns - 1];
for(unsigned i = 0; i < b.size(); ++i)
{
T x0 = control_points[i];
T x = x0;
if(!pinned)
A(i, 0) = 1;
for(unsigned j = 0; j < maxorder; ++j)
{
if(j < orderN)
A(i, j + offsetN) = x;
if(j < orderD)
{
T mult = rel_error ? T(b[i] - sign * fabs(b[i]) * Elast): T(b[i] - sign * Elast);
A(i, j + offsetD) = -x * mult;
}
x *= x0;
}
// The last variable to be solved for is the error term,
// sign changes with each control point:
T E = rel_error ? T(sign * fabs(b[i])) : T(sign);
A(i, unknowns - 1) = E;
sign = -sign;
}
#ifdef BOOST_MATH_INSTRUMENT
for(unsigned i = 0; i < b.size(); ++i)
std::cout << b[i] << " ";
std::cout << "\n\n";
for(unsigned i = 0; i < b.size(); ++i)
{
for(unsigned j = 0; j < b.size(); ++ j)
std::cout << A(i, j) << " ";
std::cout << "\n";
}
std::cout << std::endl;
#endif
//
// Now go ahead and solve the expression to get our solution:
//
solution = boost::math::tools::solve(A, b);
err_err = (Elast != 0) ? T(fabs((fabs(solution[unknowns-1]) - fabs(Elast)) / fabs(Elast))) : T(1);
}while(orderD && (convergence_count++ < 80) && (err_err > 0.001));
//
// Perform a sanity check to verify that the solution to the equations
// is not so much in error as to be useless. The matrix inversion can
// be very close to singular, so this can be a real problem.
//
vector_type sanity = prod(A, solution);
for(unsigned i = 0; i < b.size(); ++i)
{
T err = fabs((b[i] - sanity[i]) / fabs(b[i]));
if(err > sqrt(epsilon<T>()))
{
std::cerr << "Sanity check failed: more than half the digits in the found solution are in error." << std::endl;
}
}
//
// Next comes another sanity check, we want to verify that all the control
// points do actually alternate in sign, in practice we may have
// additional roots in the error function that cause this to fail.
// Failure here is always fatal: even though this code attempts to correct
// the problem it usually only postpones the inevitable.
//
polynomial<T> num, denom;
num = this->numerator();
denom = this->denominator();
T e1 = b[0] - num.evaluate(control_points[0]) / denom.evaluate(control_points[0]);
#ifdef BOOST_MATH_INSTRUMENT
std::cout << e1;
#endif
for(unsigned i = 1; i < b.size(); ++i)
{
T e2 = b[i] - num.evaluate(control_points[i]) / denom.evaluate(control_points[i]);
#ifdef BOOST_MATH_INSTRUMENT
std::cout << " " << e2;
#endif
if(e2 * e1 > 0)
{
std::cerr << std::flush << "Basic sanity check failed: Error term does not alternate in sign, non-recoverable error may follow..." << std::endl;
T perturbation = 0.05;
do{
T point = control_points[i] * (1 - perturbation) + control_points[i-1] * perturbation;
e2 = func(point) - num.evaluate(point) / denom.evaluate(point);
if(e2 * e1 < 0)
{
control_points[i] = point;
break;
}
perturbation += 0.05;
}while(perturbation < 0.8);
if((e2 * e1 > 0) && (i + 1 < b.size()))
{
perturbation = 0.05;
do{
T point = control_points[i] * (1 - perturbation) + control_points[i+1] * perturbation;
e2 = func(point) - num.evaluate(point) / denom.evaluate(point);
if(e2 * e1 < 0)
{
control_points[i] = point;
break;
}
perturbation += 0.05;
}while(perturbation < 0.8);
}
}
e1 = e2;
}
#ifdef BOOST_MATH_INSTRUMENT
for(unsigned i = 0; i < solution.size(); ++i)
std::cout << solution[i] << " ";
std::cout << std::endl << this->numerator() << std::endl;
std::cout << this->denominator() << std::endl;
std::cout << std::endl;
#endif
//
// The next step is to find all the intervals in which our maxima
// lie:
//
detail::remez_error_function<T> Err(func, this->numerator(), this->denominator(), rel_error);
zeros[0] = min;
zeros[unknowns] = max;
for(unsigned i = 1; i < control_points.size(); ++i)
{
eps_tolerance<T> tol(m_precision);
boost::uintmax_t max_iter = 1000;
std::pair<T, T> p = toms748_solve(
Err,
control_points[i-1],
control_points[i],
tol,
max_iter);
zeros[i] = (p.first + p.second) / 2;
//zeros[i] = bisect(Err, control_points[i-1], control_points[i], m_precision);
}
//
// Now find all the extrema of the error function:
//
detail::remez_max_error_function<T> Ex(Err);
m_max_error = 0;
//int max_err_location = 0;
for(unsigned i = 0; i < unknowns; ++i)
{
std::pair<T, T> r = brent_find_minima(Ex, zeros[i], zeros[i+1], m_precision);
maxima[i] = r.first;
T rel_err = fabs(r.second);
if(rel_err > m_max_error)
{
m_max_error = fabs(r.second);
//max_err_location = i;
}
}
//
// Almost done now! we just need to set our control points
// to the extrema, and calculate how much each point has changed
// (this will be our termination condition):
//
swap(control_points, maxima);
m_max_change = 0;
//int max_change_location = 0;
for(unsigned i = 0; i < unknowns; ++i)
{
control_points[i] = (control_points[i] * (100 - m_brake) + maxima[i] * m_brake) / 100;
T change = fabs((control_points[i] - maxima[i]) / control_points[i]);
#if 0
if(change > m_max_change_history[1])
{
// divergence!!! try capping the change:
std::cerr << "Possible divergent step, change will be capped!!" << std::endl;
change = m_max_change_history[1];
if(control_points[i] < maxima[i])
control_points[i] = maxima[i] - change * maxima[i];
else
control_points[i] = maxima[i] + change * maxima[i];
}
#endif
if(change > m_max_change)
{
m_max_change = change;
//max_change_location = i;
}
}
//
// store max change information:
//
m_max_change_history[0] = m_max_change_history[1];
m_max_change_history[1] = fabs(m_max_change);
return m_max_change;
}
template <class T>
polynomial<T> remez_minimax<T>::numerator()const
{
boost::scoped_array<T> a(new T[orderN + 1]);
if(pinned)
a[0] = 0;
unsigned terms = pinned ? orderN : orderN + 1;
for(unsigned i = 0; i < terms; ++i)
a[pinned ? i+1 : i] = solution[i];
return boost::math::tools::polynomial<T>(&a[0], orderN);
}
template <class T>
polynomial<T> remez_minimax<T>::denominator()const
{
unsigned terms = orderD + 1;
unsigned offsetD = pinned ? orderN : (orderN + 1);
boost::scoped_array<T> a(new T[terms]);
a[0] = 1;
for(unsigned i = 0; i < orderD; ++i)
a[i+1] = solution[i + offsetD];
return boost::math::tools::polynomial<T>(&a[0], orderD);
}
}}} // namespaces
#endif // BOOST_MATH_TOOLS_REMEZ_HPP
| 9,091 |
3,787 | {
"module_path": "fate_flow/components",
"param_class" : "fate_flow/components/param/download_param.py/DownloadParam",
"role":
{
"local":
{
"program": "download.py/Download"
}
}
}
| 121 |
643 | # Copyright 2019 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.
"""Contains common helpers for working with Android manifests."""
import os
import shlex
import xml.dom.minidom as minidom
from util import build_utils
from xml.etree import ElementTree
ANDROID_NAMESPACE = 'http://schemas.android.com/apk/res/android'
TOOLS_NAMESPACE = 'http://schemas.android.com/tools'
DIST_NAMESPACE = 'http://schemas.android.com/apk/distribution'
EMPTY_ANDROID_MANIFEST_PATH = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', 'AndroidManifest.xml'))
_xml_namespace_initialized = False
def _RegisterElementTreeNamespaces():
global _xml_namespace_initialized
if _xml_namespace_initialized:
return
_xml_namespace_initialized = True
ElementTree.register_namespace('android', ANDROID_NAMESPACE)
ElementTree.register_namespace('tools', TOOLS_NAMESPACE)
ElementTree.register_namespace('dist', DIST_NAMESPACE)
def ParseManifest(path):
"""Parses an AndroidManifest.xml using ElementTree.
Registers required namespaces, creates application node if missing, adds any
missing namespaces for 'android', 'tools' and 'dist'.
Returns tuple of:
doc: Root xml document.
manifest_node: the <manifest> node.
app_node: the <application> node.
"""
_RegisterElementTreeNamespaces()
doc = ElementTree.parse(path)
# ElementTree.find does not work if the required tag is the root.
if doc.getroot().tag == 'manifest':
manifest_node = doc.getroot()
else:
manifest_node = doc.find('manifest')
app_node = doc.find('application')
if app_node is None:
app_node = ElementTree.SubElement(manifest_node, 'application')
return doc, manifest_node, app_node
def SaveManifest(doc, path):
with build_utils.AtomicOutput(path) as f:
f.write(ElementTree.tostring(doc.getroot(), encoding='UTF-8'))
def GetPackage(manifest_node):
return manifest_node.get('package')
def AssertUsesSdk(manifest_node,
min_sdk_version=None,
target_sdk_version=None,
max_sdk_version=None,
fail_if_not_exist=False):
"""Asserts values of attributes of <uses-sdk> element.
Unless |fail_if_not_exist| is true, will only assert if both the passed value
is not None and the value of attribute exist. If |fail_if_not_exist| is true
will fail if passed value is not None but attribute does not exist.
"""
uses_sdk_node = manifest_node.find('./uses-sdk')
if uses_sdk_node is None:
return
for prefix, sdk_version in (('min', min_sdk_version), ('target',
target_sdk_version),
('max', max_sdk_version)):
value = uses_sdk_node.get('{%s}%sSdkVersion' % (ANDROID_NAMESPACE, prefix))
if fail_if_not_exist and not value and sdk_version:
assert False, (
'%sSdkVersion in Android manifest does not exist but we expect %s' %
(prefix, sdk_version))
if not value or not sdk_version:
continue
assert value == sdk_version, (
'%sSdkVersion in Android manifest is %s but we expect %s' %
(prefix, value, sdk_version))
def AssertPackage(manifest_node, package):
"""Asserts that manifest package has desired value.
Will only assert if both |package| is not None and the package is set in the
manifest.
"""
package_value = GetPackage(manifest_node)
if package_value is None or package is None:
return
assert package_value == package, (
'Package in Android manifest is %s but we expect %s' % (package_value,
package))
def _SortAndStripElementTree(tree, reverse_toplevel=False):
for node in tree:
if node.text and node.text.isspace():
node.text = None
_SortAndStripElementTree(node)
tree[:] = sorted(tree, key=ElementTree.tostring, reverse=reverse_toplevel)
def NormalizeManifest(path):
with open(path) as f:
# This also strips comments and sorts node attributes alphabetically.
root = ElementTree.fromstring(f.read())
package = GetPackage(root)
# Trichrome's static library version number is updated daily. To avoid
# frequent manifest check failures, we remove the exact version number
# during normalization.
app_node = root.find('application')
if app_node is not None:
for node in app_node.getchildren():
if (node.tag in ['uses-static-library', 'static-library']
and '{%s}version' % ANDROID_NAMESPACE in node.keys()
and '{%s}name' % ANDROID_NAMESPACE in node.keys()):
node.set('{%s}version' % ANDROID_NAMESPACE, '$VERSION_NUMBER')
# We also remove the exact package name (except the one at the root level)
# to avoid noise during manifest comparison.
def blur_package_name(node):
for key in node.keys():
node.set(key, node.get(key).replace(package, '$PACKAGE'))
for child in node.getchildren():
blur_package_name(child)
# We only blur the package names of non-root nodes because they generate a lot
# of diffs when doing manifest checks for upstream targets. We still want to
# have 1 piece of package name not blurred just in case the package name is
# mistakenly changed.
for child in root.getchildren():
blur_package_name(child)
# Sort nodes alphabetically, recursively.
_SortAndStripElementTree(root, reverse_toplevel=True)
# Fix up whitespace/indentation.
dom = minidom.parseString(ElementTree.tostring(root))
lines = []
for l in dom.toprettyxml(indent=' ').splitlines():
if l.strip():
if len(l) > 100:
indent = ' ' * l.find('<')
attributes = shlex.split(l, posix=False)
lines.append('{}{}'.format(indent, attributes[0]))
for attribute in attributes[1:]:
lines.append('{} {}'.format(indent, attribute))
else:
lines.append(l)
return '\n'.join(lines) + '\n'
| 2,233 |
348 | {"nom":"Boustroff","circ":"4ème circonscription","dpt":"Moselle","inscrits":111,"abs":52,"votants":59,"blancs":6,"nuls":3,"exp":50,"res":[{"nuance":"REM","nom":"<NAME>","voix":30},{"nuance":"LR","nom":"<NAME>","voix":20}]} | 91 |
1,474 | <gh_stars>1000+
from .logger import CompleteLogger
from .meter import *
from .data import ForeverDataIterator
__all__ = ['metric', 'analysis', 'meter', 'data', 'logger'] | 53 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-f4cp-fvmv-q37j",
"modified": "2022-05-04T00:29:07Z",
"published": "2022-05-04T00:29:07Z",
"aliases": [
"CVE-2012-0266"
],
"details": "Multiple stack-based buffer overflows in the NTR ActiveX control before 2.0.4.8 allow remote attackers to execute arbitrary code via (1) a long bstrUrl parameter to the StartModule method, (2) a long bstrParams parameter to the Check method, a long bstrUrl parameter to the (3) Download or (4) DownloadModule method during construction of a .ntr pathname, or a long bstrUrl parameter to the (5) Download or (6) DownloadModule method during construction of a URL.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2012-0266"
},
{
"type": "WEB",
"url": "https://exchange.xforce.ibmcloud.com/vulnerabilities/72291"
},
{
"type": "WEB",
"url": "https://exchange.xforce.ibmcloud.com/vulnerabilities/72292"
},
{
"type": "WEB",
"url": "https://exchange.xforce.ibmcloud.com/vulnerabilities/72293"
},
{
"type": "WEB",
"url": "http://archives.neohapsis.com/archives/bugtraq/2012-01/0074.html"
},
{
"type": "WEB",
"url": "http://osvdb.org/78252"
},
{
"type": "WEB",
"url": "http://secunia.com/advisories/45166"
},
{
"type": "WEB",
"url": "http://secunia.com/secunia_research/2012-1/"
},
{
"type": "WEB",
"url": "http://www.exploit-db.com/exploits/21841"
}
],
"database_specific": {
"cwe_ids": [
"CWE-119"
],
"severity": "HIGH",
"github_reviewed": false
}
} | 784 |
381 | #include "fragile.h"
fragile::H::HH* fragile::H::HH::copy() {
return (HH*)0;
}
fragile::I fragile::gI;
void fragile::fglobal(int, double, char) {
/* empty; only used for doc-string testing */
}
namespace fragile {
class Kderived : public K {
public:
virtual ~Kderived();
};
} // namespace fragile
fragile::Kderived::~Kderived() {}
fragile::K::~K() {}
fragile::K* fragile::K::GimeK(bool derived) {
if (!derived) return this;
else {
static Kderived kd;
return &kd;
}
};
fragile::K* fragile::K::GimeL() {
static L l;
return &l;
}
fragile::L::~L() {}
| 276 |
3,353 | //
// ========================================================================
// Copyright (c) 1995-2021 Mort Bay Consulting Pty Ltd and others.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
// which is available at https://www.apache.org/licenses/LICENSE-2.0.
//
// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
// ========================================================================
//
package org.eclipse.jetty.maven.plugin;
import java.io.File;
import java.io.IOException;
import org.eclipse.jetty.util.resource.Resource;
/**
* Overlay
*
* An Overlay represents overlay information derived from the
* maven-war-plugin.
*/
public class Overlay
{
private OverlayConfig _config;
private Resource _resource;
public Overlay(OverlayConfig config, Resource resource)
{
_config = config;
_resource = resource;
}
public Overlay(OverlayConfig config)
{
_config = config;
}
public void setResource(Resource r)
{
_resource = r;
}
public Resource getResource()
{
return _resource;
}
public OverlayConfig getConfig()
{
return _config;
}
@Override
public String toString()
{
StringBuilder strbuff = new StringBuilder();
if (_resource != null)
strbuff.append(_resource);
if (_config != null)
{
strbuff.append(" [");
strbuff.append(_config);
strbuff.append("]");
}
return strbuff.toString();
}
/**
* Unpack the overlay into the given directory. Only
* unpack if the directory does not exist, or the overlay
* has been modified since the dir was created.
*
* @param dir the directory into which to unpack the overlay
* @throws IOException
*/
public void unpackTo(File dir) throws IOException
{
if (dir == null)
throw new IllegalStateException("No overly unpack directory");
//only unpack if the overlay is newer
if (!dir.exists() || (getResource().lastModified() > dir.lastModified()))
getResource().copyTo(dir);
}
}
| 856 |
1,838 | # -*- coding: utf-8 -*-
from babelfish import LanguageReverseConverter
from ..exceptions import ConfigurationError
class LegendasTVConverter(LanguageReverseConverter):
def __init__(self):
self.from_legendastv = {1: ('por', 'BR'), 2: ('eng',), 3: ('spa',), 4: ('fra',), 5: ('deu',), 6: ('jpn',),
7: ('dan',), 8: ('nor',), 9: ('swe',), 10: ('por',), 11: ('ara',), 12: ('ces',),
13: ('zho',), 14: ('kor',), 15: ('bul',), 16: ('ita',), 17: ('pol',)}
self.to_legendastv = {v: k for k, v in self.from_legendastv.items()}
self.codes = set(self.from_legendastv.keys())
def convert(self, alpha3, country=None, script=None):
if (alpha3, country) in self.to_legendastv:
return self.to_legendastv[(alpha3, country)]
if (alpha3,) in self.to_legendastv:
return self.to_legendastv[(alpha3,)]
raise ConfigurationError('Unsupported language code for legendastv: %s, %s, %s' % (alpha3, country, script))
def reverse(self, legendastv):
if legendastv in self.from_legendastv:
return self.from_legendastv[legendastv]
raise ConfigurationError('Unsupported language number for legendastv: %s' % legendastv)
| 573 |
473 | <filename>challenges/Grit/src/cgc_gain.h<gh_stars>100-1000
/*
* Copyright (c) 2015 Kaprica Security, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#pragma once
class Gain
{
public:
inline Gain() : value(0)
{
}
static inline Gain fromDouble(double d)
{
// only positive values are valid
if (d < 0)
return Gain(0);
if (d <= 0.01)
return Gain(INT32_MIN);
if (d >= 10.0)
return Gain(INT32_MAX);
if (d >= 1)
return Gain((d-1) / 10 * INT32_MAX);
else
return Gain(((1/d) - 1) / 10 * -INT32_MAX);
}
static inline Gain fromRational(int16_t numerator, int16_t denominator)
{
double tmp = (double)numerator / (double)denominator;
tmp /= 10;
tmp *= INT32_MAX;
return Gain((int)tmp);
}
static inline Gain fromPanLeft(int32_t pan)
{
if (pan <= 0)
return Gain(0);
else
return Gain(-pan);
}
static inline Gain fromPanRight(int32_t pan)
{
if (pan >= 0)
return Gain(0);
else
return Gain(pan);
}
inline Gain operator*(const Gain &b) const
{
return fromDouble(toDouble() * b.toDouble());
}
inline Gain operator+(const Gain &b) const
{
long long tmp = value;
tmp += b.value;
if (tmp > INT32_MAX)
tmp = INT32_MAX;
if (tmp < INT32_MIN)
tmp = INT32_MIN;
return tmp;
}
inline int32_t adjustSample(int32_t sample) const
{
double tmp = sample * toDouble();
if (tmp >= INT32_MAX)
return INT32_MAX;
if (tmp <= INT32_MIN)
return INT32_MIN;
return tmp;
}
inline double toDouble() const
{
double tmp = value;
tmp *= 10.0 / INT32_MAX;
if (tmp >= 0)
return (tmp + 1);
else
return 1 / (-tmp + 1);
}
private:
inline Gain(int32_t value_) : value(value_)
{
}
int32_t value;
};
| 1,314 |
550 | #ifndef __LIBOPT_OPT_H__
#define __LIBOPT_OPT_H__
#include <stdbool.h>
#include <stdint.h>
/* The design of this package is greatly inspired by Go's standard library
* package 'flag'. It doesn't support complex argument parsing, but it's simple
* to use. */
struct opt_config {
/* Array of all flags specified by the user. */
struct opt_flag **flags;
/* The total number of flags specified. */
int32_t length;
/* Whether this flag configuration has been parsed or not. */
bool parsed;
/* Whether the '--help' flag was used. */
bool help;
/* A 'usage' function that is called whenever opt_config_print_usage
* is called. It can be replaced with your own usage function. */
void (*usage)(struct opt_config *conf);
};
/* A value with type 'struct opt_args *' is returned from 'opt_config_parse'
* will all arguments that are not flags.
*
* N.B. All flags precede the first argument. As soon as the first non-flag
* argument is found, all subsequent arguments are automatically non-flags. */
struct opt_args {
/* Number of arguments proceeding flags. */
int nargs;
/* Array of all arguments. This is a simple pointer offset from the
* original 'argv' passed into the program. */
char **args;
};
/* Initialize a command line argument parsing configuration. The value
* returned can be used to specify the different kinds of flags expected. */
struct opt_config *
opt_config_init();
void
opt_config_free(struct opt_config *conf);
void
opt_args_free(struct opt_args *args);
/* Call this after all flags have been specified. It will parse the arguments
* passed in through 'main' ('argc' and 'argv'), and return all non-flag
* arguments.
*
* N.B. All flags precede the first argument. As soon as the first non-flag
* argument is found, all subsequent arguments are automatically non-flags. */
struct opt_args *
opt_config_parse(struct opt_config *conf, int argc, char **argv);
/* Prints the usage information by calling 'conf->usage()', which is by
* default set to 'opt_config_print_defaults'. */
void
opt_config_print_usage(struct opt_config *conf);
/* Prints a kind-of-nicely formatted list of all flags, their default values
* and the usage information for each flag. */
void
opt_config_print_defaults(struct opt_config *conf);
/* All possible argument types. */
enum opt_flag_types {
OPT_BOOL,
OPT_INT,
OPT_DOUBLE,
OPT_STRING
};
/* An opaque type representing a flag specified by the user. */
struct opt_flag {
/* Whether this flag has been parsed or not. After parsing is complete,
* all flags that have this value set to 'false' will automatically
* have 'storage' loaded with 'defval'. */
bool parsed;
/* The type of this flag. */
enum opt_flag_types type;
/* The name of this flag, not including the '--' prefix. */
char *name;
/* Usage information for this flag. */
char *usage;
/* A pointer to where the value passed in by the user (or the default
* value of the flag isn't specified) will be stored. */
union {
bool *b;
int32_t *i;
double *d;
char **s;
} storage;
/* The default value of the flag. For boolean flags, this is always
* 'false'. */
union {
bool b;
int32_t i;
double d;
char *s;
} defval;
};
/* Add a new bool flag. All bool flags have a default value of 'false'. */
void
opt_flag_bool(struct opt_config *conf,
bool *storage, char *name, char *usage);
/* Add a new int flag. */
void
opt_flag_int(struct opt_config *conf,
int32_t *storage, char *name, int32_t defval, char *usage);
/* Add a new double flag. */
void
opt_flag_double(struct opt_config *conf,
double *storage, char *name, double defval, char *usage);
/* Add a new string flag. */
void
opt_flag_string(struct opt_config *conf,
char **storage, char *name, char *defval, char *usage);
#endif
| 1,337 |
1,350 | <reponame>Manny27nyc/azure-sdk-for-java<gh_stars>1000+
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.analytics.synapse.accesscontrol;
import com.azure.analytics.synapse.accesscontrol.implementation.RoleAssignmentsImpl;
import com.azure.analytics.synapse.accesscontrol.models.CheckPrincipalAccessResponse;
import com.azure.analytics.synapse.accesscontrol.models.ErrorContractException;
import com.azure.analytics.synapse.accesscontrol.models.RequiredAction;
import com.azure.analytics.synapse.accesscontrol.models.RoleAssignmentDetails;
import com.azure.analytics.synapse.accesscontrol.models.RoleAssignmentDetailsList;
import com.azure.analytics.synapse.accesscontrol.models.RoleAssignmentsListRoleAssignmentsResponse;
import com.azure.analytics.synapse.accesscontrol.models.SubjectInfo;
import com.azure.core.annotation.ReturnType;
import com.azure.core.annotation.ServiceClient;
import com.azure.core.annotation.ServiceMethod;
import com.azure.core.http.rest.Response;
import com.azure.core.util.Context;
import java.util.List;
import java.util.UUID;
/** Initializes a new instance of the synchronous AccessControlClient type. */
@ServiceClient(builder = AccessControlClientBuilder.class)
public final class RoleAssignmentsClient {
private final RoleAssignmentsImpl serviceClient;
/**
* Initializes an instance of RoleAssignments client.
*
* @param serviceClient the service client implementation.
*/
RoleAssignmentsClient(RoleAssignmentsImpl serviceClient) {
this.serviceClient = serviceClient;
}
/**
* Check if the given principalId has access to perform list of actions at a given scope.
*
* @param subject Subject details.
* @param actions List of actions.
* @param scope Scope at which the check access is done.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return check access response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public CheckPrincipalAccessResponse checkPrincipalAccess(
SubjectInfo subject, List<RequiredAction> actions, String scope) {
return this.serviceClient.checkPrincipalAccess(subject, actions, scope);
}
/**
* Check if the given principalId has access to perform list of actions at a given scope.
*
* @param subject Subject details.
* @param actions List of actions.
* @param scope Scope at which the check access is done.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return check access response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response<CheckPrincipalAccessResponse> checkPrincipalAccessWithResponse(
SubjectInfo subject, List<RequiredAction> actions, String scope, Context context) {
return this.serviceClient.checkPrincipalAccessWithResponse(subject, actions, scope, context);
}
/**
* List role assignments.
*
* @param roleId Synapse Built-In Role Id.
* @param principalId Object ID of the AAD principal or security-group.
* @param scope Scope of the Synapse Built-in Role.
* @param continuationToken Continuation token.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentDetailsList listRoleAssignments(
String roleId, String principalId, String scope, String continuationToken) {
return this.serviceClient.listRoleAssignments(roleId, principalId, scope, continuationToken);
}
/**
* List role assignments.
*
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentDetailsList listRoleAssignments() {
return this.serviceClient.listRoleAssignments();
}
/**
* List role assignments.
*
* @param roleId Synapse Built-In Role Id.
* @param principalId Object ID of the AAD principal or security-group.
* @param scope Scope of the Synapse Built-in Role.
* @param continuationToken Continuation token.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentsListRoleAssignmentsResponse listRoleAssignmentsWithResponse(
String roleId, String principalId, String scope, String continuationToken, Context context) {
return this.serviceClient.listRoleAssignmentsWithResponse(
roleId, principalId, scope, continuationToken, context);
}
/**
* Create role assignment.
*
* @param roleAssignmentId The ID of the role assignment.
* @param roleId Role ID of the Synapse Built-In Role.
* @param principalId Object ID of the AAD principal or security-group.
* @param scope Scope at which the role assignment is created.
* @param principalType Type of the principal Id: User, Group or ServicePrincipal.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentDetails createRoleAssignment(
String roleAssignmentId, UUID roleId, UUID principalId, String scope, String principalType) {
return this.serviceClient.createRoleAssignment(roleAssignmentId, roleId, principalId, scope, principalType);
}
/**
* Create role assignment.
*
* @param roleAssignmentId The ID of the role assignment.
* @param roleId Role ID of the Synapse Built-In Role.
* @param principalId Object ID of the AAD principal or security-group.
* @param scope Scope at which the role assignment is created.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentDetails createRoleAssignment(
String roleAssignmentId, UUID roleId, UUID principalId, String scope) {
return this.serviceClient.createRoleAssignment(roleAssignmentId, roleId, principalId, scope);
}
/**
* Create role assignment.
*
* @param roleAssignmentId The ID of the role assignment.
* @param roleId Role ID of the Synapse Built-In Role.
* @param principalId Object ID of the AAD principal or security-group.
* @param scope Scope at which the role assignment is created.
* @param principalType Type of the principal Id: User, Group or ServicePrincipal.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role Assignment response details.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response<RoleAssignmentDetails> createRoleAssignmentWithResponse(
String roleAssignmentId,
UUID roleId,
UUID principalId,
String scope,
String principalType,
Context context) {
return this.serviceClient.createRoleAssignmentWithResponse(
roleAssignmentId, roleId, principalId, scope, principalType, context);
}
/**
* Get role assignment by role assignment Id.
*
* @param roleAssignmentId The ID of the role assignment.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role assignment by role assignment Id.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public RoleAssignmentDetails getRoleAssignmentById(String roleAssignmentId) {
return this.serviceClient.getRoleAssignmentById(roleAssignmentId);
}
/**
* Get role assignment by role assignment Id.
*
* @param roleAssignmentId The ID of the role assignment.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return role assignment by role assignment Id.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response<RoleAssignmentDetails> getRoleAssignmentByIdWithResponse(String roleAssignmentId, Context context) {
return this.serviceClient.getRoleAssignmentByIdWithResponse(roleAssignmentId, context);
}
/**
* Delete role assignment by role assignment Id.
*
* @param roleAssignmentId The ID of the role assignment.
* @param scope Scope of the Synapse Built-in Role.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void deleteRoleAssignmentById(String roleAssignmentId, String scope) {
this.serviceClient.deleteRoleAssignmentById(roleAssignmentId, scope);
}
/**
* Delete role assignment by role assignment Id.
*
* @param roleAssignmentId The ID of the role assignment.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public void deleteRoleAssignmentById(String roleAssignmentId) {
this.serviceClient.deleteRoleAssignmentById(roleAssignmentId);
}
/**
* Delete role assignment by role assignment Id.
*
* @param roleAssignmentId The ID of the role assignment.
* @param scope Scope of the Synapse Built-in Role.
* @param context The context to associate with this operation.
* @throws IllegalArgumentException thrown if parameters fail the validation.
* @throws ErrorContractException thrown if the request is rejected by server.
* @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent.
* @return the response.
*/
@ServiceMethod(returns = ReturnType.SINGLE)
public Response<Void> deleteRoleAssignmentByIdWithResponse(String roleAssignmentId, String scope, Context context) {
return this.serviceClient.deleteRoleAssignmentByIdWithResponse(roleAssignmentId, scope, context);
}
}
| 3,871 |
791 | //--------------------------------------------------------------------------------------------------
/**
@file q3ContactManager.h
@author <NAME>
@date 10/10/2014
Copyright (c) 2014 <NAME> http://www.randygaul.net
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not
be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
//--------------------------------------------------------------------------------------------------
#ifndef Q3CONTACTMANAGER_H
#define Q3CONTACTMANAGER_H
#include "../common/q3Types.h"
#include "../broadphase/q3BroadPhase.h"
#include "../common/q3Memory.h"
//--------------------------------------------------------------------------------------------------
// q3ContactManager
//--------------------------------------------------------------------------------------------------
struct q3ContactConstraint;
class q3ContactListener;
struct q3Box;
class q3Body;
class q3Render;
class q3Stack;
class q3ContactManager
{
public:
q3ContactManager( q3Stack* stack );
// Add a new contact constraint for a pair of objects
// unless the contact constraint already exists
void AddContact( q3Box *A, q3Box *B );
// Has broadphase find all contacts and call AddContact on the
// ContactManager for each pair found
void FindNewContacts( void );
// Remove a specific contact
void RemoveContact( q3ContactConstraint *contact );
// Remove all contacts from a body
void RemoveContactsFromBody( q3Body *body );
void RemoveFromBroadphase( q3Body *body );
// Remove contacts without broadphase overlap
// Solves contact manifolds
void TestCollisions( void );
static void SolveCollision( void* param );
void RenderContacts( q3Render* debugDrawer ) const;
private:
q3ContactConstraint* m_contactList;
i32 m_contactCount;
q3Stack* m_stack;
q3PagedAllocator m_allocator;
q3BroadPhase m_broadphase;
q3ContactListener *m_contactListener;
friend class q3BroadPhase;
friend class q3Scene;
friend struct q3Box;
friend class q3Body;
};
#endif // Q3CONTACTMANAGER_H
| 731 |
444 | #define SPRAY_BUF_SIZE 247
char spray_buffer[248];
void spray_buffer_init(){
*(unsigned long*)(spray_buffer + 40)=0xfacea6d8;
*(unsigned long*)(spray_buffer + 56)=0x100000000000000;
}
#include <stdio.h>
volatile int do_spray=1;
void kmalloc_no_free(int times)
{
int i;
int ret;
char buf[256];
for(i = 0; i < times; i++){
//sprintf(buf,"wtf%d",i);
//memset(exploitbuf2,0x43+i,255);
ret=syscall(__NR_add_key, "user", buf, spray_buffer, SPRAY_BUF_SIZE-0x18, -2);
/*sizeof(struct user_key_payload)=18*/
printf("%x\n", ret);
}
}
void kmalloc(int times)
{
int i;
int ret;
//for(i=0;i<1024;i++)
for(i=0;i<times;i++){
if(do_spray){
//syscall(__NR_add_key, "user", "wtf", exploitbuf, SPRAY_BUF_SIZE, -2);
ret=syscall(__NR_add_key, "root", "wtf", spray_buffer, SPRAY_BUF_SIZE, -2);
}
}
} | 470 |
344 | from stream_django.client import stream_client
def stream(request):
context = {}
context['STREAM_API_KEY'] = stream_client.api_key
context['STREAM_APP_ID'] = stream_client.app_id
return context
| 74 |
11,356 | /*
* Copyright 1993-2002 <NAME> and Perforce Software, Inc.
*
* This file is part of Jam - see jam.c for Copyright information.
*/
/*
* pathsys.h - PATHNAME struct
*/
/*
* PATHNAME - a name of a file, broken into <grist>dir/base/suffix(member)
*
* <grist> - salt to distinguish between targets that would otherwise have the
* same name - it never appears in the bound name of a target.
*
* (member) - archive member name: the syntax is arbitrary, but must agree in
* path_parse(), path_build() and the Jambase.
*/
#ifndef PATHSYS_VP_20020211_H
#define PATHSYS_VP_20020211_H
#include "object.h"
#include "strings.h"
typedef struct _pathpart
{
char const * ptr;
int len;
} PATHPART;
typedef struct _pathname
{
PATHPART part[ 6 ];
#define f_grist part[ 0 ]
#define f_root part[ 1 ]
#define f_dir part[ 2 ]
#define f_base part[ 3 ]
#define f_suffix part[ 4 ]
#define f_member part[ 5 ]
} PATHNAME;
void path_build( PATHNAME *, string * file );
void path_parse( char const * file, PATHNAME * );
void path_parent( PATHNAME * );
int path_translate_to_os( char const *, string * file );
/* Given a path, returns an object containing an equivalent path in canonical
* format that can be used as a unique key for that path. Equivalent paths such
* as a/b, A\B, and a\B on NT all yield the same key.
*/
OBJECT * path_as_key( OBJECT * path );
/* Called as an optimization when we know we have a path that is already in its
* canonical/long/key form. Avoids the need for some subsequent path_as_key()
* call to do a potentially expensive path conversion requiring access to the
* actual underlying file system.
*/
void path_register_key( OBJECT * canonic_path );
/* Returns a static pointer to the system dependent path to the temporary
* directory. NOTE: Does *not* include a trailing path separator.
*/
string const * path_tmpdir( void );
/* Returns a new temporary name. */
OBJECT * path_tmpnam( void );
/* Returns a new temporary path. */
OBJECT * path_tmpfile( void );
/* Give the first argument to 'main', return a full path to our executable.
* Returns null in the unlikely case it cannot be determined. Caller is
* responsible for freeing the string.
*
* Implemented in jam.c
*/
char * executable_path( char const * argv0 );
void path_done( void );
#endif
| 723 |
545 | #include <functional>
#include <iostream>
#include <map>
#include <string>
int add(int a, int b) {
return a + b;
}
struct multiple {
int operator()(int a, int b) { return a * b; }
};
auto divide = [](int a, int b) { return a / b; };
int main() {
std::map<std::string, std::function<int (int, int)>> ops = {
{ "+", add },
{ "-", std::minus<int>() },
{ "*", multiple() },
{ "/", divide },
{ "%", [](int a, int b) { return a % b; } }
};
int a, b;
std::string op;
do {
std::cout << "Enter expression: ";
std::cin >> a >> op >> b;
auto it = ops.find(op);
if (it != ops.end())
std::cout << it->second(a, b) << std::endl;
else
std::cout << "Unrecognized operator: " << op << std::endl;
} while (std::cin);
return 0;
}
| 337 |
852 | <gh_stars>100-1000
#include <cassert>
#include <iostream>
#include <limits>
#include <string>
#include <utility>
#include <cuda_runtime_api.h>
#include "catch.hpp"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "HeterogeneousCore/CUDAServices/interface/CUDAService.h"
namespace {
CUDAService makeCUDAService(edm::ParameterSet ps) {
auto desc = edm::ConfigurationDescriptions("Service", "CUDAService");
CUDAService::fillDescriptions(desc);
desc.validate(ps, "CUDAService");
return CUDAService(ps);
}
} // namespace
TEST_CASE("Tests of CUDAService", "[CUDAService]") {
// Test setup: check if a simple CUDA runtime API call fails:
// if so, skip the test with the CUDAService enabled
int deviceCount = 0;
auto ret = cudaGetDeviceCount(&deviceCount);
if (ret != cudaSuccess) {
WARN("Unable to query the CUDA capable devices from the CUDA runtime API: ("
<< ret << ") " << cudaGetErrorString(ret) << ". Running only tests not requiring devices.");
}
SECTION("CUDAService enabled") {
edm::ParameterSet ps;
ps.addUntrackedParameter("enabled", true);
SECTION("Enabled only if there are CUDA capable GPUs") {
auto cs = makeCUDAService(ps);
if (deviceCount <= 0) {
REQUIRE(cs.enabled() == false);
WARN("CUDAService is disabled as there are no CUDA GPU devices");
} else {
REQUIRE(cs.enabled() == true);
INFO("CUDAService is enabled");
}
}
if (deviceCount <= 0) {
return;
}
auto cs = makeCUDAService(ps);
SECTION("CUDA Queries") {
int driverVersion = 0, runtimeVersion = 0;
ret = cudaDriverGetVersion(&driverVersion);
if (ret != cudaSuccess) {
FAIL("Unable to query the CUDA driver version from the CUDA runtime API: (" << ret << ") "
<< cudaGetErrorString(ret));
}
ret = cudaRuntimeGetVersion(&runtimeVersion);
if (ret != cudaSuccess) {
FAIL("Unable to query the CUDA runtime API version: (" << ret << ") " << cudaGetErrorString(ret));
}
WARN("CUDA Driver Version / Runtime Version: " << driverVersion / 1000 << "." << (driverVersion % 100) / 10
<< " / " << runtimeVersion / 1000 << "."
<< (runtimeVersion % 100) / 10);
// Test that the number of devices found by the service
// is the same as detected by the CUDA runtime API
REQUIRE(cs.numberOfDevices() == deviceCount);
WARN("Detected " << cs.numberOfDevices() << " CUDA Capable device(s)");
// Test that the compute capabilities of each device
// are the same as detected by the CUDA runtime API
for (int i = 0; i < deviceCount; ++i) {
cudaDeviceProp deviceProp;
ret = cudaGetDeviceProperties(&deviceProp, i);
if (ret != cudaSuccess) {
FAIL("Unable to query the CUDA properties for device " << i << " from the CUDA runtime API: (" << ret << ") "
<< cudaGetErrorString(ret));
}
REQUIRE(deviceProp.major == cs.computeCapability(i).first);
REQUIRE(deviceProp.minor == cs.computeCapability(i).second);
INFO("Device " << i << ": " << deviceProp.name << "\n CUDA Capability Major/Minor version number: "
<< deviceProp.major << "." << deviceProp.minor);
}
}
SECTION("CUDAService device free memory") {
size_t mem = 0;
int dev = -1;
for (int i = 0; i < deviceCount; ++i) {
size_t free, tot;
cudaSetDevice(i);
cudaMemGetInfo(&free, &tot);
WARN("Device " << i << " memory total " << tot << " free " << free);
if (free > mem) {
mem = free;
dev = i;
}
}
WARN("Device with most free memory " << dev << "\n"
<< " as given by CUDAService " << cs.deviceWithMostFreeMemory());
}
}
SECTION("Force to be disabled") {
edm::ParameterSet ps;
ps.addUntrackedParameter("enabled", false);
auto cs = makeCUDAService(ps);
REQUIRE(cs.enabled() == false);
REQUIRE(cs.numberOfDevices() == 0);
}
}
| 1,914 |
382 |
/// generated by: genswift.java 'java/lang|java/util|java/sql|java/awt|javax/swing' ///
/// interface java.awt.LayoutManager ///
package org.swiftjava.java_awt;
@SuppressWarnings("JniMissingFunction")
public class LayoutManagerProxy implements java.awt.LayoutManager {
// address of proxy object
long __swiftObject;
LayoutManagerProxy( long __swiftObject ) {
this.__swiftObject = __swiftObject;
}
/// public abstract void java.awt.LayoutManager.addLayoutComponent(java.lang.String,java.awt.Component)
public native void __addLayoutComponent( long __swiftObject, java.lang.String name, java.awt.Component comp );
public void addLayoutComponent( java.lang.String name, java.awt.Component comp ) {
__addLayoutComponent( __swiftObject, name, comp );
}
/// public abstract void java.awt.LayoutManager.layoutContainer(java.awt.Container)
public native void __layoutContainer( long __swiftObject, java.awt.Container parent );
public void layoutContainer( java.awt.Container parent ) {
__layoutContainer( __swiftObject, parent );
}
/// public abstract java.awt.Dimension java.awt.LayoutManager.minimumLayoutSize(java.awt.Container)
public native java.awt.Dimension __minimumLayoutSize( long __swiftObject, java.awt.Container parent );
public java.awt.Dimension minimumLayoutSize( java.awt.Container parent ) {
return __minimumLayoutSize( __swiftObject, parent );
}
/// public abstract java.awt.Dimension java.awt.LayoutManager.preferredLayoutSize(java.awt.Container)
public native java.awt.Dimension __preferredLayoutSize( long __swiftObject, java.awt.Container parent );
public java.awt.Dimension preferredLayoutSize( java.awt.Container parent ) {
return __preferredLayoutSize( __swiftObject, parent );
}
/// public abstract void java.awt.LayoutManager.removeLayoutComponent(java.awt.Component)
public native void __removeLayoutComponent( long __swiftObject, java.awt.Component comp );
public void removeLayoutComponent( java.awt.Component comp ) {
__removeLayoutComponent( __swiftObject, comp );
}
public native void __finalize( long __swiftObject );
public void finalize() {
__finalize( __swiftObject );
}
}
| 747 |
985 | package com.github.zxh.classpy.lua54.binarychunk.part;
import com.github.zxh.classpy.lua54.binarychunk.BinaryChunkPart;
import com.github.zxh.classpy.lua54.binarychunk.BinaryChunkReader;
import com.github.zxh.classpy.lua54.binarychunk.datatype.LuByte;
import com.github.zxh.classpy.lua54.binarychunk.datatype.LuaInt;
import com.github.zxh.classpy.lua54.binarychunk.datatype.LuaNum;
import com.github.zxh.classpy.lua54.binarychunk.datatype.LuaStr;
import com.github.zxh.classpy.lua54.vm.LuaType;
/**
* Lua constant.
*/
public class Constant extends BinaryChunkPart {
@Override
protected void readContent(BinaryChunkReader reader) {
int t = readHead(reader);
readBody(reader, t);
}
private int readHead(BinaryChunkReader reader) {
LuByte t = new LuByte();
t.read(reader);
super.add("t", t);
return t.getValue();
}
private void readBody(BinaryChunkReader reader, int type) {
LuaType lt = LuaType.valueOf(type);
super.setName(lt.name());
switch (lt) {
case LUA_TNIL:
case LUA_VFALSE:
case LUA_VTRUE:
break;
case LUA_TNUMBER:
case LUA_VNUMFLT:
readNumber(reader);
break;
case LUA_VNUMINT:
readInteger(reader);
break;
case LUA_TSTRING:
case LUA_VSHRSTR:
case LUA_VLNGSTR:
readString(reader);
break;
default:
throw new RuntimeException("TODO:" + lt);
}
}
private void readNumber(BinaryChunkReader reader) {
LuaNum d = new LuaNum();
d.read(reader);
super.add("k", d);
super.setDesc(d.getDesc());
}
private void readInteger(BinaryChunkReader reader) {
LuaInt i = new LuaInt();
i.read(reader);
super.add("k", i);
super.setDesc(i.getDesc());
}
private void readString(BinaryChunkReader reader) {
LuaStr str = new LuaStr();
str.read(reader);
super.add("k", str);
super.setDesc(str.getDesc());
}
}
| 1,062 |
1,144 | /**
* Contains classes around proxying and interception. This package is here because jboss-aop is not reliable and the two CDI implementations I tried out (wedld and OWB) did you work out of the box with adempiere:
* <ul>
* <li>weld: it was able to find some service implementations <i>sometimes</i> and I didn't find out the rules of that game</li>
* <li>OWB: it scans and tries to treat basically everything a a bean (i guess that would also have been the behavior of weld, had it gotten that far) and this doesn'T work with most out our classes. E.g. your X_* classes need a running DB-connection to do anything</li>
* </ul>
* So i think for both frameworks, we either need to have an export, or go a long way of refactoring and splitting the stuff into different projects/jars, so that we can then only activate CDI for the jars that have the proper classes for it.
*
* @author ts
*
*/
package org.adempiere.util.proxy;
/*
* #%L
* de.metas.util
* %%
* Copyright (C) 2015 metas GmbH
* %%
* 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/gpl-2.0.html>.
* #L%
*/
| 467 |
630 | # Capstone Python bindings, by <NAME> <<EMAIL>>
import ctypes, copy
from .sysz_const import *
# define the API
class SyszOpMem(ctypes.Structure):
_fields_ = (
('base', ctypes.c_uint8),
('index', ctypes.c_uint8),
('length', ctypes.c_uint64),
('disp', ctypes.c_int64),
)
class SyszOpValue(ctypes.Union):
_fields_ = (
('reg', ctypes.c_uint),
('imm', ctypes.c_int64),
('mem', SyszOpMem),
)
class SyszOp(ctypes.Structure):
_fields_ = (
('type', ctypes.c_uint),
('value', SyszOpValue),
)
@property
def imm(self):
return self.value.imm
@property
def reg(self):
return self.value.reg
@property
def mem(self):
return self.value.mem
class CsSysz(ctypes.Structure):
_fields_ = (
('cc', ctypes.c_uint),
('op_count', ctypes.c_uint8),
('operands', SyszOp * 6),
)
def get_arch_info(a):
return (a.cc, copy.deepcopy(a.operands[:a.op_count]))
| 499 |
435 | {
"description": "This month, we are excited to host <NAME> who will be discussing the Jupyter eco-sytem. Carol develops software, electronics, educational tutorials, and is passionate about outreach. She is a core developer on the Jupyter Project and is a former director at the Python Software foundation. She continues to contribute her time to OpenHatch, Systers, PyLadies San Diego, and San Diego Python.",
"duration": 3582,
"language": "eng",
"recorded": "2017-03-02",
"related_urls": [
{
"label": "PyData Ann Arbor Meetup",
"url": "https://www.meetup.com/PyData-Ann-Arbor/"
}
],
"speakers": [
"<NAME>"
],
"tags": [
"jupyter"
],
"thumbnail_url": "https://i.ytimg.com/vi/00j68o9RGzM/hqdefault.jpg",
"title": "Taming Big Data with Jupyter and Friends",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=00j68o9RGzM"
}
]
}
| 346 |
2,151 | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_XR_XR_PRESENTATION_FRAME_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_XR_XR_PRESENTATION_FRAME_H_
#include "device/vr/public/mojom/vr_service.mojom-blink.h"
#include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
#include "third_party/blink/renderer/platform/bindings/trace_wrapper_member.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/transforms/transformation_matrix.h"
#include "third_party/blink/renderer/platform/wtf/forward.h"
namespace blink {
class XRCoordinateSystem;
class XRDevicePose;
class XRInputPose;
class XRInputSource;
class XRSession;
class XRView;
class XRPresentationFrame final : public ScriptWrappable {
DEFINE_WRAPPERTYPEINFO();
public:
explicit XRPresentationFrame(XRSession*);
XRSession* session() const { return session_; }
const HeapVector<Member<XRView>>& views() const;
XRDevicePose* getDevicePose(XRCoordinateSystem*) const;
XRInputPose* getInputPose(XRInputSource*, XRCoordinateSystem*) const;
void SetBasePoseMatrix(const TransformationMatrix&);
void Trace(blink::Visitor*) override;
private:
const Member<XRSession> session_;
std::unique_ptr<TransformationMatrix> base_pose_matrix_;
};
} // namespace blink
#endif // XRWebGLLayer_h
| 530 |
348 | {"nom":"Rochecolombe","circ":"3ème circonscription","dpt":"Ardèche","inscrits":184,"abs":77,"votants":107,"blancs":18,"nuls":4,"exp":85,"res":[{"nuance":"LR","nom":"<NAME>","voix":53},{"nuance":"REM","nom":"M. <NAME>","voix":32}]} | 94 |
3,834 | package org.enso.table.problems;
import java.util.List;
/** A value annotated with problems that occurred when it was being computed. */
public record WithProblems<T>(T value, List<Problem> problems) {}
| 59 |
378 | <reponame>tinyweet/smart-socket
/*******************************************************************************
* Copyright (c) 2017-2019, org.smartboot. All rights reserved.
* project name: smart-socket
* file name: UdpBootstrap.java
* Date: 2019-12-31
* Author: sandao (<EMAIL>)
*
******************************************************************************/
package org.smartboot.socket.transport;
import org.smartboot.socket.MessageProcessor;
import org.smartboot.socket.NetMonitor;
import org.smartboot.socket.Protocol;
import org.smartboot.socket.StateMachineEnum;
import org.smartboot.socket.buffer.BufferPage;
import org.smartboot.socket.buffer.BufferPagePool;
import org.smartboot.socket.buffer.VirtualBuffer;
import org.smartboot.socket.util.DecoderException;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
/**
* UDP服务启动类
*
* @author 三刀
* @version V1.0 , 2019/8/18
*/
public class UdpBootstrap {
private final static int MAX_READ_TIMES = 16;
/**
* 服务ID
*/
private static int UID;
/**
* 缓存页
*/
private final BufferPage bufferPage = new BufferPagePool(1024 * 1024, 1, true).allocateBufferPage();
/**
* 服务配置
*/
private final IoServerConfig config = new IoServerConfig();
private Worker worker;
private UdpDispatcher[] workerGroup;
private ExecutorService executorService;
private boolean running = true;
public <Request> UdpBootstrap(Protocol<Request> protocol, MessageProcessor<Request> messageProcessor) {
config.setProtocol(protocol);
config.setProcessor(messageProcessor);
}
/**
* 开启一个UDP通道，端口号随机
*
* @return UDP通道
*/
public UdpChannel open() throws IOException {
return open(0);
}
/**
* 开启一个UDP通道
*
* @param port 指定绑定端口号,为0则随机指定
*/
public UdpChannel open(int port) throws IOException {
return open(null, port);
}
/**
* 开启一个UDP通道
*
* @param host 绑定本机地址
* @param port 指定绑定端口号,为0则随机指定
*/
public UdpChannel open(String host, int port) throws IOException {
//启动线程服务
if (worker == null) {
initThreadServer();
}
DatagramChannel channel = DatagramChannel.open();
channel.configureBlocking(false);
if (port > 0) {
InetSocketAddress inetSocketAddress = host == null ? new InetSocketAddress(port) : new InetSocketAddress(host, port);
channel.socket().bind(inetSocketAddress);
}
UdpChannel udpChannel = new UdpChannel(channel, worker, config, bufferPage);
worker.addRegister(selector -> {
try {
SelectionKey selectionKey = channel.register(selector, SelectionKey.OP_READ);
udpChannel.setSelectionKey(selectionKey);
selectionKey.attach(udpChannel);
} catch (ClosedChannelException e) {
e.printStackTrace();
}
});
return udpChannel;
}
private synchronized void initThreadServer() throws IOException {
if (worker != null) {
return;
}
// 增加广告说明
if (config.isBannerEnabled()) {
System.out.println(IoServerConfig.BANNER + "\r\n :: smart-socket[udp] ::\t(" + IoServerConfig.VERSION + ")");
}
int uid = UdpBootstrap.UID++;
//启动worker线程组
workerGroup = new UdpDispatcher[config.getThreadNum()];
executorService = new ThreadPoolExecutor(config.getThreadNum(), config.getThreadNum(),
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(), new ThreadFactory() {
int i = 0;
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "smart-socket:udp-" + uid + "-" + (++i));
}
});
for (int i = 0; i < config.getThreadNum(); i++) {
workerGroup[i] = new UdpDispatcher(config.getProcessor());
executorService.execute(workerGroup[i]);
}
//启动Boss线程组
worker = new Worker();
new Thread(worker, "smart-socket:udp-" + uid).start();
}
private void doRead(VirtualBuffer readBuffer, UdpChannel channel) throws IOException {
int count = MAX_READ_TIMES;
while (count-- > 0) {
//接收数据
ByteBuffer buffer = readBuffer.buffer();
buffer.clear();
SocketAddress remote = channel.getChannel().receive(buffer);
if (remote == null) {
return;
}
buffer.flip();
UdpAioSession aioSession = channel.createAndCacheSession(remote);
NetMonitor netMonitor = config.getMonitor();
if (netMonitor != null) {
netMonitor.beforeRead(aioSession);
netMonitor.afterRead(aioSession, buffer.remaining());
}
Object request;
//解码
try {
request = config.getProtocol().decode(buffer, aioSession);
} catch (Exception e) {
config.getProcessor().stateEvent(aioSession, StateMachineEnum.DECODE_EXCEPTION, e);
aioSession.close();
throw e;
}
//理论上每个UDP包都是一个完整的消息
if (request == null) {
config.getProcessor().stateEvent(aioSession, StateMachineEnum.DECODE_EXCEPTION, new DecoderException("decode result is null"));
} else {
//任务分发
workerGroup[(remote.hashCode() & Integer.MAX_VALUE) % workerGroup.length].dispatch(aioSession, request);
}
}
}
public void shutdown() {
running = false;
worker.selector.wakeup();
for (UdpDispatcher dispatcher : workerGroup) {
dispatcher.dispatch(UdpDispatcher.EXECUTE_TASK_OR_SHUTDOWN);
}
executorService.shutdown();
}
/**
* 设置读缓存区大小
*
* @param size 单位：byte
*/
public final UdpBootstrap setReadBufferSize(int size) {
this.config.setReadBufferSize(size);
return this;
}
/**
* 设置线程大小
*
* @param num 线程数
*/
public final UdpBootstrap setThreadNum(int num) {
this.config.setThreadNum(num);
return this;
}
/**
* 是否启用控制台Banner打印
*
* @param bannerEnabled true:启用，false:禁用
* @return 当前AioQuickServer对象
*/
public final UdpBootstrap setBannerEnabled(boolean bannerEnabled) {
config.setBannerEnabled(bannerEnabled);
return this;
}
class Worker implements Runnable {
/**
* 当前Worker绑定的Selector
*/
private final Selector selector;
/**
* 待注册的事件
*/
private final ConcurrentLinkedQueue<Consumer<Selector>> registers = new ConcurrentLinkedQueue<>();
Worker() throws IOException {
this.selector = Selector.open();
}
/**
* 注册事件
*/
final void addRegister(Consumer<Selector> register) {
registers.offer(register);
selector.wakeup();
}
@Override
public final void run() {
// 优先获取SelectionKey,若无关注事件触发则阻塞在selector.select(),减少select被调用次数
Set<SelectionKey> keySet = selector.selectedKeys();
//读缓冲区
VirtualBuffer readBuffer = bufferPage.allocate(config.getReadBufferSize());
try {
while (running) {
Consumer<Selector> register;
while ((register = registers.poll()) != null) {
register.accept(selector);
}
if (keySet.isEmpty() && selector.select() == 0) {
continue;
}
Iterator<SelectionKey> keyIterator = keySet.iterator();
// 执行本次已触发待处理的事件
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
keyIterator.remove();
UdpChannel udpChannel = (UdpChannel) key.attachment();
if (!key.isValid()) {
udpChannel.close();
continue;
}
if (key.isReadable()) {
doRead(readBuffer, udpChannel);
}
if (key.isWritable()) {
udpChannel.doWrite();
}
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//读缓冲区内存回收
readBuffer.clean();
}
}
}
}
| 4,739 |
310 | <reponame>dreeves/usesthis<filename>gear/hardware/g/galaxy-note-3.json
{
"name": "Galaxy Note 3",
"description": "A phone/tablet.",
"url": "https://en.wikipedia.org/wiki/Samsung_Galaxy_Note_3"
} | 82 |
3,182 | package de.plushnikov.accessors;
import lombok.Builder;
import lombok.Getter;
import lombok.experimental.Accessors;
@Accessors(prefix = "m")
@Builder
@Getter
public class Example151 {
private final String mAField;
public static void main(String[] args) {
System.out.println(builder().aField("a").build().getAField());
}
}
| 114 |
348 | {"nom":"Moncheux","circ":"2ème circonscription","dpt":"Moselle","inscrits":96,"abs":55,"votants":41,"blancs":2,"nuls":0,"exp":39,"res":[{"nuance":"REM","nom":"<NAME>","voix":20},{"nuance":"LR","nom":"<NAME>","voix":19}]} | 90 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.