content stringlengths 4 1.04M | lang stringclasses 358
values | score int64 0 5 | repo_name stringlengths 5 114 | repo_path stringlengths 4 229 | repo_licenses listlengths 1 8 |
|---|---|---|---|---|---|
==================
NEP 36 — Fair play
==================
:Author: Stéfan van der Walt <stefanv@berkeley.edu>
:Status: Accepted
:Type: Informational
:Created: 2019-10-24
:Resolution: https://mail.python.org/pipermail/numpy-discussion/2021-June/081890.html
Abstract
--------
This document sets out Rules of Play for companies and outside
developers that engage with the NumPy project. It covers:
- Restrictions on use of the NumPy name
- How and whether to publish a modified distribution
- How to make us aware of patched versions
Companies and developers will know after reading this NEP what kinds
of behavior the community would like to see, and which we consider
troublesome, bothersome, and unacceptable.
Motivation
----------
Every so often, we learn of NumPy versions modified and circulated by outsiders.
These patched versions can cause problems for the NumPy community
(see, e.g., [#erf]_ and [#CVE-2019-6446]_).
When issues like these arise, our developers waste time identifying
the problematic release, locating alterations, and determining an
appropriate course of action.
In addition, packages on the Python Packaging Index are sometimes
named such that users assume they are sanctioned or maintained by
NumPy. We wish to reduce the number of such incidents.
During a community call on `October 16th, 2019
<https://github.com/numpy/archive/blob/main/status_meetings/status-2019-10-16.md>`__
the community resolved to draft guidelines to address these matters.
.. [#erf] In December 2018, a
`bug report <https://github.com/numpy/numpy/issues/12515>`__
was filed against `np.erf` -- a function that didn't exist in the
NumPy distribution. It came to light that a company had published
a NumPy version with an extended API footprint. After several
months of discussion, the company agreed to make its patches
public, and we added a label to the NumPy issue tracker to identify
issues pertaining to that distribution.
.. [#CVE-2019-6446] After a security issue (CVE-2019-6446) was filed
against NumPy, distributions put in their own fixes, most often by
changing a default keyword value. As a result the NumPy API was
inconsistent across distributions.
Scope
-----
This document aims to define a minimal set of rules that, when
followed, will be considered good-faith efforts in line with the
expectations of the NumPy developers.
Our hope is that developers who feel they need to modify NumPy will
first consider contributing to the project, or use one of several existing
mechanisms for extending our APIs and for operating on
externally defined array objects.
When in doubt, please `talk to us first
<https://numpy.org/community/>`__. We may suggest an alternative; at
minimum, we'll be prepared.
Fair play rules
---------------
1. Do not reuse the NumPy name for projects not developed by the NumPy
community.
At time of writing, there are only a handful of ``numpy``-named
packages developed by the community, including ``numpy``,
``numpy-financial``, and ``unumpy``. We ask that external packages not
include the phrase ``numpy``, i.e., avoid names such as
``mycompany_numpy``.
To be clear, this rule only applies to modules (package names); it
is perfectly acceptable to have a *submodule* of your own library
named ``mylibrary.numpy``.
NumPy is a trademark owned by NumFOCUS.
2. Do not republish modified versions of NumPy.
Modified versions of NumPy make it very difficult for the
developers to address bug reports, since we typically do not know
which parts of NumPy have been modified.
If you have to break this rule (and we implore you not
to!), then make it clear in the ``__version__`` tag that
you have modified NumPy, e.g.::
>>> print(np.__version__)
'1.17.2+mycompany.15`
We understand that minor patches are often required to make a
library work inside of a distribution. E.g., Debian may patch
NumPy so that it searches for optimized BLAS libraries in the
correct locations. This is acceptable, but we ask that no
substantive changes are made.
3. Do not extend or modify NumPy's API.
If you absolutely have to break rule two, please do not add
additional functions to the namespace, or modify the API of
existing functions. NumPy's API is already
quite large, and we are working hard to reduce it where feasible.
Having additional functions exposed in distributed versions is
confusing for users and developers alike.
4. *DO* use official mechanism to engage with the API.
Protocols such as `__array_ufunc__
<https://numpy.org/neps/nep-0013-ufunc-overrides.html>`__ and
`__array_function__
<https://numpy.org/neps/nep-0018-array-function-protocol.html>`__
were designed to help external packages interact more easily with
NumPy. E.g., the latter allows objects from foreign libraries to
pass through NumPy. We actively encourage using any of
these "officially sanctioned" mechanisms for overriding or
interacting with NumPy.
If these mechanisms are deemed insufficient, please start a
discussion on the mailing list before monkeypatching NumPy.
Questions and answers
---------------------
**Q:** We would like to distribute an optimized version of NumPy that
utilizes special instructions for our company's CPU. You recommend
against that, so what are we to do?
**A:** Please consider including the patches required in the official
NumPy repository. Not only do we encourage such contributions, but we
already have optimized loops for some platforms available.
**Q:** We would like to ship a much faster version of FFT than NumPy
provides, but NumPy has no mechanism for overriding its FFT routines.
How do we proceed?
**A:** There are two solutions that we approve of: let the users
install your optimizations using a piece of code, such as::
from my_company_accel import patch_numpy_fft
patch_numpy_fft()
or have your distribution automatically perform the above, but print a
message to the terminal clearly stating what is happening::
We are now patching NumPy for optimal performance under MyComp
Special Platform. Please direct all bug reports to
https://mycomp.com/numpy-bugs
If you require additional mechanisms for overriding code, please
discuss this with the development team on the mailing list.
**Q:** We would like to distribute NumPy with faster linear algebra
routines. Are we allowed to do this?
**A:** Yes, this is explicitly supported by linking to a different
version of BLAS.
Discussion
----------
References and footnotes
------------------------
Copyright
---------
This document has been placed in the public domain.
| reStructuredText | 3 | iam-abbas/numpy | doc/neps/nep-0036-fair-play.rst | [
"BSD-3-Clause"
] |
/// <reference path="fourslash.ts" />
//// declare function Foo(arg1?: Function): { q: number };
//// Foo(function () { } )./**/;
verify.completions({ marker: "", exact: "q" });
| TypeScript | 4 | nilamjadhav/TypeScript | tests/cases/fourslash/completionListOnFunctionCallWithOptionalArgument.ts | [
"Apache-2.0"
] |
/******************************************************************************
* Copyright 2018 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "modules/localization/msf/local_map/ndt_map/ndt_map_matrix.h"
#include "modules/localization/msf/local_map/ndt_map/ndt_map_config.h"
namespace apollo {
namespace localization {
namespace msf {
NdtMapSingleCell::NdtMapSingleCell() {
intensity_ = 0.0;
intensity_var_ = 0.0;
road_pt_count_ = 0;
count_ = 0;
centroid_ = Eigen::Vector3f::Zero();
centroid_average_cov_ = Eigen::Matrix3f::Zero();
centroid_icov_ = Eigen::Matrix3f::Identity();
is_icov_available_ = 0;
}
unsigned int NdtMapSingleCell::LoadBinary(unsigned char* buf) {
float* f_buf = reinterpret_cast<float*>(buf);
intensity_ = *f_buf;
++f_buf;
intensity_var_ = *f_buf;
++f_buf;
unsigned int* ui_buf =
reinterpret_cast<unsigned int*>(reinterpret_cast<void*>(f_buf));
road_pt_count_ = *ui_buf;
++ui_buf;
count_ = *ui_buf;
++ui_buf;
f_buf = reinterpret_cast<float*>(reinterpret_cast<void*>(ui_buf));
centroid_[0] = *f_buf;
++f_buf;
centroid_[1] = *f_buf;
++f_buf;
centroid_[2] = *f_buf;
for (unsigned int i = 0; i < 3; ++i) {
for (unsigned int j = 0; j < 3; ++j) {
++f_buf;
centroid_average_cov_(i, j) = *f_buf;
}
}
if (count_ >= minimum_points_threshold_) {
for (unsigned int i = 0; i < 3; ++i) {
for (unsigned int j = 0; j < 3; ++j) {
++f_buf;
centroid_icov_(i, j) = *f_buf;
}
}
++f_buf;
unsigned char* uc_buf = reinterpret_cast<unsigned char*>(f_buf);
is_icov_available_ = *uc_buf;
} else {
centroid_icov_ = Eigen::Matrix3f::Identity();
is_icov_available_ = 0;
}
return GetBinarySize();
}
unsigned int NdtMapSingleCell::CreateBinary(unsigned char* buf,
unsigned int buf_size) const {
unsigned int target_size = GetBinarySize();
if (buf_size >= target_size) {
float* p = reinterpret_cast<float*>(buf);
*p = intensity_;
++p;
*p = intensity_var_;
++p;
unsigned int* pp =
reinterpret_cast<unsigned int*>(reinterpret_cast<void*>(p));
*pp = road_pt_count_;
++pp;
*pp = count_;
++pp;
float* ppp = reinterpret_cast<float*>(reinterpret_cast<void*>(pp));
*ppp = centroid_[0];
++ppp;
*ppp = centroid_[1];
++ppp;
*ppp = centroid_[2];
for (unsigned int i = 0; i < 3; ++i) {
for (unsigned int j = 0; j < 3; ++j) {
++ppp;
*ppp = centroid_average_cov_(i, j);
}
}
if (count_ >= minimum_points_threshold_) {
for (unsigned int i = 0; i < 3; ++i) {
for (unsigned int j = 0; j < 3; ++j) {
++ppp;
*ppp = centroid_icov_(i, j);
}
}
++ppp;
unsigned char* pppp = reinterpret_cast<unsigned char*>(ppp);
*pppp = is_icov_available_;
}
}
return target_size;
}
unsigned int NdtMapSingleCell::GetBinarySize() const {
unsigned int sz =
static_cast<unsigned int>(sizeof(float) * 2 + sizeof(unsigned int) * 2 +
sizeof(float) * 3 + sizeof(float) * 9);
if (count_ >= minimum_points_threshold_) {
sz += static_cast<unsigned int>(sizeof(float) * 9 +
sizeof(unsigned char) * 1);
}
return sz;
}
NdtMapSingleCell& NdtMapSingleCell::operator=(const NdtMapSingleCell& ref) {
count_ = ref.count_;
intensity_ = ref.intensity_;
intensity_var_ = ref.intensity_var_;
road_pt_count_ = ref.road_pt_count_;
centroid_ = ref.centroid_;
centroid_average_cov_ = ref.centroid_average_cov_;
centroid_icov_ = ref.centroid_icov_;
is_icov_available_ = ref.is_icov_available_;
return *this;
}
void NdtMapSingleCell::Reduce(NdtMapSingleCell* cell,
const NdtMapSingleCell& cell_new) {
cell->MergeCell(cell_new);
}
NdtMapCells::NdtMapCells() {
max_altitude_index_ = static_cast<int>(-1e10);
min_altitude_index_ = static_cast<int>(1e10);
}
void NdtMapCells::Reset() {
max_altitude_index_ = static_cast<int>(-1e10);
min_altitude_index_ = static_cast<int>(1e10);
cells_.clear();
road_cell_indices_.clear();
}
int NdtMapCells::AddSample(const float intensity, const float altitude,
const float resolution,
const Eigen::Vector3f centroid, bool is_road) {
int altitude_index = CalAltitudeIndex(resolution, altitude);
NdtMapSingleCell& cell = cells_[altitude_index];
cell.AddSample(intensity, altitude, centroid, is_road);
if (altitude_index > max_altitude_index_) {
max_altitude_index_ = altitude_index;
}
if (altitude_index < min_altitude_index_) {
min_altitude_index_ = altitude_index;
}
if (is_road) {
auto got = std::find(road_cell_indices_.begin(), road_cell_indices_.end(),
altitude_index);
if (got == road_cell_indices_.end()) {
road_cell_indices_.push_back(altitude_index);
}
}
return altitude_index;
}
unsigned int NdtMapCells::LoadBinary(unsigned char* buf) {
unsigned int* p = reinterpret_cast<unsigned int*>(buf);
unsigned int size = *p;
++p;
unsigned char* pp = reinterpret_cast<unsigned char*>(p);
for (unsigned int i = 0; i < size; ++i) {
int* ppp = reinterpret_cast<int*>(pp);
int altitude_index = *ppp;
++ppp;
pp = reinterpret_cast<unsigned char*>(ppp);
NdtMapSingleCell cell;
unsigned int processed_size = cell.LoadBinary(pp);
cells_[altitude_index] = cell;
pp += processed_size;
}
int* ppp = reinterpret_cast<int*>(pp);
max_altitude_index_ = *ppp;
++ppp;
min_altitude_index_ = *ppp;
++ppp;
p = reinterpret_cast<unsigned int*>(ppp);
size = *p;
++p;
ppp = reinterpret_cast<int*>(p);
for (unsigned int i = 0; i < size; ++i) {
int index = *ppp;
++ppp;
road_cell_indices_.push_back(index);
}
return GetBinarySize();
}
unsigned int NdtMapCells::CreateBinary(unsigned char* buf,
unsigned int buf_size) const {
unsigned int target_size = GetBinarySize();
if (buf_size >= target_size) {
unsigned int* p = reinterpret_cast<unsigned int*>(buf);
*p = static_cast<unsigned int>(cells_.size());
++p;
buf_size -= static_cast<unsigned int>(sizeof(unsigned int));
unsigned char* pp = reinterpret_cast<unsigned char*>(p);
for (auto it = cells_.begin(); it != cells_.end(); ++it) {
int altitude_index = it->first;
const NdtMapSingleCell& cell = it->second;
int* ppp = reinterpret_cast<int*>(pp);
*ppp = altitude_index;
++ppp;
pp = reinterpret_cast<unsigned char*>(ppp);
unsigned int processed_size = cell.CreateBinary(pp, buf_size);
assert(buf_size >= processed_size);
buf_size -= processed_size;
pp += processed_size;
}
int* ppp = reinterpret_cast<int*>(pp);
*ppp = max_altitude_index_;
++ppp;
*ppp = min_altitude_index_;
++ppp;
unsigned int size = static_cast<unsigned int>(road_cell_indices_.size());
p = reinterpret_cast<unsigned int*>(ppp);
*p = size;
++p;
ppp = reinterpret_cast<int*>(p);
for (unsigned int i = 0; i < size; ++i) {
*ppp = road_cell_indices_[i];
++ppp;
}
}
return target_size;
}
unsigned int NdtMapCells::GetBinarySize() const {
unsigned int target_size = sizeof(unsigned int);
for (auto it = cells_.begin(); it != cells_.end(); ++it) {
target_size += static_cast<unsigned int>(sizeof(int));
const NdtMapSingleCell& cell = it->second;
target_size += cell.GetBinarySize();
}
target_size += static_cast<unsigned int>(sizeof(int) * 2);
target_size += static_cast<unsigned int>(sizeof(unsigned int));
target_size +=
static_cast<unsigned int>(sizeof(int) * road_cell_indices_.size());
return target_size;
}
int NdtMapCells::CalAltitudeIndex(const float resolution,
const float altitude) {
return static_cast<int>(altitude / resolution);
}
float NdtMapCells::CalAltitude(const float resolution,
const int altitude_index) {
return static_cast<float>(resolution *
(static_cast<float>(altitude_index) + 0.5));
}
void NdtMapCells::Reduce(NdtMapCells* cell, const NdtMapCells& cell_new) {
// Reduce cells
for (auto it = cell_new.cells_.begin(); it != cell_new.cells_.end(); ++it) {
int altitude_index = it->first;
auto got = cell->cells_.find(altitude_index);
if (got != cell->cells_.end()) {
cell->cells_[altitude_index].MergeCell(it->second);
} else {
cell->cells_[altitude_index] = NdtMapSingleCell(it->second);
}
}
if (cell_new.max_altitude_index_ > cell->max_altitude_index_) {
cell->max_altitude_index_ = cell_new.max_altitude_index_;
}
if (cell_new.min_altitude_index_ < cell->min_altitude_index_) {
cell->min_altitude_index_ = cell_new.min_altitude_index_;
}
for (auto it_new = cell_new.road_cell_indices_.begin();
it_new != cell_new.road_cell_indices_.end(); ++it_new) {
auto got_it = std::find(cell->road_cell_indices_.begin(),
cell->road_cell_indices_.end(), *it_new);
if (got_it != cell->road_cell_indices_.end()) {
*got_it += *it_new;
} else {
cell->road_cell_indices_.push_back(*it_new);
}
}
}
NdtMapMatrix::NdtMapMatrix() {
rows_ = 0;
cols_ = 0;
map3d_cells_ = nullptr;
}
NdtMapMatrix::~NdtMapMatrix() {}
NdtMapMatrix::NdtMapMatrix(const NdtMapMatrix& cells) {
Init(cells.rows_, cells.cols_);
for (unsigned int y = 0; y < rows_; ++y) {
for (unsigned int x = 0; x < cols_; ++x) {
NdtMapCells& cell = GetMapCell(y, x);
const NdtMapCells& src_cell = cells.GetMapCell(y, x);
cell = NdtMapCells(src_cell);
}
}
}
void NdtMapMatrix::Init(const BaseMapConfig* config) {
Init(config->map_node_size_y_, config->map_node_size_x_);
}
void NdtMapMatrix::Reset(const BaseMapConfig* config) {
Reset(config->map_node_size_y_, config->map_node_size_x_);
}
void NdtMapMatrix::Init(unsigned int rows, unsigned int cols) {
map3d_cells_.reset(new NdtMapCells[rows * cols]);
rows_ = rows;
cols_ = cols;
}
void NdtMapMatrix::Reset(unsigned int rows, unsigned int cols) {
unsigned int length = rows * cols;
for (unsigned int i = 0; i < length; ++i) {
map3d_cells_[i].Reset();
}
}
unsigned int NdtMapMatrix::LoadBinary(unsigned char* buf) {
unsigned int* p = reinterpret_cast<unsigned int*>(buf);
rows_ = *p;
++p;
cols_ = *p;
++p;
Init(rows_, cols_);
unsigned char* pp = reinterpret_cast<unsigned char*>(p);
for (unsigned int y = 0; y < rows_; ++y) {
for (unsigned int x = 0; x < cols_; ++x) {
NdtMapCells& cell = GetMapCell(y, x);
unsigned int processed_size = cell.LoadBinary(pp);
pp += processed_size;
}
}
return GetBinarySize();
}
unsigned int NdtMapMatrix::CreateBinary(unsigned char* buf,
unsigned int buf_size) const {
unsigned int target_size = GetBinarySize();
if (buf_size >= target_size) {
unsigned int* p = reinterpret_cast<unsigned int*>(buf);
*p = rows_;
++p;
*p = cols_;
++p;
buf_size -= static_cast<unsigned int>(sizeof(unsigned int) * 2);
unsigned char* pp = reinterpret_cast<unsigned char*>(p);
for (unsigned int y = 0; y < rows_; ++y) {
for (unsigned int x = 0; x < cols_; ++x) {
const NdtMapCells& cell = GetMapCell(y, x);
unsigned int processed_size = cell.CreateBinary(pp, buf_size);
assert(buf_size >= processed_size);
buf_size -= processed_size;
pp += processed_size;
}
}
}
return target_size;
}
unsigned int NdtMapMatrix::GetBinarySize() const {
unsigned int target_size =
static_cast<unsigned int>(sizeof(unsigned int) * 2);
for (unsigned int y = 0; y < rows_; ++y) {
for (unsigned int x = 0; x < cols_; ++x) {
const NdtMapCells& cell = GetMapCell(y, x);
target_size += cell.GetBinarySize();
}
}
return target_size;
}
void NdtMapMatrix::Reduce(NdtMapMatrix* cells, const NdtMapMatrix& cells_new) {
for (unsigned int y = 0; y < cells->GetRows(); ++y) {
for (unsigned int x = 0; x < cells->GetCols(); ++x) {
NdtMapCells& cell = cells->GetMapCell(y, x);
const NdtMapCells& cell_new = cells_new.GetMapCell(y, x);
NdtMapCells::Reduce(&cell, cell_new);
}
}
}
void NdtMapMatrix::GetIntensityImg(cv::Mat* intensity_img) const {
*intensity_img = cv::Mat(cv::Size(cols_, rows_), CV_8UC1);
for (unsigned int y = 0; y < rows_; ++y) {
for (unsigned int x = 0; x < cols_; ++x) {
unsigned int id = y * cols_ + x;
int min_altitude_index = map3d_cells_[id].min_altitude_index_;
intensity_img->at<unsigned char>(y, x) =
(unsigned char)(map3d_cells_[id]
.cells_[min_altitude_index]
.intensity_);
}
}
}
} // namespace msf
} // namespace localization
} // namespace apollo
| C++ | 4 | seeclong/apollo | modules/localization/msf/local_map/ndt_map/ndt_map_matrix.cc | [
"Apache-2.0"
] |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# This is a Pester test suite to validate the Format-Hex cmdlet in the Microsoft.PowerShell.Utility module.
<#
Purpose:
Verify Format-Hex displays the Hexadecimal value for the input data.
Action:
Run Format-Hex.
Expected Result:
Hexadecimal equivalent of the input data is displayed.
#>
Describe "FormatHex" -tags "CI" {
BeforeAll {
$newline = [Environment]::Newline
Setup -d FormatHexDataDir
$inputFile1 = New-Item -Path "$TestDrive/SourceFile-1.txt"
$inputText1 = 'Hello World'
Set-Content -LiteralPath $inputFile1.FullName -Value $inputText1 -NoNewline
$inputFile2 = New-Item -Path "$TestDrive/SourceFile-2.txt"
$inputText2 = 'More text'
Set-Content -LiteralPath $inputFile2.FullName -Value $inputText2 -NoNewline
$inputFile3 = New-Item -Path "$TestDrive/SourceFile literal [3].txt"
$inputText3 = 'Literal path'
Set-Content -LiteralPath $inputFile3.FullName -Value $inputText3 -NoNewline
$inputFile4 = New-Item -Path "$TestDrive/SourceFile-4.txt"
$inputText4 = 'Now is the winter of our discontent'
Set-Content -LiteralPath $inputFile4.FullName -Value $inputText4 -NoNewline
$certificateProvider = Get-ChildItem Cert:\CurrentUser\My\ -ErrorAction SilentlyContinue
$thumbprint = $null
$certProviderAvailable = $false
if ($certificateProvider.Count -gt 0) {
$thumbprint = $certificateProvider[0].Thumbprint
$certProviderAvailable = $true
}
$skipTest = ([System.Management.Automation.Platform]::IsLinux -or [System.Management.Automation.Platform]::IsMacOS -or (-not $certProviderAvailable))
}
Context "InputObject Paramater" {
BeforeAll {
enum TestEnum {
TestOne = 1; TestTwo = 2; TestThree = 3; TestFour = 4
}
Add-Type -TypeDefinition @'
public enum TestSByteEnum : sbyte {
One = -1,
Two = -2,
Three = -3,
Four = -4
}
'@
}
$testCases = @(
@{
Name = "Can process bool type 'fhx -InputObject `$true'"
InputObject = $true
Count = 1
ExpectedResult = "00000000 01 00 00 00"
}
@{
Name = "Can process byte type 'fhx -InputObject [byte]5'"
InputObject = [byte]5
Count = 1
ExpectedResult = "00000000 05"
}
@{
Name = "Can process byte[] type 'fhx -InputObject [byte[]](1,2,3,4,5)'"
InputObject = [byte[]](1, 2, 3, 4, 5)
Count = 1
ExpectedResult = "00000000 01 02 03 04 05 ....."
}
@{
Name = "Can process int type 'fhx -InputObject 7'"
InputObject = 7
Count = 1
ExpectedResult = "00000000 07 00 00 00 ...."
}
@{
Name = "Can process int[] type 'fhx -InputObject [int[]](5,6,7,8)'"
InputObject = [int[]](5, 6, 7, 8)
Count = 1
ExpectedResult = "00000000 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00 ................"
}
@{
Name = "Can process int32 type 'fhx -InputObject [int32]2032'"
InputObject = [int32]2032
Count = 1
ExpectedResult = "00000000 F0 07 00 00 ð..."
}
@{
Name = "Can process int32[] type 'fhx -InputObject [int32[]](2032, 2033, 2034)'"
InputObject = [int32[]](2032, 2033, 2034)
Count = 1
ExpectedResult = "0000000000000000 F0 07 00 00 F1 07 00 00 F2 07 00 00 ð...ñ...ò..."
}
@{
Name = "Can process Int64 type 'fhx -InputObject [Int64]9223372036854775807'"
InputObject = [Int64]9223372036854775807
Count = 1
ExpectedResult = "0000000000000000 FF FF FF FF FF FF FF 7F ÿÿÿÿÿÿÿ�"
}
@{
Name = "Can process Int64[] type 'fhx -InputObject [Int64[]](9223372036852,9223372036853)'"
InputObject = [Int64[]](9223372036852, 9223372036853)
Count = 1
ExpectedResult = "0000000000000000 F4 5A D0 7B 63 08 00 00 F5 5A D0 7B 63 08 00 00 ôZÐ{c...õZÐ{c..."
}
@{
Name = "Can process string type 'fhx -InputObject hello world'"
InputObject = "hello world"
Count = 1
ExpectedResult = "0000000000000000 68 65 6C 6C 6F 20 77 6F 72 6C 64 hello world"
}
@{
Name = "Can process PS-native enum array '[TestEnum[]]('TestOne', 'TestTwo', 'TestThree', 'TestFour') | fhx'"
InputObject = [TestEnum[]]('TestOne', 'TestTwo', 'TestThree', 'TestFour')
Count = 1
ExpectedResult = "0000000000000000 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ................"
}
@{
Name = "Can process C#-native sbyte enum array '[TestSByteEnum[]]('One', 'Two', 'Three', 'Four') | fhx'"
InputObject = [TestSByteEnum[]]('One', 'Two', 'Three', 'Four')
Count = 1
ExpectedResult = "0000000000000000 FF FE FD FC .þýü"
}
)
It "<Name>" -TestCase $testCases {
param ($Name, $InputObject, $Count, $ExpectedResult)
$result = Format-Hex -InputObject $InputObject
$result.count | Should -Be $Count
$result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$result.ToString() | Should -MatchExactly $ExpectedResult
}
}
Context "InputObject From Pipeline" {
BeforeAll {
enum TestEnum {
TestOne = 1; TestTwo = 2; TestThree = 3; TestFour = 4
}
Add-Type -TypeDefinition @'
public enum TestSByteEnum : sbyte {
One = -1,
Two = -2,
Three = -3,
Four = -4
}
'@
}
$testCases = @(
@{
Name = "Can process bool type '`$true | fhx'"
InputObject = $true
Count = 1
ExpectedResult = "0000000000000000 01"
}
@{
Name = "Can process byte type '[byte]5 | fhx'"
InputObject = [byte]5
Count = 1
ExpectedResult = "0000000000000000 05"
}
@{
Name = "Can process byte[] type '[byte[]](1,2) | fhx'"
InputObject = [byte[]](1, 2)
Count = 1
ExpectedResult = "0000000000000000 01 02 ��"
}
@{
Name = "Can process int type '7 | fhx'"
InputObject = 7
Count = 1
ExpectedResult = "0000000000000000 07 00 00 00 � "
}
@{
Name = "Can process int[] type '[int[]](5,6) | fhx'"
InputObject = [int[]](5, 6)
Count = 1
ExpectedResult = "0000000000000000 05 00 00 00 06 00 00 00 � � "
}
@{
Name = "Can process int32 type '[int32]2032 | fhx'"
InputObject = [int32]2032
Count = 1
ExpectedResult = "0000000000000000 F0 07 00 00 ð� "
}
@{
Name = "Can process int32[] type '[int32[]](2032, 2033) | fhx'"
InputObject = [int32[]](2032, 2033)
Count = 1
ExpectedResult = "0000000000000000 F0 07 00 00 F1 07 00 00 ð� ñ� "
}
@{
Name = "Can process Int64 type '[Int64]9223372036854775807 | fhx'"
InputObject = [Int64]9223372036854775807
Count = 1
ExpectedResult = "0000000000000000 FF FF FF FF FF FF FF 7F ÿÿÿÿÿÿÿ�"
}
@{
Name = "Can process Int64[] type '[Int64[]](9223372036852,9223372036853) | fhx'"
InputObject = [Int64[]](9223372036852, 9223372036853)
Count = 1
ExpectedResult = "0000000000000000 F4 5A D0 7B 63 08 00 00 F5 5A D0 7B 63 08 00 00 ôZÐ{c� õZÐ{c� "
}
@{
Name = "Can process string type 'hello world | fhx'"
InputObject = "hello world"
Count = 1
ExpectedResult = "0000000000000000 68 65 6C 6C 6F 20 77 6F 72 6C 64 hello world"
}
@{
Name = "Can process string type amidst other types { 1, 2, 3, 'hello world' | fhx }"
InputObject = 1, 2, 3, "hello world"
Count = 2
ExpectedResult = "0000000000000000 01 00 00 00 02 00 00 00 03 00 00 00 � � � "
ExpectedSecondResult = "0000000000000000 68 65 6C 6C 6F 20 77 6F 72 6C 64 hello world"
}
@{
Name = "Can process jagged array type '[sbyte[]](-15, 18, 21, -5), [byte[]](1, 2, 3, 4, 5, 6) | fhx'"
InputObject = [sbyte[]](-15, 18, 21, -5), [byte[]](1, 2, 3, 4, 5, 6)
Count = 2
ExpectedResult = "0000000000000000 F1 12 15 FB ñ��û"
ExpectedSecondResult = "0000000000000000 01 02 03 04 05 06 ������"
}
@{
Name = "Can process jagged array type '[bool[]](`$true, `$false), [int[]](1, 2, 3, 4) | fhx'"
InputObject = [bool[]]($true, $false), [int[]](1, 2, 3, 4)
Count = 2
ExpectedResult = "0000000000000000 01 00 00 00 00 00 00 00 �"
ExpectedSecondResult = "0000000000000000 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 � � � �"
}
@{
Name = "Can process PS-native enum array '[TestEnum[]]('TestOne', 'TestTwo', 'TestThree', 'TestFour') | fhx'"
InputObject = [TestEnum[]]('TestOne', 'TestTwo', 'TestThree', 'TestFour')
Count = 1
ExpectedResult = "0000000000000000 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 � � � � "
}
@{
Name = "Can process C#-native sbyte enum array '[TestSByteEnum[]]('One', 'Two', 'Three', 'Four') | fhx'"
InputObject = [TestSByteEnum[]]('One', 'Two', 'Three', 'Four')
Count = 1
ExpectedResult = "0000000000000000 FF FE FD FC ÿþýü"
}
)
It "<Name>" -TestCases $testCases {
param ($Name, $InputObject, $Count, $ExpectedResult, $ExpectedSecondResult)
$result = $InputObject | Format-Hex
$result.Count | Should -Be $Count
$result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$result[0].ToString() | Should -MatchExactly $ExpectedResult
if ($result.count -gt 1) {
$result[1].ToString() | Should -MatchExactly $ExpectedSecondResult
}
}
$heterogenousInputCases = @(
@{
InputScript = { [sbyte[]](-15, 18, 21, -5), "hello", [byte[]](1..6), 1, 2, 3, 4 }
Count = 4
ExpectedResults = @(
"0000000000000000 F1 12 15 FB ñ��û"
"0000000000000000 68 65 6C 6C 6F hello"
"0000000000000000 01 02 03 04 05 06 ������"
"0000000000000000 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 � � � � "
)
ExpectedLabels = @(
"System.SByte[]"
"System.String"
"System.Byte"
"System.Int32"
).ForEach{ [regex]::Escape($_) } -join '|'
}
@{
InputScript = { $inputFile1, "Mountains are merely mountains", 1, 4, 5, 3, [ushort[]](1..10) }
Count = 6
ExpectedResults = @(
"0000000000000000 48 65 6C 6C 6F 20 57 6F 72 6C 64 Hello World"
"0000000000000000 4D 6F 75 6E 74 61 69 6E 73 20 61 72 65 20 6D 65 Mountains are me"
"0000000000000010 72 65 6C 79 20 6D 6F 75 6E 74 61 69 6E 73 rely mountains"
"0000000000000000 01 00 00 00 04 00 00 00 05 00 00 00 03 00 00 00 � � � � "
"0000000000000000 01 00 02 00 03 00 04 00 05 00 06 00 07 00 08 00 � � � � � � � � "
"0000000000000010 09 00 0A 00 � � "
)
ExpectedLabels = @(
$inputFile1.FullName
"System.String"
"System.Int32"
"System.UInt16[]"
).ForEach{ [regex]::Escape($_) } -join '|'
}
@{
InputScript = { $true, $false, $true, 123, 100, 76, $true, $false }
Count = 3
ExpectedResults = @(
"0000000000000000 01 00 00 00 00 00 00 00 01 00 00 00 � �"
"0000000000000000 7B 00 00 00 64 00 00 00 4C 00 00 00 { d L"
"0000000000000000 01 00 00 00 00 00 00 00 �"
)
ExpectedLabels = @(
"System.Boolean"
"System.Int32"
).ForEach{ [regex]::Escape($_) } -join '|'
}
)
It 'can process jagged input: <InputScript>' -TestCases $heterogenousInputCases {
param($InputScript, $Count, $ExpectedResults, $ExpectedLabels)
$Results = & $InputScript | Format-Hex
$Results | Should -HaveCount $Count
$ExpectedResults | Should -HaveCount $Count
for ($Number = 0; $Number -lt $Results.Count; $Number++) {
$Results[$Number] | Should -MatchExactly $ExpectedResults[$Number]
$Results[$Number].Label | Should -MatchExactly $ExpectedLabels
}
}
}
Context "Path and LiteralPath Parameters" {
$testDirectory = $inputFile1.DirectoryName
$testCases = @(
@{
Name = "Can process file content from given file path 'fhx -Path `$inputFile1'"
PathCase = $true
Path = $inputFile1
Count = 1
ExpectedResult = $inputText1
}
@{
Name = "Can process file content from all files in array of file paths 'fhx -Path `$inputFile1, `$inputFile2'"
PathCase = $true
Path = @($inputFile1, $inputFile2)
Count = 2
ExpectedResult = $inputText1
ExpectedSecondResult = $inputText2
}
@{
Name = "Can process file content from all files when resolved to multiple paths 'fhx -Path '`$testDirectory\SourceFile-*''"
PathCase = $true
Path = "$testDirectory\SourceFile-*"
Count = 2
ExpectedResult = $inputText1
ExpectedSecondResult = $inputText2
}
@{
Name = "Can process file content from given file path 'fhx -LiteralPath `$inputFile3'"
Path = $inputFile3
Count = 1
ExpectedResult = $inputText3
}
@{
Name = "Can process file content from all files in array of file paths 'fhx -LiteralPath `$inputFile1, `$inputFile3'"
Path = @($inputFile1, $inputFile3)
Count = 2
ExpectedResult = $inputText1
ExpectedSecondResult = $inputText3
}
)
It "<Name>" -TestCase $testCases {
param ($Name, $PathCase, $Path, $ExpectedResult, $ExpectedSecondResult)
if ($PathCase) {
$result = Format-Hex -Path $Path
} else {
# LiteralPath
$result = Format-Hex -LiteralPath $Path
}
$result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$result[0].ToString() | Should -MatchExactly $ExpectedResult
if ($result.count -gt 1) {
$result[1].ToString() | Should -MatchExactly $ExpectedSecondResult
}
}
It 'properly accepts -LiteralPath input from a FileInfo object' {
$FilePath = 'TestDrive:\FHX-LitPathTest.txt'
"Hello World!" | Set-Content -Path $FilePath
$FileObject = Get-Item -Path $FilePath
$result = $FileObject | Format-Hex
if ($IsWindows) {
$Result.Bytes[-1] | Should -Be 0x0A
$Result.Bytes[-2] | Should -Be 0x0D
$Result.Bytes.Length | Should -Be 14
} else {
$Result.Bytes[-1] | Should -Be 0x0A
$Result.Bytes.Length | Should -Be 13
}
}
}
Context "Encoding Parameter" {
$testCases = @(
@{
Name = "Can process ASCII encoding 'fhx -InputObject 'hello' -Encoding ASCII'"
Encoding = "ASCII"
Count = 1
ExpectedResult = "0000000000000000 68 65 6C 6C 6F hello"
}
@{
Name = "Can process BigEndianUnicode encoding 'fhx -InputObject 'hello' -Encoding BigEndianUnicode'"
Encoding = "BigEndianUnicode"
Count = 1
ExpectedResult = "0000000000000000 00 68 00 65 00 6C 00 6C 00 6F h e l l o"
}
@{
Name = "Can process BigEndianUTF32 encoding 'fhx -InputObject 'hello' -Encoding BigEndianUTF32'"
Encoding = "BigEndianUTF32"
Count = 2
ExpectedResult = "0000000000000000 00 00 00 68 00 00 00 65 00 00 00 6C 00 00 00 6C h e l l"
ExpectedSecondResult = "0000000000000010 00 00 00 6F o"
}
@{
Name = "Can process Unicode encoding 'fhx -InputObject 'hello' -Encoding Unicode'"
Encoding = "Unicode"
Count = 1
ExpectedResult = "0000000000000000 68 00 65 00 6C 00 6C 00 6F 00 h e l l o "
}
@{
Name = "Can process UTF7 encoding 'fhx -InputObject 'hello' -Encoding UTF7'"
Encoding = "UTF7"
Count = 1
ExpectedResult = "0000000000000000 68 65 6C 6C 6F hello"
}
@{
Name = "Can process UTF8 encoding 'fhx -InputObject 'hello' -Encoding UTF8'"
Encoding = "UTF8"
Count = 1
ExpectedResult = "0000000000000000 68 65 6C 6C 6F hello"
}
@{
Name = "Can process UTF32 encoding 'fhx -InputObject 'hello' -Encoding UTF32'"
Encoding = "UTF32"
Count = 2
ExpectedResult = "0000000000000000 68 00 00 00 65 00 00 00 6C 00 00 00 6C 00 00 00 h e l l "
ExpectedSecondResult = "0000000000000010 6F 00 00 00 o "
}
)
It "<Name>" -TestCase $testCases {
param ($Name, $Encoding, $Count, $ExpectedResult)
$result = Format-Hex -InputObject 'hello' -Encoding $Encoding
$result.count | Should -Be $Count
$result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$result[0].ToString() | Should -MatchExactly $ExpectedResult
}
}
Context "Validate Error Scenarios" {
$testDirectory = $inputFile1.DirectoryName
$testCases = @(
@{
Name = "Does not support non-FileSystem Provider paths 'fhx -Path 'Cert:\CurrentUser\My\`$thumbprint' -ErrorAction Stop'"
PathParameterErrorCase = $true
Path = "Cert:\CurrentUser\My\$thumbprint"
ExpectedFullyQualifiedErrorId = "FormatHexOnlySupportsFileSystemPaths,Microsoft.PowerShell.Commands.FormatHex"
}
@{
Name = "Type Not Supported 'fhx -InputObject @{'hash' = 'table'} -ErrorAction Stop'"
InputObjectErrorCase = $true
Path = $inputFile1
InputObject = @{ "hash" = "table" }
ExpectedFullyQualifiedErrorId = "FormatHexTypeNotSupported,Microsoft.PowerShell.Commands.FormatHex"
}
)
It "<Name>" -Skip:$skipTest -TestCase $testCases {
param ($Name, $PathParameterErrorCase, $Path, $InputObject, $InputObjectErrorCase, $ExpectedFullyQualifiedErrorId)
{
if ($PathParameterErrorCase) {
$result = Format-Hex -Path $Path -ErrorAction Stop
}
if ($InputObjectErrorCase) {
$result = Format-Hex -InputObject $InputObject -ErrorAction Stop
}
} | Should -Throw -ErrorId $ExpectedFullyQualifiedErrorId
}
}
Context "Continues to Process Valid Paths" {
$testCases = @(
@{
Name = "If given invalid path in array, continues to process valid paths 'fhx -Path `$invalidPath, `$inputFile1 -ErrorVariable e -ErrorAction SilentlyContinue'"
PathCase = $true
InvalidPath = "$($inputFile1.DirectoryName)\fakefile8888845345345348709.txt"
ExpectedFullyQualifiedErrorId = "FileNotFound,Microsoft.PowerShell.Commands.FormatHex"
}
@{
Name = "If given a non FileSystem path in array, continues to process valid paths 'fhx -Path `$invalidPath, `$inputFile1 -ErrorVariable e -ErrorAction SilentlyContinue'"
PathCase = $true
InvalidPath = "Cert:\CurrentUser\My\$thumbprint"
ExpectedFullyQualifiedErrorId = "FormatHexOnlySupportsFileSystemPaths,Microsoft.PowerShell.Commands.FormatHex"
}
@{
Name = "If given a non FileSystem path in array (with LiteralPath), continues to process valid paths 'fhx -Path `$invalidPath, `$inputFile1 -ErrorVariable e -ErrorAction SilentlyContinue'"
InvalidPath = "Cert:\CurrentUser\My\$thumbprint"
ExpectedFullyQualifiedErrorId = "FormatHexOnlySupportsFileSystemPaths,Microsoft.PowerShell.Commands.FormatHex"
}
)
It "<Name>" -Skip:$skipTest -TestCase $testCases {
param ($Name, $PathCase, $InvalidPath, $ExpectedFullyQualifiedErrorId)
$output = $null
$errorThrown = $null
if ($PathCase) {
$output = Format-Hex -Path $InvalidPath, $inputFile1 -ErrorVariable errorThrown -ErrorAction SilentlyContinue
} else {
# LiteralPath
$output = Format-Hex -LiteralPath $InvalidPath, $inputFile1 -ErrorVariable errorThrown -ErrorAction SilentlyContinue
}
$errorThrown.FullyQualifiedErrorId | Should -MatchExactly $ExpectedFullyQualifiedErrorId
$output.Length | Should -Be 1
$output[0].ToString() | Should -MatchExactly $inputText1
}
}
Context "Cmdlet Functionality" {
It "Path is default Parameter Set 'fhx `$inputFile1'" {
$result = Format-Hex $inputFile1
$result | Should -Not -BeNullOrEmpty
, $result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$actualResult = $result.ToString()
$actualResult | Should -MatchExactly $inputText1
}
It "Validate file input from Pipeline 'Get-ChildItem `$inputFile1 | Format-Hex'" {
$result = Get-ChildItem $inputFile1 | Format-Hex
$result | Should -Not -BeNullOrEmpty
, $result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$actualResult = $result.ToString()
$actualResult | Should -MatchExactly $inputText1
}
It "Validate that streamed text does not have buffer underrun problems ''a' * 30 | Format-Hex'" {
$result = "a" * 30 | Format-Hex
$result | Should -Not -BeNullOrEmpty
$result | Should -BeOfType Microsoft.PowerShell.Commands.ByteCollection
$result[0].ToString() | Should -MatchExactly "0000000000000000 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 aaaaaaaaaaaaaaaa"
$result[1].ToString() | Should -MatchExactly "0000000000000010 61 61 61 61 61 61 61 61 61 61 61 61 61 61 aaaaaaaaaaaaaa "
}
It "Validate that files do not have buffer underrun problems 'Format-Hex -Path `$InputFile4'" {
$result = Format-Hex -Path $InputFile4
$result | Should -Not -BeNullOrEmpty
$result.Count | Should -Be 3
$result[0].ToString() | Should -MatchExactly "0000000000000000 4E 6F 77 20 69 73 20 74 68 65 20 77 69 6E 74 65 Now is the winte"
$result[1].ToString() | Should -MatchExactly "0000000000000010 72 20 6F 66 20 6F 75 72 20 64 69 73 63 6F 6E 74 r of our discont"
$result[2].ToString() | Should -MatchExactly "0000000000000020 65 6E 74 ent "
}
}
Context "Count and Offset parameters" {
It "Count = length" {
$result = Format-Hex -Path $InputFile4 -Count $inputText4.Length
$result | Should -Not -BeNullOrEmpty
$result.Count | Should -Be 3
$result[0].ToString() | Should -MatchExactly "0000000000000000 4E 6F 77 20 69 73 20 74 68 65 20 77 69 6E 74 65 Now is the winte"
$result[1].ToString() | Should -MatchExactly "0000000000000010 72 20 6F 66 20 6F 75 72 20 64 69 73 63 6F 6E 74 r of our discont"
$result[2].ToString() | Should -MatchExactly "0000000000000020 65 6E 74 ent "
}
It "Count = 1" {
$result = Format-Hex -Path $inputFile4 -Count 1
$result.ToString() | Should -MatchExactly "0000000000000000 4E N "
}
It "Offset = length" {
$result = Format-Hex -Path $InputFile4 -Offset $inputText4.Length
$result | Should -BeNullOrEmpty
$result = Format-Hex -InputObject $inputText4 -Offset $inputText4.Length
$result | Should -BeNullOrEmpty
}
It "Offset = 1" {
$result = Format-Hex -Path $InputFile4 -Offset 1
$result | Should -Not -BeNullOrEmpty
$result.Count | Should -Be 3
$result[0].ToString() | Should -MatchExactly "0000000000000001 6F 77 20 69 73 20 74 68 65 20 77 69 6E 74 65 72 ow is the winter"
$result[1].ToString() | Should -MatchExactly "0000000000000011 20 6F 66 20 6F 75 72 20 64 69 73 63 6F 6E 74 65 of our disconte"
$result[2].ToString() | Should -MatchExactly "0000000000000021 6E 74 nt "
}
It "Count = 1 and Offset = 1" {
$result = Format-Hex -Path $inputFile4 -Count 1 -Offset 1
$result.ToString() | Should -MatchExactly "0000000000000001 6F o "
}
It "Count should be > 0" {
{ Format-Hex -Path $inputFile4 -Count 0 } | Should -Throw -ErrorId "ParameterArgumentValidationError,Microsoft.PowerShell.Commands.FormatHex"
}
It "Offset should be >= 0" {
{ Format-Hex -Path $inputFile4 -Offset -1 } | Should -Throw -ErrorId "ParameterArgumentValidationError,Microsoft.PowerShell.Commands.FormatHex"
}
It "Offset = 0" {
$result = Format-Hex -Path $InputFile4 -Offset 0
$result | Should -Not -BeNullOrEmpty
$result.Count | Should -Be 3
$result[0].ToString() | Should -MatchExactly "0000000000000000 4E 6F 77 20 69 73 20 74 68 65 20 77 69 6E 74 65 Now is the winte"
$result[1].ToString() | Should -MatchExactly "0000000000000010 72 20 6F 66 20 6F 75 72 20 64 69 73 63 6F 6E 74 r of our discont"
$result[2].ToString() | Should -MatchExactly "0000000000000020 65 6E 74 ent "
}
}
}
| PowerShell | 5 | rdtechie/PowerShell | test/powershell/Modules/Microsoft.PowerShell.Utility/Format-Hex.Tests.ps1 | [
"MIT"
] |
# Check build decl loading.
#
# RUN: %{llbuild} ninja load-manifest --json %s > %t
# RUN: %{FileCheck} --input-file %t %s
# CHECK: "filename": "json-dumping.ninja"
# CHECK: "bindings": {
# CHECK: "top_level_decl": "1"
top_level_decl = 1
# CHECK: "rules": {
# CHECK: "SOMERULE": {
# CHECK: "command": "the command"
# CHECK: "description": "whatever"
rule SOMERULE
command = the command
description = whatever
# JSON dumps this first, before the commands:
# CHECK: "default_targets": ["output1"],
# CHECK: "commands": [
# CHECK: {
# CHECK: "outputs": ["output1", "output2"],
# CHECK: "rule": "SOMERULE",
# CHECK: "inputs": [],
# CHECK: "deps": "gcc",
# CHECK: "depfile": "deps.d",
# CHECK: "command": "the command",
# CHECK: "description": "whatever"
build output1 output2: SOMERULE
deps = gcc
depfile = deps.d
default output1
| Ninja | 4 | val-verde/swift-llbuild | tests/Ninja/Loader/json-dumping.ninja | [
"Apache-2.0"
] |
#define move_width 16
#define move_height 16
static unsigned char move_bits[] = {
0x80, 0x00, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xc8, 0x09, 0xcc, 0x19,
0xfe, 0x3f, 0xff, 0x7f, 0xfe, 0x3f, 0xcc, 0x19, 0xc8, 0x09, 0xf0, 0x07,
0xe0, 0x03, 0xc0, 0x01, 0x80, 0x00, 0x00, 0x00};
| Mask | 2 | trofi/afterstep | afterstep/desktop/cursors/move.xbm.mask | [
"MIT"
] |
= Hello From RDoc
| RDoc | 0 | kou/sinatra | test/views/hello.rdoc | [
"MIT"
] |
// Check that one cannot subvert Drop Check rule via a user-defined
// Clone implementation.
#![allow(unused_variables, unused_assignments)]
struct D<T:Copy>(T, &'static str);
#[derive(Copy)]
struct S<'a>(&'a D<i32>, &'static str);
impl<'a> Clone for S<'a> {
fn clone(&self) -> S<'a> {
println!("cloning `S(_, {})` and thus accessing: {}", self.1, (self.0).0);
S(self.0, self.1)
}
}
impl<T:Copy> Drop for D<T> {
fn drop(&mut self) {
println!("calling Drop for {}", self.1);
let _call = self.0.clone();
}
}
fn main() {
let (d2, d1);
d1 = D(34, "d1");
d2 = D(S(&d1, "inner"), "d2");
}
//~^^ ERROR `d1` does not live long enough
| Rust | 4 | Eric-Arellano/rust | src/test/ui/span/issue-24895-copy-clone-dropck.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
(ns wisp.test.index
(:require wisp.test.util
wisp.test.sequence
wisp.test.ast
wisp.test.runtime
wisp.test.string
wisp.test.reader
wisp.test.escodegen
;wisp.test.analyzer
))
| wisp | 2 | bamboo/wisp | test/test.wisp | [
"BSD-3-Clause"
] |
p.
This is a large
body of text for
this tag.
Nothing too
exciting. | Jade | 0 | andela-jejezie/peopleProject | node_modules/grunt-mocha-test/node_modules/mocha/node_modules/jade/test.jade | [
"MIT"
] |
(*
* 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.
*)
val init_logger : Unix.file_descr option -> unit
type 'a logger_fn = ?exn:exn -> ('a, unit, string, unit) format4 -> 'a
type 'a logger_fn_s = ?exn:Exception.t -> ('a, unit, string, unit) format4 -> 'a
(* Async APIs *)
val fatal : 'a logger_fn
val error : 'a logger_fn
val warn : 'a logger_fn
val info : 'a logger_fn
val debug : 'a logger_fn
(* Sync APIs *)
val fatal_s : 'a logger_fn_s
val error_s : 'a logger_fn_s
val warn_s : 'a logger_fn_s
val info_s : 'a logger_fn_s
val debug_s : 'a logger_fn_s
| OCaml | 4 | esilkensen/flow | src/monitor/logger/flowServerMonitorLogger.mli | [
"MIT"
] |
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _createSvgIcon = _interopRequireDefault(require("./utils/createSvgIcon"));
var _jsxRuntime = require("react/jsx-runtime");
var _default = (0, _createSvgIcon.default)( /*#__PURE__*/(0, _jsxRuntime.jsx)("path", {
d: "M18 3h-4V2h-4v1H3v8h4.23l.64 4.13L6 17v5h12v-5l-1.87-1.87L18 3zM5 9V5h1.31l.62 4H5zm7 10c-.55 0-1-.45-1-1s.45-1 1-1 1 .45 1 1-.45 1-1 1zm2.29-5H9.72L8.33 5h7.34l-1.38 9z"
}), 'BlenderSharp');
exports.default = _default; | JavaScript | 3 | good-gym/material-ui | packages/material-ui-icons/lib/BlenderSharp.js | [
"MIT"
] |
{-# LANGUAGE CPP, TypeSynonymInstances, FlexibleInstances, MultiParamTypeClasses, FlexibleContexts #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Graphics.UI.FLTK.LowLevel.Base.SingleWindow
(
singleWindowNew,
singleWindowCustom
, handleSingleWindowBase
, resizeSingleWindowBase
, hideSingleWindowBase
, showWidgetSingleWindowBase
-- * Hierarchy
--
-- $hierarchy
-- * Functions
--
-- $functions
)
where
#include "Fl_C.h"
#include "Fl_Single_WindowC.h"
import Foreign
import Foreign.C
import Graphics.UI.FLTK.LowLevel.Fl_Types
import Graphics.UI.FLTK.LowLevel.Fl_Enumerations
import Graphics.UI.FLTK.LowLevel.Utils
import Graphics.UI.FLTK.LowLevel.Dispatch
import qualified Data.Text as T
import Graphics.UI.FLTK.LowLevel.Hierarchy
import Graphics.UI.FLTK.LowLevel.Base.Widget
import Graphics.UI.FLTK.LowLevel.Base.Window
{# fun Fl_OverriddenSingle_Window_New as overriddenWindowNew' {`Int',`Int', id `Ptr ()'} -> `Ptr ()' id #}
{# fun Fl_OverriddenSingle_Window_NewXY as overriddenWindowNewXY' {`Int',`Int', `Int', `Int', id `Ptr ()'} -> `Ptr ()' id #}
{# fun Fl_OverriddenSingle_Window_NewXY_WithLabel as overriddenWindowNewXYWithLabel' { `Int',`Int',`Int',`Int', `CString', id `Ptr ()'} -> `Ptr ()' id #}
{# fun Fl_OverriddenSingle_Window_New_WithLabel as overriddenWindowNewWithLabel' { `Int',`Int', `CString', id `Ptr ()'} -> `Ptr ()' id #}
singleWindowCustom :: Size -- ^ Size of this window
-> Maybe Position -- ^ Optional position of this window
-> Maybe T.Text -- ^ Optional label
-> Maybe (Ref SingleWindow -> IO ()) -- ^ Optional custom drawing function
-> CustomWidgetFuncs SingleWindow -- ^ Custom widget overrides
-> CustomWindowFuncs SingleWindow -- ^ Custom window overrides
-> IO (Ref SingleWindow)
singleWindowCustom size position title draw' customWidgetFuncs' customWindowFuncs' =
windowMaker
size
position
title
draw'
customWidgetFuncs'
customWindowFuncs'
overriddenWindowNew'
overriddenWindowNewWithLabel'
overriddenWindowNewXY'
overriddenWindowNewXYWithLabel'
singleWindowNew :: Size -> Maybe Position -> Maybe T.Text -> IO (Ref SingleWindow)
singleWindowNew size position title =
windowMaker
size
position
title
Nothing
(defaultCustomWidgetFuncs :: CustomWidgetFuncs SingleWindow)
(defaultCustomWindowFuncs :: CustomWindowFuncs SingleWindow)
overriddenWindowNew'
overriddenWindowNewWithLabel'
overriddenWindowNewXY'
overriddenWindowNewXYWithLabel'
{# fun Fl_Single_Window_Destroy as windowDestroy' { id `Ptr ()' } -> `()' supressWarningAboutRes #}
instance (impl ~ (IO ())) => Op (Destroy ()) SingleWindowBase orig impl where
runOp _ _ win = withRef win $ \winPtr -> windowDestroy' winPtr
{# fun Fl_Single_Window_handle as handleSuper' { id `Ptr ()',`Int' } -> `Int' #}
handleSingleWindowBase :: Ref SingleWindowBase -> Event -> IO (Either UnknownEvent ())
handleSingleWindowBase singleWindow event = withRef singleWindow $ \singleWindowPtr -> handleSuper' singleWindowPtr (fromIntegral (fromEnum event)) >>= return . successOrUnknownEvent
{# fun Fl_Single_Window_resize as resizeSuper' { id `Ptr ()',`Int',`Int',`Int',`Int' } -> `()' supressWarningAboutRes #}
resizeSingleWindowBase :: Ref SingleWindowBase -> Rectangle -> IO ()
resizeSingleWindowBase singleWindow rectangle =
let (x_pos, y_pos, width, height) = fromRectangle rectangle
in withRef singleWindow $ \singleWindowPtr -> resizeSuper' singleWindowPtr x_pos y_pos width height
{# fun Fl_Single_Window_hide as hideSuper' { id `Ptr ()' } -> `()' supressWarningAboutRes #}
hideSingleWindowBase :: Ref SingleWindowBase -> IO ()
hideSingleWindowBase singleWindow = withRef singleWindow $ \singleWindowPtr -> hideSuper' singleWindowPtr
{# fun Fl_Single_Window_show as showSuper' { id `Ptr ()' } -> `()' supressWarningAboutRes #}
showWidgetSingleWindowBase :: Ref SingleWindowBase -> IO ()
showWidgetSingleWindowBase singleWindow = withRef singleWindow $ \singleWindowPtr -> showSuper' singleWindowPtr
{# fun Fl_DerivedSingle_Window_hide as hide' { id `Ptr ()' } -> `()' supressWarningAboutRes #}
instance (impl ~ ( IO ())) => Op (Hide ()) SingleWindowBase orig impl where
runOp _ _ window = withRef window $ \windowPtr -> hide' windowPtr
{# fun Fl_DerivedSingle_Window_show as windowShow' {id `Ptr ()'} -> `()' supressWarningAboutRes #}
instance (impl ~ (IO ())) => Op (ShowWidget ()) SingleWindowBase orig impl where
runOp _ _ window = withRef window (\p -> windowShow' p)
{#fun Fl_DerivedSingle_Window_handle as windowHandle'
{ id `Ptr ()', id `CInt' } -> `Int' #}
instance (impl ~ (Event -> IO (Either UnknownEvent ()))) => Op (Handle ()) SingleWindowBase orig impl where
runOp _ _ window event = withRef window (\p -> windowHandle' p (fromIntegral . fromEnum $ event)) >>= return . successOrUnknownEvent
{# fun Fl_DerivedSingle_Window_resize as resize' { id `Ptr ()',`Int',`Int',`Int',`Int' } -> `()' supressWarningAboutRes #}
instance (impl ~ (Rectangle -> IO ())) => Op (Resize ()) SingleWindowBase orig impl where
runOp _ _ window rectangle = withRef window $ \windowPtr -> do
let (x_pos,y_pos,w_pos,h_pos) = fromRectangle rectangle
resize' windowPtr x_pos y_pos w_pos h_pos
-- $hierarchy
-- @
-- "Graphics.UI.FLTK.LowLevel.Base.Widget"
-- |
-- v
-- "Graphics.UI.FLTK.LowLevel.Base.Group"
-- |
-- v
-- "Graphics.UI.FLTK.LowLevel.Base.Window"
-- |
-- v
-- "Graphics.UI.FLTK.LowLevel.Base.SingleWindow"
-- @
-- $functions
-- @
-- destroy :: 'Ref' 'SingleWindowBase' -> 'IO' ()
--
-- handle :: 'Ref' 'SingleWindowBase' -> 'Event' -> 'IO' ('Either' 'UnknownEvent' ())
--
-- hide :: 'Ref' 'SingleWindowBase' -> 'IO' ()
--
-- resize :: 'Ref' 'SingleWindowBase' -> 'Rectangle' -> 'IO' ()
--
-- showWidget :: 'Ref' 'SingleWindowBase' -> 'IO' ()
-- @
| C2hs Haskell | 4 | ericu/fltkhs | src/Graphics/UI/FLTK/LowLevel/Base/SingleWindow.chs | [
"MIT"
] |
// 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 "library.al"
GLOBAL-MACROS {
LET global_is_subclass_of(x) =
is_class(x) HOLDS-IN-SOME-SUPERCLASS-OF ObjCInterfaceDecl;
LET parameter_of_type(x) =
WHEN
has_type(x)
HOLDS-IN-NODE ParmVarDecl;
LET method_has_a_parameter_with_type(x) =
WHEN
HOLDS-NEXT WITH-TRANSITION Parameters
(has_type(x))
HOLDS-IN-NODE ObjCMethodDecl;
LET method_has_at_least_a_parameter =
WHEN
HOLDS-NEXT WITH-TRANSITION Parameters
(TRUE)
HOLDS-IN-NODE ObjCMethodDecl;
LET method_has_all_parameter_with_type(x) =
WHEN
HOLDS-EVERYWHERE-NEXT WITH-TRANSITION Parameters
(has_type(x))
HOLDS-IN-NODE ObjCMethodDecl;
};
GLOBAL-PATHS {
LET filtered_files = {REGEXP("codetoanalyze/objc/linters-for-test-only/filter_by_path/.*") };
};
//Check that class A is not subclassed.
DEFINE-CHECKER SUBCLASSING_TEST_EXAMPLE = {
SET report_when =
is_class("A") HOLDS-IN-SOME-SUPERCLASS-OF ObjCInterfaceDecl;
SET message = "This is subclassing A. Class A should not be subclassed.";
};
DEFINE-CHECKER MACRO_TEST1 = {
LET call_two_methods(x,y) = call_method(x) OR call_method(y);
SET report_when = call_two_methods("foo:", "bar");
SET message = "Error message here";
};
// Test reverse parameter of macro
DEFINE-CHECKER MACRO_TEST2 = {
LET my_macro_to_call_method_of_class(x,y) = call_instance_method(x) AND is_receiver_class_named(y);
SET report_when = my_macro_to_call_method_of_class("foo:", "A");
SET message = "Error message here";
};
// Test macro call macro
DEFINE-CHECKER MACRO_TEST3 = {
LET my_macro_to_call_method_of_class(x,y) = call_instance_method(x) AND is_receiver_class_named(y);
LET call_my_macro(t,v) = my_macro_to_call_method_of_class(t,v);
SET report_when = call_my_macro("foo:", "A");
SET message = "Error message here";
};
DEFINE-CHECKER LOCAL_MACRO_SUBCLASS = {
LET is_subclass_of(x) =
is_class(x) HOLDS-IN-SOME-SUPERCLASS-OF ObjCInterfaceDecl;
SET report_when = is_subclass_of("A");
SET message = "This is subclassing A. Class A should not be subclassed.";
};
DEFINE-CHECKER GLOBAL_MACRO_SUBCLASS = {
SET report_when = global_is_subclass_of("A");
SET message = "This is subclassing A. Class A should not be subclassed.";
};
DEFINE-CHECKER IMPORTED_MACRO_SUBCLASS = {
SET report_when = imported_is_subclass_of("A");
SET message = "This is subclassing A. Class A should not be subclassed.";
};
DEFINE-CHECKER TEST_ALL_METHODS = {
SET report_when = call_class_method(REGEXP(".*"));
SET message = "Method call...";
};
DEFINE-CHECKER TEST_RETURN_METHOD = {
SET report_when =
WHEN
method_return_type("int")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method return int";
};
DEFINE-CHECKER TEST_BUILTIN_TYPE = {
SET report_when =
WHEN
is_in_objc_class_named("TestType") AND
(method_return_type("void")
OR method_return_type("bool")
OR method_return_type("char")
OR method_return_type("unsigned char")
OR method_return_type("wchar_t")
OR method_return_type("unsigned short")
OR method_return_type("unsigned int")
OR method_return_type("unsigned long")
OR method_return_type("unsigned long long")
OR method_return_type("__int128")
OR method_return_type("unsigned __int128")
OR method_return_type("signed char")
OR method_return_type("short")
OR method_return_type("int")
OR method_return_type("long")
OR method_return_type("long long")
OR method_return_type("float")
OR method_return_type("double")
OR method_return_type("long double")
OR method_return_type("id")
OR method_return_type("Class")
OR method_return_type("SEL")
OR method_return_type("float *")
OR method_return_type("unsigned int **")
OR method_return_type("A*")
OR method_return_type("REGEXP('This.+')*" ))
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method return.....";
};
DEFINE-CHECKER TEST_IMPLICIT_CAST_CHECK = {
LET has_type_long_expr = has_type("long") HOLDS-EVENTUALLY;
SET report_when =
WHEN
has_type("int") AND has_type_long_expr
HOLDS-IN-NODE ImplicitCastExpr;
SET message = "An implicit cast from long to int can cause a crash";
};
DEFINE-CHECKER TEST_VAR_TYPE_CHECK = {
SET report_when =
WHEN has_type("int") OR has_type("long")
HOLDS-IN-NODE VarDecl;
SET message = "Var has type int or long";
};
DEFINE-CHECKER TEST_TYPEDEF_CHECK = {
SET report_when =
WHEN
has_type("my_ulong") OR
has_type("my_pS") OR
has_type("my_listNode")
HOLDS-IN-NODE VarDecl;
SET message = "Var has type....";
};
DEFINE-CHECKER TEST_PARAM_TYPE_CHECK = {
SET report_when =
method_has_a_parameter_with_type("REGEXP('This.+')*" );
SET message = "Found a method with a parameter of type....";
};
DEFINE-CHECKER TEST_PARAM_TYPE_CHECK2 = {
SET report_when = method_has_at_least_a_parameter AND
method_has_all_parameter_with_type("int");
SET message = "Found a method with a parameter of type....";
};
DEFINE-CHECKER TEST_NTH_PARAM_TYPE_CHECK = {
SET report_when =
WHEN
HOLDS-NEXT WITH-TRANSITION ParameterPos "2"
(has_type("REGEXP('This.+')*"))
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Found a method with nth parameter of type....";
SET severity = "LIKE";
};
DEFINE-CHECKER TEST_NTH_PARAM_TYPE_CHECK_FUNCTION = {
SET report_when =
WHEN
HOLDS-NEXT WITH-TRANSITION ParameterPos "1"
(has_value("2") HOLDS-EVENTUALLY)
HOLDS-IN-NODE CallExpr;
SET message = "Found a method with nth parameter of type....";
SET severity = "LIKE";
};
DEFINE-CHECKER TEST_PROTOCOL_DEF_INHERITANCE = {
LET is_subprotocol_of(x) =
declaration_has_name(x) HOLDS-EVENTUALLY WITH-TRANSITION Protocol;
SET report_when =
WHEN
is_subprotocol_of("A")
HOLDS-IN-NODE ObjCProtocolDecl;
SET message = "Protocol inherit from A";
};
DEFINE-CHECKER TEST_PROTOCOL_TYPE_INHERITANCE = {
LET method_has_parameter_subprotocol_of(x) =
WHEN
HOLDS-NEXT WITH-TRANSITION Parameters
(has_type_subprotocol_of(x))
HOLDS-IN-NODE ObjCMethodDecl;
SET report_when =
WHEN
declaration_has_name(REGEXP("^newWith.*:$")) AND
method_has_parameter_subprotocol_of("A")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method declared with parameter whose type inherit from protocol A";
};
DEFINE-CHECKER TEST_GENERICS_TYPE = {
LET method_has_parameter_type(x) =
WHEN
HOLDS-NEXT WITH-TRANSITION Parameters
(has_type(x))
HOLDS-IN-NODE ObjCMethodDecl;
SET report_when =
WHEN
method_has_parameter_type ("NSArray<id<C>>*")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method declared with parameter whose type NSArray<id<C>>*";
};
DEFINE-CHECKER TEST_INSTANCE_TYPE = {
SET report_when =
WHEN
has_type("instancetype")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method declared has return type instancetype";
};
DEFINE-CHECKER TEST_DEFINE_NAMESPACE = {
SET report_when =
WHEN
declaration_has_name(REGEXP("FirstNam*"))
HOLDS-IN-NODE NamespaceDecl;
SET message = "Found a namespace with name....";
};
DEFINE-CHECKER TEST_USING_NAMESPACE = {
SET report_when =
using_namespace(REGEXP("FirstNam*"));
SET message = "Found using namespace with name....";
};
DEFINE-CHECKER FILTER_BY_PATH_EXAMPLE = {
SET report_when =
WHEN declaration_has_name("main")
HOLDS-IN-NODE FunctionDecl;
SET message = "Found main method";
SET allow_list_path = { filtered_files, "A.m" };
};
DEFINE-CHECKER ALL_PATH_NO_FILTER_EXAMPLE = {
SET report_when =
WHEN declaration_has_name("main")
HOLDS-IN-NODE FunctionDecl;
SET message = "Found main method";
};
DEFINE-CHECKER FILTER_BY_ALL_PATH_EXAMPLE = {
SET report_when =
WHEN declaration_has_name("main")
HOLDS-IN-NODE FunctionDecl;
SET message = "Found main method";
SET allow_list_path = { REGEXP(".*") };
};
DEFINE-CHECKER BLOCK_LIST_PATH_EXAMPLE = {
SET report_when =
WHEN declaration_has_name("main")
HOLDS-IN-NODE FunctionDecl;
SET message = "Found main method";
SET block_list_path = { REGEXP("codetoanalyze/objc/linters-for-test-only/filter_by_path/.*") };
};
DEFINE-CHECKER ALLOW_BLOCK_LIST_PATH_EXAMPLE = {
SET report_when =
WHEN declaration_has_name("main")
HOLDS-IN-NODE FunctionDecl;
SET message = "Found main method";
SET allow_list_path = { all_files };
SET block_list_path = { filtered_files };
SET doc_url = "www.example.com";
};
DEFINE-CHECKER ENUM_CONSTANTS = {
SET report_when = is_enum_constant(REGEXP("MyName.*")) OR is_enum_constant("IMMEDIATE");
SET message = "Do not use the enum MyName or strategy";
};
DEFINE-CHECKER ENUM_CONSTANTS_OF_ENUM = {
SET report_when = is_enum_constant_of_enum("MyName");
SET message = "Do not use the enum MyName";
};
DEFINE-CHECKER TEST_SELECTOR = {
SET report_when = is_at_selector_with_name("actionButtonTapped:");
SET message = "Found @selector(actionButtonTapped:)";
};
DEFINE-CHECKER TEST_DEFAULT_VISIBILITY = {
SET report_when =
WHEN has_visibility_attribute("Default")
HOLDS-IN-NODE CallExpr;
SET message = "%name% has default visibility";
};
DEFINE-CHECKER TEST_HIDDEN_VISIBILITY = {
SET report_when =
WHEN has_visibility_attribute("Hidden")
HOLDS-IN-NODE CallExpr;
SET message = "%name% has hidden visibility";
};
DEFINE-CHECKER TEST_USED_ATTRIBUTE = {
SET report_when =
WHEN has_used_attribute()
HOLDS-IN-NODE CallExpr;
SET message = "%name% has used attribute";
};
DEFINE-CHECKER TEST_DEFAULT_VISIBILITY_WITH_USED_ATTRIBUTE = {
SET report_when =
WHEN has_visibility_attribute("Default") AND has_used_attribute
HOLDS-IN-NODE CallExpr;
SET message = "%name% has default visibility and used attribute";
};
DEFINE-CHECKER TEST_IN_METHOD_CONTEXT = {
SET report_when =
WHEN declaration_has_name("x") AND is_in_objc_method("method")
HOLDS-IN-NODE VarDecl;
SET message = "var %name% declared in ObjC method";
};
DEFINE-CHECKER TEST_IN_BLOCK_CONTEXT = {
SET report_when =
WHEN declaration_has_name("x") AND is_in_block()
HOLDS-IN-NODE VarDecl;
SET message = "var %name% declared in block";
};
DEFINE-CHECKER TEST_IN_FUNCTION_CONTEXT = {
SET report_when =
WHEN declaration_has_name("x") AND is_in_function(REGEXP("funct.*"))
HOLDS-IN-NODE VarDecl;
SET message = "var %name% declared in function";
};
DEFINE-CHECKER TEST_PARAMETER_SEL_TYPE = {
SET report_when =
WHEN
method_return_type("instancetype") AND
method_has_a_parameter_with_type("SEL")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method has parameter of type SEL";
};
DEFINE-CHECKER IN_SUBCLASS_TEST = {
SET report_when =
WHEN is_in_objc_subclass_of("SubClassTestClass")
HOLDS-IN-NODE ObjCMessageExpr;
SET message = "Found a message call in a class that is not subclass of A.";
};
DEFINE-CHECKER TEST_IF_VIEW_METHOD_IS_NOT_CALLED_WITH_SUPER = {
SET report_when =
WHEN
call_method("testView") AND
NOT is_method_called_by_superclass()
HOLDS-IN-NODE ObjCMessageExpr;
SET message = "Method %name% is not called with super.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_INTERFACE_NAMED = {
SET report_when =
WHEN
is_in_objc_interface_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the interface named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_IMPLEMENTATION_NAMED = {
SET report_when =
WHEN
is_in_objc_implementation_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the implementation named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CLASS_NAMED = {
SET report_when =
WHEN
is_in_objc_class_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_INTERFACE_NAMED = {
SET report_when =
WHEN
is_in_objc_category_interface_named("MyBaseClassCategory")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category interface named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_IMPLEMENTATION_NAMED = {
SET report_when =
WHEN
is_in_objc_category_implementation_named("MyBaseClassCategory")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category implementation named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_NAMED = {
SET report_when =
WHEN
is_in_objc_category_named("MyBaseClassCategory")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_INTERFACE_ON_CLASS_NAMED = {
SET report_when =
WHEN
is_in_objc_category_interface_on_class_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category interface on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_IMPLEMENATION_ON_CLASS_NAMED = {
SET report_when =
WHEN
is_in_objc_category_implementation_on_class_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category implementation on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_ON_CLASS_NAMED = {
SET report_when =
WHEN
is_in_objc_category_on_class_named("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_INTERFACE_ON_SUBCLASS_OF = {
SET report_when =
WHEN
is_in_objc_category_interface_on_subclass_of("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category interface on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_IMPLEMENTATION_ON_SUBCLASS_OF = {
SET report_when =
WHEN
is_in_objc_category_implementation_on_subclass_of("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category implementation on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_CATEGORY_ON_SUBCLASS_OF = {
SET report_when =
WHEN
is_in_objc_category_on_subclass_of("MyBaseClass")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the category on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_METHOD_IS_IN_PROTOCOL_NAMED = {
SET report_when =
WHEN
is_in_objc_protocol_named("MyBaseClassProtocol")
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "Method %name% is in the protocol named MyBaseClassProtocol.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_INTERFACE_NAMED = {
SET report_when =
is_objc_category_interface_named("MyBaseClassCategory");
SET message = "Node is a category interface named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_IMPLEMENTATION_NAMED = {
SET report_when =
is_objc_category_implementation_named("MyBaseClassCategory");
SET message = "Node is a category implementation named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_NAMED = {
SET report_when =
is_objc_category_named("MyBaseClassCategory");
SET message = "Node is a category named MyBaseClassCategory.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_INTERFACE_ON_CLASS_NAMED = {
SET report_when =
is_objc_category_interface_on_class_named("MyBaseClass");
SET message = "Node is a category interface on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_IMPLEMENTATION_ON_CLASS_NAMED = {
SET report_when =
is_objc_category_implementation_on_class_named("MyBaseClass");
SET message = "Node is a category implementation on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_ON_CLASS_NAMED = {
SET report_when =
is_objc_category_on_class_named("MyBaseClass");
SET message = "Node is a category on a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_INTERFACE_ON_SUBCLASS_OF = {
SET report_when =
is_objc_category_interface_on_subclass_of("MyBaseClass");
SET message = "Node is a category interface on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_IMPLEMENTATION_ON_SUBCLASS_OF = {
SET report_when =
is_objc_category_implementation_on_subclass_of("MyBaseClass");
SET message = "Node is a category implementation on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CATEGORY_ON_SUBCLASS_OF = {
SET report_when =
is_objc_category_on_subclass_of("MyBaseClass");
SET message = "Node is a category on a subclass of MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_IMPLEMENTATION_NAMED = {
SET report_when =
is_objc_implementation_named("MyBaseClass");
SET message = "Node is an implementation named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_CLASS_NAMED = {
SET report_when =
is_objc_class_named("MyBaseClass");
SET message = "Node is a class named MyBaseClass.";
};
DEFINE-CHECKER TEST_IF_IS_PROTOCOL_NAMED = {
SET report_when =
is_objc_protocol_named("MyBaseClassProtocol");
SET message = "Node is a protocol named MyBaseClassProtocol.";
};
DEFINE-CHECKER TEST_IF_IS_CLASS_METHOD_NAMED = {
SET report_when =
is_objc_class_method_named("myBaseClassClassMethod");
SET message = "Node is a class method named myBaseClassClassMethod.";
};
DEFINE-CHECKER TEST_IF_IS_INSTANCE_METHOD_NAMED = {
SET report_when =
is_objc_instance_method_named("mySubclassMethod");
SET message = "Node is an instance method named mySubclassMethod.";
};
DEFINE-CHECKER TEST_IF_IS_METHOD_NAMED = {
SET report_when =
is_objc_method_named("mySubclassMethod") OR
is_objc_method_named("myBaseClassClassMethod");
SET message = "Node is a method named mySubclassMethod or myBaseClassClassMethod.";
};
DEFINE-CHECKER TEST_IS_OVERRIDING_METHOD = {
SET report_when =
is_objc_method_overriding;
SET message = "Method %name% is overriding a method in a superclass.";
};
DEFINE-CHECKER TEST_IS_METHOD_EXPOSED = {
SET report_when =
is_objc_method_exposed;
SET message = "Method %name% is exposed in an interface.";
};
DEFINE-CHECKER TEST_IN_CLASS_METHOD = {
SET report_when =
is_in_objc_class_method("myBaseClassClassMethod");
SET message = "This node is in a class method named myBaseClassClassMethod.";
};
DEFINE-CHECKER TEST_IN_INSTANCE_METHOD = {
SET report_when =
is_in_objc_instance_method("myBaseClassMethod");
SET message = "This node is in an instance method named myBaseClassClassMethod.";
};
DEFINE-CHECKER TEST_IS_RECEIVER_CLASS_TYPE = {
SET report_when =
is_receiver_objc_class_type;
SET message = "This node is a method call to 'Class'.";
};
DEFINE-CHECKER TEST_IS_RECEIVER_ID_TYPE = {
SET report_when =
is_receiver_objc_id_type;
SET message = "This node is a method call to 'id'.";
};
DEFINE-CHECKER TEST_IS_RECEIVER_SUBCLASS_OF = {
SET report_when =
is_receiver_subclass_of("MyBaseClass");
SET message = "This node is a method call to an object which inherits from 'MyBaseClass'.";
};
DEFINE-CHECKER TEST_IS_RECEIVER_CLASS_NAMED = {
SET report_when =
is_receiver_class_named("MyBaseClass");
SET message = "This node is a method call to an object of class 'MyBaseClass'.";
};
DEFINE-CHECKER TEST_IS_RECEIVER_SUPER = {
SET report_when =
is_receiver_super();
SET message = "This node is a method call to 'super'.";
};
DEFINE-CHECKER CONST_NAMING = {
SET report_when = WHEN
is_qual_type_const()
HOLDS-IN-NODE VarDecl;
SET message = "That's a const";
};
DEFINE-CHECKER UNNECESSARY_OBJC_INSTANCE_METHOD = {
LET is_in_implementation =
is_in_objc_implementation_named(REGEXP(".*")) OR
is_in_objc_category_implementation_named(REGEXP(".*"));
LET dereference_self =
declaration_ref_name(REGEXP("self")) HOLDS-EVENTUALLY;
LET dereference_self_in_opaque_value_expr =
IN-NODE OpaqueValueExpr WITH-TRANSITION SourceExpr
(dereference_self)
HOLDS-EVENTUALLY;
LET dereference_self_in_method_decl =
IN-NODE ObjCMethodDecl WITH-TRANSITION Body
(dereference_self OR dereference_self_in_opaque_value_expr)
HOLDS-EVENTUALLY;
LET is_private_method =
declaration_has_name(REGEXP("^_")) AND
NOT is_objc_method_exposed AND
(NOT dereference_self_in_method_decl)
AND is_in_implementation;
SET report_when =
WHEN
is_private_method
HOLDS-IN-NODE ObjCMethodDecl;
SET name = "Unnecessary Objective-C Method";
SET message = "This is an unnecessary Objective-C Method";
SET severity = "ERROR";
SET mode = "ON";
};
DEFINE-CHECKER TEST_UNAVAILABLE_ATTR = {
SET report_when =
has_unavailable_attribute;
SET message = "This node has unavailable attribute";
};
DEFINE-CHECKER TEST_IS_OPTIONAL_METHOD = {
SET report_when =
WHEN
is_optional_objc_method
HOLDS-IN-NODE ObjCMethodDecl;
SET message = "This is an optional method";
};
DEFINE-CHECKER IVAR_CAPTURED_IN_OBJC_BLOCK = {
SET report_when =
WHEN
objc_block_is_capturing_var_of_type("Ivars*")
HOLDS-IN-NODE BlockDecl;
SET message = "Found ivar of a given type captured in block";
SET severity = "ERROR";
SET mode = "ON";
};
DEFINE-CHECKER CALLS_TO_FUNCTIONS_WITH_CREATE_FUNCTION_PARAMETERS = {
LET is_create_method_parameter = HOLDS-NEXT WITH-TRANSITION Parameters
(call_function(REGEXP(".*Create.*")) AND has_type("REGEXP('__C.+')*"));
SET report_when =
WHEN
is_create_method_parameter
HOLDS-IN-NODE CallExpr;
};
DEFINE-CHECKER CLASS_AND_VAR = {
LET global_var_exists =
is_node("VarDecl");
LET var_decl =
(HOLDS-NEXT WITH-TRANSITION Sibling
(global_var_exists()));
SET report_when =
WHEN (var_decl() AND declaration_has_name("SiblingExample"))
HOLDS-IN-NODE ObjCInterfaceDecl;
SET message = "Found a global var next to a class";
};
DEFINE-CHECKER CAT_DECL_MACRO = {
LET is_linkable_var =
is_extern_var() AND
declaration_has_name(REGEXP("Linkable_.*")) AND
has_type("char");
LET var_decls =
HOLDS-NEXT WITH-TRANSITION Sibling
(is_node("VarDecl") AND is_linkable_var());
SET report_when =
WHEN
NOT (
is_node("ObjCCategoryDecl")
AND-WITH-WITNESSES var_decls() : decl_name_is_contained_in_name_of_decl()
)
HOLDS-IN-NODE ObjCCategoryDecl;
SET message = "A category is defined without the corresponding macro";
};
DEFINE-CHECKER CAT_IMPL_MACRO = {
LET is_linkable_var =
has_visibility_attribute("Default") AND
declaration_has_name(REGEXP("Linkable_.*")) AND
has_type("char");
LET var_decls =
HOLDS-NEXT WITH-TRANSITION Sibling
(is_node("VarDecl") AND is_linkable_var());
SET report_when =
WHEN
NOT (
is_node("ObjCCategoryImplDecl")
AND-WITH-WITNESSES var_decls() : decl_name_is_contained_in_name_of_decl()
) HOLDS-IN-NODE ObjCCategoryImplDecl;
SET message = "A category is implemented without the corresponding macro";
};
| Perl | 3 | niranthhr/facebook_prj | infer/tests/codetoanalyze/objc/linters-for-test-only/al_definitions/linters_example.al | [
"MIT"
] |
/*****************************************************************************
*
* QUERY:
* VACUUM
* ANALYZE
*
*****************************************************************************/
VacuumStmt: VACUUM opt_full opt_freeze opt_verbose
{
PGVacuumStmt *n = makeNode(PGVacuumStmt);
n->options = PG_VACOPT_VACUUM;
if ($2)
n->options |= PG_VACOPT_FULL;
if ($3)
n->options |= PG_VACOPT_FREEZE;
if ($4)
n->options |= PG_VACOPT_VERBOSE;
n->relation = NULL;
n->va_cols = NIL;
$$ = (PGNode *)n;
}
| VACUUM opt_full opt_freeze opt_verbose qualified_name
{
PGVacuumStmt *n = makeNode(PGVacuumStmt);
n->options = PG_VACOPT_VACUUM;
if ($2)
n->options |= PG_VACOPT_FULL;
if ($3)
n->options |= PG_VACOPT_FREEZE;
if ($4)
n->options |= PG_VACOPT_VERBOSE;
n->relation = $5;
n->va_cols = NIL;
$$ = (PGNode *)n;
}
| VACUUM opt_full opt_freeze opt_verbose AnalyzeStmt
{
PGVacuumStmt *n = (PGVacuumStmt *) $5;
n->options |= PG_VACOPT_VACUUM;
if ($2)
n->options |= PG_VACOPT_FULL;
if ($3)
n->options |= PG_VACOPT_FREEZE;
if ($4)
n->options |= PG_VACOPT_VERBOSE;
$$ = (PGNode *)n;
}
| VACUUM '(' vacuum_option_list ')'
{
PGVacuumStmt *n = makeNode(PGVacuumStmt);
n->options = PG_VACOPT_VACUUM | $3;
n->relation = NULL;
n->va_cols = NIL;
$$ = (PGNode *) n;
}
| VACUUM '(' vacuum_option_list ')' qualified_name opt_name_list
{
PGVacuumStmt *n = makeNode(PGVacuumStmt);
n->options = PG_VACOPT_VACUUM | $3;
n->relation = $5;
n->va_cols = $6;
if (n->va_cols != NIL) /* implies analyze */
n->options |= PG_VACOPT_ANALYZE;
$$ = (PGNode *) n;
}
;
vacuum_option_elem:
analyze_keyword { $$ = PG_VACOPT_ANALYZE; }
| VERBOSE { $$ = PG_VACOPT_VERBOSE; }
| FREEZE { $$ = PG_VACOPT_FREEZE; }
| FULL { $$ = PG_VACOPT_FULL; }
| IDENT
{
if (strcmp($1, "disable_page_skipping") == 0)
$$ = PG_VACOPT_DISABLE_PAGE_SKIPPING;
else
ereport(ERROR,
(errcode(PG_ERRCODE_SYNTAX_ERROR),
errmsg("unrecognized VACUUM option \"%s\"", $1),
parser_errposition(@1)));
}
;
opt_full: FULL { $$ = true; }
| /*EMPTY*/ { $$ = false; }
;
vacuum_option_list:
vacuum_option_elem { $$ = $1; }
| vacuum_option_list ',' vacuum_option_elem { $$ = $1 | $3; }
;
opt_freeze: FREEZE { $$ = true; }
| /*EMPTY*/ { $$ = false; }
;
| Yacc | 4 | AldoMyrtaj/duckdb | third_party/libpg_query/grammar/statements/vacuum.y | [
"MIT"
] |
# Check basic lexing functionality.
#
# RUN: %{llbuild} ninja lex %s 2> %t.err
# RUN: %{FileCheck} < %t.err %s
# CHECK: (Token "Comment" String:{{.*}} Length:70 Line:[[@LINE+1]] Column:0)
# This is a 70 character comment (which does not include the newline).
# CHECK: (Token "Colon" String:":" Length:1 Line:[[@LINE+1]] Column:0)
:
# CHECK: (Token "Pipe" String:"|" Length:1 Line:[[@LINE+1]] Column:0)
|
# CHECK: (Token "PipePipe" String:"||" Length:2 Line:[[@LINE+1]] Column:0)
||
# CHECK: (Token "Identifier" String:"a" Length:1 Line:[[@LINE+3]] Column:0)
# CHECK: (Token "Equals" String:"=" Length:1 Line:[[@LINE+2]] Column:1)
# CHECK: (Token "Identifier" String:"b" Length:1 Line:[[@LINE+1]] Column:3)
a= b
# CHECK: (Token "Identifier" String:"a" Length:1 Line:[[@LINE+3]] Column:0)
# CHECK: (Token "Colon" String:":" Length:1 Line:[[@LINE+2]] Column:1)
# CHECK: (Token "Identifier" String:"b" Length:1 Line:[[@LINE+1]] Column:3)
a: b
# CHECK: (Token "Identifier" String:"a" Length:1 Line:[[@LINE+3]] Column:0)
# CHECK: (Token "Unknown" String:"$" Length:1 Line:[[@LINE+2]] Column:1)
# CHECK: (Token "Identifier" String:"b" Length:1 Line:[[@LINE+1]] Column:2)
a$b
# Check indentation tokens.
#
# CHECK: (Token "Indentation" String:" " Length:4 Line:[[@LINE+2]] Column:0)
# CHECK: (Token "Identifier" String:"b" Length:1 Line:[[@LINE+1]] Column:4)
b
# Check keyword tokens.
#
# CHECK: (Token "KWBuild" String:"build" Length:5 Line:[[@LINE+1]] Column:0)
build
# CHECK: (Token "KWDefault" String:"default" Length:7 Line:[[@LINE+1]] Column:0)
default
# CHECK: (Token "KWInclude" String:"include" Length:7 Line:[[@LINE+1]] Column:0)
include
# CHECK: (Token "KWPool" String:"pool" Length:4 Line:[[@LINE+1]] Column:0)
pool
# CHECK: (Token "KWRule" String:"rule" Length:4 Line:[[@LINE+1]] Column:0)
rule
# CHECK: (Token "KWSubninja" String:"subninja" Length:8 Line:[[@LINE+1]] Column:0)
subninja
# CHECK: (Token "EndOfFile" String:{{.*}} Length:0 Line:[[@LINE+1]] Column:0)
| Ninja | 4 | uraimo/swift-llbuild | tests/Ninja/Lexer/basic.ninja | [
"Apache-2.0"
] |
// @target: ES6
// @module: commonjs
// @filename: existingModule.ts
export var x = 1;
// @filename: test.ts
import {x} from './existingModule';
import {foo} from './missingModule';
declare function use(a: any): void;
const test = { x, foo };
use(x);
use(foo); | TypeScript | 3 | nilamjadhav/TypeScript | tests/cases/compiler/shorthandPropertyAssignmentInES6Module.ts | [
"Apache-2.0"
] |
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon([/*#__PURE__*/_jsx("path", {
d: "M12 4h2v2h-2V4zM7 14H5v-2h2v2zm12 6h-2v-2h2v2z",
opacity: ".3"
}, "0"), /*#__PURE__*/_jsx("path", {
d: "M15 16v1.26l-6-3v-3.17L11.7 8H16V2h-6v4.9L7.3 10H3v6h5l7 3.5V22h6v-6h-6zM12 4h2v2h-2V4zM7 14H5v-2h2v2zm12 6h-2v-2h2v2z"
}, "1")], 'PolylineTwoTone'); | JavaScript | 3 | dany-freeman/material-ui | packages/mui-icons-material/lib/esm/PolylineTwoTone.js | [
"MIT"
] |
static const uint16_t in_com1[256] = {
0xb38e, 0xb34f, 0xb222, 0x360e, 0x319c, 0xb333, 0xb4d1, 0xb13d,
0x3661, 0x32d6, 0x3554, 0x8ebc, 0x3608, 0x365e, 0xb1ab, 0x3adb,
0x3451, 0xb57c, 0xb2a7, 0xaec7, 0x31fe, 0xb61a, 0x35aa, 0x378c,
0xb44f, 0xb5ad, 0xb04b, 0xb253, 0xb298, 0xae97, 0x38c7, 0xbad4,
0xb858, 0xb5e2, 0x3b87, 0xb7ba, 0x3858, 0xb87b, 0x3bd0, 0x2c91,
0x3b4e, 0x30f2, 0xb92e, 0x2e09, 0xaa10, 0xb054, 0x33c9, 0x3644,
0x3313, 0x318e, 0xb58a, 0x39dd, 0x362d, 0x2ce0, 0x3109, 0x34fe,
0xb50e, 0xa97a, 0x2d18, 0xb320, 0x38d0, 0x3272, 0xaa62, 0xb37e,
0xb53d, 0xb48f, 0x3481, 0x2b45, 0xb279, 0xb427, 0x380a, 0xb120,
0xace3, 0x30a9, 0x3c00, 0x3154, 0xb35b, 0x99af, 0xb658, 0xb1b4,
0xa935, 0x3295, 0x34ab, 0xb5ba, 0x374e, 0xb0d2, 0x38b5, 0xb1cb,
0x269a, 0xb08f, 0x3000, 0xb0af, 0xb71b, 0x3595, 0x31ff, 0x2d68,
0x35ae, 0xb6f5, 0xb401, 0x3326, 0x28f3, 0x376a, 0x3673, 0x2d28,
0x381f, 0xb435, 0x30d9, 0xb2f9, 0x3bab, 0x29f6, 0xad8d, 0xb4e9,
0x1968, 0xb4bd, 0x3289, 0xb185, 0xb17c, 0x26c1, 0xa41d, 0x263d,
0xb4f7, 0xba4d, 0xb843, 0x36d4, 0xb212, 0x3065, 0xad85, 0xb370,
0x2e69, 0xba35, 0x3478, 0xb078, 0x3577, 0xab81, 0xb9a7, 0x2f5d,
0x37ba, 0x3043, 0x38bd, 0xaadd, 0x32f8, 0xb429, 0x38fb, 0x2b8d,
0x3811, 0xb3f2, 0xb7b6, 0xb4eb, 0xadbc, 0x38c0, 0xa997, 0x380a,
0x3257, 0x33dd, 0xac9a, 0x3045, 0x3129, 0xaf02, 0x2cfa, 0xb798,
0xb534, 0xb957, 0x37af, 0x3034, 0xaa88, 0xb6b4, 0x334b, 0x324b,
0xb329, 0x371a, 0xb224, 0x2efd, 0x34f2, 0xaf8a, 0x3634, 0xb817,
0x39ea, 0xb14a, 0xb687, 0x359c, 0x3907, 0xb45f, 0x35da, 0xb299,
0xbacc, 0x3068, 0xb535, 0x2a17, 0x9dda, 0xb46d, 0x3123, 0x3115,
0xa8e0, 0x3305, 0x35fe, 0x2cd2, 0x3a10, 0xb34d, 0xb6e5, 0xa512,
0xa831, 0x37d8, 0xa531, 0xb371, 0xb076, 0xa8c5, 0xb5a6, 0x9864,
0xb89f, 0xb32c, 0xb401, 0x345d, 0x346c, 0xac98, 0x3049, 0x2c83,
0x36a8, 0x2961, 0xb00f, 0xb5a9, 0xb4b3, 0x2b67, 0xb779, 0x3104,
0x3747, 0xb8e3, 0x2891, 0xb910, 0xb597, 0xb5c5, 0x3541, 0x2c3d,
0x3175, 0xb60f, 0x1484, 0x2826, 0x3048, 0xb184, 0x342a, 0x2f75,
0x34d7, 0xb813, 0x3184, 0x353f, 0xb199, 0xa39f, 0x331b, 0xac92,
0xb0bb, 0xb55f, 0x9e01, 0x39c0, 0xb9ed, 0x36e1, 0xb6a8, 0x31c4
};
static const uint16_t in_com2[256] = {
0x365e, 0x2c4e, 0x2d3d, 0xb498, 0xb6b0, 0xb236, 0xae42, 0xa0d2,
0xb326, 0x34b9, 0x38ce, 0xac59, 0xb3b7, 0xb9a1, 0xb66d, 0xb587,
0xb4a2, 0xb08f, 0x2417, 0xb878, 0x31f0, 0xb8d3, 0x365a, 0x2eee,
0xb466, 0xb3e8, 0x38fb, 0x2948, 0xb434, 0x311a, 0xb2cd, 0xaf35,
0xb3bc, 0xad39, 0xa1d7, 0x2610, 0x3775, 0x2bcf, 0x2d65, 0xb6c1,
0x3421, 0xb4c9, 0xadd6, 0xbb91, 0x34b5, 0x2952, 0x3802, 0x3099,
0x309b, 0xb4e7, 0x33f0, 0x24d0, 0xb0e7, 0xb033, 0xb0fe, 0x3759,
0x38e7, 0x3456, 0x36c9, 0x2627, 0x3169, 0xb7c9, 0x36aa, 0x2d19,
0xb4fe, 0x356e, 0x30e5, 0xb443, 0xb42c, 0xb841, 0x34b2, 0x2a8a,
0xb248, 0x3414, 0x2820, 0xacd5, 0xb45e, 0x38cd, 0xaea5, 0x27bd,
0x354a, 0x364a, 0xb391, 0x36fa, 0x34a0, 0x2f8e, 0x366a, 0x2f62,
0x3036, 0xb12a, 0x2870, 0xb191, 0xb1a0, 0xa8a5, 0x3913, 0x2453,
0xb589, 0xaf5f, 0x37be, 0x35bc, 0xb738, 0xa510, 0xa94c, 0xad87,
0xb4c0, 0x38d8, 0x3453, 0xb4e8, 0xb8ef, 0xb5c5, 0x3559, 0x307f,
0xb47e, 0x147b, 0x313b, 0xb4d6, 0xa9ea, 0xb472, 0x2d7a, 0x3338,
0xaeea, 0xb689, 0x3539, 0x2c81, 0xb583, 0x3367, 0xb63b, 0x3169,
0x29dd, 0x2ee9, 0xb6b0, 0x34e2, 0x246f, 0xb52b, 0xb54a, 0xbabf,
0x300b, 0xad25, 0xb0c8, 0x2a03, 0x3806, 0x3331, 0x34e2, 0x396f,
0xb091, 0xba7b, 0xb515, 0xb4da, 0xaa0e, 0x34bd, 0x2eda, 0x3071,
0x3436, 0x35f2, 0xade4, 0xb529, 0x368c, 0x30ba, 0xb58c, 0x33b6,
0x2e08, 0xb32f, 0x327c, 0xb1f6, 0xac12, 0xb958, 0x356b, 0x3314,
0xb521, 0x389e, 0xb968, 0xb0a0, 0x3a24, 0x34c3, 0x31ca, 0x3528,
0x3343, 0xb42b, 0x2b60, 0xb3d1, 0xa2f0, 0xb883, 0x21c8, 0xb572,
0xb070, 0xafbd, 0xb3cb, 0x37f1, 0xb424, 0xb81d, 0xad80, 0x308f,
0x3628, 0xa803, 0x2ec2, 0xa9ae, 0x3407, 0xb587, 0x387f, 0x2c0f,
0x33ae, 0x328b, 0xb3db, 0xaf06, 0xac03, 0x3191, 0xaefc, 0x3575,
0x39cc, 0xad4b, 0x2cd9, 0x342e, 0x3775, 0xb40d, 0xb7e6, 0xb4ce,
0xb80b, 0x341c, 0xb260, 0xaaea, 0x3617, 0x3514, 0x3432, 0xb1a6,
0xb6f3, 0xa04b, 0x3602, 0x2c03, 0x3930, 0x30dc, 0x31bb, 0x32e3,
0xb340, 0xb75c, 0x3660, 0xb399, 0x3c00, 0x3422, 0xb0eb, 0x31b6,
0x2c4f, 0x3119, 0x2a0d, 0xba0b, 0x2950, 0x3870, 0xb470, 0x3604,
0x31a2, 0xb178, 0xac71, 0x37d1, 0xb2ad, 0x310c, 0xb61f, 0x3375
};
static const uint16_t in_clip[279] = {
0xbb33, 0xbb26, 0xbb19, 0xbb0b, 0xbafe, 0xbaf1, 0xbae4, 0xbad6,
0xbac9, 0xbabc, 0xbaaf, 0xbaa1, 0xba94, 0xba87, 0xba7a, 0xba6c,
0xba5f, 0xba52, 0xba45, 0xba37, 0xba2a, 0xba1d, 0xba0f, 0xba02,
0xb9f5, 0xb9e8, 0xb9da, 0xb9cd, 0xb9c0, 0xb9b3, 0xb9a5, 0xb998,
0xb98b, 0xb97e, 0xb970, 0xb963, 0xb956, 0xb949, 0xb93b, 0xb92e,
0xb921, 0xb914, 0xb906, 0xb8f9, 0xb8ec, 0xb8de, 0xb8d1, 0xb8c4,
0xb8b7, 0xb8a9, 0xb89c, 0xb88f, 0xb882, 0xb874, 0xb867, 0xb85a,
0xb84d, 0xb83f, 0xb832, 0xb825, 0xb818, 0xb80a, 0xb7fa, 0xb7e0,
0xb7c5, 0xb7ab, 0xb790, 0xb776, 0xb75b, 0xb740, 0xb726, 0xb70b,
0xb6f1, 0xb6d6, 0xb6bc, 0xb6a1, 0xb687, 0xb66c, 0xb652, 0xb637,
0xb61d, 0xb602, 0xb5e8, 0xb5cd, 0xb5b3, 0xb598, 0xb57e, 0xb563,
0xb549, 0xb52e, 0xb514, 0xb4f9, 0xb4de, 0xb4c4, 0xb4a9, 0xb48f,
0xb474, 0xb45a, 0xb43f, 0xb425, 0xb40a, 0xb3e0, 0xb3ab, 0xb376,
0xb340, 0xb30b, 0xb2d6, 0xb2a1, 0xb26c, 0xb237, 0xb202, 0xb1cd,
0xb198, 0xb163, 0xb12e, 0xb0f9, 0xb0c4, 0xb08f, 0xb05a, 0xb025,
0xafe0, 0xaf76, 0xaf0b, 0xaea1, 0xae37, 0xadcd, 0xad63, 0xacf9,
0xac8f, 0xac25, 0xab76, 0xaaa1, 0xa9cd, 0xa8f9, 0xa825, 0xa6a1,
0xa4f9, 0xa2a1, 0x9ea1, 0x0, 0x1ea1, 0x22a1, 0x24f9, 0x26a1,
0x2825, 0x28f9, 0x29cd, 0x2aa1, 0x2b76, 0x2c25, 0x2c8f, 0x2cf9,
0x2d63, 0x2dcd, 0x2e37, 0x2ea1, 0x2f0b, 0x2f76, 0x2fe0, 0x3025,
0x305a, 0x308f, 0x30c4, 0x30f9, 0x312e, 0x3163, 0x3198, 0x31cd,
0x3202, 0x3237, 0x326c, 0x32a1, 0x32d6, 0x330b, 0x3340, 0x3376,
0x33ab, 0x33e0, 0x340a, 0x3425, 0x343f, 0x345a, 0x3474, 0x348f,
0x34a9, 0x34c4, 0x34de, 0x34f9, 0x3514, 0x352e, 0x3549, 0x3563,
0x357e, 0x3598, 0x35b3, 0x35cd, 0x35e8, 0x3602, 0x361d, 0x3637,
0x3652, 0x366c, 0x3687, 0x36a1, 0x36bc, 0x36d6, 0x36f1, 0x370b,
0x3726, 0x3740, 0x375b, 0x3776, 0x3790, 0x37ab, 0x37c5, 0x37e0,
0x37fa, 0x380a, 0x3818, 0x3825, 0x3832, 0x383f, 0x384d, 0x385a,
0x3867, 0x3874, 0x3882, 0x388f, 0x389c, 0x38a9, 0x38b7, 0x38c4,
0x38d1, 0x38de, 0x38ec, 0x38f9, 0x3906, 0x3914, 0x3921, 0x392e,
0x393b, 0x3949, 0x3956, 0x3963, 0x3970, 0x397e, 0x398b, 0x3998,
0x39a5, 0x39b3, 0x39c0, 0x39cd, 0x39da, 0x39e8, 0x39f5, 0x3a02,
0x3a0f, 0x3a1d, 0x3a2a, 0x3a37, 0x3a45, 0x3a52, 0x3a5f, 0x3a6c,
0x3a7a, 0x3a87, 0x3a94, 0x3aa1, 0x3aaf, 0x3abc, 0x3ac9, 0x3ad6,
0x3ae4, 0x3af1, 0x3afe, 0x3b0b, 0x3b19, 0x3b26, 0x3b33
};
static const uint16_t ref_add[256] = {
0x312e, 0xb128, 0xaf06, 0x2dd6, 0xb3c4, 0xb6b5, 0xb662, 0xb18a,
0x319b, 0x3812, 0x3b78, 0xac60, 0x305a, 0xb4e4, 0xb8a1, 0x3818,
0xa50a, 0xb7c3, 0xb224, 0xb951, 0x35f7, 0xbbe0, 0x3a02, 0x38a4,
0xb85b, 0xb8d0, 0x37d1, 0xb101, 0xb781, 0x2b39, 0x3628, 0xbbba,
0xba47, 0xb731, 0x3b70, 0xb759, 0x3c09, 0xb7fc, 0x3c3e, 0xb59d,
0x3caf, 0xb09f, 0xb9e9, 0xbad0, 0x33e6, 0xadff, 0x39f4, 0x3848,
0x35d7, 0xb041, 0xae4a, 0x3a03, 0x3373, 0xab0c, 0x1577, 0x3a2b,
0x34c1, 0x334d, 0x3808, 0xb25b, 0x3a2a, 0xb490, 0x35de, 0xb0f2,
0xb91d, 0x2af9, 0x36f4, 0xb2b4, 0xb769, 0xba55, 0x3a63, 0xaefb,
0xb45d, 0x3669, 0x3c21, 0x2dd3, 0xb806, 0x38c7, 0xb801, 0xb0bd,
0x34a3, 0x38ca, 0x2b16, 0x2cff, 0x39f7, 0xa82b, 0x3bea, 0xac33,
0x3109, 0xb4dd, 0x311c, 0xb520, 0xb8f5, 0x3500, 0x3a92, 0x2e7d,
0x208d, 0xb866, 0x337b, 0x38a8, 0xb699, 0x3719, 0x35c9, 0x9df1,
0x32fd, 0x357b, 0x36bf, 0xb832, 0x3577, 0xb506, 0x33eb, 0xb153,
0xb473, 0xb4b9, 0x35e2, 0xb799, 0xb2f7, 0xb406, 0x2c73, 0x3400,
0xb6b1, 0xbcc9, 0xb299, 0x37f5, 0xb846, 0x35e6, 0xb79c, 0xac0e,
0x30ac, 0xb958, 0xb070, 0x314d, 0x35be, 0xb61b, 0xbc26, 0xb9d4,
0x38e0, 0x2ac1, 0x3717, 0x9ecc, 0x39c4, 0xa885, 0x3b6c, 0x39e8,
0x35d9, 0xbc3c, 0xba65, 0xb8e3, 0xb061, 0x3b1e, 0x2c0e, 0x3926,
0x3761, 0x38f0, 0xb13f, 0xb20e, 0x3890, 0x28e2, 0xb44e, 0xb379,
0xb364, 0xbb23, 0x3976, 0xab08, 0xaf57, 0xbc59, 0x3888, 0x36af,
0xb85b, 0x3c15, 0xbaf1, 0xa885, 0x3c4e, 0x31c1, 0x388c, 0xb20c,
0x3bbb, 0xb6cf, 0xb59b, 0x2ecd, 0x38ec, 0xbab2, 0x3609, 0xb85f,
0xbbe8, 0x2448, 0xb88e, 0x385a, 0xb43b, 0xba54, 0x2cc7, 0x34d2,
0x358c, 0x3204, 0x37af, 0x27ec, 0x3c0a, 0xb897, 0x3032, 0x2996,
0x32a2, 0x398f, 0xb441, 0xb57a, 0xb277, 0x3060, 0xb765, 0x356c,
0x30b1, 0xb4e9, 0xb195, 0x3846, 0x39f1, 0xb533, 0xb5c1, 0xb35a,
0xadbb, 0x34c8, 0xb537, 0xb686, 0x2d8f, 0x3601, 0xb28f, 0xa510,
0x253f, 0xb8f4, 0x3694, 0xb890, 0x34c8, 0xb2af, 0x380f, 0x3481,
0xab30, 0xbab6, 0x3665, 0xb290, 0x3c89, 0x2d80, 0x2ed4, 0x34b8,
0x35ea, 0xb599, 0x3308, 0xb6d6, 0xb045, 0x3852, 0xab14, 0x34df,
0x2733, 0xb80e, 0xacd1, 0x3cd4, 0xbb98, 0x38b4, 0xba63, 0x369c
};
static const uint16_t ref_sub[256] = {
0xb912, 0xb4bb, 0xb460, 0x3953, 0x38bf, 0xa7e5, 0xb281, 0xb0f0,
0x38fa, 0xad37, 0xb448, 0x2c52, 0x38f2, 0x3c68, 0x3330, 0x3ccf,
0x3879, 0xb26a, 0xb32a, 0x373e, 0x16f5, 0x331b, 0xa97e, 0x35d1,
0x1d9e, 0xaee2, 0xba0e, 0xb3a5, 0x2b42, 0xb433, 0x3a7b, 0xb9ed,
0xb4d2, 0xb494, 0x3b9f, 0xb80e, 0x2cea, 0xb8f8, 0x3b24, 0x37e5,
0x393d, 0x3742, 0xb874, 0x3c29, 0xb577, 0xb1a9, 0xb41f, 0x33f0,
0x2cf0, 0x37ae, 0xb8c1, 0x39b6, 0x3850, 0x32a3, 0x3503, 0xb0b7,
0xbb6e, 0xb505, 0xb583, 0xb3e5, 0x36eb, 0x3981, 0xb776, 0xb505,
0xa3d0, 0xb8fe, 0x301d, 0x352b, 0x2b7e, 0x345b, 0x32c5, 0xb2c3,
0x2fad, 0xaefe, 0x3bbe, 0x33be, 0x2983, 0xb8d3, 0xb4af, 0xb2ac,
0xb5f0, 0xb1ff, 0x383a, 0xba5a, 0x315c, 0xb44c, 0x3200, 0xb4be,
0xaec5, 0x24d1, 0x2dc9, 0x2711, 0xb44a, 0x3629, 0xb726, 0x2c53,
0x399b, 0xb51d, 0xb9df, 0xb053, 0x37d6, 0x37bb, 0x371c, 0x3157,
0x3a7f, 0xbaf3, 0xaf99, 0x2db0, 0x3e4d, 0x3684, 0xb6bc, 0xb729,
0x3488, 0xb4c2, 0x293a, 0x3028, 0xb001, 0x34de, 0xae82, 0xb271,
0xb278, 0xb612, 0xbadf, 0x35b4, 0x30f4, 0xae06, 0x34da, 0xb66d,
0x2af6, 0xbb13, 0x3994, 0xb71f, 0x3531, 0x343b, 0xb603, 0x3bab,
0x35b4, 0x32d5, 0x39ef, 0xae70, 0xb491, 0xb7c1, 0x3515, 0xb8f6,
0x3935, 0x387e, 0xb144, 0x9c1c, 0xa969, 0x34c2, 0xb0d3, 0x35db,
0xac2a, 0xb006, 0x252b, 0x374c, 0xb3ef, 0xb41d, 0x36cb, 0xb9ba,
0xb6b6, 0xb716, 0x3471, 0x3515, 0x2274, 0x33f8, 0xaf16, 0xa648,
0x2e30, 0xb043, 0x37be, 0x340f, 0xb757, 0xb6a5, 0x329d, 0xbaab,
0x3819, 0x2e17, 0xb773, 0x38c2, 0x3923, 0x34a7, 0x35ac, 0x304b,
0xb9b1, 0x3423, 0xad3f, 0xb72e, 0x340c, 0x339a, 0x33e3, 0x242f,
0xb6c4, 0x3403, 0x344d, 0x2fa9, 0x380c, 0x2f82, 0xbbf2, 0xad54,
0xb45d, 0x3493, 0x3335, 0xafdc, 0xace9, 0xb2c2, 0xb3cd, 0xb57e,
0xbd36, 0xb087, 0xb537, 0x21d8, 0xb213, 0x31ce, 0x3905, 0x35ef,
0x3b5f, 0xb2df, 0x2ca3, 0xb4cc, 0xb965, 0xb427, 0xb9d5, 0x3555,
0x3b1d, 0xb8d2, 0xb570, 0xb990, 0xbbfb, 0xb81a, 0x30c8, 0xb0c5,
0x365a, 0x2d36, 0xb65c, 0x3451, 0xbaee, 0xb6e4, 0x36a0, 0xabf0,
0x3386, 0xb959, 0x3001, 0x3c55, 0xb2ed, 0xb88f, 0x37fd, 0xb728,
0xb52e, 0xb146, 0x2c10, 0x335d, 0xb842, 0x345b, 0xa846, 0xaac1
};
static const uint16_t ref_mult[256] = {
0xae03, 0xa3dd, 0xa404, 0xaef4, 0xacb0, 0x2997, 0x278a, 0x1651,
0xadb3, 0x2c09, 0x3266, 0x1d5, 0xadd1, 0xb47c, 0x2c8e, 0xb4bc,
0xacff, 0x2a3f, 0x9ace, 0x2b92, 0x2873, 0x335c, 0x307f, 0x2a8a,
0x2cbd, 0x2d9c, 0xad59, 0xa02d, 0x2aef, 0xa434, 0xb010, 0x2e27,
0x3033, 0x27af, 0xa17f, 0xa1db, 0x340c, 0xa860, 0x2d45, 0xa7b5,
0x338b, 0xa9ea, 0x2b90, 0xadb6, 0xa323, 0x9dc2, 0x2fcd, 0x2b34,
0x2813, 0xaacf, 0xad7f, 0x230d, 0xab91, 0xa11e, 0xa648, 0x3096,
0xb232, 0xa1f0, 0x2852, 0x9d7b, 0x2e82, 0xae46, 0xa551, 0xa4c6,
0x2e89, 0xae2f, 0x2983, 0xa3be, 0x2ac1, 0x306b, 0x30be, 0xa030,
0x23ad, 0x28c1, 0x2820, 0xa26f, 0x2c04, 0x96d3, 0x2945, 0x9d85,
0xa2e2, 0x2d2d, 0xac6b, 0xb0ff, 0x3039, 0xa48d, 0x338c, 0xa558,
0x1af3, 0x25e3, 0x1c70, 0x2684, 0x2cff, 0xa27b, 0x2f9a, 0x15d8,
0xafdc, 0x2a69, 0xafbf, 0x2d20, 0xa477, 0xa0b1, 0xa445, 0x9f1f,
0xb0e5, 0xb119, 0x293e, 0x2c47, 0xb8bb, 0xa44d, 0xa76b, 0xa985,
0x9211, 0x8d4f, 0x2846, 0x2aad, 0x200e, 0x9f81, 0x95a2, 0x1da1,
0x284a, 0x3526, 0xb190, 0x27b1, 0x2c2f, 0x2811, 0x284c, 0xa908,
0x1cb3, 0xad5d, 0xaf78, 0xa975, 0x1e0f, 0x24d9, 0x3379, 0xae36,
0x2bd0, 0xa17b, 0xadab, 0x9929, 0x2f03, 0xab7a, 0x3214, 0x2921,
0xaca4, 0x3270, 0x30e6, 0x2df7, 0x1c57, 0x31a0, 0x9cc9, 0x2c7c,
0x2aac, 0x2dd8, 0x1ec7, 0xa982, 0x2c39, 0xa423, 0xa6e7, 0xaf52,
0xa7d9, 0x30cc, 0x2e3a, 0xa644, 0x1aa6, 0x347a, 0x2cf0, 0x2991,
0x2c97, 0x3419, 0x3026, 0xa40a, 0x3397, 0xa87d, 0x2c7d, 0xb145,
0x315e, 0x2982, 0xa604, 0xad7b, 0xa05c, 0x30ee, 0x1c3b, 0x2c7e,
0x2f8a, 0xa443, 0x2d13, 0x260b, 0x160e, 0x308d, 0xa310, 0x25ca,
0xa381, 0x9f0a, 0x2910, 0x9ad8, 0x321a, 0x2d0c, 0xb3c0, 0x9525,
0xa006, 0x2e6b, 0x1d19, 0x2688, 0x2079, 0x9ea3, 0x28ee, 0x91fe,
0xb6b3, 0x24bf, 0xa4da, 0x2c90, 0x301f, 0x24a7, 0xac3b, 0xa56b,
0xb2ba, 0x2186, 0x2677, 0x24e4, 0xaf28, 0x24b3, 0xafd6, 0xa716,
0xb252, 0x1d3f, 0x22db, 0xa914, 0xb340, 0xab03, 0x2b88, 0x234c,
0xa8f2, 0x3193, 0xf32, 0x9fe1, 0x3048, 0xa9b3, 0xa91f, 0x2553,
0x2536, 0xad31, 0x202c, 0xb3ec, 0x9f6f, 0xa03a, 0xabe1, 0xa6df,
0xa6a9, 0x2b59, 0xeaa, 0x359e, 0x30f2, 0x2c57, 0x3117, 0x2960
};
static const uint16_t ref_negate[256] = {
0x338e, 0x334f, 0x3222, 0xb60e, 0xb19c, 0x3333, 0x34d1, 0x313d,
0xb661, 0xb2d6, 0xb554, 0xebc, 0xb608, 0xb65e, 0x31ab, 0xbadb,
0xb451, 0x357c, 0x32a7, 0x2ec7, 0xb1fe, 0x361a, 0xb5aa, 0xb78c,
0x344f, 0x35ad, 0x304b, 0x3253, 0x3298, 0x2e97, 0xb8c7, 0x3ad4,
0x3858, 0x35e2, 0xbb87, 0x37ba, 0xb858, 0x387b, 0xbbd0, 0xac91,
0xbb4e, 0xb0f2, 0x392e, 0xae09, 0x2a10, 0x3054, 0xb3c9, 0xb644,
0xb313, 0xb18e, 0x358a, 0xb9dd, 0xb62d, 0xace0, 0xb109, 0xb4fe,
0x350e, 0x297a, 0xad18, 0x3320, 0xb8d0, 0xb272, 0x2a62, 0x337e,
0x353d, 0x348f, 0xb481, 0xab45, 0x3279, 0x3427, 0xb80a, 0x3120,
0x2ce3, 0xb0a9, 0xbc00, 0xb154, 0x335b, 0x19af, 0x3658, 0x31b4,
0x2935, 0xb295, 0xb4ab, 0x35ba, 0xb74e, 0x30d2, 0xb8b5, 0x31cb,
0xa69a, 0x308f, 0xb000, 0x30af, 0x371b, 0xb595, 0xb1ff, 0xad68,
0xb5ae, 0x36f5, 0x3401, 0xb326, 0xa8f3, 0xb76a, 0xb673, 0xad28,
0xb81f, 0x3435, 0xb0d9, 0x32f9, 0xbbab, 0xa9f6, 0x2d8d, 0x34e9,
0x9968, 0x34bd, 0xb289, 0x3185, 0x317c, 0xa6c1, 0x241d, 0xa63d,
0x34f7, 0x3a4d, 0x3843, 0xb6d4, 0x3212, 0xb065, 0x2d85, 0x3370,
0xae69, 0x3a35, 0xb478, 0x3078, 0xb577, 0x2b81, 0x39a7, 0xaf5d,
0xb7ba, 0xb043, 0xb8bd, 0x2add, 0xb2f8, 0x3429, 0xb8fb, 0xab8d,
0xb811, 0x33f2, 0x37b6, 0x34eb, 0x2dbc, 0xb8c0, 0x2997, 0xb80a,
0xb257, 0xb3dd, 0x2c9a, 0xb045, 0xb129, 0x2f02, 0xacfa, 0x3798,
0x3534, 0x3957, 0xb7af, 0xb034, 0x2a88, 0x36b4, 0xb34b, 0xb24b,
0x3329, 0xb71a, 0x3224, 0xaefd, 0xb4f2, 0x2f8a, 0xb634, 0x3817,
0xb9ea, 0x314a, 0x3687, 0xb59c, 0xb907, 0x345f, 0xb5da, 0x3299,
0x3acc, 0xb068, 0x3535, 0xaa17, 0x1dda, 0x346d, 0xb123, 0xb115,
0x28e0, 0xb305, 0xb5fe, 0xacd2, 0xba10, 0x334d, 0x36e5, 0x2512,
0x2831, 0xb7d8, 0x2531, 0x3371, 0x3076, 0x28c5, 0x35a6, 0x1864,
0x389f, 0x332c, 0x3401, 0xb45d, 0xb46c, 0x2c98, 0xb049, 0xac83,
0xb6a8, 0xa961, 0x300f, 0x35a9, 0x34b3, 0xab67, 0x3779, 0xb104,
0xb747, 0x38e3, 0xa891, 0x3910, 0x3597, 0x35c5, 0xb541, 0xac3d,
0xb175, 0x360f, 0x9484, 0xa826, 0xb048, 0x3184, 0xb42a, 0xaf75,
0xb4d7, 0x3813, 0xb184, 0xb53f, 0x3199, 0x239f, 0xb31b, 0x2c92,
0x30bb, 0x355f, 0x1e01, 0xb9c0, 0x39ed, 0xb6e1, 0x36a8, 0xb1c4
};
static const uint16_t ref_offset[256] = {
0x3439, 0x3458, 0x34ef, 0x3b07, 0x3967, 0x3467, 0x325e, 0x3561,
0x3b30, 0x39b5, 0x3aaa, 0x37fe, 0x3b04, 0x3b2f, 0x352b, 0x3d6d,
0x3a28, 0x3108, 0x34ac, 0x364e, 0x3980, 0x2f9a, 0x3ad5, 0x3bc6,
0x3361, 0x30a7, 0x35da, 0x34d6, 0x34b4, 0x365a, 0x3c64, 0xb5a7,
0xa980, 0x303b, 0x3dc4, 0x245b, 0x3c2c, 0xabaf, 0x3de8, 0x3892,
0x3da7, 0x393d, 0xb0b9, 0x38c1, 0x373e, 0x35d6, 0x39f2, 0x3b22,
0x39c5, 0x3963, 0x30eb, 0x3cee, 0x3b16, 0x389c, 0x3942, 0x3a7f,
0x31e4, 0x3751, 0x38a3, 0x3470, 0x3c68, 0x399d, 0x3734, 0x3441,
0x3187, 0x32e3, 0x3a41, 0x3874, 0x34c3, 0x33b2, 0x3c05, 0x3570,
0x36c7, 0x392a, 0x3e00, 0x3955, 0x3452, 0x37f5, 0x2e9f, 0x3526,
0x3759, 0x39a5, 0x3a56, 0x308b, 0x3ba7, 0x3597, 0x3c5a, 0x351b,
0x3835, 0x35b8, 0x3900, 0x35a9, 0x2b2b, 0x3aca, 0x3980, 0x38ad,
0x3ad7, 0x2c2d, 0x33ff, 0x39c9, 0x384f, 0x3bb5, 0x3b39, 0x38a5,
0x3c10, 0x3396, 0x3936, 0x3484, 0x3dd5, 0x385f, 0x369d, 0x322e,
0x3805, 0x3285, 0x39a2, 0x353d, 0x3542, 0x3836, 0x37be, 0x3832,
0x3213, 0xb49b, 0xa82d, 0x3b6a, 0x34f7, 0x3919, 0x369f, 0x3448,
0x38cd, 0xb46b, 0x3a3c, 0x35c4, 0x3abc, 0x3710, 0xb29b, 0x38ec,
0x3bdd, 0x3911, 0x3c5f, 0x3724, 0x39be, 0x33ae, 0x3c7e, 0x3879,
0x3c08, 0x3407, 0x249a, 0x322a, 0x3691, 0x3c60, 0x374d, 0x3c05,
0x3996, 0x39f7, 0x36da, 0x3911, 0x394a, 0x3640, 0x389f, 0x2683,
0x3198, 0xb15c, 0x3bd7, 0x390d, 0x372f, 0x2d30, 0x39d3, 0x3993,
0x346b, 0x3b8d, 0x34ee, 0x38e0, 0x3a79, 0x361d, 0x3b1a, 0xa1b5,
0x3cf5, 0x355b, 0x2de5, 0x3ace, 0x3c84, 0x3343, 0x3aed, 0x34b3,
0xb599, 0x391a, 0x3195, 0x3861, 0x37e9, 0x3326, 0x3949, 0x3945,
0x3764, 0x39c1, 0x3aff, 0x389a, 0x3d08, 0x3459, 0x2c6c, 0x37af,
0x377a, 0x3bec, 0x37ad, 0x3448, 0x35c5, 0x3767, 0x30b5, 0x37f7,
0xacfb, 0x346a, 0x33fe, 0x3a2f, 0x3a36, 0x36da, 0x3912, 0x3890,
0x3b54, 0x3856, 0x35f9, 0x30ae, 0x329a, 0x3876, 0x2837, 0x3941,
0x3ba3, 0xaf18, 0x3849, 0xb040, 0x30d2, 0x3075, 0x3aa1, 0x3888,
0x395d, 0x2fc4, 0x3802, 0x3842, 0x3912, 0x353e, 0x3a15, 0x38ef,
0x3a6b, 0xa0b3, 0x3961, 0x3a9f, 0x3533, 0x37c3, 0x39c7, 0x36db,
0x35a2, 0x3142, 0x37e8, 0x3ce0, 0xb3b5, 0x3b71, 0x2d62, 0x3971
};
static const uint16_t ref_scale[256] = {
0xaf8e, 0xaf4f, 0xae22, 0x320e, 0x2d9c, 0xaf33, 0xb0d1, 0xad3d,
0x3261, 0x2ed6, 0x3154, 0x8abc, 0x3208, 0x325e, 0xadab, 0x36db,
0x3051, 0xb17c, 0xaea7, 0xaac7, 0x2dfe, 0xb21a, 0x31aa, 0x338c,
0xb04f, 0xb1ad, 0xac4b, 0xae53, 0xae98, 0xaa97, 0x34c7, 0xb6d4,
0xb458, 0xb1e2, 0x3787, 0xb3ba, 0x3458, 0xb47b, 0x37d0, 0x2891,
0x374e, 0x2cf2, 0xb52e, 0x2a09, 0xa610, 0xac54, 0x2fc9, 0x3244,
0x2f13, 0x2d8e, 0xb18a, 0x35dd, 0x322d, 0x28e0, 0x2d09, 0x30fe,
0xb10e, 0xa57a, 0x2918, 0xaf20, 0x34d0, 0x2e72, 0xa662, 0xaf7e,
0xb13d, 0xb08f, 0x3081, 0x2745, 0xae79, 0xb027, 0x340a, 0xad20,
0xa8e3, 0x2ca9, 0x3800, 0x2d54, 0xaf5b, 0x95af, 0xb258, 0xadb4,
0xa535, 0x2e95, 0x30ab, 0xb1ba, 0x334e, 0xacd2, 0x34b5, 0xadcb,
0x229a, 0xac8f, 0x2c00, 0xacaf, 0xb31b, 0x3195, 0x2dff, 0x2968,
0x31ae, 0xb2f5, 0xb001, 0x2f26, 0x24f3, 0x336a, 0x3273, 0x2928,
0x341f, 0xb035, 0x2cd9, 0xaef9, 0x37ab, 0x25f6, 0xa98d, 0xb0e9,
0x1568, 0xb0bd, 0x2e89, 0xad85, 0xad7c, 0x22c1, 0xa01d, 0x223d,
0xb0f7, 0xb64d, 0xb443, 0x32d4, 0xae12, 0x2c65, 0xa985, 0xaf70,
0x2a69, 0xb635, 0x3078, 0xac78, 0x3177, 0xa781, 0xb5a7, 0x2b5d,
0x33ba, 0x2c43, 0x34bd, 0xa6dd, 0x2ef8, 0xb029, 0x34fb, 0x278d,
0x3411, 0xaff2, 0xb3b6, 0xb0eb, 0xa9bc, 0x34c0, 0xa597, 0x340a,
0x2e57, 0x2fdd, 0xa89a, 0x2c45, 0x2d29, 0xab02, 0x28fa, 0xb398,
0xb134, 0xb557, 0x33af, 0x2c34, 0xa688, 0xb2b4, 0x2f4b, 0x2e4b,
0xaf29, 0x331a, 0xae24, 0x2afd, 0x30f2, 0xab8a, 0x3234, 0xb417,
0x35ea, 0xad4a, 0xb287, 0x319c, 0x3507, 0xb05f, 0x31da, 0xae99,
0xb6cc, 0x2c68, 0xb135, 0x2617, 0x99da, 0xb06d, 0x2d23, 0x2d15,
0xa4e0, 0x2f05, 0x31fe, 0x28d2, 0x3610, 0xaf4d, 0xb2e5, 0xa112,
0xa431, 0x33d8, 0xa131, 0xaf71, 0xac76, 0xa4c5, 0xb1a6, 0x9464,
0xb49f, 0xaf2c, 0xb001, 0x305d, 0x306c, 0xa898, 0x2c49, 0x2883,
0x32a8, 0x2561, 0xac0f, 0xb1a9, 0xb0b3, 0x2767, 0xb379, 0x2d04,
0x3347, 0xb4e3, 0x2491, 0xb510, 0xb197, 0xb1c5, 0x3141, 0x283d,
0x2d75, 0xb20f, 0x1084, 0x2426, 0x2c48, 0xad84, 0x302a, 0x2b75,
0x30d7, 0xb413, 0x2d84, 0x313f, 0xad99, 0x9f9f, 0x2f1b, 0xa892,
0xacbb, 0xb15f, 0x9a01, 0x35c0, 0xb5ed, 0x32e1, 0xb2a8, 0x2dc4
};
static const uint16_t ref_dot_prod_3[1] = {
0xb37b
};
static const uint16_t ref_dot_prod_4[1] = {
0xb93c
};
static const uint16_t ref_dot_prod_4n1[1] = {
0xb31e
};
static const uint16_t ref_dot_prod_long[1] = {
0x41f6
};
static const uint16_t ref_abs[256] = {
0x338e, 0x334f, 0x3222, 0x360e, 0x319c, 0x3333, 0x34d1, 0x313d,
0x3661, 0x32d6, 0x3554, 0xebc, 0x3608, 0x365e, 0x31ab, 0x3adb,
0x3451, 0x357c, 0x32a7, 0x2ec7, 0x31fe, 0x361a, 0x35aa, 0x378c,
0x344f, 0x35ad, 0x304b, 0x3253, 0x3298, 0x2e97, 0x38c7, 0x3ad4,
0x3858, 0x35e2, 0x3b87, 0x37ba, 0x3858, 0x387b, 0x3bd0, 0x2c91,
0x3b4e, 0x30f2, 0x392e, 0x2e09, 0x2a10, 0x3054, 0x33c9, 0x3644,
0x3313, 0x318e, 0x358a, 0x39dd, 0x362d, 0x2ce0, 0x3109, 0x34fe,
0x350e, 0x297a, 0x2d18, 0x3320, 0x38d0, 0x3272, 0x2a62, 0x337e,
0x353d, 0x348f, 0x3481, 0x2b45, 0x3279, 0x3427, 0x380a, 0x3120,
0x2ce3, 0x30a9, 0x3c00, 0x3154, 0x335b, 0x19af, 0x3658, 0x31b4,
0x2935, 0x3295, 0x34ab, 0x35ba, 0x374e, 0x30d2, 0x38b5, 0x31cb,
0x269a, 0x308f, 0x3000, 0x30af, 0x371b, 0x3595, 0x31ff, 0x2d68,
0x35ae, 0x36f5, 0x3401, 0x3326, 0x28f3, 0x376a, 0x3673, 0x2d28,
0x381f, 0x3435, 0x30d9, 0x32f9, 0x3bab, 0x29f6, 0x2d8d, 0x34e9,
0x1968, 0x34bd, 0x3289, 0x3185, 0x317c, 0x26c1, 0x241d, 0x263d,
0x34f7, 0x3a4d, 0x3843, 0x36d4, 0x3212, 0x3065, 0x2d85, 0x3370,
0x2e69, 0x3a35, 0x3478, 0x3078, 0x3577, 0x2b81, 0x39a7, 0x2f5d,
0x37ba, 0x3043, 0x38bd, 0x2add, 0x32f8, 0x3429, 0x38fb, 0x2b8d,
0x3811, 0x33f2, 0x37b6, 0x34eb, 0x2dbc, 0x38c0, 0x2997, 0x380a,
0x3257, 0x33dd, 0x2c9a, 0x3045, 0x3129, 0x2f02, 0x2cfa, 0x3798,
0x3534, 0x3957, 0x37af, 0x3034, 0x2a88, 0x36b4, 0x334b, 0x324b,
0x3329, 0x371a, 0x3224, 0x2efd, 0x34f2, 0x2f8a, 0x3634, 0x3817,
0x39ea, 0x314a, 0x3687, 0x359c, 0x3907, 0x345f, 0x35da, 0x3299,
0x3acc, 0x3068, 0x3535, 0x2a17, 0x1dda, 0x346d, 0x3123, 0x3115,
0x28e0, 0x3305, 0x35fe, 0x2cd2, 0x3a10, 0x334d, 0x36e5, 0x2512,
0x2831, 0x37d8, 0x2531, 0x3371, 0x3076, 0x28c5, 0x35a6, 0x1864,
0x389f, 0x332c, 0x3401, 0x345d, 0x346c, 0x2c98, 0x3049, 0x2c83,
0x36a8, 0x2961, 0x300f, 0x35a9, 0x34b3, 0x2b67, 0x3779, 0x3104,
0x3747, 0x38e3, 0x2891, 0x3910, 0x3597, 0x35c5, 0x3541, 0x2c3d,
0x3175, 0x360f, 0x1484, 0x2826, 0x3048, 0x3184, 0x342a, 0x2f75,
0x34d7, 0x3813, 0x3184, 0x353f, 0x3199, 0x239f, 0x331b, 0x2c92,
0x30bb, 0x355f, 0x1e01, 0x39c0, 0x39ed, 0x36e1, 0x36a8, 0x31c4
};
static const uint16_t ref_clip1[263] = {
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb7fa, 0xb7e0,
0xb7c5, 0xb7ab, 0xb790, 0xb776, 0xb75b, 0xb740, 0xb726, 0xb70b,
0xb6f1, 0xb6d6, 0xb6bc, 0xb6a1, 0xb687, 0xb66c, 0xb652, 0xb637,
0xb61d, 0xb602, 0xb5e8, 0xb5cd, 0xb5b3, 0xb598, 0xb57e, 0xb563,
0xb549, 0xb52e, 0xb514, 0xb4f9, 0xb4de, 0xb4c4, 0xb4a9, 0xb48f,
0xb474, 0xb45a, 0xb43f, 0xb425, 0xb40a, 0xb3e0, 0xb3ab, 0xb376,
0xb340, 0xb30b, 0xb2d6, 0xb2a1, 0xb26c, 0xb237, 0xb202, 0xb1cd,
0xb198, 0xb163, 0xb12e, 0xb0f9, 0xb0c4, 0xb08f, 0xb05a, 0xb025,
0xafe0, 0xaf76, 0xaf0b, 0xaea1, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66,
0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66, 0xae66
};
static const uint16_t ref_clip2[272] = {
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800,
0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb800, 0xb7fa, 0xb7e0,
0xb7c5, 0xb7ab, 0xb790, 0xb776, 0xb75b, 0xb740, 0xb726, 0xb70b,
0xb6f1, 0xb6d6, 0xb6bc, 0xb6a1, 0xb687, 0xb66c, 0xb652, 0xb637,
0xb61d, 0xb602, 0xb5e8, 0xb5cd, 0xb5b3, 0xb598, 0xb57e, 0xb563,
0xb549, 0xb52e, 0xb514, 0xb4f9, 0xb4de, 0xb4c4, 0xb4a9, 0xb48f,
0xb474, 0xb45a, 0xb43f, 0xb425, 0xb40a, 0xb3e0, 0xb3ab, 0xb376,
0xb340, 0xb30b, 0xb2d6, 0xb2a1, 0xb26c, 0xb237, 0xb202, 0xb1cd,
0xb198, 0xb163, 0xb12e, 0xb0f9, 0xb0c4, 0xb08f, 0xb05a, 0xb025,
0xafe0, 0xaf76, 0xaf0b, 0xaea1, 0xae37, 0xadcd, 0xad63, 0xacf9,
0xac8f, 0xac25, 0xab76, 0xaaa1, 0xa9cd, 0xa8f9, 0xa825, 0xa6a1,
0xa4f9, 0xa2a1, 0x9ea1, 0x0, 0x1ea1, 0x22a1, 0x24f9, 0x26a1,
0x2825, 0x28f9, 0x29cd, 0x2aa1, 0x2b76, 0x2c25, 0x2c8f, 0x2cf9,
0x2d63, 0x2dcd, 0x2e37, 0x2ea1, 0x2f0b, 0x2f76, 0x2fe0, 0x3025,
0x305a, 0x308f, 0x30c4, 0x30f9, 0x312e, 0x3163, 0x3198, 0x31cd,
0x3202, 0x3237, 0x326c, 0x32a1, 0x32d6, 0x330b, 0x3340, 0x3376,
0x33ab, 0x33e0, 0x340a, 0x3425, 0x343f, 0x345a, 0x3474, 0x348f,
0x34a9, 0x34c4, 0x34de, 0x34f9, 0x3514, 0x352e, 0x3549, 0x3563,
0x357e, 0x3598, 0x35b3, 0x35cd, 0x35e8, 0x3602, 0x361d, 0x3637,
0x3652, 0x366c, 0x3687, 0x36a1, 0x36bc, 0x36d6, 0x36f1, 0x370b,
0x3726, 0x3740, 0x375b, 0x3776, 0x3790, 0x37ab, 0x37c5, 0x37e0,
0x37fa, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800
};
static const uint16_t ref_clip3[279] = {
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66, 0x2e66,
0x2e66, 0x2e66, 0x2e66, 0x2ea1, 0x2f0b, 0x2f76, 0x2fe0, 0x3025,
0x305a, 0x308f, 0x30c4, 0x30f9, 0x312e, 0x3163, 0x3198, 0x31cd,
0x3202, 0x3237, 0x326c, 0x32a1, 0x32d6, 0x330b, 0x3340, 0x3376,
0x33ab, 0x33e0, 0x340a, 0x3425, 0x343f, 0x345a, 0x3474, 0x348f,
0x34a9, 0x34c4, 0x34de, 0x34f9, 0x3514, 0x352e, 0x3549, 0x3563,
0x357e, 0x3598, 0x35b3, 0x35cd, 0x35e8, 0x3602, 0x361d, 0x3637,
0x3652, 0x366c, 0x3687, 0x36a1, 0x36bc, 0x36d6, 0x36f1, 0x370b,
0x3726, 0x3740, 0x375b, 0x3776, 0x3790, 0x37ab, 0x37c5, 0x37e0,
0x37fa, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800,
0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800, 0x3800
};
| Max | 0 | Trifunik/zephyr | tests/lib/cmsis_dsp/basicmath/src/f16.pat | [
"Apache-2.0"
] |
new a[1000][500] = { { 0, 1, ... }, ... };
new b[2000][500] = { { 0, -1, ... }, ... };
main() {
a[0][0] = b[0][0];
#error OK
}
| PAWN | 1 | pawn-lang/pawn | source/compiler/tests/md_array_crash_gh_220.pwn | [
"Zlib"
] |
/*!40101 SET NAMES binary*/;
/*!40014 SET FOREIGN_KEY_CHECKS=0*/;
/*!40103 SET TIME_ZONE='+00:00' */;
INSERT INTO `tbl_multi_index` VALUES
("0+0+0",0),
("1+0+0",0);
INSERT INTO `tbl_multi_index` VALUES
("4+0+0",0),
("1+0+1",0),
("3+0+0",0),
("0+0+1",0),
("2+0+0",0),
("4+0+1",0),
("0+0+2",0),
("0+0+3",0),
("3+0+1",0),
("2+0+1",0),
("0+0+4",0),
("1+0+2",0),
("3+0+2",0),
("1+0+3",0),
("2+0+2",0),
("3+0+3",0),
("1+0+4",0),
("0+0+5",0),
("4+0+2",0),
("0+0+6",0),
("1+0+5",0),
("0+0+7",0),
("4+0+3",0),
("1+0+6",0),
("3+0+4",0),
("4+0+4",0),
("2+0+3",0),
("2+0+4",0),
("0+0+8",0),
("1+0+7",0),
("2+0+5",0),
("2+0+6",0),
("3+0+5",0),
("1+0+8",0),
("4+0+5",0),
("1+0+9",0),
("1+0+10",0),
("2+0+7",0),
("3+0+6",0),
("4+0+6",0),
("2+0+8",0),
("4+0+7",0),
("1+0+11",0),
("4+0+8",0),
("3+0+7",0),
("2+0+9",0),
("1+0+12",0),
("3+0+8",0),
("0+0+9",0),
("4+0+9",0),
("2+0+10",0),
("1+0+13",0),
("3+0+9",0),
("4+0+10",0),
("0+0+10",0),
("2+0+11",0),
("2+0+12",0),
("0+0+11",0),
("0+0+12",0),
("2+0+13",0),
("4+0+11",0),
("0+0+13",0),
("4+0+12",0),
("3+0+10",0),
("0+0+14",0),
("1+0+14",0),
("4+0+13",0),
("4+0+14",0),
("3+0+11",0),
("1+0+15",0),
("1+0+16",0),
("2+0+14",0),
("2+0+15",0),
("0+0+15",0),
("1+0+17",0),
("3+0+12",0),
("4+0+15",0),
("0+0+16",0),
("2+0+16",0),
("1+0+18",0),
("4+0+16",0),
("1+0+19",0),
("1+0+20",0),
("3+0+13",0),
("3+0+14",0),
("0+0+17",0),
("4+0+17",0),
("0+0+18",0),
("1+0+21",0),
("2+0+17",0),
("2+0+18",0),
("2+0+19",0),
("4+0+18",0),
("3+0+15",0),
("2+0+20",0),
("4+0+19",0),
("4+0+20",0),
("0+0+19",0),
("4+0+21",0),
("1+0+22",0),
("3+0+16",0),
("1+0+23",0),
("0+0+20",0),
("3+0+17",0),
("4+0+22",0),
("3+0+18",0),
("3+0+19",0),
("1+0+24",0),
("0+0+21",0),
("4+0+23",0),
("3+0+20",0),
("3+0+21",0),
("0+0+22",0),
("3+0+22",0),
("3+0+23",0),
("1+0+25",0),
("1+0+26",0),
("0+0+23",0),
("3+0+24",0),
("2+0+21",0),
("3+0+25",0),
("4+0+24",0),
("3+0+26",0),
("1+0+27",0),
("3+0+27",0),
("0+0+24",0),
("2+0+22",0),
("2+0+23",0),
("2+0+24",0),
("4+0+25",0),
("4+0+26",0),
("3+0+28",0),
("3+0+29",0),
("3+0+30",0),
("0+0+25",0),
("0+0+26",0),
("0+0+27",0),
("4+0+27",0),
("1+0+28",0),
("1+0+29",0),
("4+0+28",0),
("0+0+28",0),
("4+0+29",0),
("0+0+29",0),
("1+0+30",0),
("4+0+30",0),
("1+0+31",0),
("1+0+32",0),
("1+0+33",0),
("3+0+31",0),
("0+0+30",0),
("4+0+31",0),
("1+0+34",0),
("0+0+31",0),
("0+0+32",0),
("4+0+32",0),
("1+0+35",0),
("4+0+33",0),
("0+0+33",0),
("1+0+36",0),
("1+0+37",0),
("1+0+38",0),
("3+0+32",0),
("1+0+39",0),
("0+0+34",0),
("1+0+40",0),
("3+0+33",0);
INSERT INTO `tbl_multi_index` VALUES
("1+0+41",0),
("2+0+25",0),
("2+0+26",0),
("4+0+34",0),
("1+0+42",0),
("1+0+43",0),
("3+0+34",0),
("2+0+27",0),
("1+0+44",0),
("3+0+35",0),
("2+0+28",0),
("2+0+29",0),
("0+0+35",0),
("0+0+36",0),
("2+0+30",0),
("1+0+45",0),
("0+0+37",0),
("0+0+38",0),
("2+0+31",0),
("4+0+35",0),
("1+0+46",0),
("2+0+32",0),
("2+0+33",0),
("0+0+39",0),
("0+0+40",0),
("2+0+34",0),
("2+0+35",0),
("4+0+36",0),
("0+0+41",0),
("3+0+36",0),
("0+0+42",0),
("0+0+43",0),
("3+0+37",0),
("3+0+38",0),
("4+0+37",0),
("0+0+44",0),
("3+0+39",0),
("0+0+45",0),
("4+0+38",0),
("2+0+36",0),
("2+0+37",0),
("4+0+39",0),
("1+0+47",0),
("2+0+38",0),
("2+0+39",0),
("4+0+40",0),
("1+0+48",0),
("3+0+40",0),
("3+0+41",0),
("0+0+46",0),
("3+0+42",0),
("3+0+43",0),
("3+0+44",0),
("3+0+45",0),
("0+0+47",0),
("1+0+49",0),
("2+0+40",0),
("3+0+46",0),
("4+0+41",0),
("2+0+41",0),
("4+0+42",0),
("3+0+47",0),
("0+0+48",0),
("1+1+0",0),
("2+0+42",0),
("3+0+48",0),
("2+0+43",0),
("3+0+49",0),
("4+0+43",0),
("4+0+44",0),
("1+1+1",1),
("0+0+49",0),
("2+0+44",0),
("1+1+2",2),
("2+0+45",0),
("1+1+3",3),
("3+1+0",0),
("1+1+4",4),
("4+0+45",0),
("1+1+5",5),
("3+1+1",1),
("0+1+0",0),
("4+0+46",0),
("1+1+6",6),
("1+1+7",7),
("0+1+1",1),
("2+0+46",0),
("0+1+2",2),
("3+1+2",2),
("3+1+3",3),
("4+0+47",0),
("2+0+47",0),
("3+1+4",4),
("2+0+48",0),
("4+0+48",0),
("3+1+5",5);
INSERT INTO `tbl_multi_index` VALUES
("0+1+3",3),
("3+1+6",6),
("4+0+49",0),
("1+1+8",8),
("0+1+4",4),
("1+1+9",9),
("0+1+5",5),
("1+1+10",10),
("1+1+11",11),
("0+1+6",6),
("1+1+12",12),
("2+0+49",0),
("0+1+7",7),
("3+1+7",7),
("0+1+8",8),
("3+1+8",8),
("0+1+9",9),
("0+1+10",10),
("3+1+9",9),
("1+1+13",13),
("3+1+10",10),
("4+1+0",0),
("2+1+0",0),
("3+1+11",11),
("1+1+14",14),
("2+1+1",1),
("3+1+12",12),
("3+1+13",13),
("4+1+1",1),
("0+1+11",11),
("3+1+14",14),
("2+1+2",2),
("0+1+12",12),
("3+1+15",15),
("1+1+15",15),
("2+1+3",3),
("4+1+2",2),
("1+1+16",16),
("0+1+13",13),
("2+1+4",4),
("1+1+17",17),
("4+1+3",3),
("2+1+5",5),
("4+1+4",4),
("0+1+14",14),
("4+1+5",5),
("3+1+16",16),
("3+1+17",17),
("4+1+6",6),
("3+1+18",18),
("1+1+18",18),
("0+1+15",15),
("0+1+16",16),
("0+1+17",17),
("0+1+18",18),
("0+1+19",19),
("2+1+6",6),
("4+1+7",7),
("1+1+19",19),
("2+1+7",7),
("0+1+20",20),
("4+1+8",8),
("4+1+9",9),
("3+1+19",19),
("3+1+20",20),
("0+1+21",21),
("1+1+20",20),
("0+1+22",22),
("1+1+21",21),
("3+1+21",21),
("1+1+22",22),
("1+1+23",23),
("3+1+22",22),
("2+1+8",8),
("2+1+9",9),
("1+1+24",24),
("4+1+10",10),
("0+1+23",23),
("2+1+10",10),
("2+1+11",11),
("2+1+12",12),
("1+1+25",25),
("1+1+26",26),
("1+1+27",27),
("2+1+13",13),
("3+1+23",23),
("2+1+14",14),
("0+1+24",24),
("3+1+24",24),
("1+1+28",28),
("1+1+29",29),
("2+1+15",15),
("2+1+16",16),
("3+1+25",25),
("0+1+25",25),
("1+1+30",30),
("4+1+11",11),
("1+1+31",31),
("3+1+26",26),
("1+1+32",32),
("4+1+12",12),
("0+1+26",26),
("3+1+27",27),
("0+1+27",27),
("1+1+33",33),
("1+1+34",34),
("1+1+35",35),
("1+1+36",36),
("4+1+13",13),
("1+1+37",37),
("3+1+28",28),
("0+1+28",28),
("0+1+29",29),
("2+1+17",17),
("0+1+30",30),
("2+1+18",18),
("3+1+29",29);
INSERT INTO `tbl_multi_index` VALUES
("2+1+19",19),
("4+1+14",14),
("4+1+15",15),
("3+1+30",30),
("0+1+31",31),
("3+1+31",31),
("3+1+32",32),
("3+1+33",33),
("0+1+32",32),
("2+1+20",20),
("0+1+33",33),
("2+1+21",21),
("1+1+38",38),
("1+1+39",39),
("1+1+40",40),
("3+1+34",34),
("2+1+22",22),
("4+1+16",16),
("2+1+23",23),
("3+1+35",35),
("1+1+41",41),
("3+1+36",36),
("3+1+37",37),
("0+1+34",34),
("1+1+42",42),
("0+1+35",35),
("1+1+43",43),
("4+1+17",17),
("4+1+18",18),
("0+1+36",36),
("1+1+44",44),
("2+1+24",24),
("4+1+19",19),
("4+1+20",20),
("1+1+45",45),
("1+1+46",46),
("0+1+37",37),
("3+1+38",38),
("3+1+39",39),
("0+1+38",38),
("3+1+40",40),
("0+1+39",39),
("0+1+40",40),
("0+1+41",41),
("2+1+25",25),
("4+1+21",21),
("3+1+41",41),
("4+1+22",22),
("1+1+47",47),
("3+1+42",42),
("1+1+48",48),
("1+1+49",49),
("2+1+26",26),
("4+1+23",23),
("3+1+43",43),
("3+1+44",44),
("0+1+42",42),
("4+1+24",24),
("2+1+27",27),
("4+1+25",25),
("3+1+45",45),
("2+1+28",28),
("4+1+26",26),
("3+1+46",46),
("0+1+43",43),
("3+1+47",47),
("3+1+48",48),
("3+1+49",49),
("4+1+27",27),
("1+2+0",0),
("1+2+1",2),
("0+1+44",44),
("4+1+28",28),
("2+1+29",29),
("1+2+2",4),
("0+1+45",45),
("1+2+3",6),
("1+2+4",8),
("3+2+0",0),
("2+1+30",30),
("3+2+1",2),
("4+1+29",29),
("0+1+46",46),
("2+1+31",31),
("3+2+2",4),
("3+2+3",6),
("0+1+47",47),
("3+2+4",8),
("0+1+48",48),
("4+1+30",30),
("4+1+31",31),
("0+1+49",49),
("4+1+32",32),
("2+1+32",32),
("4+1+33",33),
("4+1+34",34),
("3+2+5",10),
("4+1+35",35),
("2+1+33",33),
("1+2+5",10),
("2+1+34",34),
("3+2+6",12),
("4+1+36",36),
("3+2+7",14),
("4+1+37",37),
("2+1+35",35),
("0+2+0",0),
("4+1+38",38),
("2+1+36",36),
("4+1+39",39),
("2+1+37",37),
("2+1+38",38),
("0+2+1",2),
("2+1+39",39),
("1+2+6",12),
("2+1+40",40),
("1+2+7",14),
("4+1+40",40),
("3+2+8",16),
("0+2+2",4),
("2+1+41",41),
("4+1+41",41),
("1+2+8",16),
("3+2+9",18),
("0+2+3",6),
("2+1+42",42),
("1+2+9",18),
("1+2+10",20),
("3+2+10",20),
("1+2+11",22),
("0+2+4",8),
("4+1+42",42),
("2+1+43",43),
("3+2+11",22),
("4+1+43",43),
("0+2+5",10),
("1+2+12",24),
("0+2+6",12),
("0+2+7",14),
("1+2+13",26),
("0+2+8",16),
("1+2+14",28),
("1+2+15",30),
("4+1+44",44),
("1+2+16",32),
("4+1+45",45),
("3+2+12",24),
("4+1+46",46),
("2+1+44",44),
("4+1+47",47),
("1+2+17",34),
("4+1+48",48),
("2+1+45",45),
("3+2+13",26),
("0+2+9",18),
("2+1+46",46),
("4+1+49",49),
("0+2+10",20),
("2+1+47",47),
("3+2+14",28),
("0+2+11",22),
("2+1+48",48),
("1+2+18",36),
("2+1+49",49),
("0+2+12",24),
("3+2+15",30),
("0+2+13",26),
("1+2+19",38),
("0+2+14",28),
("1+2+20",40),
("1+2+21",42),
("2+2+0",0),
("1+2+22",44),
("1+2+23",46),
("4+2+0",0),
("0+2+15",30),
("4+2+1",2),
("2+2+1",2),
("3+2+16",32),
("2+2+2",4),
("0+2+16",32),
("0+2+17",34),
("2+2+3",6),
("3+2+17",34),
("3+2+18",36),
("2+2+4",8),
("0+2+18",36),
("2+2+5",10),
("1+2+24",48),
("2+2+6",12),
("3+2+19",38),
("4+2+2",4),
("3+2+20",40),
("2+2+7",14),
("1+2+25",50),
("1+2+26",52),
("2+2+8",16),
("4+2+3",6),
("2+2+9",18),
("3+2+21",42),
("4+2+4",8),
("3+2+22",44),
("0+2+19",38),
("0+2+20",40),
("2+2+10",20),
("1+2+27",54),
("0+2+21",42),
("2+2+11",22),
("2+2+12",24),
("4+2+5",10),
("2+2+13",26),
("2+2+14",28),
("1+2+28",56),
("4+2+6",12),
("2+2+15",30),
("1+2+29",58),
("3+2+23",46),
("0+2+22",44),
("4+2+7",14),
("1+2+30",60),
("2+2+16",32),
("3+2+24",48),
("0+2+23",46),
("4+2+8",16),
("2+2+17",34),
("2+2+18",36),
("0+2+24",48),
("0+2+25",50),
("2+2+19",38),
("2+2+20",40),
("1+2+31",62),
("2+2+21",42),
("0+2+26",52),
("1+2+32",64),
("1+2+33",66),
("2+2+22",44),
("0+2+27",54),
("0+2+28",56),
("1+2+34",68),
("3+2+25",50),
("3+2+26",52),
("2+2+23",46),
("3+2+27",54),
("3+2+28",56),
("2+2+24",48),
("1+2+35",70),
("3+2+29",58),
("2+2+25",50),
("2+2+26",52),
("0+2+29",58),
("2+2+27",54),
("1+2+36",72),
("4+2+9",18),
("4+2+10",20),
("2+2+28",56),
("1+2+37",74),
("0+2+30",60),
("1+2+38",76),
("4+2+11",22),
("0+2+31",62),
("4+2+12",24),
("2+2+29",58),
("3+2+30",60),
("2+2+30",60),
("3+2+31",62),
("1+2+39",78),
("4+2+13",26),
("1+2+40",80),
("2+2+31",62),
("1+2+41",82),
("1+2+42",84),
("1+2+43",86),
("2+2+32",64),
("0+2+32",64),
("0+2+33",66),
("0+2+34",68),
("3+2+32",64),
("4+2+14",28),
("0+2+35",70),
("3+2+33",66),
("3+2+34",68),
("1+2+44",88),
("1+2+45",90),
("4+2+15",30),
("1+2+46",92),
("3+2+35",70),
("1+2+47",94),
("1+2+48",96),
("0+2+36",72),
("3+2+36",72),
("4+2+16",32),
("2+2+33",66),
("3+2+37",74),
("3+2+38",76),
("1+2+49",98),
("4+2+17",34),
("4+2+18",36),
("0+2+37",74),
("3+2+39",78),
("0+2+38",76),
("3+2+40",80),
("4+2+19",38),
("3+2+41",82),
("1+3+0",0),
("1+3+1",3),
("4+2+20",40),
("4+2+21",42),
("4+2+22",44),
("0+2+39",78),
("0+2+40",80),
("0+2+41",82),
("4+2+23",46),
("4+2+24",48),
("2+2+34",68),
("0+2+42",84),
("2+2+35",70),
("0+2+43",86),
("1+3+2",6),
("4+2+25",50),
("4+2+26",52),
("4+2+27",54),
("3+2+42",84),
("4+2+28",56),
("2+2+36",72),
("3+2+43",86),
("1+3+3",9),
("2+2+37",74),
("0+2+44",88),
("4+2+29",58),
("2+2+38",76),
("0+2+45",90),
("4+2+30",60),
("3+2+44",88),
("0+2+46",92),
("2+2+39",78),
("1+3+4",12),
("4+2+31",62),
("4+2+32",64),
("3+2+45",90),
("1+3+5",15),
("0+2+47",94),
("3+2+46",92),
("3+2+47",94),
("1+3+6",18),
("0+2+48",96),
("1+3+7",21),
("0+2+49",98),
("1+3+8",24),
("4+2+33",66),
("2+2+40",80),
("4+2+34",68),
("1+3+9",27),
("2+2+41",82),
("1+3+10",30),
("4+2+35",70),
("1+3+11",33),
("2+2+42",84),
("0+3+0",0),
("4+2+36",72),
("3+2+48",96),
("0+3+1",3),
("0+3+2",6),
("1+3+12",36),
("3+2+49",98),
("4+2+37",74),
("0+3+3",9),
("0+3+4",12),
("4+2+38",76),
("2+2+43",86),
("0+3+5",15),
("4+2+39",78),
("1+3+13",39),
("1+3+14",42),
("0+3+6",18),
("4+2+40",80),
("0+3+7",21),
("4+2+41",82),
("1+3+15",45),
("2+2+44",88),
("0+3+8",24),
("1+3+16",48),
("2+2+45",90),
("0+3+9",27),
("3+3+0",0),
("1+3+17",51),
("3+3+1",3),
("0+3+10",30),
("4+2+42",84),
("0+3+11",33),
("2+2+46",92),
("4+2+43",86),
("1+3+18",54),
("4+2+44",88);
INSERT INTO `tbl_multi_index` VALUES
("4+2+45",90),
("2+2+47",94),
("4+2+46",92),
("1+3+19",57),
("2+2+48",96),
("4+2+47",94),
("2+2+49",98),
("1+3+20",60),
("1+3+21",63),
("1+3+22",66),
("0+3+12",36),
("3+3+2",6),
("0+3+13",39),
("4+2+48",96),
("3+3+3",9),
("4+2+49",98),
("2+3+0",0),
("1+3+23",69),
("0+3+14",42),
("1+3+24",72),
("0+3+15",45),
("0+3+16",48),
("2+3+1",3),
("1+3+25",75),
("0+3+17",51),
("0+3+18",54),
("0+3+19",57),
("1+3+26",78),
("3+3+4",12),
("0+3+20",60),
("2+3+2",6),
("4+3+0",0),
("1+3+27",81),
("4+3+1",3),
("1+3+28",84),
("2+3+3",9),
("4+3+2",6),
("0+3+21",63),
("2+3+4",12),
("4+3+3",9),
("3+3+5",15),
("4+3+4",12),
("3+3+6",18),
("3+3+7",21),
("0+3+22",66),
("1+3+29",87),
("4+3+5",15),
("0+3+23",69),
("3+3+8",24),
("4+3+6",18),
("2+3+5",15),
("2+3+6",18),
("0+3+24",72),
("0+3+25",75),
("3+3+9",27),
("4+3+7",21),
("0+3+26",78),
("1+3+30",90),
("4+3+8",24),
("2+3+7",21),
("4+3+9",27),
("4+3+10",30),
("0+3+27",81),
("1+3+31",93),
("2+3+8",24),
("0+3+28",84),
("1+3+32",96),
("0+3+29",87),
("4+3+11",33),
("0+3+30",90),
("1+3+33",99);
INSERT INTO `tbl_multi_index` VALUES
("2+3+9",27),
("3+3+10",30),
("3+3+11",33),
("1+3+34",102),
("0+3+31",93),
("2+3+10",30),
("1+3+35",105),
("2+3+11",33),
("1+3+36",108),
("0+3+32",96),
("4+3+12",36),
("2+3+12",36),
("2+3+13",39),
("4+3+13",39),
("3+3+12",36),
("0+3+33",99),
("3+3+13",39),
("4+3+14",42),
("1+3+37",111),
("0+3+34",102),
("4+3+15",45),
("1+3+38",114),
("1+3+39",117),
("3+3+14",42),
("4+3+16",48),
("1+3+40",120),
("0+3+35",105),
("0+3+36",108),
("2+3+14",42),
("2+3+15",45),
("0+3+37",111),
("2+3+16",48),
("1+3+41",123),
("0+3+38",114),
("1+3+42",126),
("3+3+15",45),
("2+3+17",51),
("3+3+16",48),
("1+3+43",129),
("0+3+39",117),
("4+3+17",51),
("3+3+17",51),
("4+3+18",54),
("1+3+44",132),
("1+3+45",135),
("0+3+40",120),
("4+3+19",57),
("0+3+41",123),
("3+3+18",54),
("4+3+20",60),
("1+3+46",138),
("1+3+47",141),
("3+3+19",57),
("2+3+18",54),
("4+3+21",63),
("2+3+19",57),
("0+3+42",126),
("2+3+20",60),
("3+3+20",60),
("1+3+48",144),
("4+3+22",66),
("0+3+43",129),
("0+3+44",132),
("2+3+21",63),
("1+3+49",147),
("2+3+22",66),
("4+3+23",69),
("0+3+45",135),
("4+3+24",72),
("0+3+46",138),
("3+3+21",63),
("4+3+25",75),
("3+3+22",66),
("0+3+47",141),
("3+3+23",69),
("2+3+23",69),
("1+4+0",0),
("2+3+24",72),
("3+3+24",72),
("4+3+26",78),
("1+4+1",4),
("1+4+2",8),
("3+3+25",75),
("0+3+48",144),
("2+3+25",75),
("2+3+26",78),
("0+3+49",147),
("4+3+27",81),
("1+4+3",12),
("2+3+27",81),
("2+3+28",84),
("3+3+26",78),
("4+3+28",84),
("0+4+0",0),
("2+3+29",87),
("4+3+29",87),
("3+3+27",81),
("1+4+4",16),
("2+3+30",90),
("1+4+5",20),
("2+3+31",93),
("4+3+30",90),
("3+3+28",84),
("4+3+31",93),
("0+4+1",4),
("2+3+32",96),
("4+3+32",96),
("3+3+29",87),
("1+4+6",24),
("0+4+2",8),
("2+3+33",99),
("4+3+33",99),
("3+3+30",90),
("2+3+34",102),
("0+4+3",12),
("2+3+35",105),
("4+3+34",102),
("3+3+31",93),
("4+3+35",105),
("1+4+7",28),
("2+3+36",108),
("0+4+4",16),
("3+3+32",96),
("2+3+37",111),
("3+3+33",99),
("2+3+38",114),
("4+3+36",108),
("1+4+8",32),
("3+3+34",102),
("0+4+5",20),
("1+4+9",36),
("4+3+37",111),
("0+4+6",24),
("2+3+39",117),
("3+3+35",105),
("2+3+40",120),
("1+4+10",40),
("0+4+7",28),
("3+3+36",108),
("1+4+11",44),
("4+3+38",114),
("0+4+8",32),
("1+4+12",48),
("0+4+9",36),
("4+3+39",117),
("2+3+41",123),
("0+4+10",40),
("1+4+13",52),
("1+4+14",56),
("0+4+11",44),
("1+4+15",60),
("4+3+40",120),
("3+3+37",111),
("4+3+41",123),
("3+3+38",114),
("0+4+12",48),
("1+4+16",64),
("0+4+13",52),
("3+3+39",117),
("1+4+17",68),
("2+3+42",126),
("1+4+18",72),
("0+4+14",56),
("1+4+19",76),
("0+4+15",60),
("1+4+20",80),
("4+3+42",126),
("1+4+21",84),
("0+4+16",64),
("1+4+22",88),
("3+3+40",120),
("3+3+41",123),
("0+4+17",68),
("3+3+42",126),
("4+3+43",129),
("3+3+43",129),
("3+3+44",132),
("1+4+23",92),
("0+4+18",72),
("4+3+44",132),
("3+3+45",135),
("4+3+45",135),
("0+4+19",76),
("4+3+46",138),
("3+3+46",138),
("4+3+47",141),
("2+3+43",129),
("4+3+48",144),
("1+4+24",96),
("0+4+20",80),
("0+4+21",84),
("1+4+25",100),
("2+3+44",132),
("4+3+49",147),
("3+3+47",141),
("3+3+48",144),
("0+4+22",88),
("2+3+45",135),
("3+3+49",147),
("2+3+46",138),
("0+4+23",92),
("2+3+47",141),
("4+4+0",0),
("0+4+24",96),
("1+4+26",104),
("0+4+25",100),
("4+4+1",4),
("0+4+26",104),
("4+4+2",8),
("2+3+48",144),
("0+4+27",108),
("0+4+28",112),
("2+3+49",147),
("1+4+27",108),
("0+4+29",116),
("4+4+3",12),
("0+4+30",120),
("1+4+28",112),
("1+4+29",116),
("3+4+0",0),
("1+4+30",120),
("3+4+1",4),
("0+4+31",124),
("0+4+32",128),
("1+4+31",124),
("2+4+0",0),
("4+4+4",16),
("1+4+32",128),
("4+4+5",20),
("1+4+33",132),
("0+4+33",132),
("3+4+2",8),
("0+4+34",136),
("2+4+1",4),
("4+4+6",24),
("3+4+3",12),
("0+4+35",140),
("2+4+2",8),
("2+4+3",12),
("1+4+34",136),
("2+4+4",16),
("4+4+7",28),
("0+4+36",144),
("1+4+35",140),
("0+4+37",148),
("1+4+36",144),
("4+4+8",32),
("0+4+38",152),
("1+4+37",148),
("2+4+5",20),
("4+4+9",36),
("1+4+38",152),
("3+4+4",16),
("1+4+39",156),
("0+4+39",156),
("1+4+40",160),
("3+4+5",20),
("0+4+40",160),
("4+4+10",40),
("4+4+11",44),
("4+4+12",48),
("1+4+41",164),
("3+4+6",24),
("3+4+7",28),
("2+4+6",24),
("4+4+13",52),
("2+4+7",28),
("4+4+14",56),
("4+4+15",60),
("3+4+8",32),
("2+4+8",32),
("4+4+16",64),
("0+4+41",164),
("0+4+42",168),
("3+4+9",36),
("1+4+42",168),
("0+4+43",172),
("1+4+43",172),
("0+4+44",176),
("1+4+44",176),
("1+4+45",180),
("0+4+45",180),
("4+4+17",68),
("2+4+9",36),
("0+4+46",184),
("0+4+47",188),
("1+4+46",184),
("2+4+10",40),
("0+4+48",192),
("3+4+10",40),
("4+4+18",72),
("0+4+49",196),
("1+4+47",188),
("2+4+11",44),
("3+4+11",44),
("2+4+12",48),
("3+4+12",48),
("1+4+48",192),
("2+4+13",52),
("0+5+0",0),
("3+4+13",52),
("4+4+19",76),
("4+4+20",80),
("1+4+49",196),
("4+4+21",84),
("4+4+22",88),
("3+4+14",56),
("3+4+15",60),
("4+4+23",92),
("2+4+14",56),
("0+5+1",5),
("3+4+16",64),
("3+4+17",68),
("2+4+15",60),
("0+5+2",10),
("4+4+24",96),
("0+5+3",15),
("0+5+4",20),
("0+5+5",25),
("4+4+25",100),
("4+4+26",104),
("2+4+16",64),
("4+4+27",108),
("3+4+18",72),
("2+4+17",68),
("0+5+6",30),
("4+4+28",112),
("4+4+29",116),
("2+4+18",72),
("2+4+19",76),
("3+4+19",76),
("4+4+30",120),
("2+4+20",80),
("0+5+7",35),
("0+5+8",40),
("3+4+20",80),
("0+5+9",45),
("4+4+31",124),
("2+4+21",84),
("2+4+22",88),
("4+4+32",128),
("0+5+10",50),
("0+5+11",55),
("4+4+33",132),
("4+4+34",136),
("2+4+23",92),
("0+5+12",60),
("0+5+13",65),
("0+5+14",70),
("0+5+15",75),
("4+4+35",140),
("2+4+24",96),
("2+4+25",100),
("0+5+16",80),
("0+5+17",85),
("0+5+18",90),
("3+4+21",84),
("3+4+22",88),
("4+4+36",144),
("2+4+26",104),
("3+4+23",92),
("0+5+19",95),
("3+4+24",96),
("4+4+37",148),
("3+4+25",100),
("4+4+38",152),
("2+4+27",108),
("4+4+39",156),
("0+5+20",100),
("2+4+28",112),
("3+4+26",104),
("0+5+21",105),
("4+4+40",160),
("4+4+41",164),
("3+4+27",108),
("3+4+28",112),
("4+4+42",168),
("3+4+29",116),
("0+5+22",110),
("0+5+23",115),
("4+4+43",172),
("2+4+29",116),
("3+4+30",120),
("0+5+24",120),
("3+4+31",124),
("4+4+44",176),
("2+4+30",120),
("4+4+45",180),
("4+4+46",184),
("3+4+32",128),
("4+4+47",188),
("0+5+25",125),
("3+4+33",132),
("2+4+31",124),
("2+4+32",128),
("0+5+26",130),
("4+4+48",192),
("2+4+33",132),
("4+4+49",196),
("0+5+27",135),
("3+4+34",136),
("2+4+34",136),
("3+4+35",140),
("0+5+28",140),
("2+4+35",140),
("0+5+29",145),
("2+4+36",144),
("0+5+30",150),
("3+4+36",144),
("0+5+31",155),
("3+4+37",148),
("0+5+32",160),
("2+4+37",148),
("2+4+38",152),
("2+4+39",156),
("3+4+38",152),
("3+4+39",156),
("3+4+40",160),
("0+5+33",165),
("3+4+41",164),
("2+4+40",160),
("3+4+42",168),
("0+5+34",170),
("0+5+35",175),
("3+4+43",172),
("3+4+44",176),
("2+4+41",164),
("3+4+45",180),
("0+5+36",180),
("2+4+42",168),
("3+4+46",184),
("3+4+47",188),
("3+4+48",192),
("0+5+37",185),
("3+4+49",196),
("2+4+43",172),
("2+4+44",176),
("2+4+45",180),
("2+4+46",184),
("2+4+47",188),
("2+4+48",192),
("0+5+38",190),
("2+4+49",196),
("0+5+39",195),
("0+5+40",200),
("0+5+41",205),
("0+5+42",210),
("0+5+43",215),
("0+5+44",220),
("0+5+45",225),
("0+5+46",230),
("0+5+47",235),
("0+5+48",240),
("0+5+49",245),
("1+5+0",0),
("1+5+1",5),
("1+5+2",10),
("1+5+3",15),
("1+5+4",20),
("1+5+5",25),
("1+5+6",30),
("1+5+7",35),
("1+5+8",40),
("1+5+9",45),
("1+5+10",50),
("1+5+11",55),
("1+5+12",60),
("1+5+13",65),
("1+5+14",70),
("1+5+15",75),
("1+5+16",80),
("1+5+17",85),
("1+5+18",90),
("1+5+19",95),
("1+5+20",100),
("1+5+21",105),
("1+5+22",110),
("1+5+23",115),
("1+5+24",120),
("1+5+25",125),
("1+5+26",130),
("1+5+27",135),
("1+5+28",140),
("1+5+29",145),
("1+5+30",150),
("1+5+31",155),
("1+5+32",160),
("1+5+33",165),
("1+5+34",170),
("1+5+35",175),
("1+5+36",180),
("1+5+37",185),
("1+5+38",190),
("1+5+39",195),
("1+5+40",200),
("1+5+41",205),
("1+5+42",210),
("1+5+43",215),
("1+5+44",220),
("1+5+45",225),
("1+5+46",230),
("1+5+47",235),
("4+5+0",0),
("2+5+0",0),
("1+5+48",240),
("1+5+49",245),
("0+6+0",0),
("3+5+0",0),
("4+5+1",5),
("2+5+1",5),
("0+6+1",6),
("4+5+2",10),
("2+5+2",10),
("4+5+3",15),
("0+6+2",12),
("3+5+1",5),
("4+5+4",20),
("0+6+3",18),
("1+6+0",0),
("3+5+2",10),
("4+5+5",25),
("1+6+1",6),
("2+5+3",15),
("4+5+6",30),
("3+5+3",15),
("0+6+4",24),
("3+5+4",20),
("1+6+2",12),
("1+6+3",18),
("4+5+7",35),
("3+5+5",25),
("2+5+4",20),
("1+6+4",24),
("4+5+8",40),
("0+6+5",30),
("4+5+9",45),
("1+6+5",30),
("2+5+5",25),
("3+5+6",30),
("2+5+6",30),
("1+6+6",36),
("0+6+6",36),
("3+5+7",35),
("4+5+10",50),
("1+6+7",42),
("2+5+7",35),
("1+6+8",48),
("4+5+11",55),
("3+5+8",40),
("2+5+8",40),
("0+6+7",42),
("3+5+9",45),
("0+6+8",48),
("0+6+9",54),
("4+5+12",60),
("2+5+9",45),
("0+6+10",60),
("3+5+10",50),
("0+6+11",66),
("4+5+13",65),
("3+5+11",55),
("3+5+12",60),
("1+6+9",54),
("0+6+12",72),
("4+5+14",70),
("3+5+13",65),
("3+5+14",70),
("4+5+15",75),
("2+5+10",50),
("3+5+15",75),
("0+6+13",78),
("3+5+16",80),
("4+5+16",80),
("0+6+14",84),
("4+5+17",85),
("0+6+15",90),
("1+6+10",60),
("4+5+18",90),
("3+5+17",85),
("2+5+11",55),
("0+6+16",96),
("1+6+11",66),
("1+6+12",72),
("2+5+12",60),
("1+6+13",78),
("3+5+18",90),
("1+6+14",84),
("1+6+15",90),
("4+5+19",95),
("3+5+19",95),
("4+5+20",100),
("1+6+16",96),
("0+6+17",102),
("4+5+21",105),
("3+5+20",100),
("3+5+21",105),
("2+5+13",65),
("4+5+22",110),
("3+5+22",110),
("2+5+14",70),
("1+6+17",102),
("2+5+15",75),
("0+6+18",108),
("1+6+18",108),
("4+5+23",115),
("3+5+23",115),
("2+5+16",80),
("2+5+17",85),
("4+5+24",120),
("3+5+24",120),
("0+6+19",114),
("2+5+18",90),
("1+6+19",114),
("1+6+20",120),
("2+5+19",95),
("2+5+20",100),
("2+5+21",105),
("4+5+25",125),
("0+6+20",120),
("1+6+21",126),
("4+5+26",130),
("2+5+22",110),
("3+5+25",125),
("4+5+27",135),
("4+5+28",140),
("0+6+21",126),
("3+5+26",130),
("2+5+23",115),
("3+5+27",135),
("0+6+22",132),
("2+5+24",120),
("2+5+25",125),
("1+6+22",132),
("3+5+28",140),
("2+5+26",130),
("4+5+29",145),
("1+6+23",138),
("3+5+29",145),
("4+5+30",150),
("4+5+31",155),
("1+6+24",144),
("4+5+32",160),
("3+5+30",150),
("0+6+23",138),
("2+5+27",135),
("1+6+25",150),
("4+5+33",165),
("1+6+26",156),
("3+5+31",155),
("2+5+28",140),
("1+6+27",162),
("2+5+29",145),
("1+6+28",168),
("1+6+29",174),
("3+5+32",160),
("3+5+33",165),
("4+5+34",170),
("0+6+24",144),
("3+5+34",170),
("3+5+35",175),
("4+5+35",175),
("3+5+36",180),
("2+5+30",150),
("0+6+25",150),
("0+6+26",156),
("1+6+30",180),
("0+6+27",162),
("0+6+28",168),
("4+5+36",180),
("4+5+37",185),
("1+6+31",186),
("0+6+29",174),
("0+6+30",180),
("3+5+37",185),
("2+5+31",155),
("0+6+31",186),
("3+5+38",190),
("0+6+32",192),
("1+6+32",192),
("0+6+33",198),
("2+5+32",160),
("1+6+33",198),
("0+6+34",204),
("4+5+38",190),
("4+5+39",195),
("3+5+39",195),
("2+5+33",165),
("2+5+34",170),
("4+5+40",200),
("3+5+40",200),
("2+5+35",175),
("3+5+41",205),
("4+5+41",205),
("1+6+34",204),
("0+6+35",210),
("3+5+42",210),
("2+5+36",180),
("0+6+36",216),
("2+5+37",185),
("2+5+38",190),
("2+5+39",195),
("4+5+42",210),
("2+5+40",200),
("4+5+43",215),
("4+5+44",220),
("4+5+45",225),
("2+5+41",205),
("4+5+46",230),
("1+6+35",210),
("2+5+42",210),
("0+6+37",222),
("1+6+36",216),
("3+5+43",215),
("4+5+47",235),
("1+6+37",222),
("3+5+44",220),
("2+5+43",215),
("1+6+38",228),
("0+6+38",228),
("2+5+44",220),
("0+6+39",234),
("0+6+40",240),
("3+5+45",225),
("1+6+39",234),
("0+6+41",246),
("4+5+48",240),
("4+5+49",245),
("0+6+42",252),
("3+5+46",230),
("2+5+45",225),
("1+6+40",240),
("2+5+46",230),
("3+5+47",235),
("3+5+48",240),
("1+6+41",246),
("2+5+47",235),
("1+6+42",252),
("3+5+49",245),
("2+5+48",240),
("1+6+43",258),
("1+6+44",264),
("2+5+49",245),
("4+6+0",0),
("4+6+1",6),
("0+6+43",258),
("1+6+45",270),
("4+6+2",12),
("1+6+46",276),
("3+6+0",0),
("4+6+3",18),
("0+6+44",264),
("4+6+4",24),
("0+6+45",270),
("4+6+5",30),
("1+6+47",282),
("3+6+1",6),
("0+6+46",276),
("3+6+2",12),
("4+6+6",36),
("0+6+47",282),
("4+6+7",42),
("0+6+48",288),
("2+6+0",0),
("4+6+8",48),
("3+6+3",18),
("0+6+49",294),
("3+6+4",24),
("2+6+1",6),
("3+6+5",30),
("4+6+9",54),
("1+6+48",288),
("4+6+10",60),
("1+6+49",294),
("0+7+0",0),
("4+6+11",66),
("4+6+12",72),
("0+7+1",7),
("3+6+6",36),
("0+7+2",14),
("3+6+7",42),
("2+6+2",12),
("3+6+8",48),
("4+6+13",78),
("3+6+9",54),
("0+7+3",21),
("2+6+3",18),
("3+6+10",60),
("0+7+4",28),
("1+7+0",0),
("3+6+11",66),
("2+6+4",24),
("0+7+5",35),
("2+6+5",30),
("0+7+6",42),
("1+7+1",7),
("0+7+7",49),
("1+7+2",14),
("0+7+8",56),
("3+6+12",72),
("0+7+9",63),
("3+6+13",78),
("0+7+10",70),
("2+6+6",36),
("0+7+11",77),
("2+6+7",42),
("3+6+14",84),
("2+6+8",48),
("1+7+3",21),
("3+6+15",90),
("4+6+14",84),
("3+6+16",96),
("2+6+9",54),
("0+7+12",84),
("2+6+10",60),
("1+7+4",28),
("3+6+17",102),
("2+6+11",66),
("4+6+15",90),
("1+7+5",35),
("4+6+16",96),
("1+7+6",42),
("3+6+18",108),
("1+7+7",49),
("4+6+17",102),
("4+6+18",108),
("2+6+12",72),
("3+6+19",114),
("2+6+13",78),
("1+7+8",56),
("4+6+19",114),
("2+6+14",84),
("3+6+20",120),
("4+6+20",120),
("2+6+15",90),
("1+7+9",63),
("3+6+21",126),
("3+6+22",132),
("4+6+21",126),
("3+6+23",138),
("3+6+24",144),
("4+6+22",132),
("4+6+23",138),
("3+6+25",150),
("0+7+13",91),
("2+6+16",96),
("1+7+10",70),
("0+7+14",98),
("4+6+24",144),
("3+6+26",156),
("0+7+15",105),
("1+7+11",77),
("2+6+17",102),
("4+6+25",150),
("0+7+16",112),
("1+7+12",84),
("4+6+26",156),
("1+7+13",91),
("2+6+18",108),
("1+7+14",98),
("2+6+19",114),
("3+6+27",162),
("4+6+27",162),
("3+6+28",168),
("4+6+28",168),
("1+7+15",105),
("0+7+17",119),
("3+6+29",174),
("2+6+20",120),
("0+7+18",126),
("0+7+19",133),
("2+6+21",126),
("0+7+20",140),
("3+6+30",180),
("0+7+21",147),
("1+7+16",112),
("0+7+22",154),
("1+7+17",119),
("3+6+31",186),
("4+6+29",174),
("1+7+18",126),
("4+6+30",180),
("4+6+31",186),
("2+6+22",132),
("1+7+19",133),
("1+7+20",140),
("2+6+23",138),
("3+6+32",192),
("2+6+24",144),
("2+6+25",150),
("4+6+32",192),
("0+7+23",161),
("3+6+33",198),
("2+6+26",156),
("1+7+21",147),
("1+7+22",154),
("2+6+27",162),
("4+6+33",198),
("4+6+34",204),
("1+7+23",161),
("2+6+28",168),
("0+7+24",168),
("2+6+29",174),
("3+6+34",204),
("2+6+30",180),
("0+7+25",175),
("4+6+35",210),
("0+7+26",182),
("4+6+36",216),
("2+6+31",186),
("0+7+27",189),
("1+7+24",168),
("4+6+37",222),
("3+6+35",210),
("3+6+36",216),
("2+6+32",192),
("1+7+25",175),
("4+6+38",228),
("2+6+33",198),
("0+7+28",196),
("4+6+39",234),
("4+6+40",240),
("1+7+26",182),
("3+6+37",222),
("3+6+38",228),
("4+6+41",246),
("2+6+34",204),
("3+6+39",234),
("2+6+35",210),
("0+7+29",203),
("3+6+40",240),
("0+7+30",210),
("2+6+36",216),
("1+7+27",189),
("4+6+42",252),
("2+6+37",222),
("4+6+43",258),
("1+7+28",196),
("3+6+41",246),
("1+7+29",203),
("2+6+38",228),
("2+6+39",234),
("4+6+44",264),
("0+7+31",217),
("4+6+45",270),
("1+7+30",210),
("3+6+42",252),
("0+7+32",224),
("3+6+43",258),
("3+6+44",264),
("2+6+40",240),
("0+7+33",231),
("1+7+31",217),
("2+6+41",246),
("4+6+46",276),
("1+7+32",224),
("1+7+33",231),
("2+6+42",252),
("3+6+45",270),
("3+6+46",276),
("0+7+34",238),
("3+6+47",282),
("4+6+47",282),
("2+6+43",258),
("1+7+34",238),
("2+6+44",264),
("1+7+35",245),
("4+6+48",288),
("3+6+48",288),
("0+7+35",245),
("4+6+49",294),
("0+7+36",252),
("2+6+45",270),
("0+7+37",259),
("2+6+46",276),
("0+7+38",266),
("1+7+36",252),
("0+7+39",273),
("0+7+40",280),
("3+6+49",294),
("2+6+47",282),
("1+7+37",259),
("4+7+0",0),
("2+6+48",288),
("2+6+49",294),
("0+7+41",287),
("1+7+38",266),
("0+7+42",294),
("4+7+1",7),
("0+7+43",301),
("4+7+2",14),
("1+7+39",273),
("4+7+3",21),
("3+7+0",0),
("1+7+40",280),
("0+7+44",308),
("1+7+41",287),
("1+7+42",294),
("0+7+45",315),
("4+7+4",28),
("1+7+43",301),
("4+7+5",35),
("1+7+44",308),
("1+7+45",315),
("3+7+1",7),
("4+7+6",42),
("2+7+0",0),
("3+7+2",14),
("2+7+1",7),
("0+7+46",322),
("4+7+7",49),
("0+7+47",329),
("3+7+3",21),
("0+7+48",336),
("4+7+8",56),
("1+7+46",322),
("3+7+4",28),
("3+7+5",35),
("2+7+2",14),
("1+7+47",329),
("1+7+48",336),
("2+7+3",21),
("0+7+49",343),
("2+7+4",28),
("2+7+5",35),
("3+7+6",42),
("2+7+6",42),
("3+7+7",49),
("4+7+9",63),
("0+8+0",0),
("4+7+10",70),
("2+7+7",49),
("1+7+49",343),
("0+8+1",8),
("0+8+2",16),
("2+7+8",56),
("0+8+3",24),
("3+7+8",56),
("3+7+9",63),
("0+8+4",32),
("3+7+10",70),
("0+8+5",40),
("4+7+11",77),
("3+7+11",77),
("2+7+9",63),
("4+7+12",84),
("2+7+10",70),
("3+7+12",84),
("0+8+6",48),
("4+7+13",91),
("2+7+11",77),
("0+8+7",56),
("2+7+12",84),
("1+8+0",0),
("0+8+8",64),
("1+8+1",8),
("3+7+13",91),
("2+7+13",91),
("1+8+2",16),
("1+8+3",24),
("1+8+4",32),
("3+7+14",98),
("4+7+14",98),
("3+7+15",105),
("4+7+15",105),
("2+7+14",98),
("4+7+16",112),
("1+8+5",40),
("0+8+9",72),
("3+7+16",112),
("4+7+17",119),
("3+7+17",119),
("1+8+6",48),
("4+7+18",126),
("4+7+19",133),
("3+7+18",126),
("3+7+19",133),
("0+8+10",80),
("4+7+20",140),
("4+7+21",147),
("3+7+20",140),
("1+8+7",56),
("4+7+22",154),
("0+8+11",88),
("4+7+23",161),
("0+8+12",96),
("3+7+21",147),
("4+7+24",168),
("4+7+25",175),
("3+7+22",154),
("1+8+8",64),
("0+8+13",104),
("1+8+9",72),
("4+7+26",182),
("0+8+14",112),
("2+7+15",105),
("0+8+15",120),
("2+7+16",112),
("1+8+10",80),
("4+7+27",189),
("2+7+17",119),
("0+8+16",128),
("4+7+28",196),
("1+8+11",88),
("2+7+18",126),
("0+8+17",136),
("3+7+23",161),
("4+7+29",203),
("0+8+18",144),
("0+8+19",152),
("0+8+20",160),
("4+7+30",210),
("1+8+12",96),
("0+8+21",168),
("0+8+22",176),
("2+7+19",133),
("0+8+23",184),
("3+7+24",168),
("0+8+24",192),
("1+8+13",104),
("1+8+14",112),
("3+7+25",175),
("4+7+31",217),
("4+7+32",224),
("4+7+33",231),
("1+8+15",120),
("3+7+26",182),
("2+7+20",140),
("2+7+21",147),
("2+7+22",154),
("4+7+34",238),
("4+7+35",245),
("3+7+27",189),
("3+7+28",196),
("0+8+25",200),
("0+8+26",208),
("4+7+36",252),
("4+7+37",259),
("4+7+38",266),
("4+7+39",273),
("3+7+29",203),
("1+8+16",128),
("3+7+30",210),
("3+7+31",217),
("1+8+17",136),
("0+8+27",216),
("0+8+28",224),
("3+7+32",224),
("2+7+23",161),
("3+7+33",231),
("3+7+34",238),
("3+7+35",245),
("2+7+24",168),
("4+7+40",280),
("2+7+25",175),
("3+7+36",252),
("3+7+37",259),
("0+8+29",232),
("0+8+30",240),
("0+8+31",248),
("3+7+38",266),
("2+7+26",182),
("0+8+32",256),
("2+7+27",189),
("4+7+41",287),
("4+7+42",294),
("4+7+43",301),
("4+7+44",308),
("1+8+18",144),
("4+7+45",315),
("4+7+46",322),
("3+7+39",273),
("0+8+33",264),
("2+7+28",196),
("2+7+29",203),
("0+8+34",272),
("1+8+19",152),
("3+7+40",280),
("0+8+35",280),
("4+7+47",329),
("4+7+48",336),
("0+8+36",288),
("0+8+37",296),
("2+7+30",210),
("1+8+20",160),
("4+7+49",343),
("2+7+31",217),
("1+8+21",168),
("2+7+32",224),
("1+8+22",176),
("0+8+38",304),
("2+7+33",231),
("4+8+0",0),
("1+8+23",184),
("4+8+1",8),
("3+7+41",287),
("2+7+34",238),
("0+8+39",312),
("3+7+42",294),
("1+8+24",192),
("1+8+25",200),
("3+7+43",301),
("4+8+2",16),
("2+7+35",245),
("3+7+44",308),
("0+8+40",320),
("2+7+36",252),
("2+7+37",259),
("4+8+3",24),
("4+8+4",32),
("4+8+5",40),
("1+8+26",208),
("1+8+27",216),
("2+7+38",266),
("4+8+6",48),
("1+8+28",224),
("4+8+7",56),
("0+8+41",328),
("0+8+42",336),
("4+8+8",64),
("3+7+45",315),
("2+7+39",273),
("4+8+9",72),
("2+7+40",280),
("3+7+46",322),
("3+7+47",329),
("0+8+43",344),
("1+8+29",232),
("0+8+44",352),
("3+7+48",336),
("0+8+45",360),
("0+8+46",368),
("2+7+41",287),
("1+8+30",240),
("1+8+31",248),
("0+8+47",376),
("4+8+10",80),
("3+7+49",343),
("1+8+32",256),
("0+8+48",384),
("1+8+33",264),
("0+8+49",392),
("2+7+42",294),
("1+8+34",272),
("3+8+0",0),
("1+8+35",280),
("3+8+1",8),
("4+8+11",88),
("4+8+12",96),
("0+9+0",0),
("2+7+43",301),
("2+7+44",308),
("1+8+36",288),
("3+8+2",16),
("0+9+1",9),
("3+8+3",24),
("4+8+13",104),
("0+9+2",18),
("1+8+37",296),
("0+9+3",27),
("3+8+4",32),
("1+8+38",304),
("4+8+14",112),
("1+8+39",312),
("1+8+40",320),
("4+8+15",120),
("2+7+45",315),
("4+8+16",128),
("4+8+17",136),
("3+8+5",40),
("0+9+4",36),
("2+7+46",322),
("1+8+41",328),
("2+7+47",329),
("4+8+18",144),
("0+9+5",45),
("2+7+48",336),
("2+7+49",343),
("4+8+19",152),
("3+8+6",48),
("3+8+7",56),
("4+8+20",160),
("4+8+21",168),
("1+8+42",336),
("3+8+8",64),
("1+8+43",344),
("3+8+9",72),
("3+8+10",80),
("1+8+44",352),
("3+8+11",88),
("3+8+12",96),
("1+8+45",360),
("0+9+6",54),
("1+8+46",368),
("3+8+13",104),
("0+9+7",63),
("3+8+14",112),
("3+8+15",120),
("1+8+47",376),
("0+9+8",72),
("4+8+22",176),
("4+8+23",184),
("0+9+9",81),
("1+8+48",384),
("2+8+0",0),
("0+9+10",90),
("1+8+49",392),
("3+8+16",128),
("2+8+1",8),
("0+9+11",99),
("3+8+17",136),
("4+8+24",192),
("4+8+25",200),
("2+8+2",16),
("0+9+12",108),
("4+8+26",208),
("0+9+13",117),
("3+8+18",144),
("2+8+3",24),
("0+9+14",126),
("3+8+19",152),
("2+8+4",32),
("3+8+20",160),
("1+9+0",0),
("3+8+21",168),
("4+8+27",216),
("2+8+5",40),
("0+9+15",135),
("2+8+6",48),
("3+8+22",176),
("4+8+28",224),
("3+8+23",184),
("0+9+16",144),
("4+8+29",232),
("3+8+24",192),
("2+8+7",56),
("4+8+30",240),
("3+8+25",200),
("1+9+1",9),
("4+8+31",248),
("2+8+8",64),
("1+9+2",18),
("4+8+32",256),
("1+9+3",27),
("0+9+17",153),
("4+8+33",264),
("3+8+26",208),
("2+8+9",72),
("0+9+18",162),
("0+9+19",171),
("1+9+4",36),
("1+9+5",45),
("2+8+10",80),
("1+9+6",54),
("4+8+34",272),
("4+8+35",280),
("1+9+7",63),
("4+8+36",288),
("3+8+27",216),
("2+8+11",88),
("1+9+8",72),
("0+9+20",180),
("0+9+21",189),
("1+9+9",81),
("3+8+28",224),
("0+9+22",198),
("2+8+12",96),
("4+8+37",296),
("4+8+38",304),
("2+8+13",104),
("1+9+10",90),
("0+9+23",207),
("4+8+39",312),
("0+9+24",216),
("4+8+40",320),
("1+9+11",99),
("1+9+12",108),
("4+8+41",328),
("1+9+13",117),
("0+9+25",225),
("3+8+29",232),
("2+8+14",112),
("3+8+30",240),
("4+8+42",336),
("3+8+31",248),
("1+9+14",126),
("4+8+43",344),
("0+9+26",234),
("3+8+32",256),
("1+9+15",135),
("4+8+44",352),
("0+9+27",243),
("1+9+16",144),
("1+9+17",153),
("3+8+33",264),
("1+9+18",162),
("2+8+15",120),
("0+9+28",252),
("4+8+45",360),
("1+9+19",171),
("4+8+46",368),
("1+9+20",180),
("2+8+16",128),
("1+9+21",189),
("3+8+34",272),
("1+9+22",198),
("3+8+35",280),
("4+8+47",376),
("3+8+36",288),
("1+9+23",207),
("2+8+17",136),
("1+9+24",216),
("3+8+37",296),
("4+8+48",384),
("1+9+25",225),
("0+9+29",261),
("2+8+18",144),
("1+9+26",234),
("0+9+30",270),
("1+9+27",243),
("1+9+28",252),
("3+8+38",304),
("2+8+19",152),
("1+9+29",261),
("0+9+31",279),
("2+8+20",160),
("1+9+30",270),
("0+9+32",288),
("1+9+31",279),
("3+8+39",312),
("4+8+49",392),
("0+9+33",297),
("1+9+32",288),
("3+8+40",320),
("0+9+34",306),
("3+8+41",328),
("2+8+21",168),
("3+8+42",336),
("0+9+35",315),
("2+8+22",176),
("0+9+36",324),
("2+8+23",184),
("1+9+33",297),
("3+8+43",344),
("0+9+37",333),
("0+9+38",342),
("2+8+24",192),
("0+9+39",351),
("0+9+40",360),
("1+9+34",306),
("1+9+35",315),
("1+9+36",324),
("0+9+41",369),
("1+9+37",333),
("2+8+25",200),
("1+9+38",342),
("3+8+44",352),
("3+8+45",360),
("0+9+42",378),
("2+8+26",208),
("0+9+43",387),
("3+8+46",368),
("2+8+27",216),
("3+8+47",376),
("2+8+28",224),
("0+9+44",396),
("1+9+39",351),
("3+8+48",384),
("2+8+29",232),
("1+9+40",360),
("0+9+45",405),
("1+9+41",369),
("2+8+30",240),
("2+8+31",248),
("3+8+49",392),
("1+9+42",378),
("2+8+32",256),
("0+9+46",414),
("0+9+47",423),
("1+9+43",387),
("0+9+48",432),
("2+8+33",264),
("2+8+34",272),
("1+9+44",396),
("2+8+35",280),
("0+9+49",441),
("1+9+45",405),
("2+8+36",288),
("1+9+46",414),
("1+9+47",423),
("1+9+48",432),
("2+8+37",296),
("2+8+38",304),
("1+9+49",441),
("2+8+39",312),
("2+8+40",320),
("2+8+41",328),
("2+8+42",336),
("2+8+43",344),
("2+8+44",352),
("2+8+45",360),
("2+8+46",368),
("2+8+47",376),
("2+8+48",384),
("2+8+49",392),
("2+9+0",0),
("0+10+0",0),
("3+9+0",0),
("4+9+0",0),
("0+10+1",10),
("1+10+0",0),
("2+9+1",9),
("0+10+2",20),
("4+9+1",9),
("1+10+1",10),
("3+9+1",9),
("2+9+2",18),
("3+9+2",18),
("2+9+3",27),
("1+10+2",20),
("2+9+4",36),
("0+10+3",30),
("0+10+4",40),
("3+9+3",27),
("1+10+3",30),
("2+9+5",45),
("2+9+6",54),
("3+9+4",36),
("0+10+5",50),
("2+9+7",63),
("2+9+8",72),
("0+10+6",60),
("0+10+7",70),
("4+9+2",18),
("0+10+8",80),
("1+10+4",40),
("2+9+9",81),
("0+10+9",90),
("3+9+5",45),
("1+10+5",50),
("2+9+10",90),
("3+9+6",54),
("3+9+7",63),
("1+10+6",60),
("2+9+11",99),
("1+10+7",70),
("3+9+8",72),
("0+10+10",100),
("2+9+12",108),
("3+9+9",81),
("0+10+11",110),
("3+9+10",90),
("1+10+8",80),
("2+9+13",117),
("3+9+11",99),
("1+10+9",90),
("2+9+14",126),
("0+10+12",120),
("4+9+3",27),
("1+10+10",100),
("2+9+15",135),
("0+10+13",130),
("2+9+16",144),
("4+9+4",36),
("4+9+5",45),
("0+10+14",140),
("3+9+12",108),
("2+9+17",153),
("4+9+6",54),
("0+10+15",150),
("3+9+13",117),
("3+9+14",126),
("0+10+16",160),
("0+10+17",170),
("4+9+7",63),
("1+10+11",110),
("2+9+18",162),
("2+9+19",171),
("4+9+8",72),
("2+9+20",180),
("1+10+12",120),
("4+9+9",81),
("3+9+15",135),
("0+10+18",180),
("1+10+13",130),
("3+9+16",144),
("1+10+14",140),
("4+9+10",90),
("0+10+19",190),
("2+9+21",189),
("1+10+15",150),
("1+10+16",160),
("2+9+22",198),
("1+10+17",170),
("3+9+17",153),
("1+10+18",180),
("4+9+11",99),
("4+9+12",108),
("3+9+18",162),
("3+9+19",171),
("3+9+20",180),
("2+9+23",207),
("1+10+19",190),
("1+10+20",200),
("0+10+20",200),
("0+10+21",210),
("3+9+21",189),
("4+9+13",117),
("1+10+21",210),
("2+9+24",216),
("1+10+22",220),
("1+10+23",230),
("4+9+14",126),
("2+9+25",225),
("0+10+22",220),
("1+10+24",240),
("4+9+15",135),
("2+9+26",234),
("1+10+25",250),
("1+10+26",260),
("0+10+23",230),
("1+10+27",270),
("2+9+27",243),
("3+9+22",198),
("0+10+24",240),
("1+10+28",280),
("0+10+25",250),
("4+9+16",144),
("2+9+28",252),
("2+9+29",261),
("2+9+30",270),
("4+9+17",153),
("3+9+23",207),
("2+9+31",279),
("4+9+18",162),
("0+10+26",260),
("2+9+32",288),
("3+9+24",216),
("1+10+29",290),
("2+9+33",297),
("0+10+27",270),
("0+10+28",280),
("1+10+30",300),
("2+9+34",306),
("0+10+29",290),
("1+10+31",310),
("3+9+25",225),
("2+9+35",315),
("3+9+26",234),
("4+9+19",171),
("0+10+30",300),
("2+9+36",324),
("2+9+37",333),
("3+9+27",243),
("0+10+31",310),
("4+9+20",180),
("1+10+32",320),
("4+9+21",189),
("1+10+33",330),
("0+10+32",320),
("4+9+22",198),
("2+9+38",342),
("2+9+39",351),
("2+9+40",360),
("4+9+23",207),
("1+10+34",340),
("2+9+41",369),
("4+9+24",216),
("2+9+42",378),
("0+10+33",330),
("1+10+35",350),
("0+10+34",340),
("0+10+35",350),
("1+10+36",360),
("4+9+25",225),
("2+9+43",387),
("0+10+36",360),
("4+9+26",234),
("3+9+28",252),
("2+9+44",396),
("4+9+27",243),
("3+9+29",261),
("2+9+45",405),
("4+9+28",252),
("0+10+37",370),
("2+9+46",414),
("4+9+29",261),
("0+10+38",380),
("1+10+37",370),
("2+9+47",423),
("4+9+30",270),
("2+9+48",432),
("1+10+38",380),
("4+9+31",279),
("2+9+49",441),
("0+10+39",390),
("4+9+32",288),
("0+10+40",400),
("0+10+41",410),
("1+10+39",390),
("3+9+30",270),
("4+9+33",297),
("3+9+31",279),
("0+10+42",420),
("1+10+40",400),
("2+10+0",0),
("4+9+34",306),
("3+9+32",288),
("0+10+43",430),
("4+9+35",315),
("2+10+1",10),
("1+10+41",410),
("4+9+36",324),
("3+9+33",297),
("2+10+2",20),
("4+9+37",333),
("3+9+34",306),
("1+10+42",420),
("0+10+44",440),
("3+9+35",315),
("2+10+3",30),
("2+10+4",40),
("3+9+36",324),
("2+10+5",50),
("4+9+38",342),
("0+10+45",450),
("1+10+43",430),
("4+9+39",351),
("3+9+37",333),
("4+9+40",360),
("2+10+6",60),
("0+10+46",460),
("3+9+38",342),
("4+9+41",369),
("0+10+47",470),
("2+10+7",70),
("3+9+39",351),
("1+10+44",440),
("2+10+8",80),
("1+10+45",450),
("2+10+9",90),
("1+10+46",460),
("1+10+47",470),
("2+10+10",100),
("4+9+42",378),
("1+10+48",480),
("2+10+11",110),
("1+10+49",490),
("3+9+40",360),
("2+10+12",120),
("4+9+43",387),
("0+10+48",480),
("2+10+13",130),
("1+11+0",0),
("2+10+14",140),
("3+9+41",369),
("3+9+42",378),
("1+11+1",11),
("3+9+43",387),
("4+9+44",396),
("1+11+2",22),
("4+9+45",405),
("4+9+46",414),
("3+9+44",396),
("0+10+49",490),
("3+9+45",405),
("4+9+47",423),
("3+9+46",414),
("3+9+47",423),
("4+9+48",432),
("2+10+15",150),
("3+9+48",432),
("4+9+49",441),
("2+10+16",160),
("1+11+3",33),
("1+11+4",44),
("1+11+5",55),
("3+9+49",441),
("2+10+17",170),
("1+11+6",66),
("2+10+18",180),
("2+10+19",190),
("1+11+7",77),
("0+11+0",0),
("1+11+8",88),
("2+10+20",200),
("2+10+21",210),
("1+11+9",99),
("0+11+1",11),
("0+11+2",22),
("4+10+0",0),
("2+10+22",220),
("3+10+0",0),
("4+10+1",10),
("2+10+23",230),
("0+11+3",33),
("0+11+4",44),
("2+10+24",240),
("4+10+2",20),
("0+11+5",55),
("4+10+3",30),
("0+11+6",66),
("3+10+1",10),
("0+11+7",77),
("3+10+2",20),
("1+11+10",110),
("0+11+8",88),
("4+10+4",40),
("3+10+3",30),
("3+10+4",40),
("2+10+25",250),
("3+10+5",50),
("1+11+11",121),
("3+10+6",60),
("4+10+5",50),
("2+10+26",260),
("0+11+9",99),
("2+10+27",270),
("3+10+7",70),
("4+10+6",60),
("4+10+7",70),
("3+10+8",80),
("3+10+9",90),
("4+10+8",80),
("1+11+12",132),
("0+11+10",110),
("1+11+13",143),
("1+11+14",154),
("1+11+15",165),
("3+10+10",100),
("1+11+16",176),
("2+10+28",280),
("3+10+11",110),
("0+11+11",121),
("4+10+9",90),
("3+10+12",120),
("0+11+12",132),
("4+10+10",100),
("0+11+13",143),
("1+11+17",187),
("0+11+14",154),
("4+10+11",110),
("4+10+12",120),
("2+10+29",290),
("2+10+30",300),
("0+11+15",165),
("1+11+18",198),
("0+11+16",176),
("4+10+13",130),
("2+10+31",310),
("4+10+14",140),
("2+10+32",320),
("0+11+17",187),
("2+10+33",330),
("4+10+15",150),
("2+10+34",340),
("3+10+13",130),
("2+10+35",350),
("4+10+16",160),
("0+11+18",198),
("1+11+19",209),
("2+10+36",360),
("1+11+20",220),
("4+10+17",170),
("2+10+37",370),
("3+10+14",140),
("1+11+21",231),
("2+10+38",380),
("1+11+22",242),
("1+11+23",253),
("0+11+19",209),
("4+10+18",180),
("2+10+39",390),
("0+11+20",220),
("3+10+15",150),
("4+10+19",190),
("0+11+21",231),
("1+11+24",264),
("0+11+22",242),
("3+10+16",160),
("4+10+20",200),
("0+11+23",253),
("1+11+25",275),
("0+11+24",264),
("4+10+21",210),
("3+10+17",170),
("2+10+40",400),
("1+11+26",286),
("0+11+25",275),
("4+10+22",220),
("0+11+26",286),
("2+10+41",410),
("2+10+42",420),
("1+11+27",297),
("1+11+28",308),
("3+10+18",180),
("2+10+43",430),
("0+11+27",297),
("0+11+28",308),
("0+11+29",319),
("3+10+19",190),
("4+10+23",230),
("2+10+44",440),
("3+10+20",200),
("3+10+21",210),
("0+11+30",330),
("1+11+29",319),
("3+10+22",220),
("4+10+24",240),
("2+10+45",450),
("0+11+31",341),
("0+11+32",352),
("0+11+33",363),
("2+10+46",460),
("4+10+25",250),
("0+11+34",374),
("4+10+26",260),
("1+11+30",330),
("2+10+47",470),
("0+11+35",385),
("0+11+36",396),
("4+10+27",270),
("2+10+48",480),
("3+10+23",230),
("0+11+37",407),
("3+10+24",240),
("3+10+25",250),
("0+11+38",418),
("1+11+31",341),
("0+11+39",429),
("1+11+32",352),
("0+11+40",440),
("1+11+33",363),
("1+11+34",374),
("2+10+49",490),
("4+10+28",280),
("0+11+41",451),
("4+10+29",290),
("0+11+42",462),
("4+10+30",300),
("1+11+35",385),
("0+11+43",473),
("0+11+44",484),
("4+10+31",310),
("1+11+36",396),
("4+10+32",320),
("3+10+26",260),
("4+10+33",330),
("4+10+34",340),
("2+11+0",0),
("3+10+27",270),
("2+11+1",11),
("3+10+28",280),
("4+10+35",350),
("1+11+37",407),
("0+11+45",495),
("1+11+38",418),
("3+10+29",290),
("3+10+30",300),
("0+11+46",506),
("3+10+31",310),
("1+11+39",429),
("4+10+36",360),
("4+10+37",370),
("3+10+32",320),
("2+11+2",22),
("0+11+47",517),
("4+10+38",380),
("3+10+33",330),
("4+10+39",390),
("2+11+3",33),
("1+11+40",440),
("4+10+40",400),
("3+10+34",340),
("0+11+48",528),
("0+11+49",539),
("1+11+41",451),
("3+10+35",350),
("3+10+36",360),
("1+11+42",462),
("2+11+4",44),
("3+10+37",370),
("2+11+5",55),
("1+11+43",473),
("2+11+6",66),
("3+10+38",380),
("1+11+44",484),
("0+12+0",0),
("3+10+39",390),
("2+11+7",77),
("0+12+1",12),
("2+11+8",88),
("0+12+2",24),
("0+12+3",36),
("1+11+45",495),
("0+12+4",48),
("4+10+41",410),
("4+10+42",420),
("1+11+46",506),
("4+10+43",430),
("1+11+47",517),
("0+12+5",60),
("1+11+48",528),
("2+11+9",99),
("0+12+6",72),
("2+11+10",110),
("1+11+49",539),
("0+12+7",84),
("0+12+8",96),
("2+11+11",121),
("3+10+40",400),
("2+11+12",132),
("4+10+44",440),
("4+10+45",450),
("3+10+41",410),
("3+10+42",420),
("2+11+13",143),
("0+12+9",108),
("0+12+10",120),
("0+12+11",132),
("3+10+43",430),
("1+12+0",0),
("1+12+1",12),
("1+12+2",24),
("0+12+12",144),
("4+10+46",460),
("4+10+47",470),
("4+10+48",480),
("4+10+49",490),
("3+10+44",440),
("2+11+14",154),
("1+12+3",36),
("2+11+15",165),
("1+12+4",48),
("2+11+16",176),
("0+12+13",156),
("2+11+17",187),
("2+11+18",198),
("4+11+0",0),
("1+12+5",60),
("0+12+14",168),
("3+10+45",450),
("1+12+6",72),
("0+12+15",180),
("4+11+1",11),
("0+12+16",192),
("2+11+19",209),
("4+11+2",22),
("3+10+46",460),
("4+11+3",33),
("3+10+47",470),
("1+12+7",84),
("3+10+48",480),
("0+12+17",204),
("2+11+20",220),
("2+11+21",231),
("2+11+22",242),
("2+11+23",253),
("0+12+18",216),
("2+11+24",264),
("4+11+4",44),
("1+12+8",96),
("3+10+49",490),
("1+12+9",108),
("1+12+10",120),
("1+12+11",132),
("4+11+5",55),
("1+12+12",144),
("1+12+13",156),
("1+12+14",168),
("0+12+19",228),
("1+12+15",180),
("0+12+20",240),
("0+12+21",252),
("2+11+25",275),
("3+11+0",0),
("3+11+1",11),
("1+12+16",192),
("4+11+6",66),
("4+11+7",77),
("2+11+26",286),
("4+11+8",88),
("1+12+17",204),
("1+12+18",216),
("2+11+27",297),
("4+11+9",99),
("2+11+28",308),
("0+12+22",264),
("2+11+29",319),
("1+12+19",228),
("1+12+20",240),
("0+12+23",276),
("4+11+10",110),
("0+12+24",288),
("3+11+2",22),
("1+12+21",252),
("3+11+3",33),
("4+11+11",121),
("2+11+30",330),
("3+11+4",44),
("2+11+31",341),
("0+12+25",300),
("3+11+5",55),
("0+12+26",312),
("1+12+22",264),
("1+12+23",276),
("3+11+6",66),
("1+12+24",288),
("1+12+25",300),
("2+11+32",352),
("1+12+26",312),
("1+12+27",324),
("2+11+33",363),
("2+11+34",374),
("1+12+28",336),
("2+11+35",385),
("4+11+12",132),
("1+12+29",348),
("1+12+30",360),
("2+11+36",396),
("3+11+7",77),
("4+11+13",143),
("4+11+14",154),
("0+12+27",324),
("1+12+31",372),
("0+12+28",336),
("2+11+37",407),
("0+12+29",348),
("0+12+30",360),
("1+12+32",384),
("2+11+38",418),
("0+12+31",372),
("4+11+15",165),
("0+12+32",384),
("3+11+8",88),
("4+11+16",176),
("2+11+39",429),
("3+11+9",99),
("3+11+10",110),
("4+11+17",187),
("1+12+33",396),
("4+11+18",198),
("0+12+33",396),
("0+12+34",408),
("3+11+11",121),
("0+12+35",420),
("1+12+34",408),
("4+11+19",209),
("0+12+36",432),
("1+12+35",420),
("4+11+20",220),
("0+12+37",444),
("4+11+21",231),
("0+12+38",456),
("2+11+40",440),
("4+11+22",242),
("4+11+23",253),
("3+11+12",132),
("1+12+36",432),
("4+11+24",264),
("4+11+25",275),
("0+12+39",468),
("2+11+41",451),
("0+12+40",480),
("1+12+37",444),
("2+11+42",462),
("1+12+38",456),
("2+11+43",473),
("0+12+41",492),
("4+11+26",286),
("0+12+42",504),
("3+11+13",143),
("4+11+27",297),
("0+12+43",516),
("1+12+39",468),
("0+12+44",528),
("2+11+44",484),
("0+12+45",540),
("1+12+40",480),
("1+12+41",492),
("0+12+46",552),
("1+12+42",504),
("4+11+28",308),
("0+12+47",564),
("0+12+48",576),
("1+12+43",516),
("3+11+14",154),
("2+11+45",495),
("4+11+29",319),
("4+11+30",330),
("2+11+46",506),
("1+12+44",528),
("2+11+47",517),
("1+12+45",540),
("2+11+48",528),
("0+12+49",588),
("4+11+31",341),
("3+11+15",165),
("4+11+32",352),
("1+12+46",552),
("3+11+16",176),
("1+12+47",564),
("1+12+48",576),
("1+12+49",588),
("3+11+17",187),
("2+11+49",539),
("3+11+18",198),
("4+11+33",363),
("3+11+19",209),
("4+11+34",374),
("4+11+35",385),
("4+11+36",396),
("4+11+37",407),
("3+11+20",220),
("4+11+38",418),
("3+11+21",231),
("3+11+22",242),
("4+11+39",429),
("3+11+23",253),
("0+13+0",0),
("2+12+0",0),
("3+11+24",264),
("4+11+40",440),
("0+13+1",13),
("2+12+1",12),
("1+13+0",0),
("4+11+41",451),
("3+11+25",275),
("4+11+42",462),
("4+11+43",473),
("1+13+1",13),
("4+11+44",484),
("0+13+2",26),
("4+11+45",495),
("1+13+2",26),
("0+13+3",39),
("1+13+3",39),
("4+11+46",506),
("3+11+26",286),
("0+13+4",52),
("1+13+4",52),
("3+11+27",297),
("1+13+5",65),
("0+13+5",65),
("1+13+6",78),
("0+13+6",78),
("2+12+2",24),
("4+11+47",517),
("1+13+7",91),
("2+12+3",36),
("0+13+7",91),
("1+13+8",104),
("1+13+9",117),
("2+12+4",48),
("1+13+10",130),
("2+12+5",60),
("1+13+11",143),
("2+12+6",72),
("4+11+48",528),
("1+13+12",156),
("0+13+8",104),
("3+11+28",308),
("1+13+13",169),
("2+12+7",84),
("3+11+29",319),
("4+11+49",539),
("0+13+9",117),
("1+13+14",182),
("3+11+30",330),
("0+13+10",130),
("3+11+31",341),
("0+13+11",143),
("3+11+32",352),
("4+12+0",0),
("3+11+33",363),
("0+13+12",156),
("0+13+13",169),
("2+12+8",96),
("4+12+1",12),
("2+12+9",108),
("1+13+15",195),
("4+12+2",24),
("1+13+16",208),
("3+11+34",374),
("1+13+17",221),
("3+11+35",385),
("1+13+18",234),
("4+12+3",36),
("3+11+36",396),
("4+12+4",48),
("3+11+37",407),
("4+12+5",60),
("3+11+38",418),
("2+12+10",120),
("4+12+6",72),
("1+13+19",247),
("3+11+39",429),
("1+13+20",260),
("2+12+11",132),
("2+12+12",144),
("1+13+21",273),
("1+13+22",286),
("0+13+14",182),
("2+12+13",156),
("3+11+40",440),
("1+13+23",299),
("4+12+7",84),
("0+13+15",195),
("1+13+24",312),
("0+13+16",208),
("3+11+41",451),
("3+11+42",462),
("4+12+8",96),
("3+11+43",473),
("2+12+14",168),
("3+11+44",484),
("4+12+9",108),
("0+13+17",221),
("3+11+45",495),
("0+13+18",234),
("3+11+46",506),
("2+12+15",180),
("0+13+19",247),
("2+12+16",192),
("2+12+17",204),
("1+13+25",325),
("2+12+18",216),
("0+13+20",260),
("3+11+47",517),
("4+12+10",120),
("3+11+48",528),
("0+13+21",273),
("3+11+49",539),
("0+13+22",286),
("1+13+26",338),
("0+13+23",299),
("2+12+19",228),
("2+12+20",240),
("4+12+11",132),
("0+13+24",312),
("4+12+12",144),
("0+13+25",325),
("0+13+26",338),
("0+13+27",351),
("4+12+13",156),
("0+13+28",364),
("2+12+21",252),
("0+13+29",377),
("2+12+22",264),
("4+12+14",168),
("0+13+30",390),
("2+12+23",276),
("0+13+31",403),
("1+13+27",351),
("3+12+0",0),
("2+12+24",288),
("1+13+28",364),
("0+13+32",416),
("1+13+29",377),
("3+12+1",12),
("1+13+30",390),
("4+12+15",180),
("2+12+25",300),
("2+12+26",312),
("0+13+33",429),
("2+12+27",324),
("2+12+28",336),
("3+12+2",24),
("0+13+34",442),
("2+12+29",348),
("0+13+35",455),
("2+12+30",360),
("3+12+3",36),
("0+13+36",468),
("3+12+4",48),
("1+13+31",403),
("2+12+31",372),
("0+13+37",481),
("3+12+5",60),
("0+13+38",494),
("2+12+32",384),
("1+13+32",416),
("4+12+16",192),
("2+12+33",396),
("1+13+33",429),
("0+13+39",507),
("0+13+40",520),
("3+12+6",72),
("3+12+7",84),
("2+12+34",408),
("0+13+41",533),
("3+12+8",96),
("0+13+42",546),
("3+12+9",108),
("4+12+17",204),
("2+12+35",420),
("1+13+34",442),
("2+12+36",432),
("0+13+43",559),
("4+12+18",216),
("0+13+44",572),
("3+12+10",120),
("0+13+45",585),
("4+12+19",228),
("0+13+46",598),
("4+12+20",240),
("2+12+37",444),
("1+13+35",455),
("2+12+38",456),
("1+13+36",468),
("2+12+39",468),
("3+12+11",132),
("2+12+40",480),
("1+13+37",481),
("4+12+21",252),
("1+13+38",494),
("4+12+22",264),
("0+13+47",611),
("3+12+12",144),
("4+12+23",276),
("0+13+48",624),
("1+13+39",507),
("4+12+24",288),
("0+13+49",637),
("4+12+25",300),
("2+12+41",492),
("1+13+40",520),
("3+12+13",156),
("2+12+42",504),
("3+12+14",168),
("1+13+41",533),
("1+13+42",546),
("1+13+43",559),
("1+13+44",572),
("1+13+45",585),
("2+12+43",516),
("3+12+15",180),
("4+12+26",312),
("1+13+46",598),
("1+13+47",611),
("4+12+27",324),
("2+12+44",528),
("4+12+28",336),
("4+12+29",348),
("3+12+16",192),
("3+12+17",204),
("1+13+48",624),
("4+12+30",360),
("2+12+45",540),
("1+13+49",637),
("4+12+31",372),
("3+12+18",216),
("4+12+32",384),
("4+12+33",396),
("4+12+34",408),
("3+12+19",228),
("3+12+20",240),
("4+12+35",420),
("3+12+21",252),
("2+12+46",552),
("3+12+22",264),
("4+12+36",432),
("4+12+37",444),
("3+12+23",276),
("3+12+24",288),
("4+12+38",456),
("3+12+25",300),
("3+12+26",312),
("2+12+47",564),
("4+12+39",468),
("4+12+40",480),
("3+12+27",324),
("4+12+41",492),
("4+12+42",504),
("2+12+48",576),
("4+12+43",516),
("3+12+28",336),
("4+12+44",528),
("2+12+49",588),
("4+12+45",540),
("3+12+29",348),
("3+12+30",360),
("3+12+31",372),
("3+12+32",384),
("4+12+46",552),
("3+12+33",396),
("3+12+34",408),
("4+12+47",564),
("3+12+35",420),
("3+12+36",432),
("3+12+37",444),
("4+12+48",576),
("4+12+49",588),
("3+12+38",456),
("3+12+39",468),
("3+12+40",480),
("3+12+41",492),
("3+12+42",504),
("3+12+43",516),
("3+12+44",528),
("3+12+45",540),
("3+12+46",552),
("3+12+47",564),
("3+12+48",576),
("3+12+49",588),
("3+13+0",0),
("1+14+0",0),
("0+14+0",0),
("2+13+0",0),
("4+13+0",0),
("2+13+1",13),
("0+14+1",14),
("1+14+1",14),
("0+14+2",28),
("3+13+1",13),
("2+13+2",26),
("0+14+3",42),
("0+14+4",56),
("4+13+1",13),
("0+14+5",70),
("4+13+2",26),
("1+14+2",28),
("2+13+3",39),
("2+13+4",52),
("4+13+3",39),
("3+13+2",26),
("4+13+4",52),
("4+13+5",65),
("0+14+6",84),
("0+14+7",98),
("1+14+3",42),
("4+13+6",78),
("2+13+5",65),
("1+14+4",56),
("2+13+6",78),
("0+14+8",112),
("1+14+5",70),
("3+13+3",39),
("3+13+4",52),
("0+14+9",126),
("3+13+5",65),
("2+13+7",91),
("2+13+8",104),
("0+14+10",140),
("2+13+9",117),
("2+13+10",130),
("1+14+6",84),
("2+13+11",143),
("3+13+6",78),
("1+14+7",98),
("4+13+7",91),
("2+13+12",156),
("2+13+13",169),
("2+13+14",182),
("3+13+7",91),
("2+13+15",195),
("1+14+8",112),
("0+14+11",154),
("0+14+12",168),
("3+13+8",104),
("2+13+16",208),
("3+13+9",117),
("0+14+13",182),
("3+13+10",130),
("4+13+8",104),
("1+14+9",126),
("3+13+11",143),
("3+13+12",156),
("0+14+14",196),
("1+14+10",140),
("4+13+9",117),
("4+13+10",130),
("2+13+17",221),
("3+13+13",169),
("3+13+14",182),
("0+14+15",210),
("1+14+11",154),
("0+14+16",224),
("1+14+12",168),
("1+14+13",182),
("2+13+18",234),
("4+13+11",143),
("3+13+15",195),
("0+14+17",238),
("1+14+14",196),
("1+14+15",210),
("0+14+18",252),
("0+14+19",266),
("3+13+16",208),
("3+13+17",221),
("2+13+19",247),
("4+13+12",156),
("2+13+20",260),
("2+13+21",273),
("0+14+20",280),
("3+13+18",234),
("2+13+22",286),
("4+13+13",169),
("2+13+23",299),
("3+13+19",247),
("3+13+20",260),
("3+13+21",273),
("3+13+22",286),
("4+13+14",182),
("3+13+23",299),
("0+14+21",294),
("4+13+15",195),
("4+13+16",208),
("3+13+24",312),
("2+13+24",312),
("3+13+25",325),
("2+13+25",325),
("2+13+26",338),
("4+13+17",221),
("4+13+18",234),
("4+13+19",247),
("0+14+22",308),
("0+14+23",322),
("1+14+16",224),
("1+14+17",238),
("3+13+26",338),
("0+14+24",336),
("3+13+27",351),
("0+14+25",350),
("4+13+20",260),
("0+14+26",364),
("1+14+18",252),
("0+14+27",378),
("0+14+28",392),
("3+13+28",364),
("4+13+21",273),
("2+13+27",351),
("3+13+29",377),
("2+13+28",364),
("1+14+19",266),
("3+13+30",390),
("3+13+31",403),
("4+13+22",286),
("0+14+29",406),
("2+13+29",377),
("2+13+30",390),
("2+13+31",403),
("0+14+30",420),
("1+14+20",280),
("2+13+32",416),
("1+14+21",294),
("4+13+23",299),
("0+14+31",434),
("1+14+22",308),
("0+14+32",448),
("0+14+33",462),
("4+13+24",312),
("4+13+25",325),
("2+13+33",429),
("0+14+34",476),
("1+14+23",322),
("4+13+26",338),
("0+14+35",490),
("4+13+27",351),
("2+13+34",442),
("1+14+24",336),
("2+13+35",455),
("0+14+36",504),
("1+14+25",350),
("3+13+32",416),
("1+14+26",364),
("0+14+37",518),
("1+14+27",378),
("3+13+33",429),
("2+13+36",468),
("3+13+34",442),
("3+13+35",455),
("3+13+36",468),
("2+13+37",481),
("3+13+37",481),
("4+13+28",364),
("2+13+38",494),
("2+13+39",507),
("3+13+38",494),
("1+14+28",392),
("2+13+40",520),
("4+13+29",377),
("3+13+39",507),
("2+13+41",533),
("1+14+29",406),
("0+14+38",532),
("4+13+30",390),
("3+13+40",520),
("2+13+42",546),
("4+13+31",403),
("1+14+30",420),
("4+13+32",416),
("2+13+43",559),
("0+14+39",546),
("1+14+31",434),
("3+13+41",533),
("1+14+32",448),
("0+14+40",560),
("1+14+33",462),
("0+14+41",574),
("1+14+34",476),
("2+13+44",572),
("0+14+42",588),
("3+13+42",546),
("1+14+35",490),
("0+14+43",602),
("4+13+33",429),
("1+14+36",504),
("3+13+43",559),
("0+14+44",616),
("2+13+45",585),
("3+13+44",572),
("1+14+37",518),
("4+13+34",442),
("3+13+45",585),
("4+13+35",455),
("0+14+45",630),
("1+14+38",532),
("4+13+36",468),
("2+13+46",598),
("3+13+46",598),
("2+13+47",611),
("4+13+37",481),
("0+14+46",644),
("2+13+48",624),
("4+13+38",494),
("2+13+49",637),
("4+13+39",507),
("0+14+47",658),
("4+13+40",520),
("1+14+39",546),
("0+14+48",672),
("1+14+40",560),
("0+14+49",686),
("1+14+41",574),
("1+14+42",588),
("4+13+41",533),
("2+14+0",0),
("4+13+42",546),
("1+14+43",602),
("3+13+47",611),
("0+15+0",0),
("1+14+44",616),
("2+14+1",14),
("2+14+2",28),
("2+14+3",42),
("4+13+43",559),
("3+13+48",624),
("4+13+44",572),
("4+13+45",585),
("0+15+1",15),
("1+14+45",630),
("4+13+46",598),
("1+14+46",644),
("2+14+4",56),
("1+14+47",658),
("0+15+2",30),
("4+13+47",611),
("0+15+3",45),
("2+14+5",70),
("1+14+48",672),
("2+14+6",84),
("3+13+49",637),
("1+14+49",686),
("0+15+4",60),
("4+13+48",624),
("0+15+5",75),
("4+13+49",637),
("0+15+6",90),
("2+14+7",98),
("2+14+8",112),
("3+14+0",0),
("1+15+0",0),
("4+14+0",0),
("0+15+7",105),
("2+14+9",126),
("3+14+1",14),
("0+15+8",120),
("3+14+2",28),
("0+15+9",135),
("3+14+3",42),
("1+15+1",15),
("3+14+4",56),
("0+15+10",150),
("2+14+10",140),
("4+14+1",14),
("2+14+11",154),
("4+14+2",28),
("3+14+5",70),
("3+14+6",84),
("4+14+3",42),
("0+15+11",165),
("2+14+12",168),
("0+15+12",180),
("1+15+2",30),
("2+14+13",182),
("3+14+7",98),
("1+15+3",45),
("3+14+8",112),
("1+15+4",60),
("3+14+9",126),
("1+15+5",75),
("2+14+14",196),
("0+15+13",195),
("4+14+4",56),
("0+15+14",210),
("1+15+6",90),
("3+14+10",140),
("0+15+15",225),
("4+14+5",70),
("0+15+16",240),
("3+14+11",154),
("0+15+17",255),
("4+14+6",84),
("0+15+18",270),
("0+15+19",285),
("4+14+7",98),
("4+14+8",112),
("3+14+12",168),
("1+15+7",105),
("1+15+8",120),
("0+15+20",300),
("1+15+9",135),
("0+15+21",315),
("2+14+15",210),
("1+15+10",150),
("2+14+16",224),
("3+14+13",182),
("3+14+14",196),
("2+14+17",238),
("1+15+11",165),
("3+14+15",210),
("0+15+22",330),
("3+14+16",224),
("4+14+9",126),
("3+14+17",238),
("4+14+10",140),
("1+15+12",180),
("1+15+13",195),
("4+14+11",154),
("2+14+18",252),
("3+14+18",252),
("2+14+19",266),
("3+14+19",266),
("4+14+12",168),
("1+15+14",210),
("2+14+20",280),
("3+14+20",280),
("0+15+23",345),
("1+15+15",225),
("3+14+21",294),
("0+15+24",360),
("1+15+16",240),
("2+14+21",294),
("3+14+22",308),
("1+15+17",255),
("3+14+23",322),
("0+15+25",375),
("4+14+13",182),
("3+14+24",336),
("1+15+18",270),
("1+15+19",285),
("3+14+25",350),
("2+14+22",308),
("3+14+26",364),
("4+14+14",196),
("3+14+27",378),
("0+15+26",390),
("2+14+23",322),
("3+14+28",392),
("0+15+27",405),
("2+14+24",336),
("1+15+20",300),
("2+14+25",350),
("1+15+21",315),
("0+15+28",420),
("0+15+29",435),
("4+14+15",210),
("2+14+26",364),
("0+15+30",450),
("1+15+22",330),
("4+14+16",224),
("0+15+31",465),
("3+14+29",406),
("4+14+17",238),
("2+14+27",378),
("3+14+30",420),
("0+15+32",480),
("1+15+23",345),
("4+14+18",252),
("4+14+19",266),
("3+14+31",434),
("3+14+32",448),
("0+15+33",495),
("3+14+33",462),
("3+14+34",476),
("0+15+34",510),
("0+15+35",525),
("2+14+28",392),
("4+14+20",280),
("1+15+24",360),
("0+15+36",540),
("2+14+29",406),
("1+15+25",375),
("3+14+35",490),
("1+15+26",390),
("3+14+36",504),
("2+14+30",420),
("0+15+37",555),
("4+14+21",294),
("3+14+37",518),
("2+14+31",434),
("2+14+32",448),
("1+15+27",405),
("4+14+22",308),
("2+14+33",462),
("3+14+38",532),
("1+15+28",420),
("2+14+34",476),
("0+15+38",570),
("1+15+29",435),
("4+14+23",322),
("3+14+39",546),
("4+14+24",336),
("2+14+35",490),
("4+14+25",350),
("2+14+36",504),
("2+14+37",518),
("0+15+39",585),
("4+14+26",364),
("4+14+27",378),
("4+14+28",392),
("3+14+40",560),
("0+15+40",600),
("3+14+41",574),
("2+14+38",532),
("1+15+30",450),
("4+14+29",406),
("4+14+30",420),
("0+15+41",615),
("1+15+31",465),
("1+15+32",480),
("0+15+42",630),
("3+14+42",588),
("3+14+43",602),
("2+14+39",546),
("2+14+40",560),
("2+14+41",574),
("1+15+33",495),
("0+15+43",645),
("0+15+44",660),
("4+14+31",434),
("1+15+34",510),
("3+14+44",616),
("3+14+45",630),
("1+15+35",525),
("1+15+36",540),
("0+15+45",675),
("4+14+32",448),
("3+14+46",644),
("4+14+33",462),
("0+15+46",690),
("4+14+34",476),
("4+14+35",490),
("3+14+47",658),
("3+14+48",672),
("3+14+49",686),
("2+14+42",588),
("0+15+47",705),
("4+14+36",504),
("4+14+37",518),
("1+15+37",555),
("4+14+38",532),
("4+14+39",546),
("3+15+0",0),
("4+14+40",560),
("3+15+1",15),
("2+14+43",602),
("0+15+48",720),
("2+14+44",616),
("3+15+2",30),
("3+15+3",45),
("4+14+41",574),
("3+15+4",60),
("1+15+38",570),
("0+15+49",735),
("4+14+42",588),
("3+15+5",75),
("2+14+45",630),
("3+15+6",90),
("3+15+7",105),
("3+15+8",120),
("4+14+43",602),
("2+14+46",644),
("4+14+44",616),
("2+14+47",658),
("3+15+9",135),
("1+15+39",585),
("2+14+48",672),
("3+15+10",150),
("4+14+45",630),
("0+16+0",0),
("1+15+40",600),
("2+14+49",686),
("1+15+41",615),
("0+16+1",16),
("0+16+2",32),
("0+16+3",48),
("4+14+46",644),
("3+15+11",165),
("4+14+47",658),
("1+15+42",630),
("4+14+48",672),
("4+14+49",686),
("0+16+4",64),
("3+15+12",180),
("1+15+43",645),
("3+15+13",195),
("3+15+14",210),
("1+15+44",660),
("0+16+5",80),
("3+15+15",225),
("0+16+6",96),
("0+16+7",112),
("2+15+0",0),
("0+16+8",128),
("4+15+0",0),
("4+15+1",15),
("1+15+45",675),
("3+15+16",240),
("0+16+9",144),
("4+15+2",30),
("3+15+17",255),
("4+15+3",45),
("3+15+18",270),
("4+15+4",60),
("2+15+1",15),
("1+15+46",690),
("0+16+10",160),
("3+15+19",285),
("0+16+11",176),
("4+15+5",75),
("1+15+47",705),
("3+15+20",300),
("1+15+48",720),
("4+15+6",90),
("4+15+7",105),
("1+15+49",735),
("3+15+21",315),
("3+15+22",330),
("3+15+23",345),
("3+15+24",360),
("0+16+12",192),
("4+15+8",120),
("4+15+9",135),
("3+15+25",375),
("2+15+2",30),
("3+15+26",390),
("0+16+13",208),
("4+15+10",150),
("0+16+14",224),
("3+15+27",405),
("4+15+11",165),
("3+15+28",420),
("0+16+15",240),
("0+16+16",256),
("0+16+17",272),
("2+15+3",45),
("0+16+18",288),
("2+15+4",60),
("0+16+19",304),
("4+15+12",180),
("0+16+20",320),
("4+15+13",195),
("1+16+0",0),
("0+16+21",336),
("4+15+14",210),
("2+15+5",75),
("3+15+29",435),
("1+16+1",16),
("4+15+15",225),
("1+16+2",32),
("4+15+16",240),
("4+15+17",255),
("0+16+22",352),
("4+15+18",270),
("2+15+6",90),
("1+16+3",48),
("4+15+19",285),
("1+16+4",64),
("3+15+30",450),
("2+15+7",105),
("1+16+5",80),
("4+15+20",300),
("4+15+21",315),
("2+15+8",120),
("2+15+9",135),
("3+15+31",465),
("4+15+22",330),
("0+16+23",368),
("3+15+32",480),
("0+16+24",384),
("1+16+6",96),
("4+15+23",345),
("1+16+7",112),
("1+16+8",128),
("1+16+9",144),
("1+16+10",160),
("2+15+10",150),
("2+15+11",165),
("3+15+33",495),
("1+16+11",176),
("4+15+24",360),
("3+15+34",510),
("0+16+25",400),
("1+16+12",192),
("1+16+13",208),
("1+16+14",224),
("1+16+15",240),
("0+16+26",416),
("1+16+16",256),
("0+16+27",432),
("2+15+12",180),
("0+16+28",448),
("4+15+25",375),
("0+16+29",464),
("4+15+26",390),
("0+16+30",480),
("1+16+17",272),
("1+16+18",288),
("0+16+31",496),
("0+16+32",512),
("2+15+13",195),
("2+15+14",210),
("0+16+33",528),
("0+16+34",544),
("0+16+35",560),
("0+16+36",576),
("3+15+35",525),
("2+15+15",225),
("3+15+36",540),
("0+16+37",592),
("4+15+27",405),
("4+15+28",420),
("1+16+19",304),
("0+16+38",608),
("1+16+20",320),
("1+16+21",336),
("2+15+16",240),
("0+16+39",624),
("2+15+17",255),
("2+15+18",270),
("4+15+29",435),
("4+15+30",450),
("4+15+31",465),
("1+16+22",352),
("2+15+19",285),
("1+16+23",368),
("0+16+40",640),
("4+15+32",480),
("0+16+41",656),
("3+15+37",555),
("4+15+33",495),
("1+16+24",384),
("1+16+25",400),
("0+16+42",672),
("3+15+38",570),
("0+16+43",688),
("2+15+20",300),
("4+15+34",510),
("2+15+21",315),
("4+15+35",525),
("0+16+44",704),
("2+15+22",330),
("4+15+36",540),
("3+15+39",585),
("1+16+26",416),
("4+15+37",555),
("3+15+40",600),
("4+15+38",570),
("3+15+41",615),
("1+16+27",432),
("0+16+45",720),
("1+16+28",448),
("0+16+46",736),
("4+15+39",585),
("0+16+47",752),
("1+16+29",464),
("3+15+42",630),
("3+15+43",645),
("1+16+30",480),
("1+16+31",496),
("0+16+48",768),
("4+15+40",600),
("4+15+41",615),
("2+15+23",345),
("0+16+49",784),
("4+15+42",630),
("4+15+43",645),
("2+15+24",360),
("2+15+25",375),
("1+16+32",512),
("2+15+26",390),
("3+15+44",660),
("1+16+33",528),
("3+15+45",675),
("2+15+27",405),
("3+15+46",690),
("4+15+44",660),
("2+15+28",420),
("4+15+45",675),
("0+17+0",0),
("4+15+46",690),
("4+15+47",705),
("3+15+47",705),
("2+15+29",435),
("2+15+30",450),
("4+15+48",720),
("2+15+31",465),
("4+15+49",735),
("2+15+32",480),
("0+17+1",17),
("2+15+33",495),
("1+16+34",544),
("0+17+2",34),
("2+15+34",510),
("0+17+3",51),
("2+15+35",525),
("0+17+4",68),
("1+16+35",560),
("2+15+36",540),
("1+16+36",576),
("4+16+0",0),
("1+16+37",592),
("2+15+37",555),
("0+17+5",85),
("3+15+48",720),
("3+15+49",735),
("2+15+38",570),
("0+17+6",102),
("1+16+38",608),
("1+16+39",624),
("0+17+7",119),
("0+17+8",136),
("3+16+0",0),
("0+17+9",153),
("4+16+1",16),
("4+16+2",32),
("2+15+39",585),
("3+16+1",16),
("0+17+10",170),
("3+16+2",32),
("2+15+40",600),
("4+16+3",48),
("2+15+41",615),
("3+16+3",48),
("2+15+42",630),
("0+17+11",187),
("0+17+12",204),
("1+16+40",640),
("3+16+4",64),
("1+16+41",656),
("3+16+5",80),
("3+16+6",96),
("4+16+4",64),
("3+16+7",112),
("1+16+42",672),
("0+17+13",221),
("2+15+43",645),
("4+16+5",80),
("2+15+44",660),
("3+16+8",128),
("0+17+14",238),
("2+15+45",675),
("3+16+9",144),
("1+16+43",688),
("1+16+44",704),
("2+15+46",690),
("0+17+15",255),
("1+16+45",720),
("0+17+16",272),
("3+16+10",160),
("3+16+11",176),
("0+17+17",289),
("0+17+18",306),
("0+17+19",323),
("2+15+47",705),
("1+16+46",736),
("1+16+47",752),
("0+17+20",340),
("2+15+48",720),
("1+16+48",768),
("1+16+49",784),
("4+16+6",96),
("2+15+49",735),
("0+17+21",357),
("0+17+22",374),
("0+17+23",391),
("4+16+7",112),
("0+17+24",408),
("2+16+0",0),
("4+16+8",128),
("1+17+0",0),
("3+16+12",192),
("3+16+13",208),
("4+16+9",144),
("1+17+1",17),
("0+17+25",425),
("1+17+2",34),
("1+17+3",51),
("3+16+14",224),
("2+16+1",16),
("1+17+4",68),
("2+16+2",32),
("2+16+3",48),
("1+17+5",85),
("2+16+4",64),
("0+17+26",442),
("2+16+5",80),
("1+17+6",102),
("0+17+27",459),
("3+16+15",240),
("4+16+10",160),
("1+17+7",119),
("3+16+16",256),
("3+16+17",272),
("4+16+11",176),
("4+16+12",192),
("2+16+6",96),
("0+17+28",476),
("1+17+8",136),
("1+17+9",153),
("4+16+13",208),
("2+16+7",112),
("0+17+29",493),
("3+16+18",288),
("4+16+14",224),
("2+16+8",128),
("0+17+30",510),
("4+16+15",240),
("0+17+31",527),
("0+17+32",544),
("4+16+16",256),
("2+16+9",144),
("4+16+17",272),
("0+17+33",561),
("1+17+10",170),
("3+16+19",304),
("1+17+11",187),
("4+16+18",288),
("1+17+12",204),
("1+17+13",221),
("0+17+34",578),
("2+16+10",160),
("4+16+19",304),
("2+16+11",176),
("3+16+20",320),
("4+16+20",320),
("1+17+14",238),
("2+16+12",192),
("1+17+15",255),
("3+16+21",336),
("1+17+16",272),
("0+17+35",595),
("4+16+21",336),
("1+17+17",289),
("3+16+22",352),
("4+16+22",352),
("1+17+18",306),
("0+17+36",612),
("1+17+19",323),
("2+16+13",208),
("4+16+23",368),
("2+16+14",224),
("1+17+20",340),
("4+16+24",384),
("0+17+37",629),
("2+16+15",240),
("1+17+21",357),
("4+16+25",400),
("1+17+22",374),
("4+16+26",416),
("1+17+23",391),
("0+17+38",646),
("3+16+23",368),
("2+16+16",256),
("0+17+39",663),
("2+16+17",272),
("4+16+27",432),
("0+17+40",680),
("2+16+18",288),
("0+17+41",697),
("2+16+19",304),
("3+16+24",384),
("2+16+20",320),
("0+17+42",714),
("4+16+28",448),
("2+16+21",336),
("1+17+24",408),
("4+16+29",464),
("1+17+25",425),
("3+16+25",400),
("0+17+43",731),
("3+16+26",416),
("3+16+27",432),
("1+17+26",442),
("3+16+28",448),
("2+16+22",352),
("1+17+27",459),
("0+17+44",748),
("4+16+30",480),
("3+16+29",464),
("1+17+28",476),
("3+16+30",480),
("1+17+29",493),
("3+16+31",496),
("2+16+23",368),
("4+16+31",496),
("1+17+30",510),
("2+16+24",384),
("0+17+45",765),
("0+17+46",782),
("3+16+32",512),
("1+17+31",527),
("3+16+33",528),
("0+17+47",799),
("4+16+32",512),
("1+17+32",544),
("0+17+48",816),
("2+16+25",400),
("1+17+33",561),
("1+17+34",578),
("4+16+33",528),
("1+17+35",595),
("2+16+26",416),
("1+17+36",612),
("1+17+37",629),
("4+16+34",544),
("1+17+38",646),
("4+16+35",560),
("2+16+27",432),
("3+16+34",544),
("4+16+36",576),
("0+17+49",833),
("1+17+39",663),
("4+16+37",592),
("3+16+35",560),
("1+17+40",680),
("3+16+36",576),
("1+17+41",697),
("2+16+28",448),
("2+16+29",464),
("3+16+37",592),
("4+16+38",608),
("3+16+38",608),
("4+16+39",624),
("3+16+39",624),
("1+17+42",714),
("1+17+43",731),
("4+16+40",640),
("2+16+30",480),
("0+18+0",0),
("2+16+31",496),
("0+18+1",18),
("1+17+44",748),
("2+16+32",512),
("1+17+45",765),
("4+16+41",656),
("2+16+33",528),
("1+17+46",782),
("3+16+40",640),
("3+16+41",656),
("4+16+42",672),
("0+18+2",36),
("3+16+42",672),
("0+18+3",54),
("4+16+43",688),
("3+16+43",688),
("0+18+4",72),
("1+17+47",799),
("2+16+34",544),
("3+16+44",704),
("4+16+44",704),
("4+16+45",720),
("3+16+45",720),
("1+17+48",816),
("0+18+5",90),
("1+17+49",833),
("0+18+6",108),
("3+16+46",736),
("2+16+35",560),
("0+18+7",126),
("4+16+46",736),
("3+16+47",752),
("0+18+8",144),
("2+16+36",576),
("3+16+48",768),
("4+16+47",752),
("3+16+49",784),
("0+18+9",162),
("2+16+37",592),
("1+18+0",0),
("0+18+10",180),
("0+18+11",198),
("0+18+12",216),
("4+16+48",768),
("1+18+1",18),
("2+16+38",608),
("1+18+2",36),
("0+18+13",234),
("4+16+49",784),
("0+18+14",252),
("2+16+39",624),
("1+18+3",54),
("0+18+15",270),
("1+18+4",72),
("2+16+40",640),
("0+18+16",288),
("2+16+41",656),
("1+18+5",90),
("2+16+42",672),
("1+18+6",108),
("0+18+17",306),
("3+17+0",0),
("2+16+43",688),
("0+18+18",324),
("1+18+7",126),
("1+18+8",144),
("4+17+0",0),
("0+18+19",342),
("4+17+1",17),
("1+18+9",162),
("3+17+1",17),
("2+16+44",704),
("3+17+2",34),
("0+18+20",360),
("3+17+3",51),
("3+17+4",68),
("3+17+5",85),
("4+17+2",34),
("2+16+45",720),
("3+17+6",102),
("3+17+7",119),
("0+18+21",378),
("2+16+46",736),
("2+16+47",752),
("2+16+48",768),
("4+17+3",51),
("4+17+4",68),
("2+16+49",784),
("0+18+22",396),
("3+17+8",136),
("1+18+10",180),
("1+18+11",198),
("0+18+23",414),
("1+18+12",216),
("3+17+9",153),
("3+17+10",170),
("1+18+13",234),
("1+18+14",252),
("3+17+11",187),
("2+17+0",0),
("0+18+24",432),
("1+18+15",270),
("1+18+16",288),
("4+17+5",85),
("4+17+6",102),
("3+17+12",204),
("4+17+7",119),
("3+17+13",221),
("3+17+14",238),
("0+18+25",450),
("2+17+1",17),
("4+17+8",136),
("0+18+26",468),
("0+18+27",486),
("2+17+2",34),
("3+17+15",255),
("1+18+17",306),
("3+17+16",272),
("0+18+28",504),
("0+18+29",522),
("3+17+17",289),
("4+17+9",153),
("4+17+10",170),
("3+17+18",306),
("2+17+3",51),
("2+17+4",68),
("2+17+5",85),
("1+18+18",324),
("4+17+11",187),
("1+18+19",342),
("0+18+30",540),
("4+17+12",204),
("4+17+13",221),
("3+17+19",323),
("3+17+20",340),
("3+17+21",357),
("2+17+6",102),
("0+18+31",558),
("0+18+32",576),
("1+18+20",360),
("0+18+33",594),
("4+17+14",238),
("0+18+34",612),
("0+18+35",630),
("0+18+36",648),
("1+18+21",378),
("0+18+37",666),
("4+17+15",255),
("1+18+22",396),
("4+17+16",272),
("2+17+7",119),
("3+17+22",374),
("0+18+38",684),
("1+18+23",414),
("3+17+23",391),
("3+17+24",408),
("4+17+17",289),
("0+18+39",702),
("1+18+24",432),
("0+18+40",720),
("4+17+18",306),
("1+18+25",450),
("0+18+41",738),
("2+17+8",136),
("1+18+26",468),
("4+17+19",323),
("3+17+25",425),
("0+18+42",756),
("2+17+9",153),
("3+17+26",442),
("4+17+20",340),
("2+17+10",170),
("2+17+11",187),
("3+17+27",459),
("2+17+12",204),
("4+17+21",357),
("1+18+27",486),
("2+17+13",221),
("4+17+22",374),
("1+18+28",504),
("2+17+14",238),
("0+18+43",774),
("0+18+44",792),
("3+17+28",476),
("0+18+45",810),
("1+18+29",522),
("3+17+29",493),
("0+18+46",828),
("3+17+30",510),
("4+17+23",391),
("4+17+24",408),
("3+17+31",527),
("3+17+32",544),
("1+18+30",540),
("4+17+25",425),
("2+17+15",255),
("0+18+47",846),
("4+17+26",442),
("1+18+31",558),
("4+17+27",459),
("2+17+16",272),
("3+17+33",561),
("1+18+32",576),
("4+17+28",476),
("3+17+34",578),
("1+18+33",594),
("0+18+48",864),
("3+17+35",595),
("0+18+49",882),
("4+17+29",493),
("3+17+36",612),
("3+17+37",629),
("3+17+38",646),
("3+17+39",663),
("4+17+30",510),
("2+17+17",289),
("0+19+0",0),
("1+18+34",612),
("4+17+31",527),
("2+17+18",306),
("2+17+19",323),
("3+17+40",680),
("4+17+32",544),
("1+18+35",630),
("1+18+36",648),
("3+17+41",697),
("1+18+37",666),
("2+17+20",340),
("1+18+38",684),
("2+17+21",357),
("0+19+1",19),
("1+18+39",702),
("1+18+40",720),
("1+18+41",738),
("4+17+33",561),
("4+17+34",578),
("3+17+42",714),
("0+19+2",38),
("2+17+22",374),
("2+17+23",391),
("2+17+24",408),
("4+17+35",595),
("2+17+25",425),
("3+17+43",731),
("4+17+36",612),
("1+18+42",756),
("2+17+26",442),
("4+17+37",629),
("0+19+3",57),
("3+17+44",748),
("0+19+4",76),
("4+17+38",646),
("3+17+45",765),
("4+17+39",663),
("4+17+40",680),
("2+17+27",459),
("2+17+28",476),
("0+19+5",95),
("3+17+46",782),
("0+19+6",114),
("4+17+41",697),
("4+17+42",714),
("1+18+43",774),
("0+19+7",133),
("4+17+43",731),
("3+17+47",799),
("3+17+48",816),
("3+17+49",833),
("1+18+44",792),
("4+17+44",748),
("0+19+8",152),
("2+17+29",493),
("0+19+9",171),
("4+17+45",765),
("4+17+46",782),
("2+17+30",510),
("4+17+47",799),
("0+19+10",190),
("4+17+48",816),
("1+18+45",810),
("3+18+0",0),
("0+19+11",209),
("3+18+1",18),
("2+17+31",527),
("4+17+49",833),
("1+18+46",828),
("1+18+47",846),
("2+17+32",544),
("1+18+48",864),
("3+18+2",36),
("0+19+12",228),
("4+18+0",0),
("4+18+1",18),
("4+18+2",36),
("4+18+3",54),
("4+18+4",72),
("4+18+5",90),
("4+18+6",108),
("4+18+7",126),
("3+18+3",54),
("1+18+49",882),
("4+18+8",144),
("3+18+4",72),
("0+19+13",247),
("4+18+9",162),
("3+18+5",90),
("0+19+14",266),
("4+18+10",180),
("4+18+11",198),
("1+19+0",0),
("2+17+33",561),
("2+17+34",578),
("2+17+35",595),
("1+19+1",19),
("3+18+6",108),
("4+18+12",216),
("4+18+13",234),
("0+19+15",285),
("2+17+36",612),
("3+18+7",126),
("4+18+14",252),
("2+17+37",629),
("0+19+16",304),
("1+19+2",38),
("2+17+38",646),
("4+18+15",270),
("3+18+8",144),
("0+19+17",323),
("2+17+39",663),
("4+18+16",288),
("1+19+3",57),
("1+19+4",76),
("3+18+9",162),
("1+19+5",95),
("1+19+6",114),
("0+19+18",342),
("2+17+40",680),
("0+19+19",361),
("3+18+10",180),
("1+19+7",133),
("2+17+41",697),
("1+19+8",152),
("2+17+42",714),
("4+18+17",306),
("4+18+18",324),
("2+17+43",731),
("3+18+11",198),
("3+18+12",216),
("1+19+9",171),
("0+19+20",380),
("3+18+13",234),
("1+19+10",190),
("1+19+11",209),
("1+19+12",228),
("3+18+14",252),
("1+19+13",247),
("0+19+21",399),
("1+19+14",266),
("2+17+44",748),
("2+17+45",765),
("1+19+15",285),
("2+17+46",782),
("1+19+16",304),
("0+19+22",418),
("4+18+19",342),
("0+19+23",437),
("0+19+24",456),
("3+18+15",270),
("4+18+20",360),
("0+19+25",475),
("2+17+47",799),
("1+19+17",323),
("0+19+26",494),
("1+19+18",342),
("2+17+48",816),
("4+18+21",378),
("4+18+22",396),
("0+19+27",513),
("0+19+28",532),
("4+18+23",414),
("1+19+19",361),
("3+18+16",288),
("0+19+29",551),
("4+18+24",432),
("2+17+49",833),
("0+19+30",570),
("0+19+31",589),
("1+19+20",380),
("4+18+25",450),
("1+19+21",399),
("0+19+32",608),
("3+18+17",306),
("4+18+26",468),
("3+18+18",324),
("1+19+22",418),
("4+18+27",486),
("4+18+28",504),
("0+19+33",627),
("3+18+19",342),
("1+19+23",437),
("2+18+0",0),
("1+19+24",456),
("0+19+34",646),
("3+18+20",360),
("0+19+35",665),
("1+19+25",475),
("2+18+1",18),
("1+19+26",494),
("4+18+29",522),
("3+18+21",378),
("2+18+2",36),
("4+18+30",540),
("2+18+3",54),
("1+19+27",513),
("0+19+36",684),
("2+18+4",72),
("4+18+31",558),
("3+18+22",396),
("3+18+23",414),
("1+19+28",532),
("3+18+24",432),
("4+18+32",576),
("1+19+29",551),
("0+19+37",703),
("2+18+5",90),
("0+19+38",722),
("3+18+25",450),
("0+19+39",741),
("3+18+26",468),
("0+19+40",760),
("4+18+33",594),
("0+19+41",779),
("4+18+34",612),
("0+19+42",798),
("3+18+27",486),
("3+18+28",504),
("2+18+6",108),
("1+19+30",570),
("3+18+29",522),
("2+18+7",126),
("1+19+31",589),
("0+19+43",817),
("2+18+8",144),
("1+19+32",608),
("0+19+44",836),
("1+19+33",627),
("2+18+9",162),
("0+19+45",855),
("1+19+34",646),
("0+19+46",874),
("2+18+10",180),
("3+18+30",540),
("2+18+11",198),
("4+18+35",630),
("2+18+12",216),
("3+18+31",558),
("2+18+13",234),
("1+19+35",665),
("4+18+36",648),
("4+18+37",666),
("0+19+47",893),
("4+18+38",684),
("1+19+36",684),
("0+19+48",912),
("2+18+14",252),
("3+18+32",576),
("1+19+37",703),
("1+19+38",722),
("1+19+39",741),
("2+18+15",270),
("3+18+33",594),
("0+19+49",931),
("1+19+40",760),
("1+19+41",779),
("2+18+16",288),
("3+18+34",612),
("4+18+39",702),
("2+18+17",306),
("3+18+35",630),
("4+18+40",720),
("3+18+36",648),
("2+18+18",324),
("2+18+19",342),
("3+18+37",666),
("4+18+41",738),
("0+20+0",0),
("2+18+20",360),
("2+18+21",378),
("3+18+38",684),
("1+19+42",798),
("2+18+22",396),
("1+19+43",817),
("4+18+42",756),
("2+18+23",414),
("0+20+1",20),
("2+18+24",432),
("3+18+39",702),
("4+18+43",774),
("2+18+25",450),
("3+18+40",720),
("4+18+44",792),
("2+18+26",468),
("1+19+44",836),
("1+19+45",855),
("1+19+46",874),
("4+18+45",810),
("1+19+47",893),
("2+18+27",486),
("1+19+48",912),
("0+20+2",40),
("0+20+3",60),
("0+20+4",80),
("0+20+5",100),
("4+18+46",828),
("3+18+41",738),
("2+18+28",504),
("1+19+49",931),
("4+18+47",846),
("2+18+29",522),
("0+20+6",120),
("2+18+30",540),
("0+20+7",140),
("0+20+8",160),
("4+18+48",864),
("4+18+49",882),
("2+18+31",558),
("3+18+42",756),
("2+18+32",576),
("3+18+43",774),
("0+20+9",180),
("2+18+33",594),
("3+18+44",792),
("1+20+0",0),
("2+18+34",612),
("1+20+1",20),
("2+18+35",630),
("1+20+2",40),
("2+18+36",648),
("3+18+45",810),
("1+20+3",60),
("0+20+10",200),
("3+18+46",828),
("2+18+37",666),
("1+20+4",80),
("0+20+11",220),
("4+19+0",0),
("3+18+47",846),
("3+18+48",864),
("2+18+38",684),
("3+18+49",882),
("1+20+5",100),
("1+20+6",120),
("2+18+39",702),
("1+20+7",140),
("2+18+40",720),
("0+20+12",240),
("1+20+8",160),
("2+18+41",738),
("1+20+9",180),
("2+18+42",756),
("2+18+43",774),
("2+18+44",792),
("4+19+1",19),
("2+18+45",810),
("0+20+13",260),
("1+20+10",200),
("0+20+14",280),
("2+18+46",828),
("0+20+15",300),
("1+20+11",220),
("0+20+16",320),
("4+19+2",38),
("0+20+17",340),
("2+18+47",846),
("2+18+48",864),
("4+19+3",57),
("0+20+18",360),
("4+19+4",76),
("1+20+12",240),
("2+18+49",882),
("0+20+19",380),
("0+20+20",400),
("1+20+13",260),
("4+19+5",95),
("0+20+21",420),
("1+20+14",280),
("0+20+22",440),
("4+19+6",114),
("0+20+23",460),
("4+19+7",133),
("4+19+8",152),
("0+20+24",480),
("4+19+9",171),
("0+20+25",500),
("1+20+15",300),
("0+20+26",520),
("0+20+27",540),
("4+19+10",190),
("4+19+11",209),
("0+20+28",560),
("1+20+16",320),
("4+19+12",228),
("1+20+17",340),
("0+20+29",580),
("0+20+30",600),
("1+20+18",360),
("4+19+13",247),
("1+20+19",380),
("1+20+20",400),
("4+19+14",266),
("1+20+21",420),
("1+20+22",440),
("1+20+23",460),
("4+19+15",285),
("0+20+31",620),
("4+19+16",304),
("0+20+32",640),
("0+20+33",660),
("0+20+34",680),
("0+20+35",700),
("4+19+17",323),
("0+20+36",720),
("4+19+18",342),
("4+19+19",361),
("0+20+37",740),
("4+19+20",380),
("1+20+24",480),
("1+20+25",500),
("1+20+26",520),
("1+20+27",540),
("1+20+28",560),
("4+19+21",399),
("4+19+22",418),
("4+19+23",437),
("0+20+38",760),
("4+19+24",456),
("0+20+39",780),
("1+20+29",580),
("0+20+40",800),
("4+19+25",475),
("1+20+30",600),
("1+20+31",620),
("0+20+41",820),
("1+20+32",640),
("1+20+33",660),
("1+20+34",680),
("1+20+35",700),
("1+20+36",720),
("4+19+26",494),
("1+20+37",740),
("4+19+27",513),
("1+20+38",760),
("4+19+28",532),
("1+20+39",780),
("1+20+40",800),
("1+20+41",820),
("0+20+42",840),
("1+20+42",840),
("0+20+43",860),
("1+20+43",860),
("1+20+44",880),
("0+20+44",880),
("0+20+45",900),
("0+20+46",920),
("0+20+47",940),
("4+19+29",551),
("0+20+48",960),
("4+19+30",570),
("4+19+31",589),
("1+20+45",900),
("1+20+46",920),
("0+20+49",980),
("4+19+32",608),
("4+19+33",627),
("4+19+34",646),
("4+19+35",665),
("1+20+47",940),
("4+19+36",684),
("4+19+37",703),
("1+20+48",960),
("4+19+38",722),
("1+20+49",980),
("4+19+39",741),
("4+19+40",760),
("4+19+41",779),
("4+19+42",798),
("4+19+43",817),
("4+19+44",836),
("4+19+45",855),
("4+19+46",874),
("4+19+47",893),
("4+19+48",912),
("4+19+49",931),
("2+19+0",0),
("4+20+0",0),
("0+21+0",0),
("2+19+1",19),
("3+19+0",0),
("0+21+1",21),
("4+20+1",20),
("1+21+0",0),
("4+20+2",40),
("3+19+1",19),
("1+21+1",21),
("4+20+3",60),
("0+21+2",42),
("4+20+4",80),
("2+19+2",38),
("1+21+2",42),
("4+20+5",100),
("0+21+3",63),
("1+21+3",63),
("0+21+4",84),
("1+21+4",84),
("4+20+6",120),
("2+19+3",57),
("0+21+5",105),
("0+21+6",126),
("1+21+5",105),
("2+19+4",76),
("1+21+6",126),
("4+20+7",140),
("3+19+2",38),
("0+21+7",147),
("0+21+8",168),
("2+19+5",95),
("3+19+3",57),
("4+20+8",160),
("1+21+7",147),
("1+21+8",168),
("0+21+9",189),
("4+20+9",180),
("0+21+10",210),
("4+20+10",200),
("3+19+4",76),
("2+19+6",114),
("0+21+11",231),
("1+21+9",189),
("4+20+11",220),
("3+19+5",95),
("4+20+12",240),
("0+21+12",252),
("1+21+10",210),
("3+19+6",114),
("0+21+13",273),
("4+20+13",260),
("1+21+11",231),
("0+21+14",294),
("4+20+14",280),
("1+21+12",252),
("2+19+7",133),
("0+21+15",315),
("0+21+16",336),
("0+21+17",357),
("4+20+15",300),
("0+21+18",378),
("3+19+7",133),
("4+20+16",320),
("0+21+19",399),
("3+19+8",152),
("2+19+8",152),
("3+19+9",171),
("3+19+10",190),
("4+20+17",340),
("0+21+20",420),
("3+19+11",209),
("0+21+21",441),
("2+19+9",171),
("0+21+22",462),
("2+19+10",190),
("1+21+13",273),
("0+21+23",483),
("1+21+14",294),
("2+19+11",209),
("3+19+12",228),
("2+19+12",228),
("1+21+15",315),
("4+20+18",360),
("4+20+19",380),
("1+21+16",336),
("3+19+13",247),
("2+19+13",247),
("0+21+24",504),
("1+21+17",357),
("4+20+20",400),
("0+21+25",525),
("1+21+18",378),
("3+19+14",266),
("4+20+21",420),
("1+21+19",399),
("2+19+14",266),
("2+19+15",285),
("1+21+20",420),
("2+19+16",304),
("3+19+15",285),
("0+21+26",546),
("3+19+16",304),
("1+21+21",441),
("1+21+22",462),
("0+21+27",567),
("1+21+23",483),
("4+20+22",440),
("3+19+17",323),
("1+21+24",504),
("0+21+28",588),
("2+19+17",323),
("1+21+25",525),
("4+20+23",460),
("1+21+26",546),
("4+20+24",480),
("4+20+25",500),
("2+19+18",342),
("4+20+26",520),
("2+19+19",361),
("3+19+18",342),
("0+21+29",609),
("4+20+27",540),
("3+19+19",361),
("3+19+20",380),
("4+20+28",560),
("0+21+30",630),
("3+19+21",399),
("3+19+22",418),
("2+19+20",380),
("3+19+23",437),
("4+20+29",580),
("0+21+31",651),
("4+20+30",600),
("4+20+31",620),
("3+19+24",456),
("1+21+27",567),
("3+19+25",475),
("0+21+32",672),
("1+21+28",588),
("2+19+21",399),
("1+21+29",609),
("0+21+33",693),
("2+19+22",418),
("4+20+32",640),
("3+19+26",494),
("4+20+33",660),
("0+21+34",714),
("0+21+35",735),
("3+19+27",513),
("3+19+28",532),
("0+21+36",756),
("2+19+23",437),
("0+21+37",777),
("4+20+34",680),
("2+19+24",456),
("2+19+25",475),
("1+21+30",630),
("0+21+38",798),
("3+19+29",551),
("2+19+26",494),
("3+19+30",570),
("1+21+31",651),
("2+19+27",513),
("1+21+32",672),
("2+19+28",532),
("4+20+35",700),
("3+19+31",589),
("4+20+36",720),
("2+19+29",551),
("0+21+39",819),
("4+20+37",740),
("2+19+30",570),
("3+19+32",608),
("3+19+33",627),
("2+19+31",589),
("3+19+34",646),
("3+19+35",665),
("4+20+38",760),
("4+20+39",780),
("1+21+33",693),
("1+21+34",714),
("4+20+40",800),
("4+20+41",820),
("0+21+40",840),
("3+19+36",684),
("4+20+42",840),
("4+20+43",860),
("0+21+41",861),
("2+19+32",608),
("4+20+44",880),
("1+21+35",735),
("0+21+42",882),
("2+19+33",627),
("2+19+34",646),
("4+20+45",900),
("0+21+43",903),
("4+20+46",920),
("0+21+44",924),
("2+19+35",665),
("0+21+45",945),
("1+21+36",756),
("2+19+36",684),
("2+19+37",703),
("3+19+37",703),
("3+19+38",722),
("1+21+37",777),
("0+21+46",966),
("1+21+38",798),
("0+21+47",987),
("0+21+48",1008),
("3+19+39",741),
("2+19+38",722),
("0+21+49",1029),
("2+19+39",741),
("1+21+39",819),
("1+21+40",840),
("4+20+47",940),
("1+21+41",861),
("1+21+42",882),
("3+19+40",760),
("2+19+40",760),
("3+19+41",779),
("1+21+43",903),
("0+22+0",0),
("2+19+41",779),
("3+19+42",798),
("0+22+1",22),
("2+19+42",798),
("1+21+44",924),
("3+19+43",817),
("1+21+45",945),
("2+19+43",817),
("0+22+2",44),
("2+19+44",836),
("1+21+46",966),
("4+20+48",960),
("2+19+45",855),
("2+19+46",874),
("0+22+3",66),
("3+19+44",836),
("2+19+47",893),
("4+20+49",980),
("2+19+48",912),
("1+21+47",987),
("2+19+49",931),
("1+21+48",1008),
("0+22+4",88),
("1+21+49",1029),
("0+22+5",110),
("0+22+6",132),
("4+21+0",0),
("4+21+1",21),
("0+22+7",154),
("0+22+8",176),
("3+19+45",855),
("4+21+2",42),
("3+19+46",874),
("0+22+9",198),
("3+19+47",893),
("0+22+10",220),
("2+20+0",0),
("4+21+3",63),
("2+20+1",20),
("3+19+48",912),
("3+19+49",931),
("2+20+2",40),
("1+22+0",0),
("0+22+11",242),
("2+20+3",60),
("0+22+12",264),
("1+22+1",22),
("0+22+13",286),
("2+20+4",80),
("4+21+4",84),
("3+20+0",0),
("0+22+14",308),
("2+20+5",100),
("1+22+2",44),
("0+22+15",330),
("0+22+16",352),
("2+20+6",120),
("3+20+1",20),
("0+22+17",374),
("1+22+3",66),
("4+21+5",105),
("0+22+18",396),
("0+22+19",418),
("4+21+6",126),
("1+22+4",88),
("4+21+7",147),
("2+20+7",140),
("4+21+8",168),
("4+21+9",189),
("1+22+5",110),
("4+21+10",210),
("1+22+6",132),
("3+20+2",40),
("3+20+3",60),
("2+20+8",160),
("2+20+9",180),
("4+21+11",231),
("4+21+12",252),
("4+21+13",273),
("3+20+4",80),
("3+20+5",100),
("0+22+20",440),
("1+22+7",154),
("3+20+6",120),
("0+22+21",462),
("0+22+22",484),
("4+21+14",294),
("3+20+7",140),
("3+20+8",160),
("3+20+9",180),
("4+21+15",315),
("1+22+8",176),
("2+20+10",200),
("2+20+11",220),
("2+20+12",240),
("2+20+13",260),
("3+20+10",200),
("0+22+23",506),
("0+22+24",528),
("1+22+9",198),
("1+22+10",220),
("0+22+25",550),
("0+22+26",572),
("0+22+27",594),
("2+20+14",280),
("2+20+15",300),
("4+21+16",336),
("3+20+11",220),
("3+20+12",240),
("1+22+11",242),
("3+20+13",260),
("4+21+17",357),
("2+20+16",320),
("4+21+18",378),
("2+20+17",340),
("1+22+12",264),
("3+20+14",280),
("4+21+19",399),
("1+22+13",286),
("3+20+15",300),
("4+21+20",420),
("0+22+28",616),
("0+22+29",638),
("3+20+16",320),
("4+21+21",441),
("3+20+17",340),
("4+21+22",462),
("1+22+14",308),
("3+20+18",360),
("2+20+18",360),
("2+20+19",380),
("4+21+23",483),
("0+22+30",660),
("2+20+20",400),
("0+22+31",682),
("2+20+21",420),
("2+20+22",440),
("2+20+23",460),
("0+22+32",704),
("3+20+19",380),
("1+22+15",330),
("2+20+24",480),
("4+21+24",504),
("2+20+25",500),
("2+20+26",520),
("1+22+16",352),
("0+22+33",726),
("3+20+20",400),
("4+21+25",525),
("0+22+34",748),
("0+22+35",770),
("2+20+27",540),
("0+22+36",792),
("4+21+26",546),
("0+22+37",814),
("2+20+28",560),
("4+21+27",567),
("1+22+17",374),
("3+20+21",420),
("0+22+38",836),
("4+21+28",588),
("0+22+39",858),
("1+22+18",396),
("3+20+22",440),
("2+20+29",580),
("1+22+19",418),
("0+22+40",880),
("2+20+30",600),
("0+22+41",902),
("1+22+20",440),
("1+22+21",462),
("1+22+22",484),
("0+22+42",924),
("3+20+23",460),
("3+20+24",480),
("4+21+29",609),
("2+20+31",620),
("4+21+30",630),
("2+20+32",640),
("2+20+33",660),
("1+22+23",506),
("4+21+31",651),
("2+20+34",680),
("1+22+24",528),
("4+21+32",672),
("1+22+25",550),
("2+20+35",700),
("2+20+36",720),
("2+20+37",740),
("0+22+43",946),
("4+21+33",693),
("3+20+25",500),
("2+20+38",760),
("3+20+26",520),
("3+20+27",540),
("4+21+34",714),
("4+21+35",735),
("4+21+36",756),
("0+22+44",968),
("1+22+26",572),
("4+21+37",777),
("0+22+45",990),
("0+22+46",1012),
("0+22+47",1034),
("4+21+38",798),
("4+21+39",819),
("4+21+40",840),
("4+21+41",861),
("4+21+42",882),
("0+22+48",1056),
("1+22+27",594),
("1+22+28",616),
("3+20+28",560),
("4+21+43",903),
("3+20+29",580),
("2+20+39",780),
("2+20+40",800),
("4+21+44",924),
("3+20+30",600),
("1+22+29",638),
("2+20+41",820),
("2+20+42",840),
("0+22+49",1078),
("1+22+30",660),
("1+22+31",682),
("1+22+32",704),
("2+20+43",860),
("3+20+31",620),
("2+20+44",880),
("2+20+45",900),
("4+21+45",945),
("4+21+46",966),
("2+20+46",920),
("4+21+47",987),
("0+23+0",0),
("4+21+48",1008),
("3+20+32",640),
("2+20+47",940),
("1+22+33",726),
("2+20+48",960),
("2+20+49",980),
("1+22+34",748),
("1+22+35",770),
("1+22+36",792),
("0+23+1",23),
("3+20+33",660),
("0+23+2",46),
("1+22+37",814),
("0+23+3",69),
("4+21+49",1029),
("3+20+34",680),
("2+21+0",0),
("2+21+1",21),
("0+23+4",92),
("1+22+38",836),
("2+21+2",42),
("3+20+35",700),
("1+22+39",858),
("3+20+36",720),
("0+23+5",115),
("2+21+3",63),
("4+22+0",0),
("4+22+1",22),
("3+20+37",740),
("1+22+40",880),
("4+22+2",44),
("3+20+38",760),
("2+21+4",84),
("3+20+39",780),
("1+22+41",902),
("3+20+40",800),
("2+21+5",105),
("0+23+6",138),
("3+20+41",820),
("3+20+42",840),
("3+20+43",860),
("0+23+7",161),
("0+23+8",184),
("4+22+3",66),
("3+20+44",880),
("0+23+9",207),
("4+22+4",88),
("4+22+5",110),
("4+22+6",132),
("0+23+10",230),
("2+21+6",126),
("4+22+7",154),
("4+22+8",176),
("1+22+42",924),
("1+22+43",946),
("4+22+9",198),
("3+20+45",900),
("0+23+11",253),
("1+22+44",968),
("1+22+45",990),
("1+22+46",1012),
("4+22+10",220),
("4+22+11",242),
("4+22+12",264),
("0+23+12",276),
("0+23+13",299),
("3+20+46",920),
("3+20+47",940),
("2+21+7",147),
("3+20+48",960),
("0+23+14",322),
("2+21+8",168),
("1+22+47",1034),
("2+21+9",189),
("4+22+13",286),
("0+23+15",345),
("0+23+16",368),
("3+20+49",980),
("1+22+48",1056),
("2+21+10",210),
("0+23+17",391),
("0+23+18",414),
("0+23+19",437),
("4+22+14",308),
("1+22+49",1078),
("2+21+11",231),
("4+22+15",330),
("2+21+12",252),
("4+22+16",352),
("2+21+13",273),
("1+23+0",0),
("4+22+17",374),
("1+23+1",23),
("2+21+14",294),
("1+23+2",46),
("2+21+15",315),
("4+22+18",396),
("2+21+16",336),
("1+23+3",69),
("3+21+0",0),
("4+22+19",418),
("0+23+20",460),
("0+23+21",483),
("0+23+22",506),
("4+22+20",440),
("2+21+17",357),
("4+22+21",462),
("4+22+22",484),
("1+23+4",92),
("1+23+5",115),
("1+23+6",138),
("0+23+23",529),
("4+22+23",506),
("3+21+1",21),
("0+23+24",552),
("2+21+18",378),
("0+23+25",575),
("2+21+19",399),
("4+22+24",528),
("0+23+26",598),
("1+23+7",161),
("1+23+8",184),
("4+22+25",550),
("0+23+27",621),
("4+22+26",572),
("1+23+9",207),
("3+21+2",42),
("2+21+20",420),
("1+23+10",230),
("1+23+11",253),
("1+23+12",276),
("0+23+28",644),
("1+23+13",299),
("3+21+3",63),
("3+21+4",84),
("1+23+14",322),
("2+21+21",441),
("1+23+15",345),
("0+23+29",667),
("4+22+27",594),
("1+23+16",368),
("4+22+28",616),
("3+21+5",105),
("1+23+17",391),
("1+23+18",414),
("4+22+29",638),
("2+21+22",462),
("2+21+23",483),
("3+21+6",126),
("1+23+19",437),
("0+23+30",690),
("1+23+20",460),
("4+22+30",660),
("4+22+31",682),
("3+21+7",147),
("1+23+21",483),
("1+23+22",506),
("4+22+32",704),
("0+23+31",713),
("2+21+24",504),
("2+21+25",525),
("2+21+26",546),
("1+23+23",529),
("0+23+32",736),
("4+22+33",726),
("4+22+34",748),
("4+22+35",770),
("2+21+27",567),
("1+23+24",552),
("3+21+8",168),
("2+21+28",588),
("0+23+33",759),
("4+22+36",792),
("2+21+29",609),
("1+23+25",575),
("0+23+34",782),
("2+21+30",630),
("4+22+37",814),
("4+22+38",836),
("2+21+31",651),
("0+23+35",805),
("1+23+26",598),
("3+21+9",189),
("4+22+39",858),
("2+21+32",672),
("3+21+10",210),
("2+21+33",693),
("3+21+11",231),
("0+23+36",828),
("1+23+27",621),
("4+22+40",880),
("4+22+41",902),
("3+21+12",252),
("0+23+37",851),
("1+23+28",644),
("2+21+34",714),
("0+23+38",874),
("2+21+35",735),
("2+21+36",756),
("2+21+37",777),
("1+23+29",667),
("3+21+13",273),
("1+23+30",690),
("1+23+31",713),
("2+21+38",798),
("2+21+39",819),
("3+21+14",294),
("4+22+42",924),
("3+21+15",315),
("2+21+40",840),
("4+22+43",946),
("3+21+16",336),
("3+21+17",357),
("0+23+39",897),
("3+21+18",378),
("4+22+44",968),
("1+23+32",736),
("3+21+19",399),
("2+21+41",861),
("4+22+45",990),
("2+21+42",882),
("2+21+43",903),
("4+22+46",1012),
("1+23+33",759),
("3+21+20",420),
("3+21+21",441),
("0+23+40",920),
("1+23+34",782),
("2+21+44",924),
("0+23+41",943),
("0+23+42",966),
("3+21+22",462),
("0+23+43",989),
("1+23+35",805),
("1+23+36",828),
("1+23+37",851),
("1+23+38",874),
("1+23+39",897),
("2+21+45",945),
("0+23+44",1012),
("1+23+40",920),
("1+23+41",943),
("2+21+46",966),
("2+21+47",987),
("2+21+48",1008),
("3+21+23",483),
("1+23+42",966),
("2+21+49",1029),
("0+23+45",1035),
("0+23+46",1058),
("3+21+24",504),
("3+21+25",525),
("1+23+43",989),
("4+22+47",1034),
("0+23+47",1081),
("2+22+0",0),
("0+23+48",1104),
("3+21+26",546),
("1+23+44",1012),
("0+23+49",1127),
("2+22+1",22),
("4+22+48",1056),
("2+22+2",44),
("1+23+45",1035),
("3+21+27",567),
("0+24+0",0),
("4+22+49",1078),
("2+22+3",66),
("2+22+4",88),
("2+22+5",110),
("1+23+46",1058),
("2+22+6",132),
("1+23+47",1081),
("2+22+7",154),
("3+21+28",588),
("4+23+0",0),
("3+21+29",609),
("4+23+1",23),
("0+24+1",24),
("2+22+8",176),
("4+23+2",46),
("4+23+3",69),
("4+23+4",92),
("1+23+48",1104),
("0+24+2",48),
("0+24+3",72),
("4+23+5",115),
("1+23+49",1127),
("4+23+6",138),
("0+24+4",96),
("0+24+5",120),
("4+23+7",161),
("3+21+30",630),
("2+22+9",198),
("3+21+31",651),
("0+24+6",144),
("1+24+0",0),
("1+24+1",24),
("0+24+7",168),
("0+24+8",192),
("1+24+2",48),
("0+24+9",216),
("1+24+3",72),
("3+21+32",672),
("0+24+10",240),
("2+22+10",220),
("2+22+11",242),
("3+21+33",693),
("3+21+34",714),
("3+21+35",735),
("4+23+8",184),
("0+24+11",264),
("0+24+12",288),
("1+24+4",96),
("4+23+9",207),
("0+24+13",312),
("1+24+5",120),
("0+24+14",336),
("3+21+36",756),
("1+24+6",144),
("3+21+37",777),
("4+23+10",230),
("2+22+12",264),
("3+21+38",798),
("1+24+7",168),
("2+22+13",286),
("1+24+8",192),
("1+24+9",216),
("0+24+15",360),
("0+24+16",384),
("1+24+10",240),
("4+23+11",253),
("3+21+39",819),
("4+23+12",276),
("1+24+11",264),
("1+24+12",288),
("1+24+13",312),
("0+24+17",408),
("3+21+40",840),
("3+21+41",861),
("0+24+18",432),
("3+21+42",882),
("0+24+19",456),
("1+24+14",336),
("3+21+43",903),
("1+24+15",360),
("4+23+13",299),
("3+21+44",924),
("0+24+20",480),
("1+24+16",384),
("4+23+14",322),
("4+23+15",345),
("1+24+17",408),
("2+22+14",308),
("0+24+21",504),
("0+24+22",528),
("2+22+15",330),
("3+21+45",945),
("1+24+18",432),
("1+24+19",456),
("1+24+20",480),
("2+22+16",352),
("1+24+21",504),
("4+23+16",368),
("4+23+17",391),
("4+23+18",414),
("2+22+17",374),
("1+24+22",528),
("1+24+23",552),
("1+24+24",576),
("1+24+25",600),
("0+24+23",552),
("1+24+26",624),
("3+21+46",966),
("3+21+47",987),
("4+23+19",437),
("4+23+20",460),
("3+21+48",1008),
("2+22+18",396),
("1+24+27",648),
("1+24+28",672),
("1+24+29",696),
("1+24+30",720),
("1+24+31",744),
("2+22+19",418),
("3+21+49",1029),
("4+23+21",483),
("0+24+24",576),
("0+24+25",600),
("0+24+26",624),
("2+22+20",440),
("0+24+27",648),
("4+23+22",506),
("4+23+23",529),
("2+22+21",462),
("4+23+24",552),
("0+24+28",672),
("3+22+0",0),
("1+24+32",768),
("4+23+25",575),
("0+24+29",696),
("4+23+26",598),
("4+23+27",621),
("1+24+33",792),
("4+23+28",644),
("1+24+34",816),
("2+22+22",484),
("1+24+35",840),
("4+23+29",667),
("2+22+23",506),
("3+22+1",22),
("4+23+30",690),
("0+24+30",720),
("1+24+36",864),
("4+23+31",713),
("2+22+24",528),
("3+22+2",44),
("0+24+31",744),
("4+23+32",736),
("3+22+3",66),
("0+24+32",768),
("2+22+25",550),
("0+24+33",792),
("2+22+26",572),
("4+23+33",759),
("1+24+37",888),
("4+23+34",782),
("1+24+38",912),
("3+22+4",88),
("1+24+39",936),
("2+22+27",594),
("4+23+35",805),
("1+24+40",960),
("0+24+34",816),
("4+23+36",828),
("2+22+28",616),
("4+23+37",851),
("2+22+29",638),
("2+22+30",660),
("3+22+5",110),
("0+24+35",840),
("2+22+31",682),
("1+24+41",984),
("2+22+32",704),
("4+23+38",874),
("1+24+42",1008),
("0+24+36",864),
("1+24+43",1032),
("4+23+39",897),
("3+22+6",132),
("0+24+37",888),
("3+22+7",154),
("3+22+8",176),
("4+23+40",920),
("2+22+33",726),
("4+23+41",943),
("3+22+9",198),
("2+22+34",748),
("3+22+10",220),
("2+22+35",770),
("1+24+44",1056),
("1+24+45",1080),
("2+22+36",792),
("1+24+46",1104),
("3+22+11",242),
("4+23+42",966),
("1+24+47",1128),
("2+22+37",814),
("2+22+38",836),
("0+24+38",912),
("4+23+43",989),
("2+22+39",858),
("1+24+48",1152),
("3+22+12",264),
("1+24+49",1176),
("2+22+40",880),
("4+23+44",1012),
("0+24+39",936),
("0+24+40",960),
("4+23+45",1035),
("3+22+13",286),
("3+22+14",308),
("2+22+41",902),
("4+23+46",1058),
("3+22+15",330),
("4+23+47",1081),
("2+22+42",924),
("3+22+16",352),
("0+24+41",984),
("0+24+42",1008),
("3+22+17",374),
("1+25+0",0),
("4+23+48",1104),
("0+24+43",1032),
("4+23+49",1127),
("3+22+18",396),
("3+22+19",418),
("2+22+43",946),
("0+24+44",1056),
("2+22+44",968),
("0+24+45",1080),
("2+22+45",990),
("4+24+0",0),
("2+22+46",1012),
("0+24+46",1104),
("1+25+1",25),
("3+22+20",440),
("4+24+1",24),
("1+25+2",50),
("2+22+47",1034),
("2+22+48",1056),
("3+22+21",462),
("1+25+3",75),
("3+22+22",484),
("0+24+47",1128),
("4+24+2",48),
("2+22+49",1078),
("4+24+3",72),
("4+24+4",96),
("0+24+48",1152),
("3+22+23",506),
("3+22+24",528),
("0+24+49",1176),
("1+25+4",100),
("4+24+5",120),
("3+22+25",550),
("1+25+5",125),
("2+23+0",0),
("1+25+6",150),
("3+22+26",572),
("3+22+27",594),
("2+23+1",23),
("0+25+0",0),
("3+22+28",616),
("3+22+29",638),
("4+24+6",144),
("3+22+30",660),
("2+23+2",46),
("0+25+1",25),
("0+25+2",50),
("3+22+31",682),
("2+23+3",69),
("2+23+4",92),
("3+22+32",704),
("2+23+5",115),
("1+25+7",175),
("3+22+33",726),
("3+22+34",748),
("2+23+6",138),
("0+25+3",75),
("2+23+7",161),
("3+22+35",770),
("0+25+4",100),
("1+25+8",200),
("1+25+9",225),
("4+24+7",168),
("2+23+8",184),
("3+22+36",792),
("0+25+5",125),
("0+25+6",150),
("2+23+9",207),
("2+23+10",230),
("0+25+7",175),
("0+25+8",200),
("0+25+9",225),
("3+22+37",814),
("4+24+8",192),
("2+23+11",253),
("0+25+10",250),
("1+25+10",250),
("4+24+9",216),
("4+24+10",240),
("2+23+12",276),
("0+25+11",275),
("1+25+11",275),
("3+22+38",836),
("2+23+13",299),
("1+25+12",300),
("4+24+11",264),
("1+25+13",325),
("1+25+14",350),
("4+24+12",288),
("1+25+15",375),
("0+25+12",300),
("3+22+39",858),
("0+25+13",325),
("4+24+13",312),
("4+24+14",336),
("0+25+14",350),
("3+22+40",880),
("0+25+15",375),
("3+22+41",902),
("4+24+15",360),
("1+25+16",400),
("2+23+14",322),
("3+22+42",924),
("4+24+16",384),
("3+22+43",946),
("1+25+17",425),
("3+22+44",968),
("0+25+16",400),
("1+25+18",450),
("2+23+15",345),
("1+25+19",475),
("3+22+45",990),
("0+25+17",425),
("0+25+18",450),
("4+24+17",408),
("4+24+18",432),
("2+23+16",368),
("3+22+46",1012),
("3+22+47",1034),
("3+22+48",1056),
("4+24+19",456),
("3+22+49",1078),
("4+24+20",480),
("1+25+20",500),
("2+23+17",391),
("0+25+19",475),
("4+24+21",504),
("4+24+22",528),
("4+24+23",552),
("1+25+21",525),
("4+24+24",576),
("0+25+20",500),
("0+25+21",525),
("1+25+22",550),
("0+25+22",550),
("2+23+18",414),
("3+23+0",0),
("1+25+23",575),
("2+23+19",437),
("4+24+25",600),
("4+24+26",624),
("0+25+23",575),
("0+25+24",600),
("1+25+24",600),
("3+23+1",23),
("2+23+20",460),
("4+24+27",648),
("0+25+25",625),
("1+25+25",625),
("0+25+26",650),
("3+23+2",46),
("3+23+3",69),
("1+25+26",650),
("0+25+27",675),
("4+24+28",672),
("0+25+28",700),
("3+23+4",92),
("0+25+29",725),
("2+23+21",483),
("2+23+22",506),
("1+25+27",675),
("0+25+30",750),
("4+24+29",696),
("0+25+31",775),
("4+24+30",720),
("0+25+32",800),
("2+23+23",529),
("2+23+24",552),
("0+25+33",825),
("1+25+28",700),
("4+24+31",744),
("4+24+32",768),
("2+23+25",575),
("2+23+26",598),
("3+23+5",115),
("0+25+34",850),
("3+23+6",138),
("0+25+35",875),
("0+25+36",900),
("0+25+37",925),
("4+24+33",792),
("4+24+34",816),
("1+25+29",725),
("4+24+35",840),
("1+25+30",750),
("2+23+27",621),
("3+23+7",161),
("1+25+31",775),
("1+25+32",800),
("4+24+36",864),
("1+25+33",825),
("2+23+28",644),
("1+25+34",850),
("2+23+29",667),
("0+25+38",950),
("4+24+37",888),
("4+24+38",912),
("1+25+35",875),
("1+25+36",900),
("4+24+39",936),
("4+24+40",960),
("1+25+37",925),
("4+24+41",984),
("1+25+38",950),
("2+23+30",690),
("3+23+8",184),
("0+25+39",975),
("3+23+9",207),
("0+25+40",1000),
("3+23+10",230),
("3+23+11",253),
("4+24+42",1008),
("3+23+12",276),
("3+23+13",299),
("2+23+31",713),
("2+23+32",736),
("0+25+41",1025),
("1+25+39",975),
("4+24+43",1032),
("4+24+44",1056),
("1+25+40",1000),
("1+25+41",1025),
("1+25+42",1050),
("2+23+33",759),
("3+23+14",322),
("4+24+45",1080),
("4+24+46",1104),
("0+25+42",1050),
("4+24+47",1128),
("1+25+43",1075),
("2+23+34",782),
("3+23+15",345),
("3+23+16",368),
("1+25+44",1100),
("2+23+35",805),
("3+23+17",391),
("1+25+45",1125),
("2+23+36",828),
("2+23+37",851),
("0+25+43",1075),
("2+23+38",874),
("2+23+39",897),
("0+25+44",1100),
("0+25+45",1125),
("0+25+46",1150),
("1+25+46",1150),
("0+25+47",1175),
("0+25+48",1200),
("4+24+48",1152),
("4+24+49",1176),
("3+23+18",414),
("0+25+49",1225),
("1+25+47",1175),
("3+23+19",437),
("3+23+20",460),
("2+23+40",920),
("2+23+41",943),
("4+25+0",0),
("3+23+21",483),
("4+25+1",25),
("0+26+0",0),
("0+26+1",26),
("3+23+22",506),
("0+26+2",52),
("2+23+42",966),
("1+25+48",1200),
("3+23+23",529),
("0+26+3",78),
("0+26+4",104),
("2+23+43",989),
("1+25+49",1225),
("0+26+5",130),
("3+23+24",552),
("2+23+44",1012),
("0+26+6",156),
("4+25+2",50),
("0+26+7",182),
("1+26+0",0),
("2+23+45",1035),
("4+25+3",75),
("4+25+4",100),
("3+23+25",575),
("0+26+8",208),
("1+26+1",26),
("3+23+26",598),
("2+23+46",1058),
("4+25+5",125),
("4+25+6",150),
("2+23+47",1081),
("0+26+9",234),
("4+25+7",175),
("4+25+8",200),
("3+23+27",621),
("0+26+10",260),
("0+26+11",286),
("3+23+28",644),
("3+23+29",667),
("4+25+9",225),
("1+26+2",52),
("2+23+48",1104),
("2+23+49",1127),
("0+26+12",312),
("3+23+30",690),
("1+26+3",78),
("3+23+31",713),
("0+26+13",338),
("1+26+4",104),
("1+26+5",130),
("0+26+14",364),
("2+24+0",0),
("0+26+15",390),
("2+24+1",24),
("3+23+32",736),
("1+26+6",156),
("4+25+10",250),
("4+25+11",275),
("0+26+16",416),
("4+25+12",300),
("3+23+33",759),
("0+26+17",442),
("1+26+7",182),
("1+26+8",208),
("1+26+9",234),
("3+23+34",782),
("1+26+10",260),
("0+26+18",468),
("3+23+35",805),
("3+23+36",828),
("4+25+13",325),
("0+26+19",494),
("0+26+20",520),
("2+24+2",48),
("0+26+21",546),
("1+26+11",286),
("1+26+12",312),
("0+26+22",572),
("0+26+23",598),
("0+26+24",624),
("0+26+25",650),
("4+25+14",350),
("1+26+13",338),
("3+23+37",851),
("0+26+26",676),
("4+25+15",375),
("0+26+27",702),
("2+24+3",72),
("3+23+38",874),
("0+26+28",728),
("4+25+16",400),
("1+26+14",364),
("4+25+17",425),
("1+26+15",390),
("4+25+18",450),
("0+26+29",754),
("0+26+30",780),
("0+26+31",806),
("1+26+16",416),
("0+26+32",832),
("2+24+4",96),
("0+26+33",858),
("1+26+17",442),
("3+23+39",897),
("1+26+18",468),
("4+25+19",475),
("1+26+19",494),
("0+26+34",884),
("0+26+35",910),
("4+25+20",500),
("4+25+21",525),
("2+24+5",120),
("3+23+40",920),
("3+23+41",943),
("0+26+36",936),
("1+26+20",520),
("3+23+42",966),
("4+25+22",550),
("2+24+6",144),
("0+26+37",962),
("0+26+38",988),
("2+24+7",168),
("1+26+21",546),
("3+23+43",989),
("1+26+22",572),
("3+23+44",1012),
("0+26+39",1014),
("1+26+23",598),
("0+26+40",1040),
("3+23+45",1035),
("4+25+23",575),
("0+26+41",1066),
("2+24+8",192),
("0+26+42",1092),
("2+24+9",216),
("3+23+46",1058),
("2+24+10",240),
("3+23+47",1081),
("2+24+11",264),
("3+23+48",1104),
("1+26+24",624),
("3+23+49",1127),
("1+26+25",650),
("2+24+12",288),
("0+26+43",1118),
("4+25+24",600),
("2+24+13",312),
("0+26+44",1144),
("3+24+0",0),
("2+24+14",336),
("2+24+15",360),
("1+26+26",676),
("4+25+25",625),
("1+26+27",702),
("0+26+45",1170),
("1+26+28",728),
("4+25+26",650),
("1+26+29",754),
("2+24+16",384),
("3+24+1",24),
("2+24+17",408),
("1+26+30",780),
("0+26+46",1196),
("1+26+31",806),
("0+26+47",1222),
("3+24+2",48),
("1+26+32",832),
("1+26+33",858),
("3+24+3",72),
("1+26+34",884),
("0+26+48",1248),
("3+24+4",96),
("2+24+18",432),
("4+25+27",675),
("3+24+5",120),
("1+26+35",910),
("0+26+49",1274),
("3+24+6",144),
("2+24+19",456),
("2+24+20",480),
("1+26+36",936),
("3+24+7",168),
("2+24+21",504),
("1+26+37",962),
("2+24+22",528),
("2+24+23",552),
("3+24+8",192),
("2+24+24",576),
("4+25+28",700),
("1+26+38",988),
("2+24+25",600),
("4+25+29",725),
("0+27+0",0),
("1+26+39",1014),
("1+26+40",1040),
("4+25+30",750),
("1+26+41",1066),
("4+25+31",775),
("2+24+26",624),
("0+27+1",27),
("4+25+32",800),
("2+24+27",648),
("4+25+33",825),
("0+27+2",54),
("4+25+34",850),
("3+24+9",216),
("1+26+42",1092),
("2+24+28",672),
("3+24+10",240),
("4+25+35",875),
("4+25+36",900),
("1+26+43",1118),
("4+25+37",925),
("3+24+11",264),
("4+25+38",950),
("2+24+29",696),
("3+24+12",288),
("1+26+44",1144),
("4+25+39",975),
("3+24+13",312),
("1+26+45",1170),
("4+25+40",1000),
("0+27+3",81),
("4+25+41",1025),
("0+27+4",108),
("3+24+14",336),
("4+25+42",1050),
("0+27+5",135),
("2+24+30",720),
("0+27+6",162),
("4+25+43",1075),
("2+24+31",744),
("3+24+15",360),
("4+25+44",1100),
("3+24+16",384),
("3+24+17",408),
("4+25+45",1125),
("2+24+32",768),
("1+26+46",1196),
("1+26+47",1222),
("3+24+18",432),
("1+26+48",1248),
("4+25+46",1150),
("2+24+33",792),
("2+24+34",816),
("0+27+7",189),
("2+24+35",840),
("2+24+36",864),
("3+24+19",456),
("3+24+20",480),
("4+25+47",1175),
("3+24+21",504),
("3+24+22",528),
("1+26+49",1274),
("2+24+37",888),
("0+27+8",216),
("3+24+23",552),
("2+24+38",912),
("3+24+24",576),
("4+25+48",1200),
("3+24+25",600),
("4+25+49",1225),
("3+24+26",624),
("3+24+27",648),
("1+27+0",0),
("2+24+39",936),
("3+24+28",672),
("3+24+29",696),
("0+27+9",243),
("0+27+10",270),
("1+27+1",27),
("1+27+2",54),
("3+24+30",720),
("2+24+40",960),
("1+27+3",81),
("3+24+31",744),
("3+24+32",768),
("0+27+11",297),
("2+24+41",984),
("3+24+33",792),
("1+27+4",108),
("2+24+42",1008),
("2+24+43",1032),
("0+27+12",324),
("1+27+5",135),
("0+27+13",351),
("2+24+44",1056),
("2+24+45",1080),
("3+24+34",816),
("1+27+6",162),
("2+24+46",1104),
("2+24+47",1128),
("3+24+35",840),
("1+27+7",189),
("2+24+48",1152),
("3+24+36",864),
("0+27+14",378),
("2+24+49",1176),
("1+27+8",216),
("1+27+9",243),
("0+27+15",405),
("0+27+16",432),
("0+27+17",459),
("0+27+18",486),
("1+27+10",270),
("1+27+11",297),
("3+24+37",888),
("1+27+12",324),
("3+24+38",912),
("3+24+39",936),
("1+27+13",351),
("0+27+19",513),
("0+27+20",540),
("1+27+14",378),
("1+27+15",405),
("3+24+40",960),
("3+24+41",984),
("0+27+21",567),
("1+27+16",432),
("0+27+22",594),
("1+27+17",459),
("0+27+23",621),
("1+27+18",486),
("1+27+19",513),
("0+27+24",648),
("3+24+42",1008),
("3+24+43",1032),
("0+27+25",675),
("0+27+26",702),
("3+24+44",1056),
("3+24+45",1080),
("0+27+27",729),
("0+27+28",756),
("0+27+29",783),
("1+27+20",540),
("3+24+46",1104),
("1+27+21",567),
("3+24+47",1128),
("0+27+30",810),
("1+27+22",594),
("1+27+23",621),
("3+24+48",1152),
("0+27+31",837),
("0+27+32",864),
("3+24+49",1176),
("1+27+24",648),
("1+27+25",675),
("0+27+33",891),
("1+27+26",702),
("1+27+27",729),
("0+27+34",918),
("1+27+28",756),
("0+27+35",945),
("1+27+29",783),
("0+27+36",972),
("1+27+30",810),
("0+27+37",999),
("1+27+31",837),
("0+27+38",1026),
("1+27+32",864),
("0+27+39",1053),
("0+27+40",1080),
("1+27+33",891),
("0+27+41",1107),
("1+27+34",918),
("0+27+42",1134),
("0+27+43",1161),
("1+27+35",945),
("1+27+36",972),
("0+27+44",1188),
("1+27+37",999),
("1+27+38",1026),
("1+27+39",1053),
("1+27+40",1080),
("1+27+41",1107),
("1+27+42",1134),
("0+27+45",1215),
("0+27+46",1242),
("1+27+43",1161),
("0+27+47",1269),
("1+27+44",1188),
("0+27+48",1296),
("0+27+49",1323),
("1+27+45",1215),
("1+27+46",1242),
("1+27+47",1269),
("1+27+48",1296),
("1+27+49",1323),
("4+26+0",0),
("2+25+0",0),
("2+25+1",25),
("4+26+1",26),
("4+26+2",52),
("2+25+2",50),
("2+25+3",75),
("4+26+3",78),
("4+26+4",104),
("2+25+4",100),
("4+26+5",130),
("2+25+5",125),
("4+26+6",156),
("2+25+6",150),
("2+25+7",175),
("4+26+7",182),
("2+25+8",200),
("4+26+8",208),
("4+26+9",234),
("4+26+10",260),
("2+25+9",225),
("4+26+11",286),
("4+26+12",312),
("4+26+13",338),
("4+26+14",364),
("4+26+15",390),
("2+25+10",250),
("2+25+11",275),
("2+25+12",300),
("4+26+16",416),
("4+26+17",442),
("4+26+18",468),
("4+26+19",494),
("2+25+13",325),
("2+25+14",350),
("2+25+15",375),
("4+26+20",520),
("4+26+21",546),
("2+25+16",400),
("4+26+22",572),
("2+25+17",425),
("4+26+23",598),
("2+25+18",450),
("4+26+24",624),
("4+26+25",650),
("2+25+19",475),
("2+25+20",500),
("4+26+26",676),
("4+26+27",702),
("4+26+28",728),
("4+26+29",754),
("4+26+30",780),
("2+25+21",525),
("2+25+22",550),
("4+26+31",806),
("4+26+32",832),
("2+25+23",575),
("4+26+33",858),
("4+26+34",884),
("2+25+24",600),
("2+25+25",625),
("4+26+35",910),
("2+25+26",650),
("4+26+36",936),
("4+26+37",962),
("2+25+27",675),
("2+25+28",700),
("2+25+29",725),
("4+26+38",988),
("2+25+30",750),
("2+25+31",775),
("4+26+39",1014),
("2+25+32",800),
("4+26+40",1040),
("4+26+41",1066),
("4+26+42",1092),
("4+26+43",1118),
("4+26+44",1144),
("2+25+33",825),
("4+26+45",1170),
("2+25+34",850),
("4+26+46",1196),
("2+25+35",875),
("4+26+47",1222),
("4+26+48",1248),
("4+26+49",1274),
("2+25+36",900),
("2+25+37",925),
("2+25+38",950),
("2+25+39",975),
("2+25+40",1000),
("2+25+41",1025),
("2+25+42",1050),
("0+28+0",0),
("4+27+0",0),
("3+25+0",0),
("1+28+0",0),
("2+25+43",1075),
("0+28+1",28),
("2+25+44",1100),
("3+25+1",25),
("4+27+1",27),
("3+25+2",50),
("4+27+2",54),
("3+25+3",75),
("1+28+1",28),
("0+28+2",56),
("3+25+4",100),
("2+25+45",1125),
("4+27+3",81),
("2+25+46",1150),
("1+28+2",56),
("4+27+4",108),
("3+25+5",125),
("1+28+3",84),
("0+28+3",84),
("2+25+47",1175),
("4+27+5",135),
("3+25+6",150),
("4+27+6",162),
("4+27+7",189),
("1+28+4",112),
("2+25+48",1200),
("0+28+4",112),
("3+25+7",175),
("2+25+49",1225),
("4+27+8",216),
("1+28+5",140),
("0+28+5",140),
("3+25+8",200),
("0+28+6",168),
("3+25+9",225),
("4+27+9",243),
("0+28+7",196),
("4+27+10",270),
("3+25+10",250),
("0+28+8",224),
("4+27+11",297),
("1+28+6",168),
("0+28+9",252),
("4+27+12",324),
("1+28+7",196),
("3+25+11",275),
("4+27+13",351),
("1+28+8",224),
("3+25+12",300),
("4+27+14",378),
("2+26+0",0),
("4+27+15",405),
("0+28+10",280),
("2+26+1",26),
("0+28+11",308),
("1+28+9",252),
("3+25+13",325),
("1+28+10",280),
("1+28+11",308),
("3+25+14",350),
("0+28+12",336),
("0+28+13",364),
("1+28+12",336),
("1+28+13",364),
("0+28+14",392),
("2+26+2",52),
("4+27+16",432),
("2+26+3",78),
("4+27+17",459),
("0+28+15",420),
("0+28+16",448),
("1+28+14",392),
("4+27+18",486),
("1+28+15",420),
("4+27+19",513),
("0+28+17",476),
("4+27+20",540),
("3+25+15",375),
("2+26+4",104),
("0+28+18",504),
("0+28+19",532),
("3+25+16",400),
("3+25+17",425),
("0+28+20",560),
("4+27+21",567),
("0+28+21",588),
("3+25+18",450),
("1+28+16",448),
("2+26+5",130),
("4+27+22",594),
("0+28+22",616),
("2+26+6",156),
("0+28+23",644),
("1+28+17",476),
("4+27+23",621),
("1+28+18",504),
("4+27+24",648),
("3+25+19",475),
("2+26+7",182),
("4+27+25",675),
("0+28+24",672),
("1+28+19",532),
("3+25+20",500),
("0+28+25",700),
("2+26+8",208),
("3+25+21",525),
("1+28+20",560),
("4+27+26",702),
("2+26+9",234),
("3+25+22",550),
("4+27+27",729),
("0+28+26",728),
("0+28+27",756),
("2+26+10",260),
("2+26+11",286),
("0+28+28",784),
("4+27+28",756),
("1+28+21",588),
("2+26+12",312),
("4+27+29",783),
("2+26+13",338),
("4+27+30",810),
("0+28+29",812),
("2+26+14",364),
("1+28+22",616),
("0+28+30",840),
("0+28+31",868),
("0+28+32",896),
("4+27+31",837),
("0+28+33",924),
("2+26+15",390),
("2+26+16",416),
("3+25+23",575),
("2+26+17",442),
("4+27+32",864),
("1+28+23",644),
("2+26+18",468),
("4+27+33",891),
("1+28+24",672),
("0+28+34",952),
("2+26+19",494),
("3+25+24",600),
("3+25+25",625),
("2+26+20",520),
("4+27+34",918),
("3+25+26",650),
("1+28+25",700),
("0+28+35",980),
("4+27+35",945),
("0+28+36",1008),
("2+26+21",546),
("2+26+22",572),
("1+28+26",728),
("2+26+23",598),
("3+25+27",675),
("1+28+27",756),
("0+28+37",1036),
("2+26+24",624),
("1+28+28",784),
("4+27+36",972),
("3+25+28",700),
("1+28+29",812),
("2+26+25",650),
("3+25+29",725),
("3+25+30",750),
("0+28+38",1064),
("2+26+26",676),
("3+25+31",775),
("2+26+27",702),
("0+28+39",1092),
("2+26+28",728),
("2+26+29",754),
("1+28+30",840),
("4+27+37",999),
("1+28+31",868),
("2+26+30",780),
("3+25+32",800),
("0+28+40",1120),
("3+25+33",825),
("0+28+41",1148),
("0+28+42",1176),
("2+26+31",806),
("3+25+34",850),
("0+28+43",1204),
("3+25+35",875),
("2+26+32",832),
("1+28+32",896),
("1+28+33",924),
("1+28+34",952),
("1+28+35",980),
("1+28+36",1008),
("2+26+33",858),
("1+28+37",1036),
("4+27+38",1026),
("0+28+44",1232),
("2+26+34",884),
("0+28+45",1260),
("2+26+35",910),
("1+28+38",1064),
("4+27+39",1053),
("0+28+46",1288),
("4+27+40",1080),
("0+28+47",1316),
("1+28+39",1092),
("0+28+48",1344),
("3+25+36",900),
("3+25+37",925),
("0+28+49",1372),
("3+25+38",950),
("2+26+36",936),
("3+25+39",975),
("1+28+40",1120),
("3+25+40",1000),
("3+25+41",1025),
("1+28+41",1148),
("4+27+41",1107),
("4+27+42",1134),
("3+25+42",1050),
("1+28+42",1176),
("2+26+37",962),
("2+26+38",988),
("4+27+43",1161),
("1+28+43",1204),
("4+27+44",1188),
("1+28+44",1232),
("3+25+43",1075),
("4+27+45",1215),
("2+26+39",1014),
("4+27+46",1242),
("3+25+44",1100),
("1+28+45",1260),
("0+29+0",0),
("2+26+40",1040),
("1+28+46",1288),
("3+25+45",1125),
("4+27+47",1269),
("2+26+41",1066),
("1+28+47",1316),
("4+27+48",1296),
("0+29+1",29),
("3+25+46",1150),
("4+27+49",1323),
("2+26+42",1092),
("0+29+2",58),
("1+28+48",1344),
("1+28+49",1372),
("3+25+47",1175),
("0+29+3",87),
("4+28+0",0),
("3+25+48",1200),
("3+25+49",1225),
("0+29+4",116),
("0+29+5",145),
("4+28+1",28),
("0+29+6",174),
("0+29+7",203),
("2+26+43",1118),
("4+28+2",56),
("4+28+3",84),
("2+26+44",1144),
("2+26+45",1170),
("2+26+46",1196),
("4+28+4",112),
("0+29+8",232),
("0+29+9",261),
("0+29+10",290),
("4+28+5",140),
("0+29+11",319),
("0+29+12",348),
("2+26+47",1222),
("2+26+48",1248),
("2+26+49",1274),
("4+28+6",168),
("0+29+13",377),
("4+28+7",196),
("0+29+14",406),
("0+29+15",435),
("4+28+8",224),
("4+28+9",252),
("4+28+10",280),
("4+28+11",308),
("0+29+16",464),
("0+29+17",493),
("4+28+12",336),
("4+28+13",364),
("0+29+18",522),
("4+28+14",392),
("4+28+15",420),
("4+28+16",448),
("4+28+17",476),
("4+28+18",504),
("4+28+19",532),
("4+28+20",560),
("0+29+19",551),
("4+28+21",588),
("4+28+22",616),
("0+29+20",580),
("0+29+21",609),
("4+28+23",644),
("0+29+22",638),
("0+29+23",667),
("4+28+24",672),
("4+28+25",700),
("0+29+24",696),
("0+29+25",725),
("4+28+26",728),
("4+28+27",756),
("4+28+28",784),
("0+29+26",754),
("0+29+27",783),
("4+28+29",812),
("0+29+28",812),
("0+29+29",841),
("4+28+30",840),
("0+29+30",870),
("0+29+31",899),
("0+29+32",928),
("0+29+33",957),
("4+28+31",868),
("0+29+34",986),
("0+29+35",1015),
("4+28+32",896),
("0+29+36",1044),
("0+29+37",1073),
("0+29+38",1102),
("0+29+39",1131),
("0+29+40",1160),
("4+28+33",924),
("4+28+34",952),
("0+29+41",1189),
("0+29+42",1218),
("4+28+35",980),
("0+29+43",1247),
("4+28+36",1008),
("0+29+44",1276),
("0+29+45",1305),
("0+29+46",1334),
("0+29+47",1363),
("0+29+48",1392),
("0+29+49",1421),
("4+28+37",1036),
("4+28+38",1064),
("4+28+39",1092),
("4+28+40",1120),
("4+28+41",1148),
("4+28+42",1176),
("4+28+43",1204),
("4+28+44",1232),
("4+28+45",1260),
("4+28+46",1288),
("4+28+47",1316),
("4+28+48",1344),
("4+28+49",1372),
("4+29+0",0),
("1+29+0",0),
("3+26+0",0),
("2+27+0",0),
("0+30+0",0),
("0+30+1",30),
("4+29+1",29),
("3+26+1",26),
("0+30+2",60),
("3+26+2",52),
("3+26+3",78),
("3+26+4",104),
("0+30+3",90),
("3+26+5",130),
("4+29+2",58),
("1+29+1",29),
("3+26+6",156),
("4+29+3",87),
("1+29+2",58),
("2+27+1",27),
("0+30+4",120),
("2+27+2",54),
("0+30+5",150),
("0+30+6",180),
("4+29+4",116),
("4+29+5",145),
("2+27+3",81),
("1+29+3",87),
("0+30+7",210),
("4+29+6",174),
("1+29+4",116),
("2+27+4",108),
("4+29+7",203),
("2+27+5",135),
("3+26+7",182),
("3+26+8",208),
("0+30+8",240),
("3+26+9",234),
("0+30+9",270),
("3+26+10",260),
("3+26+11",286),
("1+29+5",145),
("1+29+6",174),
("0+30+10",300),
("0+30+11",330),
("0+30+12",360),
("1+29+7",203),
("0+30+13",390),
("4+29+8",232),
("2+27+6",162),
("0+30+14",420),
("2+27+7",189),
("4+29+9",261),
("3+26+12",312),
("0+30+15",450),
("0+30+16",480),
("1+29+8",232),
("1+29+9",261),
("3+26+13",338),
("0+30+17",510),
("3+26+14",364),
("4+29+10",290),
("2+27+8",216),
("3+26+15",390),
("2+27+9",243),
("1+29+10",290),
("1+29+11",319),
("2+27+10",270),
("0+30+18",540),
("1+29+12",348),
("3+26+16",416),
("1+29+13",377),
("1+29+14",406),
("3+26+17",442),
("3+26+18",468),
("2+27+11",297),
("2+27+12",324),
("0+30+19",570),
("0+30+20",600),
("2+27+13",351),
("0+30+21",630),
("2+27+14",378),
("2+27+15",405),
("3+26+19",494),
("2+27+16",432),
("2+27+17",459),
("2+27+18",486),
("3+26+20",520),
("4+29+11",319),
("4+29+12",348),
("2+27+19",513),
("4+29+13",377),
("0+30+22",660),
("2+27+20",540),
("4+29+14",406),
("2+27+21",567),
("3+26+21",546),
("0+30+23",690),
("4+29+15",435),
("2+27+22",594),
("0+30+24",720),
("4+29+16",464),
("3+26+22",572),
("0+30+25",750),
("4+29+17",493),
("1+29+15",435),
("3+26+23",598),
("3+26+24",624),
("4+29+18",522),
("2+27+23",621),
("4+29+19",551),
("3+26+25",650),
("2+27+24",648),
("1+29+16",464),
("0+30+26",780),
("1+29+17",493),
("2+27+25",675),
("2+27+26",702),
("2+27+27",729),
("3+26+26",676),
("1+29+18",522),
("2+27+28",756),
("3+26+27",702),
("4+29+20",580),
("2+27+29",783),
("0+30+27",810),
("3+26+28",728),
("4+29+21",609),
("4+29+22",638),
("4+29+23",667),
("1+29+19",551),
("2+27+30",810),
("2+27+31",837),
("1+29+20",580),
("4+29+24",696),
("2+27+32",864),
("3+26+29",754),
("1+29+21",609),
("4+29+25",725),
("4+29+26",754),
("3+26+30",780),
("4+29+27",783),
("3+26+31",806),
("0+30+28",840),
("4+29+28",812),
("0+30+29",870),
("1+29+22",638),
("2+27+33",891),
("1+29+23",667),
("4+29+29",841),
("2+27+34",918),
("0+30+30",900),
("4+29+30",870),
("0+30+31",930),
("4+29+31",899),
("4+29+32",928),
("1+29+24",696),
("0+30+32",960),
("1+29+25",725),
("1+29+26",754),
("2+27+35",945),
("2+27+36",972),
("0+30+33",990),
("2+27+37",999),
("3+26+32",832),
("0+30+34",1020),
("2+27+38",1026),
("0+30+35",1050),
("1+29+27",783),
("1+29+28",812),
("3+26+33",858),
("3+26+34",884),
("0+30+36",1080),
("4+29+33",957),
("4+29+34",986),
("3+26+35",910),
("2+27+39",1053),
("0+30+37",1110),
("0+30+38",1140),
("1+29+29",841),
("4+29+35",1015),
("2+27+40",1080),
("2+27+41",1107),
("4+29+36",1044),
("2+27+42",1134),
("1+29+30",870),
("4+29+37",1073),
("2+27+43",1161),
("2+27+44",1188),
("0+30+39",1170),
("2+27+45",1215),
("1+29+31",899),
("0+30+40",1200),
("1+29+32",928),
("2+27+46",1242),
("0+30+41",1230),
("4+29+38",1102),
("2+27+47",1269),
("1+29+33",957),
("0+30+42",1260),
("3+26+36",936),
("2+27+48",1296),
("0+30+43",1290),
("2+27+49",1323),
("4+29+39",1131),
("4+29+40",1160),
("3+26+37",962),
("0+30+44",1320),
("4+29+41",1189),
("1+29+34",986),
("1+29+35",1015),
("4+29+42",1218),
("2+28+0",0),
("2+28+1",28),
("4+29+43",1247),
("2+28+2",56),
("4+29+44",1276),
("4+29+45",1305),
("2+28+3",84),
("4+29+46",1334),
("3+26+38",988),
("3+26+39",1014),
("1+29+36",1044),
("3+26+40",1040),
("0+30+45",1350),
("3+26+41",1066),
("4+29+47",1363),
("0+30+46",1380),
("4+29+48",1392),
("2+28+4",112),
("4+29+49",1421),
("2+28+5",140),
("2+28+6",168),
("2+28+7",196),
("1+29+37",1073),
("2+28+8",224),
("4+30+0",0),
("1+29+38",1102),
("1+29+39",1131),
("3+26+42",1092),
("3+26+43",1118),
("4+30+1",30),
("4+30+2",60),
("1+29+40",1160),
("1+29+41",1189),
("2+28+9",252),
("0+30+47",1410),
("1+29+42",1218),
("3+26+44",1144),
("2+28+10",280),
("1+29+43",1247),
("4+30+3",90),
("4+30+4",120),
("2+28+11",308),
("2+28+12",336),
("1+29+44",1276),
("1+29+45",1305),
("4+30+5",150),
("2+28+13",364),
("0+30+48",1440),
("2+28+14",392),
("0+30+49",1470),
("4+30+6",180),
("1+29+46",1334),
("4+30+7",210),
("4+30+8",240),
("2+28+15",420),
("3+26+45",1170),
("2+28+16",448),
("0+31+0",0),
("3+26+46",1196),
("4+30+9",270),
("4+30+10",300),
("0+31+1",31),
("3+26+47",1222),
("1+29+47",1363),
("1+29+48",1392),
("1+29+49",1421),
("0+31+2",62),
("0+31+3",93),
("3+26+48",1248),
("3+26+49",1274),
("0+31+4",124),
("0+31+5",155),
("0+31+6",186),
("2+28+17",476),
("0+31+7",217),
("2+28+18",504),
("0+31+8",248),
("2+28+19",532),
("4+30+11",330),
("0+31+9",279),
("2+28+20",560),
("1+30+0",0),
("4+30+12",360),
("2+28+21",588),
("4+30+13",390),
("0+31+10",310),
("3+27+0",0),
("2+28+22",616),
("3+27+1",27),
("0+31+11",341),
("4+30+14",420),
("4+30+15",450),
("1+30+1",30),
("2+28+23",644),
("0+31+12",372),
("2+28+24",672),
("4+30+16",480),
("4+30+17",510),
("3+27+2",54),
("0+31+13",403),
("2+28+25",700),
("1+30+2",60),
("0+31+14",434),
("0+31+15",465),
("1+30+3",90),
("0+31+16",496),
("4+30+18",540),
("0+31+17",527),
("1+30+4",120),
("2+28+26",728),
("2+28+27",756),
("3+27+3",81),
("1+30+5",150),
("2+28+28",784),
("4+30+19",570),
("1+30+6",180),
("0+31+18",558),
("4+30+20",600),
("2+28+29",812),
("0+31+19",589),
("4+30+21",630),
("0+31+20",620),
("1+30+7",210),
("0+31+21",651),
("4+30+22",660),
("0+31+22",682),
("2+28+30",840),
("4+30+23",690),
("0+31+23",713),
("1+30+8",240),
("0+31+24",744),
("4+30+24",720),
("0+31+25",775),
("2+28+31",868),
("2+28+32",896),
("4+30+25",750),
("2+28+33",924),
("0+31+26",806),
("2+28+34",952),
("4+30+26",780),
("0+31+27",837),
("4+30+27",810),
("0+31+28",868),
("2+28+35",980),
("3+27+4",108),
("1+30+9",270),
("3+27+5",135),
("3+27+6",162),
("2+28+36",1008),
("2+28+37",1036),
("2+28+38",1064),
("3+27+7",189),
("4+30+28",840),
("3+27+8",216),
("4+30+29",870),
("1+30+10",300),
("4+30+30",900),
("4+30+31",930),
("3+27+9",243),
("2+28+39",1092),
("4+30+32",960),
("0+31+29",899),
("1+30+11",330),
("1+30+12",360),
("0+31+30",930),
("2+28+40",1120),
("1+30+13",390),
("4+30+33",990),
("3+27+10",270),
("0+31+31",961),
("0+31+32",992),
("3+27+11",297),
("2+28+41",1148),
("3+27+12",324),
("2+28+42",1176),
("3+27+13",351),
("4+30+34",1020),
("0+31+33",1023),
("2+28+43",1204),
("3+27+14",378),
("4+30+35",1050),
("4+30+36",1080),
("2+28+44",1232),
("2+28+45",1260),
("2+28+46",1288),
("1+30+14",420),
("2+28+47",1316),
("2+28+48",1344),
("0+31+34",1054),
("4+30+37",1110),
("4+30+38",1140),
("2+28+49",1372),
("3+27+15",405),
("4+30+39",1170),
("4+30+40",1200),
("3+27+16",432),
("3+27+17",459),
("1+30+15",450),
("1+30+16",480),
("0+31+35",1085),
("0+31+36",1116),
("1+30+17",510),
("4+30+41",1230),
("0+31+37",1147),
("0+31+38",1178),
("0+31+39",1209),
("3+27+18",486),
("4+30+42",1260),
("3+27+19",513),
("3+27+20",540),
("4+30+43",1290),
("4+30+44",1320),
("4+30+45",1350),
("0+31+40",1240),
("0+31+41",1271),
("1+30+18",540),
("0+31+42",1302),
("4+30+46",1380),
("4+30+47",1410),
("1+30+19",570),
("4+30+48",1440),
("1+30+20",600),
("4+30+49",1470),
("2+29+0",0),
("1+30+21",630),
("1+30+22",660),
("3+27+21",567),
("3+27+22",594),
("1+30+23",690),
("1+30+24",720),
("0+31+43",1333),
("0+31+44",1364),
("0+31+45",1395),
("2+29+1",29),
("0+31+46",1426),
("1+30+25",750),
("3+27+23",621),
("4+31+0",0),
("3+27+24",648),
("4+31+1",31),
("4+31+2",62),
("0+31+47",1457),
("1+30+26",780),
("1+30+27",810),
("1+30+28",840),
("1+30+29",870),
("0+31+48",1488),
("4+31+3",93),
("1+30+30",900),
("1+30+31",930),
("3+27+25",675),
("4+31+4",124),
("1+30+32",960),
("0+31+49",1519),
("2+29+2",58),
("2+29+3",87),
("3+27+26",702),
("1+30+33",990),
("4+31+5",155),
("2+29+4",116),
("4+31+6",186),
("3+27+27",729),
("0+32+0",0),
("3+27+28",756),
("4+31+7",217),
("2+29+5",145),
("2+29+6",174),
("2+29+7",203),
("2+29+8",232),
("2+29+9",261),
("0+32+1",32),
("0+32+2",64),
("0+32+3",96),
("2+29+10",290),
("1+30+34",1020),
("0+32+4",128),
("0+32+5",160),
("3+27+29",783),
("4+31+8",248),
("4+31+9",279),
("3+27+30",810),
("4+31+10",310),
("1+30+35",1050),
("3+27+31",837),
("3+27+32",864),
("4+31+11",341),
("1+30+36",1080),
("1+30+37",1110),
("0+32+6",192),
("1+30+38",1140),
("1+30+39",1170),
("4+31+12",372),
("0+32+7",224),
("3+27+33",891),
("1+30+40",1200),
("2+29+11",319),
("3+27+34",918),
("4+31+13",403),
("4+31+14",434),
("4+31+15",465),
("1+30+41",1230),
("0+32+8",256),
("2+29+12",348),
("3+27+35",945),
("4+31+16",496),
("0+32+9",288),
("3+27+36",972),
("4+31+17",527),
("3+27+37",999),
("2+29+13",377),
("2+29+14",406),
("2+29+15",435),
("4+31+18",558),
("4+31+19",589),
("0+32+10",320),
("2+29+16",464),
("4+31+20",620),
("1+30+42",1260),
("1+30+43",1290),
("2+29+17",493),
("2+29+18",522),
("3+27+38",1026),
("0+32+11",352),
("0+32+12",384),
("1+30+44",1320),
("3+27+39",1053),
("0+32+13",416),
("4+31+21",651),
("3+27+40",1080),
("2+29+19",551),
("2+29+20",580),
("4+31+22",682),
("1+30+45",1350),
("3+27+41",1107),
("0+32+14",448),
("1+30+46",1380),
("1+30+47",1410),
("1+30+48",1440),
("3+27+42",1134),
("4+31+23",713),
("0+32+15",480),
("1+30+49",1470),
("0+32+16",512),
("3+27+43",1161),
("3+27+44",1188),
("2+29+21",609),
("2+29+22",638),
("3+27+45",1215),
("4+31+24",744),
("0+32+17",544),
("0+32+18",576),
("3+27+46",1242),
("3+27+47",1269),
("2+29+23",667),
("1+31+0",0),
("1+31+1",31),
("3+27+48",1296),
("3+27+49",1323),
("4+31+25",775),
("0+32+19",608),
("4+31+26",806),
("4+31+27",837),
("2+29+24",696),
("4+31+28",868),
("0+32+20",640),
("2+29+25",725),
("3+28+0",0),
("2+29+26",754),
("0+32+21",672),
("2+29+27",783),
("3+28+1",28),
("1+31+2",62),
("1+31+3",93),
("1+31+4",124),
("4+31+29",899),
("1+31+5",155),
("0+32+22",704),
("1+31+6",186),
("4+31+30",930),
("4+31+31",961),
("1+31+7",217),
("2+29+28",812),
("3+28+2",56),
("2+29+29",841),
("3+28+3",84),
("4+31+32",992),
("4+31+33",1023),
("0+32+23",736),
("4+31+34",1054),
("1+31+8",248),
("1+31+9",279),
("3+28+4",112),
("4+31+35",1085),
("2+29+30",870),
("4+31+36",1116),
("1+31+10",310),
("1+31+11",341),
("0+32+24",768),
("2+29+31",899),
("3+28+5",140),
("3+28+6",168),
("0+32+25",800),
("0+32+26",832),
("1+31+12",372),
("4+31+37",1147),
("4+31+38",1178),
("3+28+7",196),
("1+31+13",403),
("2+29+32",928),
("1+31+14",434),
("3+28+8",224),
("2+29+33",957),
("4+31+39",1209),
("1+31+15",465),
("3+28+9",252),
("2+29+34",986),
("4+31+40",1240),
("4+31+41",1271),
("3+28+10",280),
("3+28+11",308),
("2+29+35",1015),
("3+28+12",336),
("3+28+13",364),
("3+28+14",392),
("0+32+27",864),
("4+31+42",1302),
("0+32+28",896),
("0+32+29",928),
("2+29+36",1044),
("0+32+30",960),
("4+31+43",1333),
("4+31+44",1364),
("3+28+15",420),
("3+28+16",448),
("3+28+17",476),
("4+31+45",1395),
("4+31+46",1426),
("0+32+31",992),
("4+31+47",1457),
("3+28+18",504),
("3+28+19",532),
("1+31+16",496),
("1+31+17",527),
("4+31+48",1488),
("2+29+37",1073),
("3+28+20",560),
("0+32+32",1024),
("1+31+18",558),
("1+31+19",589),
("0+32+33",1056),
("0+32+34",1088),
("4+31+49",1519),
("0+32+35",1120),
("0+32+36",1152),
("1+31+20",620),
("3+28+21",588),
("1+31+21",651),
("3+28+22",616),
("0+32+37",1184),
("4+32+0",0),
("4+32+1",32),
("2+29+38",1102),
("0+32+38",1216),
("1+31+22",682),
("4+32+2",64),
("0+32+39",1248),
("0+32+40",1280),
("3+28+23",644),
("2+29+39",1131),
("2+29+40",1160),
("2+29+41",1189),
("0+32+41",1312),
("0+32+42",1344),
("0+32+43",1376),
("3+28+24",672),
("0+32+44",1408),
("2+29+42",1218),
("0+32+45",1440),
("3+28+25",700),
("4+32+3",96),
("3+28+26",728),
("3+28+27",756),
("4+32+4",128),
("4+32+5",160),
("4+32+6",192),
("3+28+28",784),
("3+28+29",812),
("2+29+43",1247),
("2+29+44",1276),
("4+32+7",224),
("1+31+23",713),
("3+28+30",840),
("2+29+45",1305),
("2+29+46",1334),
("3+28+31",868),
("3+28+32",896),
("3+28+33",924),
("2+29+47",1363),
("2+29+48",1392),
("2+29+49",1421),
("4+32+8",256),
("4+32+9",288),
("3+28+34",952),
("3+28+35",980),
("1+31+24",744),
("3+28+36",1008),
("1+31+25",775),
("3+28+37",1036),
("1+31+26",806),
("1+31+27",837),
("4+32+10",320),
("3+28+38",1064),
("1+31+28",868),
("0+32+46",1472),
("2+30+0",0),
("0+32+47",1504),
("0+32+48",1536),
("0+32+49",1568),
("1+31+29",899),
("3+28+39",1092),
("1+31+30",930),
("2+30+1",30),
("1+31+31",961),
("1+31+32",992),
("1+31+33",1023),
("3+28+40",1120),
("4+32+11",352),
("0+33+0",0),
("2+30+2",60),
("0+33+1",33),
("4+32+12",384),
("0+33+2",66),
("0+33+3",99),
("1+31+34",1054),
("2+30+3",90),
("1+31+35",1085),
("2+30+4",120),
("1+31+36",1116),
("0+33+4",132),
("3+28+41",1148),
("4+32+13",416),
("1+31+37",1147),
("1+31+38",1178),
("1+31+39",1209),
("1+31+40",1240),
("2+30+5",150),
("1+31+41",1271),
("1+31+42",1302),
("3+28+42",1176),
("1+31+43",1333),
("1+31+44",1364),
("0+33+5",165),
("2+30+6",180),
("4+32+14",448),
("3+28+43",1204),
("1+31+45",1395),
("2+30+7",210),
("3+28+44",1232),
("4+32+15",480),
("4+32+16",512),
("1+31+46",1426),
("2+30+8",240),
("4+32+17",544),
("1+31+47",1457),
("1+31+48",1488),
("3+28+45",1260),
("3+28+46",1288),
("0+33+6",198),
("3+28+47",1316),
("2+30+9",270),
("0+33+7",231),
("0+33+8",264),
("3+28+48",1344),
("1+31+49",1519),
("4+32+18",576),
("2+30+10",300),
("4+32+19",608),
("3+28+49",1372),
("2+30+11",330),
("2+30+12",360),
("4+32+20",640),
("0+33+9",297),
("0+33+10",330),
("4+32+21",672),
("4+32+22",704),
("2+30+13",390),
("4+32+23",736),
("0+33+11",363),
("2+30+14",420),
("4+32+24",768),
("2+30+15",450),
("1+32+0",0),
("0+33+12",396),
("1+32+1",32),
("4+32+25",800),
("2+30+16",480),
("3+29+0",0),
("1+32+2",64),
("0+33+13",429),
("0+33+14",462),
("1+32+3",96),
("3+29+1",29),
("3+29+2",58),
("2+30+17",510),
("2+30+18",540),
("1+32+4",128),
("3+29+3",87),
("3+29+4",116),
("3+29+5",145),
("3+29+6",174),
("3+29+7",203),
("1+32+5",160),
("0+33+15",495),
("2+30+19",570),
("4+32+26",832),
("0+33+16",528),
("2+30+20",600),
("4+32+27",864),
("3+29+8",232),
("0+33+17",561),
("1+32+6",192),
("0+33+18",594),
("3+29+9",261),
("3+29+10",290),
("1+32+7",224),
("0+33+19",627),
("2+30+21",630),
("4+32+28",896),
("2+30+22",660),
("3+29+11",319),
("2+30+23",690),
("3+29+12",348),
("2+30+24",720),
("4+32+29",928),
("2+30+25",750),
("1+32+8",256),
("2+30+26",780),
("3+29+13",377),
("0+33+20",660),
("4+32+30",960),
("2+30+27",810),
("0+33+21",693),
("1+32+9",288),
("2+30+28",840),
("4+32+31",992),
("0+33+22",726),
("2+30+29",870),
("4+32+32",1024),
("0+33+23",759),
("4+32+33",1056),
("4+32+34",1088),
("2+30+30",900),
("4+32+35",1120),
("0+33+24",792),
("4+32+36",1152),
("3+29+14",406),
("0+33+25",825),
("4+32+37",1184),
("1+32+10",320),
("0+33+26",858),
("4+32+38",1216),
("3+29+15",435),
("3+29+16",464),
("1+32+11",352),
("4+32+39",1248),
("1+32+12",384),
("1+32+13",416),
("1+32+14",448),
("3+29+17",493),
("3+29+18",522),
("4+32+40",1280),
("4+32+41",1312),
("3+29+19",551),
("3+29+20",580),
("2+30+31",930),
("2+30+32",960),
("3+29+21",609),
("3+29+22",638),
("3+29+23",667),
("0+33+27",891),
("3+29+24",696),
("0+33+28",924),
("1+32+15",480),
("2+30+33",990),
("3+29+25",725),
("0+33+29",957),
("3+29+26",754),
("0+33+30",990),
("3+29+27",783),
("3+29+28",812),
("1+32+16",512),
("4+32+42",1344),
("0+33+31",1023),
("4+32+43",1376),
("2+30+34",1020),
("0+33+32",1056),
("3+29+29",841),
("0+33+33",1089),
("2+30+35",1050),
("2+30+36",1080),
("4+32+44",1408),
("2+30+37",1110),
("1+32+17",544),
("4+32+45",1440),
("0+33+34",1122),
("2+30+38",1140),
("0+33+35",1155),
("3+29+30",870),
("4+32+46",1472),
("2+30+39",1170),
("0+33+36",1188),
("4+32+47",1504),
("2+30+40",1200),
("4+32+48",1536),
("2+30+41",1230),
("1+32+18",576),
("0+33+37",1221),
("4+32+49",1568),
("0+33+38",1254),
("1+32+19",608),
("0+33+39",1287),
("1+32+20",640),
("1+32+21",672),
("2+30+42",1260),
("2+30+43",1290),
("1+32+22",704),
("2+30+44",1320),
("3+29+31",899),
("1+32+23",736),
("3+29+32",928),
("3+29+33",957),
("1+32+24",768),
("0+33+40",1320),
("1+32+25",800),
("0+33+41",1353),
("2+30+45",1350),
("3+29+34",986),
("4+33+0",0),
("1+32+26",832),
("1+32+27",864),
("3+29+35",1015),
("0+33+42",1386),
("3+29+36",1044),
("0+33+43",1419),
("2+30+46",1380),
("0+33+44",1452),
("1+32+28",896),
("4+33+1",33),
("0+33+45",1485),
("1+32+29",928),
("2+30+47",1410),
("0+33+46",1518),
("1+32+30",960),
("0+33+47",1551),
("2+30+48",1440),
("0+33+48",1584),
("2+30+49",1470),
("0+33+49",1617),
("4+33+2",66),
("3+29+37",1073),
("1+32+31",992),
("3+29+38",1102),
("3+29+39",1131),
("4+33+3",99),
("1+32+32",1024),
("1+32+33",1056),
("4+33+4",132),
("4+33+5",165),
("1+32+34",1088),
("0+34+0",0),
("1+32+35",1120),
("4+33+6",198),
("0+34+1",34),
("1+32+36",1152),
("3+29+40",1160),
("1+32+37",1184),
("1+32+38",1216),
("1+32+39",1248),
("3+29+41",1189),
("0+34+2",68),
("4+33+7",231),
("1+32+40",1280),
("2+31+0",0),
("0+34+3",102),
("1+32+41",1312),
("4+33+8",264),
("2+31+1",31),
("3+29+42",1218),
("4+33+9",297),
("0+34+4",136),
("4+33+10",330),
("0+34+5",170),
("2+31+2",62),
("0+34+6",204),
("4+33+11",363),
("2+31+3",93),
("1+32+42",1344),
("0+34+7",238),
("2+31+4",124),
("1+32+43",1376),
("2+31+5",155),
("3+29+43",1247),
("4+33+12",396),
("2+31+6",186),
("2+31+7",217),
("0+34+8",272),
("1+32+44",1408),
("4+33+13",429),
("3+29+44",1276),
("2+31+8",248),
("4+33+14",462),
("4+33+15",495),
("3+29+45",1305),
("0+34+9",306),
("4+33+16",528),
("4+33+17",561),
("3+29+46",1334),
("1+32+45",1440),
("0+34+10",340),
("1+32+46",1472),
("0+34+11",374),
("1+32+47",1504),
("0+34+12",408),
("3+29+47",1363),
("0+34+13",442),
("1+32+48",1536),
("3+29+48",1392),
("0+34+14",476),
("4+33+18",594),
("3+29+49",1421),
("4+33+19",627),
("1+32+49",1568),
("4+33+20",660),
("2+31+9",279),
("4+33+21",693),
("2+31+10",310),
("4+33+22",726),
("2+31+11",341),
("0+34+15",510),
("2+31+12",372),
("0+34+16",544),
("2+31+13",403),
("4+33+23",759),
("4+33+24",792),
("3+30+0",0),
("4+33+25",825),
("0+34+17",578),
("3+30+1",30),
("2+31+14",434),
("4+33+26",858),
("3+30+2",60),
("4+33+27",891),
("4+33+28",924),
("3+30+3",90),
("1+33+0",0),
("0+34+18",612),
("3+30+4",120),
("1+33+1",33),
("1+33+2",66),
("4+33+29",957),
("4+33+30",990),
("4+33+31",1023),
("4+33+32",1056),
("1+33+3",99),
("1+33+4",132),
("4+33+33",1089),
("1+33+5",165),
("3+30+5",150),
("1+33+6",198),
("1+33+7",231),
("1+33+8",264),
("2+31+15",465),
("2+31+16",496),
("3+30+6",180),
("2+31+17",527),
("2+31+18",558),
("2+31+19",589),
("1+33+9",297),
("1+33+10",330),
("3+30+7",210),
("3+30+8",240),
("0+34+19",646),
("1+33+11",363),
("4+33+34",1122),
("0+34+20",680),
("1+33+12",396),
("1+33+13",429),
("2+31+20",620),
("3+30+9",270),
("2+31+21",651),
("1+33+14",462),
("1+33+15",495),
("3+30+10",300),
("3+30+11",330),
("0+34+21",714),
("1+33+16",528),
("0+34+22",748),
("1+33+17",561),
("2+31+22",682),
("3+30+12",360),
("0+34+23",782),
("2+31+23",713),
("3+30+13",390),
("0+34+24",816),
("4+33+35",1155),
("2+31+24",744),
("4+33+36",1188),
("4+33+37",1221),
("4+33+38",1254),
("1+33+18",594),
("1+33+19",627),
("1+33+20",660),
("1+33+21",693),
("0+34+25",850),
("0+34+26",884),
("1+33+22",726),
("4+33+39",1287),
("4+33+40",1320),
("3+30+14",420),
("2+31+25",775),
("0+34+27",918),
("0+34+28",952),
("3+30+15",450),
("4+33+41",1353),
("3+30+16",480),
("3+30+17",510),
("2+31+26",806),
("0+34+29",986),
("1+33+23",759),
("1+33+24",792),
("4+33+42",1386),
("1+33+25",825),
("1+33+26",858),
("0+34+30",1020),
("0+34+31",1054),
("2+31+27",837),
("2+31+28",868),
("1+33+27",891),
("3+30+18",540),
("4+33+43",1419),
("1+33+28",924),
("1+33+29",957),
("2+31+29",899),
("3+30+19",570),
("3+30+20",600),
("3+30+21",630),
("0+34+32",1088),
("0+34+33",1122),
("0+34+34",1156),
("1+33+30",990),
("4+33+44",1452),
("4+33+45",1485),
("0+34+35",1190),
("2+31+30",930),
("1+33+31",1023),
("0+34+36",1224),
("1+33+32",1056),
("1+33+33",1089),
("3+30+22",660),
("2+31+31",961),
("2+31+32",992),
("4+33+46",1518),
("2+31+33",1023),
("3+30+23",690),
("1+33+34",1122),
("1+33+35",1155),
("3+30+24",720),
("3+30+25",750),
("1+33+36",1188),
("1+33+37",1221),
("2+31+34",1054),
("0+34+37",1258),
("0+34+38",1292),
("4+33+47",1551),
("3+30+26",780),
("1+33+38",1254),
("2+31+35",1085),
("1+33+39",1287),
("0+34+39",1326),
("2+31+36",1116),
("4+33+48",1584),
("2+31+37",1147),
("4+33+49",1617),
("0+34+40",1360),
("1+33+40",1320),
("0+34+41",1394),
("1+33+41",1353),
("0+34+42",1428),
("2+31+38",1178),
("0+34+43",1462),
("4+34+0",0),
("2+31+39",1209),
("0+34+44",1496),
("4+34+1",34),
("2+31+40",1240),
("4+34+2",68),
("2+31+41",1271),
("1+33+42",1386),
("3+30+27",810),
("0+34+45",1530),
("1+33+43",1419),
("4+34+3",102),
("3+30+28",840),
("4+34+4",136),
("3+30+29",870),
("4+34+5",170),
("3+30+30",900),
("1+33+44",1452),
("2+31+42",1302),
("0+34+46",1564),
("4+34+6",204),
("0+34+47",1598),
("0+34+48",1632),
("2+31+43",1333),
("3+30+31",930),
("0+34+49",1666),
("3+30+32",960),
("2+31+44",1364),
("2+31+45",1395),
("1+33+45",1485),
("4+34+7",238),
("1+33+46",1518),
("0+35+0",0),
("4+34+8",272),
("1+33+47",1551),
("2+31+46",1426),
("0+35+1",35),
("3+30+33",990),
("4+34+9",306),
("1+33+48",1584),
("3+30+34",1020),
("2+31+47",1457),
("1+33+49",1617),
("4+34+10",340),
("0+35+2",70),
("2+31+48",1488),
("4+34+11",374),
("2+31+49",1519),
("0+35+3",105),
("1+34+0",0),
("4+34+12",408),
("4+34+13",442),
("3+30+35",1050),
("4+34+14",476),
("0+35+4",140),
("4+34+15",510),
("0+35+5",175),
("0+35+6",210),
("3+30+36",1080),
("4+34+16",544),
("4+34+17",578),
("1+34+1",34),
("3+30+37",1110),
("1+34+2",68),
("0+35+7",245),
("0+35+8",280),
("1+34+3",102),
("0+35+9",315),
("1+34+4",136),
("4+34+18",612),
("0+35+10",350),
("3+30+38",1140),
("4+34+19",646),
("2+32+0",0),
("3+30+39",1170),
("3+30+40",1200),
("1+34+5",170),
("3+30+41",1230),
("4+34+20",680),
("2+32+1",32),
("3+30+42",1260),
("4+34+21",714),
("1+34+6",204),
("4+34+22",748),
("3+30+43",1290),
("1+34+7",238),
("0+35+11",385),
("3+30+44",1320),
("4+34+23",782),
("4+34+24",816),
("0+35+12",420),
("1+34+8",272),
("2+32+2",64),
("3+30+45",1350),
("0+35+13",455),
("2+32+3",96),
("0+35+14",490),
("2+32+4",128),
("2+32+5",160),
("3+30+46",1380),
("2+32+6",192),
("0+35+15",525),
("2+32+7",224),
("1+34+9",306),
("0+35+16",560),
("1+34+10",340),
("2+32+8",256),
("2+32+9",288),
("2+32+10",320),
("1+34+11",374),
("1+34+12",408),
("0+35+17",595),
("3+30+47",1410),
("0+35+18",630),
("2+32+11",352),
("2+32+12",384),
("2+32+13",416),
("4+34+25",850),
("4+34+26",884),
("1+34+13",442),
("2+32+14",448),
("4+34+27",918),
("1+34+14",476),
("4+34+28",952),
("2+32+15",480),
("0+35+19",665),
("4+34+29",986),
("4+34+30",1020),
("2+32+16",512),
("4+34+31",1054),
("3+30+48",1440),
("2+32+17",544),
("0+35+20",700),
("4+34+32",1088),
("2+32+18",576),
("4+34+33",1122),
("3+30+49",1470),
("2+32+19",608),
("4+34+34",1156),
("0+35+21",735),
("4+34+35",1190),
("0+35+22",770),
("2+32+20",640),
("0+35+23",805),
("2+32+21",672),
("4+34+36",1224),
("0+35+24",840),
("4+34+37",1258),
("0+35+25",875),
("4+34+38",1292),
("3+31+0",0),
("0+35+26",910),
("2+32+22",704),
("4+34+39",1326),
("3+31+1",31),
("0+35+27",945),
("2+32+23",736),
("4+34+40",1360),
("0+35+28",980),
("4+34+41",1394),
("1+34+15",510),
("3+31+2",62),
("1+34+16",544),
("3+31+3",93),
("0+35+29",1015),
("1+34+17",578),
("4+34+42",1428),
("2+32+24",768),
("1+34+18",612),
("4+34+43",1462),
("3+31+4",124),
("3+31+5",155),
("3+31+6",186),
("0+35+30",1050),
("3+31+7",217),
("2+32+25",800),
("3+31+8",248),
("0+35+31",1085),
("0+35+32",1120),
("3+31+9",279),
("1+34+19",646),
("0+35+33",1155),
("1+34+20",680),
("0+35+34",1190),
("3+31+10",310),
("1+34+21",714),
("3+31+11",341),
("4+34+44",1496),
("1+34+22",748),
("3+31+12",372),
("3+31+13",403),
("1+34+23",782),
("4+34+45",1530),
("0+35+35",1225),
("0+35+36",1260),
("1+34+24",816),
("3+31+14",434),
("3+31+15",465),
("2+32+26",832),
("2+32+27",864),
("0+35+37",1295),
("3+31+16",496),
("3+31+17",527),
("1+34+25",850),
("2+32+28",896),
("2+32+29",928),
("4+34+46",1564),
("3+31+18",558),
("0+35+38",1330),
("0+35+39",1365),
("4+34+47",1598),
("2+32+30",960),
("4+34+48",1632),
("3+31+19",589),
("4+34+49",1666),
("2+32+31",992),
("1+34+26",884),
("2+32+32",1024),
("3+31+20",620),
("2+32+33",1056),
("1+34+27",918),
("2+32+34",1088),
("0+35+40",1400),
("1+34+28",952),
("1+34+29",986),
("1+34+30",1020),
("0+35+41",1435),
("3+31+21",651),
("1+34+31",1054),
("0+35+42",1470),
("4+35+0",0),
("2+32+35",1120),
("1+34+32",1088),
("0+35+43",1505),
("3+31+22",682),
("1+34+33",1122),
("4+35+1",35),
("2+32+36",1152),
("3+31+23",713),
("2+32+37",1184),
("4+35+2",70),
("1+34+34",1156),
("0+35+44",1540),
("3+31+24",744),
("1+34+35",1190),
("1+34+36",1224),
("0+35+45",1575),
("2+32+38",1216),
("4+35+3",105),
("0+35+46",1610),
("0+35+47",1645),
("3+31+25",775),
("2+32+39",1248),
("4+35+4",140),
("0+35+48",1680),
("4+35+5",175),
("4+35+6",210),
("4+35+7",245),
("2+32+40",1280),
("1+34+37",1258),
("3+31+26",806),
("3+31+27",837),
("2+32+41",1312),
("2+32+42",1344),
("1+34+38",1292),
("1+34+39",1326),
("1+34+40",1360),
("4+35+8",280),
("4+35+9",315),
("3+31+28",868),
("0+35+49",1715),
("4+35+10",350),
("3+31+29",899),
("2+32+43",1376),
("3+31+30",930),
("1+34+41",1394),
("2+32+44",1408),
("3+31+31",961),
("4+35+11",385),
("0+36+0",0),
("2+32+45",1440),
("3+31+32",992),
("3+31+33",1023),
("4+35+12",420),
("1+34+42",1428),
("4+35+13",455),
("4+35+14",490),
("3+31+34",1054),
("2+32+46",1472),
("4+35+15",525),
("0+36+1",36),
("1+34+43",1462),
("3+31+35",1085),
("0+36+2",72),
("3+31+36",1116),
("3+31+37",1147),
("2+32+47",1504),
("2+32+48",1536),
("1+34+44",1496),
("0+36+3",108),
("4+35+16",560),
("2+32+49",1568),
("1+34+45",1530),
("1+34+46",1564),
("4+35+17",595),
("3+31+38",1178),
("1+34+47",1598),
("3+31+39",1209),
("2+33+0",0),
("1+34+48",1632),
("4+35+18",630),
("0+36+4",144),
("4+35+19",665),
("1+34+49",1666),
("3+31+40",1240),
("0+36+5",180),
("4+35+20",700),
("0+36+6",216),
("3+31+41",1271),
("0+36+7",252),
("2+33+1",33),
("2+33+2",66),
("3+31+42",1302),
("3+31+43",1333),
("0+36+8",288),
("0+36+9",324),
("3+31+44",1364),
("4+35+21",735),
("0+36+10",360),
("2+33+3",99),
("4+35+22",770),
("4+35+23",805),
("4+35+24",840),
("4+35+25",875),
("3+31+45",1395),
("0+36+11",396),
("2+33+4",132),
("2+33+5",165),
("0+36+12",432),
("2+33+6",198),
("3+31+46",1426),
("2+33+7",231),
("3+31+47",1457),
("4+35+26",910),
("2+33+8",264),
("4+35+27",945),
("2+33+9",297),
("2+33+10",330),
("4+35+28",980),
("2+33+11",363),
("3+31+48",1488),
("0+36+13",468),
("4+35+29",1015),
("3+31+49",1519),
("4+35+30",1050),
("4+35+31",1085),
("0+36+14",504),
("2+33+12",396),
("4+35+32",1120),
("0+36+15",540),
("2+33+13",429),
("2+33+14",462),
("0+36+16",576),
("0+36+17",612),
("0+36+18",648),
("4+35+33",1155),
("0+36+19",684),
("2+33+15",495),
("4+35+34",1190),
("2+33+16",528),
("2+33+17",561),
("4+35+35",1225),
("4+35+36",1260),
("0+36+20",720),
("4+35+37",1295),
("0+36+21",756),
("0+36+22",792),
("2+33+18",594),
("2+33+19",627),
("2+33+20",660),
("2+33+21",693),
("4+35+38",1330),
("4+35+39",1365),
("4+35+40",1400),
("0+36+23",828),
("4+35+41",1435),
("2+33+22",726),
("2+33+23",759),
("0+36+24",864),
("2+33+24",792),
("4+35+42",1470),
("4+35+43",1505),
("0+36+25",900),
("2+33+25",825),
("2+33+26",858),
("0+36+26",936),
("0+36+27",972),
("4+35+44",1540),
("4+35+45",1575),
("4+35+46",1610),
("2+33+27",891),
("4+35+47",1645),
("0+36+28",1008),
("2+33+28",924),
("4+35+48",1680),
("4+35+49",1715),
("2+33+29",957),
("2+33+30",990),
("2+33+31",1023),
("0+36+29",1044),
("0+36+30",1080),
("0+36+31",1116),
("0+36+32",1152),
("0+36+33",1188),
("2+33+32",1056),
("2+33+33",1089),
("0+36+34",1224),
("0+36+35",1260),
("2+33+34",1122),
("2+33+35",1155),
("2+33+36",1188),
("2+33+37",1221),
("0+36+36",1296),
("0+36+37",1332),
("2+33+38",1254),
("0+36+38",1368),
("2+33+39",1287),
("0+36+39",1404),
("2+33+40",1320),
("2+33+41",1353),
("2+33+42",1386),
("0+36+40",1440),
("2+33+43",1419),
("2+33+44",1452),
("2+33+45",1485),
("2+33+46",1518),
("2+33+47",1551),
("2+33+48",1584),
("2+33+49",1617),
("0+36+41",1476),
("0+36+42",1512),
("0+36+43",1548),
("0+36+44",1584),
("0+36+45",1620),
("0+36+46",1656),
("0+36+47",1692),
("0+36+48",1728),
("0+36+49",1764),
("0+37+0",0),
("3+32+0",0),
("4+36+0",0),
("2+34+0",0),
("1+35+0",0),
("1+35+1",35),
("2+34+1",34),
("0+37+1",37),
("2+34+2",68),
("4+36+1",36),
("3+32+1",32),
("4+36+2",72),
("0+37+2",74),
("4+36+3",108),
("1+35+2",70),
("4+36+4",144),
("1+35+3",105),
("4+36+5",180),
("3+32+2",64),
("1+35+4",140),
("4+36+6",216),
("0+37+3",111),
("1+35+5",175),
("4+36+7",252),
("0+37+4",148),
("2+34+3",102),
("1+35+6",210),
("3+32+3",96),
("1+35+7",245),
("0+37+5",185),
("1+35+8",280),
("0+37+6",222),
("3+32+4",128),
("4+36+8",288),
("4+36+9",324),
("0+37+7",259),
("4+36+10",360),
("3+32+5",160),
("1+35+9",315),
("4+36+11",396),
("0+37+8",296),
("2+34+4",136),
("4+36+12",432),
("0+37+9",333),
("1+35+10",350),
("4+36+13",468),
("3+32+6",192),
("1+35+11",385),
("3+32+7",224),
("1+35+12",420),
("0+37+10",370),
("0+37+11",407),
("2+34+5",170),
("3+32+8",256),
("1+35+13",455),
("0+37+12",444),
("1+35+14",490),
("4+36+14",504),
("0+37+13",481),
("1+35+15",525),
("2+34+6",204),
("0+37+14",518),
("0+37+15",555),
("0+37+16",592),
("3+32+9",288),
("4+36+15",540),
("2+34+7",238),
("3+32+10",320),
("3+32+11",352),
("0+37+17",629),
("2+34+8",272),
("1+35+16",560),
("3+32+12",384),
("1+35+17",595),
("3+32+13",416),
("0+37+18",666),
("3+32+14",448),
("2+34+9",306),
("3+32+15",480),
("0+37+19",703),
("2+34+10",340),
("4+36+16",576),
("0+37+20",740),
("1+35+18",630),
("0+37+21",777),
("1+35+19",665),
("2+34+11",374),
("4+36+17",612),
("1+35+20",700),
("3+32+16",512),
("1+35+21",735),
("4+36+18",648),
("3+32+17",544),
("1+35+22",770),
("3+32+18",576),
("0+37+22",814),
("2+34+12",408),
("0+37+23",851),
("1+35+23",805),
("1+35+24",840),
("3+32+19",608),
("2+34+13",442),
("3+32+20",640),
("0+37+24",888),
("1+35+25",875),
("4+36+19",684),
("3+32+21",672),
("2+34+14",476),
("3+32+22",704),
("4+36+20",720),
("3+32+23",736),
("1+35+26",910),
("1+35+27",945),
("3+32+24",768),
("4+36+21",756),
("0+37+25",925),
("4+36+22",792),
("0+37+26",962),
("3+32+25",800),
("2+34+15",510),
("1+35+28",980),
("3+32+26",832),
("4+36+23",828),
("4+36+24",864),
("0+37+27",999),
("3+32+27",864),
("2+34+16",544),
("4+36+25",900),
("1+35+29",1015),
("0+37+28",1036),
("2+34+17",578),
("3+32+28",896),
("1+35+30",1050),
("4+36+26",936),
("0+37+29",1073),
("2+34+18",612),
("1+35+31",1085),
("3+32+29",928),
("4+36+27",972),
("4+36+28",1008),
("1+35+32",1120),
("2+34+19",646),
("4+36+29",1044),
("0+37+30",1110),
("1+35+33",1155),
("2+34+20",680),
("0+37+31",1147),
("4+36+30",1080),
("4+36+31",1116),
("3+32+30",960),
("1+35+34",1190),
("3+32+31",992),
("0+37+32",1184),
("2+34+21",714),
("0+37+33",1221),
("1+35+35",1225),
("3+32+32",1024),
("3+32+33",1056),
("1+35+36",1260),
("3+32+34",1088),
("1+35+37",1295),
("0+37+34",1258),
("4+36+32",1152),
("3+32+35",1120),
("3+32+36",1152),
("1+35+38",1330),
("4+36+33",1188),
("1+35+39",1365),
("0+37+35",1295),
("3+32+37",1184),
("0+37+36",1332),
("1+35+40",1400),
("2+34+22",748),
("3+32+38",1216),
("4+36+34",1224),
("3+32+39",1248),
("0+37+37",1369),
("2+34+23",782),
("0+37+38",1406),
("4+36+35",1260),
("0+37+39",1443),
("2+34+24",816),
("4+36+36",1296),
("1+35+41",1435),
("3+32+40",1280),
("4+36+37",1332),
("0+37+40",1480),
("3+32+41",1312),
("4+36+38",1368),
("0+37+41",1517),
("2+34+25",850),
("4+36+39",1404),
("2+34+26",884),
("1+35+42",1470),
("2+34+27",918),
("4+36+40",1440),
("1+35+43",1505),
("4+36+41",1476),
("4+36+42",1512),
("1+35+44",1540),
("4+36+43",1548),
("0+37+42",1554),
("2+34+28",952),
("0+37+43",1591),
("1+35+45",1575),
("3+32+42",1344),
("2+34+29",986),
("4+36+44",1584),
("3+32+43",1376),
("4+36+45",1620),
("0+37+44",1628),
("3+32+44",1408),
("4+36+46",1656),
("1+35+46",1610),
("3+32+45",1440),
("0+37+45",1665),
("4+36+47",1692),
("1+35+47",1645),
("4+36+48",1728),
("2+34+30",1020),
("1+35+48",1680),
("4+36+49",1764),
("0+37+46",1702),
("3+32+46",1472),
("2+34+31",1054),
("0+37+47",1739),
("1+35+49",1715),
("2+34+32",1088),
("3+32+47",1504),
("2+34+33",1122),
("3+32+48",1536),
("4+37+0",0),
("4+37+1",37),
("3+32+49",1568),
("4+37+2",74),
("4+37+3",111),
("0+37+48",1776),
("2+34+34",1156),
("0+37+49",1813),
("2+34+35",1190),
("2+34+36",1224),
("4+37+4",148),
("2+34+37",1258),
("4+37+5",185),
("2+34+38",1292),
("4+37+6",222),
("2+34+39",1326),
("4+37+7",259),
("1+36+0",0),
("3+33+0",0),
("0+38+0",0),
("4+37+8",296),
("4+37+9",333),
("2+34+40",1360),
("3+33+1",33),
("1+36+1",36),
("3+33+2",66),
("2+34+41",1394),
("0+38+1",38),
("1+36+2",72),
("3+33+3",99),
("1+36+3",108),
("2+34+42",1428),
("3+33+4",132),
("4+37+10",370),
("1+36+4",144),
("4+37+11",407),
("1+36+5",180),
("3+33+5",165),
("2+34+43",1462),
("0+38+2",76),
("0+38+3",114),
("1+36+6",216),
("3+33+6",198),
("1+36+7",252),
("0+38+4",152),
("3+33+7",231),
("3+33+8",264),
("1+36+8",288),
("2+34+44",1496),
("4+37+12",444),
("4+37+13",481),
("4+37+14",518),
("1+36+9",324),
("4+37+15",555),
("2+34+45",1530),
("4+37+16",592),
("0+38+5",190),
("1+36+10",360),
("3+33+9",297),
("3+33+10",330),
("2+34+46",1564),
("4+37+17",629),
("2+34+47",1598),
("3+33+11",363),
("4+37+18",666),
("0+38+6",228),
("4+37+19",703),
("1+36+11",396),
("4+37+20",740),
("1+36+12",432),
("2+34+48",1632),
("4+37+21",777),
("0+38+7",266),
("1+36+13",468),
("3+33+12",396),
("1+36+14",504),
("0+38+8",304),
("3+33+13",429),
("0+38+9",342),
("4+37+22",814),
("4+37+23",851),
("1+36+15",540),
("2+34+49",1666),
("0+38+10",380),
("1+36+16",576),
("0+38+11",418),
("3+33+14",462),
("1+36+17",612),
("0+38+12",456),
("1+36+18",648),
("0+38+13",494),
("4+37+24",888),
("0+38+14",532),
("4+37+25",925),
("0+38+15",570),
("1+36+19",684),
("3+33+15",495),
("0+38+16",608),
("1+36+20",720),
("3+33+16",528),
("0+38+17",646),
("1+36+21",756),
("0+38+18",684),
("4+37+26",962),
("1+36+22",792),
("4+37+27",999),
("2+35+0",0),
("4+37+28",1036),
("0+38+19",722),
("3+33+17",561),
("1+36+23",828),
("1+36+24",864),
("1+36+25",900),
("1+36+26",936),
("3+33+18",594),
("1+36+27",972),
("0+38+20",760),
("4+37+29",1073),
("4+37+30",1110),
("2+35+1",35),
("3+33+19",627),
("0+38+21",798),
("4+37+31",1147),
("3+33+20",660),
("3+33+21",693),
("0+38+22",836),
("3+33+22",726),
("1+36+28",1008),
("4+37+32",1184),
("4+37+33",1221),
("4+37+34",1258),
("0+38+23",874),
("2+35+2",70),
("1+36+29",1044),
("2+35+3",105),
("0+38+24",912),
("2+35+4",140),
("1+36+30",1080),
("3+33+23",759),
("4+37+35",1295),
("1+36+31",1116),
("0+38+25",950),
("3+33+24",792),
("0+38+26",988),
("4+37+36",1332),
("3+33+25",825),
("4+37+37",1369),
("4+37+38",1406),
("2+35+5",175),
("3+33+26",858),
("4+37+39",1443),
("1+36+32",1152),
("4+37+40",1480),
("0+38+27",1026),
("3+33+27",891),
("1+36+33",1188),
("0+38+28",1064),
("3+33+28",924),
("0+38+29",1102),
("1+36+34",1224),
("2+35+6",210),
("2+35+7",245),
("0+38+30",1140),
("4+37+41",1517),
("0+38+31",1178),
("2+35+8",280),
("4+37+42",1554),
("0+38+32",1216),
("4+37+43",1591),
("1+36+35",1260),
("0+38+33",1254),
("2+35+9",315),
("1+36+36",1296),
("1+36+37",1332),
("2+35+10",350),
("3+33+29",957),
("4+37+44",1628),
("0+38+34",1292),
("3+33+30",990),
("1+36+38",1368),
("4+37+45",1665),
("0+38+35",1330),
("0+38+36",1368),
("4+37+46",1702),
("4+37+47",1739),
("0+38+37",1406),
("3+33+31",1023),
("1+36+39",1404),
("1+36+40",1440),
("2+35+11",385),
("3+33+32",1056),
("4+37+48",1776),
("1+36+41",1476),
("4+37+49",1813),
("1+36+42",1512),
("0+38+38",1444),
("0+38+39",1482),
("1+36+43",1548),
("3+33+33",1089),
("1+36+44",1584),
("1+36+45",1620),
("0+38+40",1520),
("1+36+46",1656),
("1+36+47",1692),
("2+35+12",420),
("2+35+13",455),
("3+33+34",1122),
("0+38+41",1558),
("0+38+42",1596),
("3+33+35",1155),
("3+33+36",1188),
("1+36+48",1728),
("1+36+49",1764),
("3+33+37",1221),
("2+35+14",490),
("3+33+38",1254),
("2+35+15",525),
("4+38+0",0),
("2+35+16",560),
("3+33+39",1287),
("4+38+1",38),
("0+38+43",1634),
("3+33+40",1320),
("0+38+44",1672),
("3+33+41",1353),
("1+37+0",0),
("3+33+42",1386),
("2+35+17",595),
("3+33+43",1419),
("0+38+45",1710),
("4+38+2",76),
("1+37+1",37),
("0+38+46",1748),
("2+35+18",630),
("2+35+19",665),
("0+38+47",1786),
("3+33+44",1452),
("0+38+48",1824),
("0+38+49",1862),
("2+35+20",700),
("3+33+45",1485),
("1+37+2",74),
("3+33+46",1518),
("4+38+3",114),
("2+35+21",735),
("1+37+3",111),
("2+35+22",770),
("2+35+23",805),
("4+38+4",152),
("3+33+47",1551),
("4+38+5",190),
("4+38+6",228),
("3+33+48",1584),
("1+37+4",148),
("1+37+5",185),
("4+38+7",266),
("3+33+49",1617),
("2+35+24",840),
("4+38+8",304),
("1+37+6",222),
("4+38+9",342),
("2+35+25",875),
("1+37+7",259),
("1+37+8",296),
("4+38+10",380),
("3+34+0",0),
("1+37+9",333),
("0+39+0",0),
("2+35+26",910),
("4+38+11",418),
("1+37+10",370),
("2+35+27",945),
("4+38+12",456),
("1+37+11",407),
("3+34+1",34),
("2+35+28",980),
("0+39+1",39),
("4+38+13",494),
("2+35+29",1015),
("3+34+2",68),
("1+37+12",444),
("4+38+14",532),
("4+38+15",570),
("2+35+30",1050),
("3+34+3",102),
("2+35+31",1085),
("1+37+13",481),
("2+35+32",1120),
("4+38+16",608),
("2+35+33",1155),
("2+35+34",1190),
("2+35+35",1225),
("2+35+36",1260),
("1+37+14",518),
("4+38+17",646),
("0+39+2",78),
("2+35+37",1295),
("1+37+15",555),
("3+34+4",136),
("2+35+38",1330),
("2+35+39",1365),
("4+38+18",684),
("2+35+40",1400),
("1+37+16",592),
("0+39+3",117),
("4+38+19",722),
("1+37+17",629),
("3+34+5",170),
("1+37+18",666),
("4+38+20",760),
("4+38+21",798),
("2+35+41",1435),
("1+37+19",703),
("3+34+6",204),
("0+39+4",156),
("0+39+5",195),
("4+38+22",836),
("1+37+20",740),
("2+35+42",1470),
("3+34+7",238),
("0+39+6",234),
("2+35+43",1505),
("1+37+21",777),
("3+34+8",272),
("3+34+9",306),
("4+38+23",874),
("4+38+24",912),
("1+37+22",814),
("0+39+7",273),
("0+39+8",312),
("2+35+44",1540),
("1+37+23",851),
("1+37+24",888),
("2+35+45",1575),
("1+37+25",925),
("3+34+10",340),
("1+37+26",962),
("4+38+25",950),
("3+34+11",374),
("3+34+12",408),
("3+34+13",442),
("4+38+26",988),
("1+37+27",999),
("0+39+9",351),
("0+39+10",390),
("1+37+28",1036),
("3+34+14",476),
("4+38+27",1026),
("2+35+46",1610),
("3+34+15",510),
("1+37+29",1073),
("0+39+11",429),
("3+34+16",544),
("3+34+17",578),
("0+39+12",468),
("0+39+13",507),
("1+37+30",1110),
("1+37+31",1147),
("0+39+14",546),
("4+38+28",1064),
("1+37+32",1184),
("2+35+47",1645),
("0+39+15",585),
("0+39+16",624),
("3+34+18",612),
("4+38+29",1102),
("3+34+19",646),
("0+39+17",663),
("0+39+18",702),
("0+39+19",741),
("3+34+20",680),
("0+39+20",780),
("0+39+21",819),
("1+37+33",1221),
("2+35+48",1680),
("4+38+30",1140),
("4+38+31",1178),
("0+39+22",858),
("2+35+49",1715),
("3+34+21",714),
("1+37+34",1258),
("4+38+32",1216),
("3+34+22",748),
("0+39+23",897),
("3+34+23",782),
("1+37+35",1295),
("0+39+24",936),
("3+34+24",816),
("0+39+25",975),
("4+38+33",1254),
("2+36+0",0),
("1+37+36",1332),
("4+38+34",1292),
("2+36+1",36),
("0+39+26",1014),
("1+37+37",1369),
("0+39+27",1053),
("0+39+28",1092),
("3+34+25",850),
("2+36+2",72),
("0+39+29",1131),
("0+39+30",1170),
("4+38+35",1330),
("4+38+36",1368),
("1+37+38",1406),
("4+38+37",1406),
("2+36+3",108),
("1+37+39",1443),
("4+38+38",1444),
("2+36+4",144),
("3+34+26",884),
("0+39+31",1209),
("1+37+40",1480),
("0+39+32",1248),
("4+38+39",1482),
("4+38+40",1520),
("3+34+27",918),
("0+39+33",1287),
("0+39+34",1326),
("0+39+35",1365),
("1+37+41",1517),
("3+34+28",952),
("3+34+29",986),
("0+39+36",1404),
("0+39+37",1443),
("3+34+30",1020),
("3+34+31",1054),
("4+38+41",1558),
("3+34+32",1088),
("2+36+5",180),
("3+34+33",1122),
("2+36+6",216),
("2+36+7",252),
("3+34+34",1156),
("4+38+42",1596),
("0+39+38",1482),
("4+38+43",1634),
("1+37+42",1554),
("1+37+43",1591),
("1+37+44",1628),
("3+34+35",1190),
("0+39+39",1521),
("1+37+45",1665),
("0+39+40",1560),
("2+36+8",288),
("2+36+9",324),
("3+34+36",1224),
("0+39+41",1599),
("4+38+44",1672),
("3+34+37",1258),
("0+39+42",1638),
("3+34+38",1292),
("3+34+39",1326),
("2+36+10",360),
("2+36+11",396),
("2+36+12",432),
("2+36+13",468),
("4+38+45",1710),
("0+39+43",1677),
("0+39+44",1716),
("2+36+14",504),
("4+38+46",1748),
("0+39+45",1755),
("4+38+47",1786),
("2+36+15",540),
("1+37+46",1702),
("1+37+47",1739),
("0+39+46",1794),
("4+38+48",1824),
("3+34+40",1360),
("4+38+49",1862),
("3+34+41",1394),
("0+39+47",1833),
("1+37+48",1776),
("0+39+48",1872),
("2+36+16",576),
("4+39+0",0),
("0+39+49",1911),
("3+34+42",1428),
("1+37+49",1813),
("3+34+43",1462),
("3+34+44",1496),
("2+36+17",612),
("3+34+45",1530),
("4+39+1",39),
("2+36+18",648),
("4+39+2",78),
("4+39+3",117),
("3+34+46",1564),
("4+39+4",156),
("2+36+19",684),
("2+36+20",720),
("4+39+5",195),
("4+39+6",234),
("3+34+47",1598),
("2+36+21",756),
("2+36+22",792),
("3+34+48",1632),
("4+39+7",273),
("3+34+49",1666),
("1+38+0",0),
("4+39+8",312),
("2+36+23",828),
("1+38+1",38),
("1+38+2",76),
("1+38+3",114),
("1+38+4",152),
("2+36+24",864),
("3+35+0",0),
("2+36+25",900),
("3+35+1",35),
("2+36+26",936),
("3+35+2",70),
("3+35+3",105),
("3+35+4",140),
("4+39+9",351),
("4+39+10",390),
("2+36+27",972),
("2+36+28",1008),
("1+38+5",190),
("2+36+29",1044),
("4+39+11",429),
("3+35+5",175),
("1+38+6",228),
("1+38+7",266),
("3+35+6",210),
("4+39+12",468),
("2+36+30",1080),
("4+39+13",507),
("2+36+31",1116),
("1+38+8",304),
("2+36+32",1152),
("2+36+33",1188),
("3+35+7",245),
("2+36+34",1224),
("2+36+35",1260),
("1+38+9",342),
("2+36+36",1296),
("1+38+10",380),
("3+35+8",280),
("2+36+37",1332),
("4+39+14",546),
("4+39+15",585),
("2+36+38",1368),
("4+39+16",624),
("2+36+39",1404),
("4+39+17",663),
("4+39+18",702),
("4+39+19",741),
("3+35+9",315),
("2+36+40",1440),
("3+35+10",350),
("3+35+11",385),
("1+38+11",418),
("1+38+12",456),
("2+36+41",1476),
("2+36+42",1512),
("1+38+13",494),
("4+39+20",780),
("2+36+43",1548),
("2+36+44",1584),
("1+38+14",532),
("1+38+15",570),
("2+36+45",1620),
("2+36+46",1656),
("2+36+47",1692),
("3+35+12",420),
("4+39+21",819),
("4+39+22",858),
("1+38+16",608),
("3+35+13",455),
("3+35+14",490),
("3+35+15",525),
("4+39+23",897),
("2+36+48",1728),
("1+38+17",646),
("3+35+16",560),
("3+35+17",595),
("1+38+18",684),
("4+39+24",936),
("1+38+19",722),
("2+36+49",1764),
("3+35+18",630),
("4+39+25",975),
("4+39+26",1014),
("1+38+20",760),
("1+38+21",798),
("1+38+22",836),
("3+35+19",665),
("4+39+27",1053),
("3+35+20",700),
("4+39+28",1092),
("1+38+23",874),
("4+39+29",1131),
("2+37+0",0),
("3+35+21",735),
("1+38+24",912),
("1+38+25",950),
("2+37+1",37),
("3+35+22",770),
("3+35+23",805),
("3+35+24",840),
("3+35+25",875),
("1+38+26",988),
("2+37+2",74),
("2+37+3",111),
("2+37+4",148),
("4+39+30",1170),
("2+37+5",185),
("4+39+31",1209),
("3+35+26",910),
("1+38+27",1026),
("2+37+6",222),
("3+35+27",945),
("3+35+28",980),
("2+37+7",259),
("3+35+29",1015),
("2+37+8",296),
("2+37+9",333),
("4+39+32",1248),
("1+38+28",1064),
("4+39+33",1287),
("3+35+30",1050),
("1+38+29",1102),
("3+35+31",1085),
("4+39+34",1326),
("1+38+30",1140),
("2+37+10",370),
("1+38+31",1178),
("4+39+35",1365),
("3+35+32",1120),
("3+35+33",1155),
("2+37+11",407),
("2+37+12",444),
("2+37+13",481),
("3+35+34",1190),
("3+35+35",1225),
("4+39+36",1404),
("4+39+37",1443),
("4+39+38",1482),
("3+35+36",1260),
("1+38+32",1216),
("1+38+33",1254),
("1+38+34",1292),
("2+37+14",518),
("2+37+15",555),
("1+38+35",1330),
("1+38+36",1368),
("1+38+37",1406),
("3+35+37",1295),
("3+35+38",1330),
("1+38+38",1444),
("3+35+39",1365),
("2+37+16",592),
("2+37+17",629),
("3+35+40",1400),
("3+35+41",1435),
("2+37+18",666),
("4+39+39",1521),
("4+39+40",1560),
("4+39+41",1599),
("1+38+39",1482),
("1+38+40",1520),
("3+35+42",1470),
("4+39+42",1638),
("2+37+19",703),
("4+39+43",1677),
("1+38+41",1558),
("3+35+43",1505),
("4+39+44",1716),
("2+37+20",740),
("1+38+42",1596),
("3+35+44",1540),
("3+35+45",1575),
("2+37+21",777),
("3+35+46",1610),
("3+35+47",1645),
("1+38+43",1634),
("4+39+45",1755),
("2+37+22",814),
("2+37+23",851),
("2+37+24",888),
("4+39+46",1794),
("4+39+47",1833),
("1+38+44",1672),
("4+39+48",1872),
("1+38+45",1710),
("3+35+48",1680),
("3+35+49",1715),
("4+39+49",1911),
("2+37+25",925),
("2+37+26",962),
("1+38+46",1748),
("2+37+27",999),
("1+38+47",1786),
("3+36+0",0),
("3+36+1",36),
("2+37+28",1036),
("3+36+2",72),
("3+36+3",108),
("1+38+48",1824),
("3+36+4",144),
("3+36+5",180),
("2+37+29",1073),
("3+36+6",216),
("1+38+49",1862),
("3+36+7",252),
("3+36+8",288),
("3+36+9",324),
("3+36+10",360),
("2+37+30",1110),
("2+37+31",1147),
("3+36+11",396),
("3+36+12",432),
("1+39+0",0),
("1+39+1",39),
("2+37+32",1184),
("1+39+2",78),
("1+39+3",117),
("3+36+13",468),
("2+37+33",1221),
("3+36+14",504),
("2+37+34",1258),
("3+36+15",540),
("1+39+4",156),
("1+39+5",195),
("3+36+16",576),
("3+36+17",612),
("3+36+18",648),
("2+37+35",1295),
("3+36+19",684),
("2+37+36",1332),
("1+39+6",234),
("3+36+20",720),
("2+37+37",1369),
("1+39+7",273),
("2+37+38",1406),
("1+39+8",312),
("1+39+9",351),
("1+39+10",390),
("2+37+39",1443),
("2+37+40",1480),
("3+36+21",756),
("3+36+22",792),
("3+36+23",828),
("2+37+41",1517),
("1+39+11",429),
("1+39+12",468),
("1+39+13",507),
("2+37+42",1554),
("3+36+24",864),
("2+37+43",1591),
("2+37+44",1628),
("3+36+25",900),
("3+36+26",936),
("3+36+27",972),
("1+39+14",546),
("3+36+28",1008),
("2+37+45",1665),
("2+37+46",1702),
("3+36+29",1044),
("2+37+47",1739),
("3+36+30",1080),
("1+39+15",585),
("1+39+16",624),
("1+39+17",663),
("1+39+18",702),
("1+39+19",741),
("1+39+20",780),
("3+36+31",1116),
("1+39+21",819),
("2+37+48",1776),
("3+36+32",1152),
("2+37+49",1813),
("3+36+33",1188),
("3+36+34",1224),
("3+36+35",1260),
("3+36+36",1296),
("1+39+22",858),
("3+36+37",1332),
("1+39+23",897),
("2+38+0",0),
("3+36+38",1368),
("2+38+1",38),
("3+36+39",1404),
("2+38+2",76),
("3+36+40",1440),
("1+39+24",936),
("1+39+25",975),
("1+39+26",1014),
("3+36+41",1476),
("1+39+27",1053),
("3+36+42",1512),
("3+36+43",1548),
("2+38+3",114),
("1+39+28",1092),
("1+39+29",1131),
("2+38+4",152),
("2+38+5",190),
("1+39+30",1170),
("3+36+44",1584),
("2+38+6",228),
("2+38+7",266),
("2+38+8",304),
("3+36+45",1620),
("2+38+9",342),
("3+36+46",1656),
("2+38+10",380),
("3+36+47",1692),
("2+38+11",418),
("1+39+31",1209),
("1+39+32",1248),
("2+38+12",456),
("1+39+33",1287),
("1+39+34",1326),
("2+38+13",494),
("1+39+35",1365),
("2+38+14",532),
("1+39+36",1404),
("1+39+37",1443),
("3+36+48",1728),
("2+38+15",570),
("2+38+16",608),
("1+39+38",1482),
("1+39+39",1521),
("3+36+49",1764),
("2+38+17",646),
("2+38+18",684),
("1+39+40",1560),
("2+38+19",722),
("1+39+41",1599),
("2+38+20",760),
("3+37+0",0),
("2+38+21",798),
("1+39+42",1638),
("1+39+43",1677),
("2+38+22",836),
("1+39+44",1716),
("1+39+45",1755),
("1+39+46",1794),
("3+37+1",37),
("3+37+2",74),
("1+39+47",1833),
("1+39+48",1872),
("2+38+23",874),
("2+38+24",912),
("1+39+49",1911),
("2+38+25",950),
("3+37+3",111),
("2+38+26",988),
("2+38+27",1026),
("2+38+28",1064),
("3+37+4",148),
("2+38+29",1102),
("3+37+5",185),
("2+38+30",1140),
("2+38+31",1178),
("2+38+32",1216),
("2+38+33",1254),
("2+38+34",1292),
("2+38+35",1330),
("2+38+36",1368),
("2+38+37",1406),
("2+38+38",1444),
("2+38+39",1482),
("2+38+40",1520),
("2+38+41",1558),
("2+38+42",1596),
("3+37+6",222),
("3+37+7",259),
("2+38+43",1634),
("3+37+8",296),
("2+38+44",1672),
("2+38+45",1710),
("3+37+9",333),
("2+38+46",1748),
("3+37+10",370),
("2+38+47",1786),
("2+38+48",1824),
("2+38+49",1862),
("3+37+11",407),
("3+37+12",444),
("3+37+13",481),
("3+37+14",518),
("3+37+15",555),
("3+37+16",592),
("3+37+17",629),
("2+39+0",0),
("3+37+18",666),
("2+39+1",39),
("3+37+19",703),
("3+37+20",740),
("3+37+21",777),
("2+39+2",78),
("3+37+22",814),
("3+37+23",851),
("3+37+24",888),
("2+39+3",117),
("2+39+4",156),
("2+39+5",195),
("2+39+6",234),
("2+39+7",273),
("2+39+8",312),
("2+39+9",351),
("3+37+25",925),
("2+39+10",390),
("3+37+26",962),
("2+39+11",429),
("3+37+27",999),
("2+39+12",468),
("3+37+28",1036),
("2+39+13",507),
("3+37+29",1073),
("2+39+14",546),
("3+37+30",1110),
("2+39+15",585),
("3+37+31",1147),
("2+39+16",624),
("3+37+32",1184),
("2+39+17",663),
("3+37+33",1221),
("2+39+18",702),
("3+37+34",1258),
("2+39+19",741),
("3+37+35",1295),
("2+39+20",780),
("3+37+36",1332),
("2+39+21",819),
("3+37+37",1369),
("2+39+22",858),
("3+37+38",1406),
("2+39+23",897),
("3+37+39",1443),
("2+39+24",936),
("3+37+40",1480),
("2+39+25",975),
("3+37+41",1517),
("2+39+26",1014),
("3+37+42",1554),
("2+39+27",1053),
("3+37+43",1591),
("2+39+28",1092),
("3+37+44",1628),
("2+39+29",1131),
("3+37+45",1665),
("2+39+30",1170),
("3+37+46",1702),
("2+39+31",1209),
("3+37+47",1739),
("2+39+32",1248),
("3+37+48",1776),
("2+39+33",1287),
("3+37+49",1813),
("2+39+34",1326),
("2+39+35",1365),
("2+39+36",1404),
("2+39+37",1443),
("2+39+38",1482),
("2+39+39",1521),
("3+38+0",0),
("2+39+40",1560),
("2+39+41",1599),
("3+38+1",38),
("2+39+42",1638),
("3+38+2",76),
("2+39+43",1677),
("2+39+44",1716),
("2+39+45",1755),
("3+38+3",114),
("2+39+46",1794),
("3+38+4",152),
("2+39+47",1833),
("3+38+5",190),
("2+39+48",1872),
("2+39+49",1911),
("3+38+6",228),
("3+38+7",266),
("3+38+8",304),
("3+38+9",342),
("3+38+10",380),
("3+38+11",418),
("3+38+12",456),
("3+38+13",494),
("3+38+14",532),
("3+38+15",570),
("3+38+16",608),
("3+38+17",646),
("3+38+18",684),
("3+38+19",722),
("3+38+20",760),
("3+38+21",798),
("3+38+22",836),
("3+38+23",874),
("3+38+24",912),
("3+38+25",950),
("3+38+26",988),
("3+38+27",1026),
("3+38+28",1064),
("3+38+29",1102),
("3+38+30",1140),
("3+38+31",1178),
("3+38+32",1216),
("3+38+33",1254),
("3+38+34",1292),
("3+38+35",1330),
("3+38+36",1368),
("3+38+37",1406),
("3+38+38",1444),
("3+38+39",1482),
("3+38+40",1520),
("3+38+41",1558),
("3+38+42",1596),
("3+38+43",1634),
("3+38+44",1672),
("3+38+45",1710),
("3+38+46",1748),
("3+38+47",1786),
("3+38+48",1824),
("3+38+49",1862),
("3+39+0",0),
("3+39+1",39),
("3+39+2",78),
("3+39+3",117),
("3+39+4",156),
("3+39+5",195),
("3+39+6",234),
("3+39+7",273),
("3+39+8",312),
("3+39+9",351),
("3+39+10",390),
("3+39+11",429),
("3+39+12",468),
("3+39+13",507),
("3+39+14",546),
("3+39+15",585),
("3+39+16",624),
("3+39+17",663),
("3+39+18",702),
("3+39+19",741),
("3+39+20",780),
("3+39+21",819),
("3+39+22",858),
("3+39+23",897),
("3+39+24",936),
("3+39+25",975),
("3+39+26",1014),
("3+39+27",1053),
("3+39+28",1092),
("3+39+29",1131),
("3+39+30",1170),
("3+39+31",1209),
("3+39+32",1248),
("3+39+33",1287),
("3+39+34",1326),
("3+39+35",1365),
("3+39+36",1404),
("3+39+37",1443),
("3+39+38",1482),
("3+39+39",1521),
("3+39+40",1560),
("3+39+41",1599),
("3+39+42",1638),
("3+39+43",1677),
("3+39+44",1716),
("3+39+45",1755),
("3+39+46",1794),
("3+39+47",1833),
("3+39+48",1872),
("3+39+49",1911); | SQL | 1 | suryatmodulus/tidb | br/pkg/lightning/mydump/examples/mocker_test.tbl_multi_index.sql | [
"Apache-2.0",
"BSD-3-Clause"
] |
[[using.structuring-your-code]]
== Structuring Your Code
Spring Boot does not require any specific code layout to work.
However, there are some best practices that help.
[[using.structuring-your-code.using-the-default-package]]
=== Using the "`default`" Package
When a class does not include a `package` declaration, it is considered to be in the "`default package`".
The use of the "`default package`" is generally discouraged and should be avoided.
It can cause particular problems for Spring Boot applications that use the `@ComponentScan`, `@ConfigurationPropertiesScan`, `@EntityScan`, or `@SpringBootApplication` annotations, since every class from every jar is read.
TIP: We recommend that you follow Java's recommended package naming conventions and use a reversed domain name (for example, `com.example.project`).
[[using.structuring-your-code.locating-the-main-class]]
=== Locating the Main Application Class
We generally recommend that you locate your main application class in a root package above other classes.
The <<using#using.using-the-springbootapplication-annotation, `@SpringBootApplication` annotation>> is often placed on your main class, and it implicitly defines a base "`search package`" for certain items.
For example, if you are writing a JPA application, the package of the `@SpringBootApplication` annotated class is used to search for `@Entity` items.
Using a root package also allows component scan to apply only on your project.
TIP: If you do not want to use `@SpringBootApplication`, the `@EnableAutoConfiguration` and `@ComponentScan` annotations that it imports defines that behavior so you can also use those instead.
The following listing shows a typical layout:
[indent=0]
----
com
+- example
+- myapplication
+- MyApplication.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
----
The `MyApplication.java` file would declare the `main` method, along with the basic `@SpringBootApplication`, as follows:
[source,java,indent=0,subs="verbatim"]
----
include::{docs-java}/using/structuringyourcode/locatingthemainclass/MyApplication.java[]
----
| AsciiDoc | 5 | techAi007/spring-boot | spring-boot-project/spring-boot-docs/src/docs/asciidoc/using/structuring-your-code.adoc | [
"Apache-2.0"
] |
#!/usr/bin/env bash
set -eou pipefail
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
source "${DIR}/promote/common_utils.sh"
if [[ -z "${RESTORE_FROM:-}" ]]; then
echo "ERROR: RESTORE_FROM environment variable must be specified"
echo " example: RESTORE_FROM=v1.6.0-rc3 ${0}"
exit 1
fi
DRY_RUN=${DRY_RUN:-enabled}
PYTORCH_S3_BACKUP_BUCKET=${PYTORCH_S3_BACKUP_BUCKET:-s3://pytorch-backup/${RESTORE_FROM}}
PYTORCH_S3_TEST_BUCKET=${PYTORCH_S3_TEST_BUCKET:-s3://pytorch/}
PYTORCH_S3_FROM=${PYTORCH_S3_FROM:-${PYTORCH_S3_BACKUP_BUCKET}}
PYTORCH_S3_TO=${PYTORCH_S3_TO:-s3://pytorch/}
restore_wheels() {
aws_promote torch whl
}
restore_libtorch() {
aws_promote libtorch-* libtorch
}
ANACONDA="true anaconda"
if [[ ${DRY_RUN} = "disabled" ]]; then
ANACONDA="anaconda"
fi
PYTORCH_CONDA_TO=${PYTORCH_CONDA_TO:-pytorch-test}
upload_conda() {
local pkg
pkg=${1}
(
set -x
${ANACONDA} upload --skip -u "${PYTORCH_CONDA_TO}" "${pkg}"
)
}
export -f upload_conda
restore_conda() {
TMP_DIR="$(mktemp -d)"
trap 'rm -rf ${TMP_DIR}' EXIT
(
set -x
aws s3 cp --recursive "${PYTORCH_S3_BACKUP_BUCKET}/conda" "${TMP_DIR}/"
)
export ANACONDA
export PYTORCH_CONDA_TO
# Should upload all bz2 packages in parallel for quick restoration
find "${TMP_DIR}" -name '*.bz2' -type f \
| xargs -P 10 -I % bash -c "(declare -t upload_conda); upload_conda %"
}
restore_wheels
restore_libtorch
restore_conda
| Shell | 4 | Hacky-DH/pytorch | scripts/release/restore-backup.sh | [
"Intel"
] |
;ACE header
$tagACCESS_ALLOWED_ACE = "dword Mask;dword SidStart"
$tagACCESS_ALLOWED_CALLBACK_ACE = "dword Mask;dword SidStart"
$tagACCESS_ALLOWED_CALLBACK_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
$tagACCESS_ALLOWED_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
$tagACCESS_DENIED_ACE = "dword Mask;dword SidStart"
$tagACCESS_DENIED_CALLBACK_ACE = "dword Mask;dword SidStart"
$tagACCESS_DENIED_CALLBACK_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
$tagACCESS_DENIED_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
;Unsupported
;SYSTEM_ALARM_ACE
;SYSTEM_ALARM_CALLBACK_ACE
;SYSTEM_ALARM_CALLBACK_OBJECT_ACE
;SYSTEM_ALARM_OBJECT_ACE
$tagSYSTEM_AUDIT_ACE = "dword Mask;dword SidStart"
$tagSYSTEM_AUDIT_CALLBACK_ACE = "dword Mask;dword SidStart"
$tagSYSTEM_AUDIT_CALLBACK_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
$tagSYSTEM_AUDIT_OBJECT_ACE = "dword Mask;dword Flags;GUID ObjectType;GUID InheritedObjectType;dword SidStart"
$tagSYSTEM_MANDATORY_LABEL_ACE = "dword Mask;dword SidStart"
$tagSYSTEM_RESOURCE_ATTRIBUTE_ACE = "dword Mask;dword SidStart"
$tagSYSTEM_SCOPED_POLICY_ID_ACE = "dword Mask;dword SidStart"
$tagACL = "byte AclRevision;byte Sbz1;word AclSize;word AceCount;word Sbz2"
$tagACE_HEADER = "byte AceType;byte AceFlags;word AceSize"
;AceType (1 byte): An unsigned 8-bit integer that specifies the ACE types. This field MUST be one of the following values.
Global Const $ACCESS_ALLOWED_ACE_TYPE = 0x00 ;Access-allowed ACE that uses the ACCESS_ALLOWED_ACE (section 2.4.4.2) structure.
Global Const $ACCESS_DENIED_ACE_TYPE = 0x01 ;Access-denied ACE that uses the ACCESS_DENIED_ACE (section 2.4.4.4) structure.
Global Const $SYSTEM_AUDIT_ACE_TYPE = 0x02 ;System-audit ACE that uses the SYSTEM_AUDIT_ACE (section 2.4.4.10) structure.
Global Const $SYSTEM_ALARM_ACE_TYPE = 0x03 ;Reserved for future use.
Global Const $ACCESS_ALLOWED_COMPOUND_ACE_TYPE = 0x04 ;Reserved for future use.
Global Const $ACCESS_ALLOWED_OBJECT_ACE_TYPE = 0x05 ;Object-specific access-allowed ACE that uses the ACCESS_ALLOWED_OBJECT_ACE (section 2.4.4.3) structure.<31>
Global Const $ACCESS_DENIED_OBJECT_ACE_TYPE = 0x06 ;Object-specific access-denied ACE that uses the ACCESS_DENIED_OBJECT_ACE (section 2.4.4.5) structure.<32>
Global Const $SYSTEM_AUDIT_OBJECT_ACE_TYPE = 0x07 ;Object-specific system-audit ACE that uses the SYSTEM_AUDIT_OBJECT_ACE (section 2.4.4.11) structure.<33>
Global Const $SYSTEM_ALARM_OBJECT_ACE_TYPE = 0x08 ;Reserved for future use.
Global Const $ACCESS_ALLOWED_CALLBACK_ACE_TYPE = 0x09 ;Access-allowed callback ACE that uses the ACCESS_ALLOWED_CALLBACK_ACE (section 2.4.4.6) structure.<34>
Global Const $ACCESS_DENIED_CALLBACK_ACE_TYPE = 0x0A ;Access-denied callback ACE that uses the ACCESS_DENIED_CALLBACK_ACE (section 2.4.4.7) structure.<35>
Global Const $ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE = 0x0B ;Object-specific access-allowed callback ACE that uses the ACCESS_ALLOWED_CALLBACK_OBJECT_ACE (section 2.4.4.8) structure.<36>
Global Const $ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE = 0x0C ;Object-specific access-denied callback ACE that uses the ACCESS_DENIED_CALLBACK_OBJECT_ACE (section 2.4.4.9) structure.<37>
Global Const $SYSTEM_AUDIT_CALLBACK_ACE_TYPE = 0x0D ;System-audit callback ACE that uses the SYSTEM_AUDIT_CALLBACK_ACE (section 2.4.4.12) structure.<38>
Global Const $SYSTEM_ALARM_CALLBACK_ACE_TYPE = 0x0E ;Reserved for future use.
Global Const $SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE = 0x0F ;Object-specific system-audit callback ACE that uses the SYSTEM_AUDIT_CALLBACK_OBJECT_ACE (section 2.4.4.14) structure.
Global Const $SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE = 0x10 ;Reserved for future use.
Global Const $SYSTEM_MANDATORY_LABEL_ACE_TYPE = 0x11 ;Mandatory label ACE that uses the SYSTEM_MANDATORY_LABEL_ACE (section 2.4.4.13) structure.
Global Const $SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE = 0x12 ;Resource attribute ACE that uses the SYSTEM_RESOURCE_ATTRIBUTE_ACE (section 2.4.4.15)
Global Const $SYSTEM_SCOPED_POLICY_ID_ACE_TYPE = 0x13 ;A central policy ID ACE that uses the SYSTEM_SCOPED_POLICY_ID_ACE (section 2.4.4.16)
Global Const $SYSTEM_PROCESS_TRUST_LABEL_ACE_TYPE = 0x14
;AceFlags (1 byte): An unsigned 8-bit integer that specifies a set of ACE type-specific control flags. This field can be a combination of the following values.
Global Const $CONTAINER_INHERIT_ACE = 0x02 ;Child objects that are containers, such as directories, inherit the ACE as an effective ACE. The inherited ACE is inheritable unless the NO_PROPAGATE_INHERIT_ACE bit flag is also set.
Global Const $FAILED_ACCESS_ACE_FLAG = 0x80 ;Used with system-audit ACEs in a system access control list (SACL) to generate audit messages for failed access attempts.
Global Const $INHERIT_ONLY_ACE = 0x08 ;Indicates an inherit-only ACE, which does not control access to the object to which it is attached. If this flag is not set, the ACE is an effective ACE that controls access to the object to which it is attached. Both effective and inherit-only ACEs can be inherited depending on the state of the other inheritance flags.
Global Const $INHERITED_ACE = 0x10 ;Indicates that the ACE was inherited. The system sets this bit when it propagates an inherited ACE to a child object.<40>
Global Const $NO_PROPAGATE_INHERIT_ACE = 0x04 ;If the ACE is inherited by a child object, the system clears the OBJECT_INHERIT_ACE and CONTAINER_INHERIT_ACE flags in the inherited ACE. This prevents the ACE from being inherited by subsequent generations of objects.
Global Const $OBJECT_INHERIT_ACE = 0x01 ;Noncontainer child objects inherit the ACE as an effective ACE. For child objects that are containers, the ACE is inherited as an inherit-only ACE unless the NO_PROPAGATE_INHERIT_ACE bit flag is also set.
Global Const $SUCCESSFUL_ACCESS_ACE_FLAG = 0x40 ;Used with system-audit ACEs in a SACL to generate audit messages for successful access attempts.
;AceObjectFlags A 32-bit unsigned integer that specifies a set of bit flags that indicate whether the ObjectType and InheritedObjectType fields contain valid data. This parameter can be one or more of the following values.
Global Const $ACE_NO_VALID_OBJECT_TYPE_PRESENT = 0x00000000 ;Neither ObjectType nor InheritedObjectType are valid.
Global Const $ACE_OBJECT_TYPE_PRESENT = 0x00000001 ;ObjectType is valid.
Global Const $ACE_INHERITED_OBJECT_TYPE_PRESENT = 0x00000002 ;InheritedObjectType is valid. If this value is not specified, all types of child objects can inherit the ACE.
;Access masks used with object types
Global Const $ADS_RIGHT_DS_CONTROL_ACCESS = 0x00000100 ;The ObjectType GUID identifies an extended access right.
Global Const $ADS_RIGHT_DS_CREATE_CHILD = 0x00000001 ;The ObjectType GUID identifies a type of child object. The ACE controls the trustee's right to create this type of child object.
Global Const $ADS_RIGHT_DS_READ_PROP = 0x00000010 ;The ObjectType GUID identifies a property set or property of the object. The ACE controls the trustee's right to read the property or property set.
Global Const $ADS_RIGHT_DS_WRITE_PROP = 0x00000020 ;The ObjectType GUID identifies a property set or property of the object. The ACE controls the trustee's right to write the property or property set.
Global Const $ADS_RIGHT_DS_SELF = 0x00000008 ;The ObjectType GUID identifies a validated write.
;AceSize (2 bytes): An unsigned 16-bit integer that specifies the size, in bytes, of the ACE. The AceSize field can be greater than the sum of the individual fields,
;but MUST be a multiple of 4 to ensure alignment on a DWORD boundary. In cases where the AceSize field encompasses additional data for the callback ACEs types,
;that data is implementation-specific. Otherwise, this additional data is not interpreted and MUST be ignored.
;SECURITY_DESCRIPTOR_CONTROL
Global Const $SE_OWNER_DEFAULTED = 0x0001
Global Const $SE_GROUP_DEFAULTED = 0x0002
Global Const $SE_DACL_PRESENT = 0x0004
Global Const $SE_DACL_DEFAULTED = 0x0008
Global Const $SE_SACL_PRESENT = 0x0010
Global Const $SE_SACL_DEFAULTED = 0x0020
Global Const $SE_DACL_UNTRUSTED = 0x0040
Global Const $SE_SERVER_SECURITY = 0x0080
Global Const $SE_DACL_AUTO_INHERIT_REQ = 0x0100
Global Const $SE_SACL_AUTO_INHERIT_REQ = 0x0200
Global Const $SE_DACL_AUTO_INHERITED = 0x0400
Global Const $SE_SACL_AUTO_INHERITED = 0x0800
Global Const $SE_DACL_PROTECTED = 0x1000
Global Const $SE_SACL_PROTECTED = 0x2000
Global Const $SE_RM_CONTROL_VALID = 0x4000
Global Const $SE_SELF_RELATIVE = 0x8000
| AutoIt | 4 | jschicht/LogFileParser | SecureConstants.au3 | [
"CC-BY-3.0"
] |
component{
function x(aRg1,Arg2){
}
} | ColdFusion CFC | 1 | tonym128/CFLint | src/test/resources/com/cflint/tests/UnusedArgument/UnusedArgument_Case_545.cfc | [
"BSD-3-Clause"
] |
% C# parser based on the TXL C# grammar
% March 2006 (Revised Oct 2010)
% Simple null program to test the C# grammar
% TXL ECMA-334 C# Grammar
include "CSharp.grm"
% Comment out this line to use grammar without preserving comments
% #define COMMENTS
% Experimental overrides to allow for comment preservation
#ifdef COMMENTS
include "CSharpCommentOverrides.grm"
#endif
% Comment out this line to use grammar without preserving intentional extra newlines
% #define NEWLINES
% Experimental overrides to allow for preservation of intentional extra newlines
#ifdef NEWLINES
include "CSharpPreserveNewlines.grm"
#endif
% Temporary handling of designated Linq extensions
redefine invocation_operator
...
| '(( [repeat argument_list_or_key] '))
end redefine
define argument_list_or_key
[argument_list]
| 'in
end define
% Just parse
function main
replace [program]
P [program]
by
P
#ifdef NEWLINES
[preserveNewlines]
#endif
end function
| TXL | 4 | grammarware/slps | topics/grammars/csharp/cordy/CSharp/cs.txl | [
"BSD-3-Clause"
] |
using Uno;
using Fuse;
using Fuse.Controls;
public partial class SimplePressedTriggerTest_00
{
public SimplePressedTriggerTest_00()
{
InitializeUX();
}
public Translation Translation1
{
get
{
return panelTranslation1;
}
}
}
| Uno | 4 | helilabs/fuselibs | Source/Fuse.Animations/Tests/Old/SimplePressedTriggerTest_00.ux.uno | [
"MIT"
] |
unit CompFileAssoc;
{
Inno Setup
Copyright (C) 1997-2020 Jordan Russell
Portions by Martijn Laan
For conditions of distribution and use, see LICENSE.TXT.
Compiler IDE's functions for registering/unregistering the .iss file association
}
interface
function RegisterISSFileAssociation(const AllowInteractive: Boolean; var AllUsers: Boolean): Boolean;
procedure UnregisterISSFileAssociation;
implementation
uses
Windows, SysUtils, PathFunc, ShlObj, CmnFunc, CmnFunc2;
function GetRootkey: HKEY;
begin
if IsAdminLoggedOn then
Result := HKEY_LOCAL_MACHINE
else
Result := HKEY_CURRENT_USER;
end;
procedure UnregisterISSFileAssociationDo(const Rootkey: HKEY; const ChangeNotify: Boolean); forward;
function RegisterISSFileAssociation(const AllowInteractive: Boolean; var AllUsers: Boolean): Boolean;
procedure SetKeyValue(const Rootkey: HKEY; const Subkey, ValueName: PChar; const Data: String);
procedure Check(const Res: Longint);
begin
if Res <> ERROR_SUCCESS then
raise Exception.CreateFmt('Error creating file association:'#13#10'%d - %s',
[Res, Win32ErrorString(Res)]);
end;
var
K: HKEY;
Disp: DWORD;
begin
Check(RegCreateKeyExView(rvDefault, Rootkey, Subkey, 0, nil, 0, KEY_SET_VALUE,
nil, K, @Disp));
try
Check(RegSetValueEx(K, ValueName, 0, REG_SZ, PChar(Data), (Length(Data)+1)*SizeOf(Data[1])));
finally
RegCloseKey(K);
end;
end;
var
SelfName: String;
Rootkey: HKEY;
begin
Rootkey := GetRootkey;
AllUsers := Rootkey = HKEY_LOCAL_MACHINE;
Result := AllUsers or not AllowInteractive or
(MsgBox('Unable to associate for all users without administrative privileges. Do you want to associate only for yourself instead?',
'Associate', mbConfirmation, MB_YESNO) = IDYES);
if not Result then
Exit;
SelfName := NewParamStr(0);
SetKeyValue(Rootkey, 'Software\Classes\.iss', nil, 'InnoSetupScriptFile');
SetKeyValue(Rootkey, 'Software\Classes\.iss', 'Content Type', 'text/plain');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile', nil, 'Inno Setup Script');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\DefaultIcon', nil, SelfName + ',1');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\open\command', nil,
'"' + SelfName + '" "%1"');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\OpenWithInnoSetup', nil,
'Open with &Inno Setup');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\OpenWithInnoSetup\command', nil,
'"' + SelfName + '" "%1"');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\Compile', nil, 'Compi&le');
SetKeyValue(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\Compile\command', nil,
'"' + SelfName + '" /cc "%1"');
SetKeyValue(Rootkey, PChar('Software\Classes\Applications\' + PathExtractName(SelfName) + '\SupportedTypes'), '.iss', '');
{ If we just associated for all users, remove our existing association for the current user if it exists. }
if AllUsers then
UnregisterISSFileAssociationDo(HKEY_CURRENT_USER, False);
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nil, nil);
end;
procedure UnregisterISSFileAssociationDo(const Rootkey: HKEY; const ChangeNotify: Boolean);
function KeyValueEquals(const Rootkey: HKEY; const Subkey: PChar; const Data: String): Boolean;
var
K: HKEY;
S: String;
begin
Result := False;
if RegOpenKeyExView(rvDefault, Rootkey, Subkey, 0, KEY_QUERY_VALUE, K) = ERROR_SUCCESS then begin
if RegQueryStringValue(K, nil, S) and (PathCompare(Data, S) = 0) then
Result := True;
RegCloseKey(K);
end;
end;
function KeyExists(const Rootkey: HKEY; const Subkey: PChar): Boolean;
var
K: HKEY;
begin
Result := (RegOpenKeyExView(rvDefault, Rootkey, Subkey, 0, KEY_QUERY_VALUE,
K) = ERROR_SUCCESS);
if Result then
RegCloseKey(K);
end;
function GetKeyNumSubkeysValues(const Rootkey: HKEY; const Subkey: PChar;
var NumSubkeys, NumValues: DWORD): Boolean;
var
K: HKEY;
begin
Result := False;
if RegOpenKeyExView(rvDefault, Rootkey, Subkey, 0, KEY_QUERY_VALUE, K) = ERROR_SUCCESS then begin
Result := RegQueryInfoKey(K, nil, nil, nil, @NumSubkeys, nil, nil,
@NumValues, nil, nil, nil, nil) = ERROR_SUCCESS;
RegCloseKey(K);
end;
end;
procedure DeleteValue(const Rootkey: HKEY; const Subkey, ValueName: PChar);
var
K: HKEY;
begin
if RegOpenKeyExView(rvDefault, Rootkey, Subkey, 0, KEY_SET_VALUE, K) = ERROR_SUCCESS then begin
RegDeleteValue(K, ValueName);
RegCloseKey(K);
end;
end;
var
SelfName: String;
NumSubkeys, NumValues: DWORD;
begin
if not KeyExists(Rootkey, 'Software\Classes\InnoSetupScriptFile') and not KeyExists(Rootkey, 'Software\Classes\.iss') then
Exit;
SelfName := NewParamStr(0);
{ NOTE: We can't just blindly delete the entire .iss & InnoSetupScriptFile
keys, otherwise we'd remove the association even if we weren't the one who
registered it in the first place. }
{ Clean up 'InnoSetupScriptFile' }
if KeyValueEquals(Rootkey, 'Software\Classes\InnoSetupScriptFile\DefaultIcon', SelfName + ',1') then
RegDeleteKeyIncludingSubkeys(rvDefault, Rootkey, 'Software\Classes\InnoSetupScriptFile\DefaultIcon');
if KeyValueEquals(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\open\command', '"' + SelfName + '" "%1"') then
RegDeleteKeyIncludingSubkeys(rvDefault, Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\open');
if KeyValueEquals(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\OpenWithInnoSetup\command', '"' + SelfName + '" "%1"') then
RegDeleteKeyIncludingSubkeys(rvDefault, Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\OpenWithInnoSetup');
if KeyValueEquals(Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\Compile\command', '"' + SelfName + '" /cc "%1"') then
RegDeleteKeyIncludingSubkeys(rvDefault, Rootkey, 'Software\Classes\InnoSetupScriptFile\shell\Compile');
RegDeleteKeyIfEmpty(rvDefault, Rootkey, 'Software\Classes\InnoSetupScriptFile\shell');
if KeyValueEquals(Rootkey, 'Software\Classes\InnoSetupScriptFile', 'Inno Setup Script') and
GetKeyNumSubkeysValues(Rootkey, 'Software\Classes\InnoSetupScriptFile', NumSubkeys, NumValues) and
(NumSubkeys = 0) and (NumValues <= 1) then
RegDeleteKey(Rootkey, 'Software\Classes\InnoSetupScriptFile');
{ Clean up '.iss' }
if not KeyExists(Rootkey, 'Software\Classes\InnoSetupScriptFile') and
KeyValueEquals(Rootkey, 'Software\Classes\.iss', 'InnoSetupScriptFile') then begin
DeleteValue(Rootkey, 'Software\Classes\.iss', nil);
DeleteValue(Rootkey, 'Software\Classes\.iss', 'Content Type');
end;
RegDeleteKeyIfEmpty(rvDefault, RootKey, 'Software\Classes\.iss');
if ChangeNotify then
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nil, nil);
end;
procedure UnregisterISSFileAssociation;
begin
UnregisterISSFileAssociationDo(GetRootkey, True);
end;
end.
| Pascal | 5 | Patriccollu/issrc | Projects/CompFileAssoc.pas | [
"FSFAP"
] |
# Legal, if unusual, IRIs
SELECT * WHERE { <a> <b> <?z> }
| SPARQL | 1 | alpano-unibz/ontop | test/sparql-compliance/src/test/resources/testcases-dawg/data-r2/syntax-sparql2/syntax-general-12.rq | [
"Apache-2.0"
] |
require meta-multimedia-image-base.bb
IMAGE_INSTALL += "packagegroup-meta-multimedia"
| BitBake | 2 | guillon/meta-openembedded | meta-multimedia/recipes-multimedia/images/meta-multimedia-image.bb | [
"MIT"
] |
(* -*- sml-lex -*- *)
structure T = FormatCommentLrVals.Tokens
type token = T.token
type pos = T.pos
type lexresult = T.token
(* if you use ml-lex of SML/NJ, you need to specify this to 2. *)
val INITIAL_POS_OF_LEXER = 0
type arg =
{
error : string * pos * pos -> unit,
comment : pos list ref,
string : {buf : string list ref, startPos : pos option ref},
offset : int
}
fun initArg {error, offset} =
{
error = error,
comment = ref nil,
string = {buf = ref nil, startPos = ref NONE},
offset = offset
} : arg
fun startComment (yypos, arg as {comment,...}) =
comment := yypos :: !comment
fun closeComment ({comment,...}:arg) =
case !comment of
nil => raise Fail "BUG: closeComment"
| h::t => (comment := t; case t of nil => true | _::_ => false)
fun pos (yypos, yytext, {offset, ...} : arg) =
(offset + yypos, offset + yypos + size yytext - 1)
fun startString (yypos, arg as {string = {buf, startPos}, ...} : arg) =
(buf := nil; startPos := SOME yypos)
fun closeString (yypos, arg as {string = {buf, startPos}, ...} : arg) =
case !startPos of
NONE => raise Fail "BUG: closeString"
| SOME l =>
(T.STRING (String.concat (rev (!buf)), l, yypos), l, yypos)
before (buf := nil; startPos := NONE)
fun addString (s, {string = {buf, ...}, ...}:arg) =
buf := s :: !buf
fun eof ({string, comment, error, ...} : arg) =
(case !(#startPos string) of
SOME pos => error ("unclosed string", pos, ~1)
| NONE => ();
case !comment of
pos::_ => error ("unclosed comment", pos, ~1)
| nil => ();
T.EOF (~1, ~1))
%%
%full
%s COMM FC FCOMM STR;
%structure FormatCommentLex
%arg (arg);
underscore="\_";
alpha=[A-Za-z\128-\255];
digit=[0-9];
xdigit=[0-9a-fA-F];
alnum=({alpha}|{digit}|{underscore});
id=({alpha}({alnum}|"'")*);
ws=("\012"|[\t\ ]);
eol=("\013\010"|"\010"|"\013");
symid=([-!%&$#+/:<=>?@\\~`^|*]+);
int=([1-9]{digit}*);
num={digit}+;
prefixedlabel={int}"_"({id}|{symid});
%%
<INITIAL>{ws} => (continue());
<INITIAL>{eol} => (continue ());
<INITIAL>"(*%" => (YYBEGIN FC; T.FORMATCOMMENTSTART (pos (yypos, yytext, arg)));
<INITIAL>"(*" => (startComment (yypos, arg); YYBEGIN COMM; continue ());
<INITIAL>. => (case pos (yypos, yytext, arg) of
(l, r) => T.SPECIAL (String.sub (yytext, 0), l, r));
<COMM>{eol} => (continue ());
<COMM>"(*" => (startComment (yypos, arg); continue ());
<COMM>"*)" => (if closeComment arg then YYBEGIN INITIAL else (); continue ());
<COMM>. => (continue ());
<FCOMM>{eol} => (continue ());
<FCOMM>"(*" => (startComment (yypos, arg); continue ());
<FCOMM>"*)" => (if closeComment arg then YYBEGIN FC else (); continue ());
<FCOMM>. => (continue ());
<FC>{eol} => (continue());
<FC>{ws} => (continue());
<FC>^{ws}*"*" => (continue());
<FC>"(*" => (startComment (yypos, arg); YYBEGIN FCOMM; continue ());
<FC>"*)" => (YYBEGIN INITIAL; T.FORMATCOMMENTEND (pos (yypos, yytext, arg)));
<FC>^{ws}*"*)" =>
(YYBEGIN INITIAL; T.FORMATCOMMENTEND (pos (yypos, yytext, arg)));
<FC>\" => (startString (yypos, arg); YYBEGIN STR; continue ());
<FC>"@ditto" => (T.DITTOTAG (pos (yypos, yytext, arg)));
<FC>"@prefix" => (T.PREFIXTAG (pos (yypos, yytext, arg)));
<FC>"@formatter" => (T.FORMATTERTAG (pos (yypos, yytext, arg)));
<FC>"@params" => (T.FORMATPARAMSTAG (pos (yypos, yytext, arg)));
<FC>"@extern" => (T.FORMATEXTERNTAG (pos (yypos, yytext, arg)));
<FC>"@destination" => (T.DESTINATIONTAG (pos (yypos, yytext, arg)));
<FC>"@header" => (T.HEADERTAG (pos (yypos, yytext, arg)));
<FC>"@format" => (T.FORMATTAG (pos (yypos, yytext, arg)));
<FC>"@format:"{id} => (T.LOCALFORMATTAG (String.extract (yytext, 8, NONE),
yypos, yypos + size yytext - 1));
<FC>"\\n" => (T.NEWLINE (pos (yypos, yytext, arg)));
<FC>"*" => (T.ASTERISK (pos (yypos, yytext, arg)));
<FC>":" => (T.COLON (pos (yypos, yytext, arg)));
<FC>"," => (T.COMMA (pos (yypos, yytext, arg)));
<FC>"..." => (T.DOTDOTDOT (pos (yypos, yytext, arg)));
<FC>"." => (T.DOT (pos (yypos, yytext, arg)));
<FC>"{" => (T.LBRACE (pos (yypos, yytext, arg)));
<FC>"}" => (T.RBRACE (pos (yypos, yytext, arg)));
<FC>"]" => (T.RBRACKET (pos (yypos, yytext, arg)));
<FC>"(" => (T.LPAREN (pos (yypos, yytext, arg)));
<FC>")" => (T.RPAREN (pos (yypos, yytext, arg)));
<FC>"_" => (T.WILD (pos (yypos, yytext, arg)));
<FC>("~")?{int}"[" =>
(case pos (yypos, yytext, arg) of
(l, r) => T.STARTOFINDENT (valOf (Int.fromString yytext), l, r));
<FC>"+" => (case pos (yypos, yytext, arg) of
(l, r) => T.FORMATINDICATOR
({space = true, newline = NONE}, l, r));
<FC>"+"?("d"|{int}) =>
(let
val space = String.sub (yytext, 0) = #"+"
val priorityText =
if space then String.extract (yytext, 1, NONE) else yytext
val priority =
if priorityText = "d"
then FormatTemplate.Deferred
else FormatTemplate.Preferred
(valOf (Int.fromString (priorityText)))
val indicatorArg =
{space = space, newline = SOME{priority = priority}}
val (l, r) = pos (yypos, yytext, arg)
in
T.FORMATINDICATOR (indicatorArg, l, r)
end);
<FC>"!"?[LRN]("~")?{num} =>
(let
val (cut, directionCharPos, numStartPos) =
if #"!" = String.sub (yytext, 0)
then (true, 1, 2)
else (false, 0, 1)
val direction =
case String.sub (yytext, directionCharPos)
of #"L" => FormatTemplate.Left
| #"R" => FormatTemplate.Right
| #"N" => FormatTemplate.Neutral
| _ => raise Fail "BUG: illeagal direction"
val strengthText = String.extract (yytext, numStartPos, NONE)
val strength = valOf (Int.fromString strengthText)
val (l, r) = pos (yypos, yytext, arg)
in
T.ASSOCINDICATOR
({cut = cut, strength = strength, direction = direction}, l, r)
end);
<FC>{id} =>
(case pos (yypos, yytext, arg) of (l, r) => T.ID (yytext, l, r));
<FC>{prefixedlabel} =>
(case pos (yypos, yytext, arg) of
(l, r) => T.PREFIXEDLABEL (yytext, l, r));
<FC>. =>
(case pos (yypos, yytext, arg) of
(l, r) => T.SPECIAL (String.sub (yytext, 0), l, r));
<STR>{eol} => (let val (t, l, r) = closeString (yypos, arg)
in #error arg ("unclosed string", l, r);
YYBEGIN FC;
t
end);
<STR>\" => (YYBEGIN FC; #1 (closeString (yypos, arg)));
<STR>\\a => (addString ("\007", arg); continue());
<STR>\\b => (addString ("\008", arg); continue());
<STR>\\f => (addString ("\012", arg); continue());
<STR>\\n => (addString ("\010", arg); continue());
<STR>\\r => (addString ("\013", arg); continue());
<STR>\\t => (addString ("\009", arg); continue());
<STR>\\v => (addString ("\011", arg); continue());
<STR>\\\\ => (addString ("\\", arg); continue());
<STR>\\\" => (addString ("\"", arg); continue());
<STR>\\\^[@-_] => (addString (str (chr (ord (String.sub (yytext, 2)) - 64)),
arg);
continue ());
<STR>\\\^. => (#error arg
("illegal control escape; must be one of \
\@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_",
yypos,
yypos + size yytext - 1);
continue ());
<STR>\\[0-9]{3} =>
(let
val c = StringCvt.scanString
(Int.scan StringCvt.DEC)
(String.substring (yytext, 1, 3))
in
addString (str (chr (valOf c)), arg)
handle _ => #error arg ("illegal ascii escape",
yypos,
yypos + size yytext - 1);
continue ()
end);
<STR>\\u{xdigit}{4} =>
(let
val x = valOf (StringCvt.scanString
(Word.scan StringCvt.HEX)
(String.substring (yytext, 1, 4)))
fun byte (w, shift, mask, set) =
Word.orb (Word.andb (Word.>> (x, shift), mask), set)
fun str x =
String.str (Char.chr (Word.toInt x))
in
(* UTF-8 encoding *)
if x <= 0wx7f then
(addString (str (byte (x, 0w0, 0wx7f, 0wx00)), arg))
else if x <= 0wx7ff then
(addString (str (byte (x, 0w6, 0wx1f, 0wxc0)), arg);
addString (str (byte (x, 0w0, 0wx3f, 0wx80)), arg))
else
(addString (str (byte (x, 0w12, 0wx0f, 0wxe0)), arg);
addString (str (byte (x, 0w6, 0wx3f, 0wx80)), arg);
addString (str (byte (x, 0w0, 0wx3f, 0wx80)), arg));
continue()
end);
<STR>\\ => (#error arg ("illegal string escape",
#offset arg + yypos, #offset arg + yypos);
continue ());
<STR>[^\000-\031\\\"\r\n]+ => (addString (yytext, arg); continue ());
<STR>. => (#error arg
("illegal non-printing character in string",
#offset arg + yypos, #offset arg + yypos);
continue());
| Lex | 5 | plveir/smlsharp | src/smlformat/generator/main/FormatComment.lex | [
"MIT"
] |
;;; term/shell/config.el -*- lexical-binding: t; -*-
;;;###package shell
(add-hook 'shell-mode-hook #'doom-mark-buffer-as-real-h)
(add-hook 'shell-mode-hook #'hide-mode-line-mode)
| Emacs Lisp | 3 | leezu/doom-emacs | modules/term/shell/config.el | [
"MIT"
] |
within ;
package ModelicaByExample
annotation (uses(Modelica(version="3.2.1")));
end ModelicaByExample;
| Modelica | 3 | JavascriptID/sourcerer-app | src/test/resources/samples/langs/Modelica/package.mo | [
"MIT"
] |
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2014-2014
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP
#define BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP
#ifndef BOOST_CONFIG_HPP
# include <boost/config.hpp>
#endif
#if defined(BOOST_HAS_PRAGMA_ONCE)
# pragma once
#endif
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/intrusive/detail/ebo_functor_holder.hpp>
#include <boost/intrusive/detail/tree_value_compare.hpp>
namespace boost {
namespace intrusive {
namespace detail {
template < class KeyTypeKeyCompare
, class ValueTraits
, class KeyOfValue
>
struct key_nodeptr_comp_types
{
typedef ValueTraits value_traits;
typedef typename value_traits::value_type value_type;
typedef typename value_traits::node_ptr node_ptr;
typedef typename value_traits::const_node_ptr const_node_ptr;
typedef typename detail::if_c
< detail::is_same<KeyOfValue, void>::value
, detail::identity<value_type>
, KeyOfValue
>::type key_of_value;
typedef tree_value_compare
<typename ValueTraits::pointer, KeyTypeKeyCompare, key_of_value> base_t;
};
//This function object transforms a key comparison type to
//a function that can compare nodes or nodes with nodes or keys.
template < class KeyTypeKeyCompare
, class ValueTraits
, class KeyOfValue = void
>
struct key_nodeptr_comp
//Use public inheritance to avoid MSVC bugs with closures
: public key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue>::base_t
{
private:
struct sfinae_type;
public:
typedef key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue> types_t;
typedef typename types_t::value_traits value_traits;
typedef typename types_t::value_type value_type;
typedef typename types_t::node_ptr node_ptr;
typedef typename types_t::const_node_ptr const_node_ptr;
typedef typename types_t::base_t base_t;
typedef typename types_t::key_of_value key_of_value;
template <class P1>
struct is_same_or_nodeptr_convertible
{
static const bool same_type = is_same<P1,const_node_ptr>::value || is_same<P1,node_ptr>::value;
static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
};
BOOST_INTRUSIVE_FORCEINLINE base_t base() const
{ return static_cast<const base_t&>(*this); }
BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
: base_t(kcomp), traits_(traits)
{}
//pred(pnode)
template<class T1>
BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
{ return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); }
//operator() 2 arg
//pred(pnode, pnode)
template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); }
//pred(pnode, key)
template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(*traits_->to_value_ptr(t1), t2); }
//pred(key, pnode)
template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(t1, *traits_->to_value_ptr(t2)); }
//pred(key, key)
template<class T1, class T2>
BOOST_INTRUSIVE_FORCEINLINE bool operator()
(const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
{ return base()(t1, t2); }
const ValueTraits *const traits_;
};
} //namespace detail{
} //namespace intrusive{
} //namespace boost{
#endif //BOOST_INTRUSIVE_DETAIL_KEY_NODEPTR_COMP_HPP
| C++ | 4 | jason-fox/Fast-RTPS | thirdparty/boost/include/boost/intrusive/detail/key_nodeptr_comp.hpp | [
"Apache-2.0"
] |
/*
A2Printer.ino
This is a special example for the A2 Thermo Printer
This example can NOT be used with LCDs and OLEDs
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
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.
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 HOLDER 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.
*/
// use this serial interface
#define PRINTER_SERIAL Serial
// #define PRINTER_SERIAL Serial1
#include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
/* define our own serial function, this will be assigned later */
extern "C" uint8_t u8x8_byte_arduino_serial(u8x8_t *u8g2, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t *data;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
while(PRINTER_SERIAL.available() > 0)
PRINTER_SERIAL.read();
PRINTER_SERIAL.write((uint8_t)*data);
data++;
arg_int--;
}
break;
case U8X8_MSG_BYTE_INIT:
delay(1000);
PRINTER_SERIAL.begin(19200);
/* send something.... */
//PRINTER_SERIAL.begin(9600);
PRINTER_SERIAL.write(27); /* ESC */
PRINTER_SERIAL.write(64); /* @ --> reset printer */
delay(1000);
break;
case U8X8_MSG_BYTE_SET_DC:
break;
case U8X8_MSG_BYTE_START_TRANSFER:
break;
case U8X8_MSG_BYTE_END_TRANSFER:
break;
default:
return 0;
}
return 1;
}
/* define a u8g2 object just with the base class */
/* the baseclass will be configured for the A2 printer in the setup() procedure */
class U8G2 u8g2;
void setup(void) {
u8g2_Setup_a2printer_384x240_1( /* several different a2 printer procs exist... */
u8g2.getU8g2(), /* this is a c call, so use the u8g2 struct instead of the class */
U8G2_R0, /* this defines the usual rotation of the bitmap */
u8x8_byte_arduino_serial, /* this is the new procedure from above */
u8x8_gpio_and_delay_arduino); /* standard arduino low level proc, used only for delay */
u8g2.beginSimple(); /* Do not clear the display, wake is not required */
}
#define XO 10
void drawLogo(void)
{
u8g2.setFontMode(1); // Transparent
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(0+XO, 30, "U");
u8g2.setFontDirection(1);
u8g2.setFont(u8g2_font_inb30_mn);
u8g2.drawStr(21+XO,8,"8");
u8g2.setFontDirection(0);
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(51+XO,30,"g");
u8g2.drawStr(67+XO,30,"\xb2");
u8g2.drawHLine(2+XO, 35, 47);
u8g2.drawHLine(3+XO, 36, 47);
u8g2.drawVLine(45+XO, 32, 12);
u8g2.drawVLine(46+XO, 33, 12);
}
void drawURL(void)
{
u8g2.setFont(u8g2_font_6x12_tr);
u8g2.drawStr(1+XO,54,"github.com/olikraus/u8g2");
}
void loop(void) {
u8g2.firstPage();
do {
drawLogo();
drawURL();
/* worst case heating test */
u8g2.drawRBox(4,90,384-8,20, 8);
/* heating test with some text */
u8g2.setFont(u8g2_font_inb24_mf);
u8g2.drawStr(10,160,"Hello World!");
/* draw a frame around the picture */
u8g2.drawFrame(0,0,384,240);
u8g2.drawFrame(1,1,384-2,240-2);
} while ( u8g2.nextPage() );
delay(1000);
}
| Arduino | 4 | sei-kiu/Grove-Beginner-Kit-for-Arduino-Grove-OLED-Display-0.96-SSD1315- | lib/U8g2_Arduino-2.31.2/examples/page_buffer/A2Printer/A2Printer.ino | [
"MIT"
] |
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "include/cppgc/cross-thread-persistent.h"
#include "include/cppgc/allocation.h"
#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"
#include "src/base/platform/platform.h"
#include "test/unittests/heap/cppgc/tests.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cppgc {
namespace internal {
namespace {
struct GCed final : GarbageCollected<GCed> {
static size_t destructor_call_count;
GCed() { destructor_call_count = 0; }
~GCed() { destructor_call_count++; }
virtual void Trace(cppgc::Visitor*) const {}
int a = 0;
};
size_t GCed::destructor_call_count = 0;
class Runner final : public v8::base::Thread {
public:
template <typename Callback>
explicit Runner(Callback callback)
: Thread(v8::base::Thread::Options("CrossThreadPersistent Thread")),
callback_(callback) {}
void Run() final { callback_(); }
private:
std::function<void()> callback_;
};
} // namespace
class CrossThreadPersistentTest : public testing::TestWithHeap {};
TEST_F(CrossThreadPersistentTest, RetainStronglyOnDifferentThread) {
subtle::CrossThreadPersistent<GCed> holder =
MakeGarbageCollected<GCed>(GetAllocationHandle());
{
Runner runner([obj = std::move(holder)]() {});
EXPECT_FALSE(holder);
EXPECT_EQ(0u, GCed::destructor_call_count);
PreciseGC();
EXPECT_EQ(0u, GCed::destructor_call_count);
runner.StartSynchronously();
runner.Join();
}
EXPECT_EQ(0u, GCed::destructor_call_count);
PreciseGC();
EXPECT_EQ(1u, GCed::destructor_call_count);
}
TEST_F(CrossThreadPersistentTest, RetainWeaklyOnDifferentThread) {
subtle::WeakCrossThreadPersistent<GCed> in =
MakeGarbageCollected<GCed>(GetAllocationHandle());
// Set up |out| with an object that is always retained to ensure that the
// different thread indeed moves back an empty handle.
Persistent<GCed> out_holder =
MakeGarbageCollected<GCed>(GetAllocationHandle());
subtle::WeakCrossThreadPersistent<GCed> out = *out_holder;
{
Persistent<GCed> temporary_holder = *in;
Runner runner([obj = std::move(in), &out]() { out = std::move(obj); });
EXPECT_FALSE(in);
EXPECT_TRUE(out);
EXPECT_EQ(0u, GCed::destructor_call_count);
PreciseGC();
EXPECT_EQ(0u, GCed::destructor_call_count);
temporary_holder.Clear();
PreciseGC();
EXPECT_EQ(1u, GCed::destructor_call_count);
runner.StartSynchronously();
runner.Join();
}
EXPECT_FALSE(out);
}
TEST_F(CrossThreadPersistentTest, DestroyRacingWithGC) {
// Destroy a handle on a different thread while at the same time invoking a
// garbage collection on the original thread.
subtle::CrossThreadPersistent<GCed> holder =
MakeGarbageCollected<GCed>(GetAllocationHandle());
Runner runner([&obj = holder]() { obj.Clear(); });
EXPECT_TRUE(holder);
runner.StartSynchronously();
PreciseGC();
runner.Join();
EXPECT_FALSE(holder);
}
} // namespace internal
} // namespace cppgc
| C++ | 4 | EXHades/v8 | test/unittests/heap/cppgc/cross-thread-persistent-unittest.cc | [
"BSD-3-Clause"
] |
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:include href="include.xsl"/>
<xsl:param name="owner" select="'Nicolas Eliaszewicz'"/>
<xsl:output method="html" encoding="iso-8859-1" indent="no"/>
<xsl:template match="collection">
Hey! Welcome to <xsl:value-of select="$owner"/>'s sweet CD collection!
<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet> | XSLT | 4 | donsbot/hhvm | hphp/test/zend/good/ext/xsl/tests/53965/collection.xsl | [
"PHP-3.01",
"Zend-2.0"
] |
Note 0
Copyright (C) 2017 Jonathan Hough. All rights reserved.
)
NB. Conjugate Gradient method
Note 'References'
[1] Scipy Implementation
https://github.com/scipy/scipy/blob/master/scipy/optimize/optimize.py
[2] Numerical Optimization, Nocedal & Wright
)
require jpath '~Projects/jlearn/optimize/linesearch.ijs'
cocurrent 'jLearnOpt'
dot=: +/ . *
minCGX=: 3 : 0
'funcWrapper x0 maxIter tol beta'=: y
func=. 3 : ' func__funcWrapper y'
fprime=. 3 : 'fprime__funcWrapper y'
minCG ((func f.)`'');((fprime f.) `'');x0;maxIter;tol;beta
)
NB. Finds the minimum of the given function, partial derivative pair,
NB. given the start point, max number of iterations, tolerance, and
NB. optimization method.
NB. example call:
NB. Params: minFRCG_jLearnOpt_ (f f. `'');(fp f.`'');(0.1 0.1 0.1); 1000; 0.001;'fr'
NB.
NB. 0: gerund of the function to minimize
NB. 1: gerund of the partial derivative of the function
NB. 2: initial start point to use
NB. 3: max number of iterations
NB. 4: tolerance
NB. 5: optimization method, either ...
NB. returns: minimization point. That is, the point at a local minimum
NB. of the given function.
minCG=: 3 : 0
'fg fpg x0 maxIter tol beta'=: y
func=. fg `:6
fprime=. fpg `:6
xk=. x0
gfk=. -fprime x0
if. maxIter < 1 do. maxIter=. 1 end.
if. tol < 1e_6 do. tol=. 1e_6 end.
beta=. tolower beta
'Value must either be ''pr'' or ''fr''' assert (<beta) e. 'pr';'fr'
p0=. gfk
pk=. p0
k=. 0
while. tol < +/&.:*:gfk do.
k=. k+1
if.-. k < maxIter do.
smoutput 'Failed search after ',(": maxIter), ' iterations.'
throw.
end.
try.
ak=. lineSearch_jLearnOpt_ fg;fpg;xk;pk;0;1e_4;0.9;50;100
catcht.
smoutput 'Error attempting line search.'
throw.
end.
xkp1=. xk + ak * pk
gfkp1=. fprime xkp1
gfk=. fprime xk
if. beta -: 'fr' do.
bkp1=. (+/ *: gfkp1) % (+/ *: gfk) NB. fletcher-reeves
elseif. beta -: 'pr' do.
bkp1=. ((+/ *: gfkp1) * (gfkp1 - gfk)) % (+/ *: gfk) NB. polak-ribiere
end.
pk=. (-gfkp1) + bkp1 * pk
xk=. xkp1
end.
xk
)
| J | 4 | jonghough/jlearn | optimize/conjugategradient.ijs | [
"MIT"
] |
{% set dict_one = {'a': 'b', 'c': 'd'} %}
{% set result = dict_one | json_encode_dict() %}
{% include 'jinja_filters/common.sls' %}
| SaltStack | 3 | byteskeptical/salt | tests/integration/files/file/base/jinja_filters/data_encode_dict.sls | [
"Apache-2.0"
] |
(defmodule ut.os
(export
(ps-alive? 1)
(ps-pid 1)
(run 2) (run 3)))
(include-lib "logjam/include/logjam.hrl")
(defun default-run-opts ()
'(stdin stdout monitor))
;;;;;::=-----------------=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;::=- API functions -=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;::=-----------------=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun ps-alive? (os-pid)
(ut.util:has-str? (ps-pid os-pid) (integer_to_list os-pid))) ;
;; XXX is this still needed?
(defun ps-pid (pid-str)
(os:cmd (++ "ps -o pid -p" pid-str)))
(defun run (cmd args)
(run cmd args #m()))
(defun run (cmd args opts)
(log-debug "Starting OS process for ~s with args ~p and opts ~p"
(list cmd args opts))
(let* ((executable (join-cmd-args cmd args))
(`#(ok ,pid ,os-pid) (exec:run_link executable (run-opts opts)))
(data `#m(pid ,pid os-pid ,os-pid)))
(if (extract-version? opts)
(mset data 'raw-version (extract-version cmd))
data)))
;;;;;::=---------------------=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;::=- private functions -=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;::=---------------------=::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun join-cmd-args (cmd args)
(clj:-> (list cmd)
(lists:append args)
(string:join " ")))
(defun extract-version? (opts)
(if (not (maps:is_key 'extract-version? opts))
'false
(mref opts 'extract-version?)))
(defun extract-version (cmd)
"Extract the version number from the output, returned as binary."
(clj:-> cmd
(++ " --version")
(os:cmd)
(string:trim)))
(defun run-opts (opts)
(if (maps:is_key 'run-opts opts)
(mref opts 'run-opts)
(default-run-opts)))
| LFE | 4 | ut-proj/undertone | src/ut/os.lfe | [
"Apache-2.0"
] |
#tag Class
Protected Class CalendarWFS
#tag Method, Flags = &h21
Private Sub ChangeWindowStyle(flag as Integer, set as Boolean)
#if TargetWin32
Dim oldFlags as Integer
Dim newFlags as Integer
Dim styleFlags As Integer
Const SWP_NOSIZE = &H1
Const SWP_NOMOVE = &H2
Const SWP_NOZORDER = &H4
Const SWP_FRAMECHANGED = &H20
Const GWL_STYLE = -16
Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" (hwnd As Integer, _
nIndex As Integer) As Integer
Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (hwnd As Integer, _
nIndex As Integer, dwNewLong As Integer) As Integer
Declare Function SetWindowPos Lib "user32" (hwnd as Integer, hWndInstertAfter as Integer, _
x as Integer, y as Integer, cx as Integer, cy as Integer, flags as Integer) as Integer
oldFlags = GetWindowLong( mWnd, GWL_STYLE )
if not set then
newFlags = BitwiseAnd( oldFlags, Bitwise.OnesComplement( flag ) )
else
newFlags = BitwiseOr( oldFlags, flag )
end
styleFlags = SetWindowLong( mWnd, GWL_STYLE, newFlags )
styleFlags = SetWindowPos( mWnd, 0, 0, 0, 0, 0, SWP_NOMOVE +_
SWP_NOSIZE + SWP_NOZORDER + SWP_FRAMECHANGED )
#else
#pragma unused flag
#pragma unused set
#endif
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Function CircleToday() As Boolean
Const MCS_NOTODAYCIRCLE = &h08
return TestWindowStyle( MCS_NOTODAYCIRCLE )
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub CircleToday(assigns set as Boolean)
Const MCS_NOTODAYCIRCLE = &h08
ChangeWindowStyle( MCS_NOTODAYCIRCLE, set )
End Sub
#tag EndMethod
#tag Method, Flags = &h21
Private Function ColorToInt(c as Color) As Integer
dim mb as new MemoryBlock( 4 )
mb.Byte( 0 ) = c.Red
mb.Byte( 1 ) = c.Green
mb.Byte( 2 ) = c.Blue
return mb.Long( 0 )
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub Constructor()
#if TargetWin32
// We need to initialize the common controls library and tell it
// that we are going to be adding calendar controls
Declare Sub InitCommonControlsEx Lib "comctl32" ( ex as Ptr )
dim ex as new MemoryBlock( 8 )
ex.Long( 0 ) = ex.Size
Const ICC_DATE_CLASSES = &h00000100
ex.Long( 4 ) = ICC_DATE_CLASSES
InitCommonControlsEx( ex )
#endif
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Sub Create(onWindow as Window, x as Integer, y as Integer)
#if TargetWin32
Const MONTHCAL_CLASS = "SysMonthCal32"
Soft Declare Function CreateWindowExA Lib "User32" ( ex as Integer, className as CString, _
title as Integer, style as Integer, x as Integer, y as Integer, width as Integer, _
height as Integer, parent as Integer, menu as Integer, hInstance as Integer, _
lParam as Integer ) as Integer
Soft Declare Function CreateWindowExW Lib "User32" ( ex as Integer, className as WString, _
title as Integer, style as Integer, x as Integer, y as Integer, width as Integer, _
height as Integer, parent as Integer, menu as Integer, hInstance as Integer, _
lParam as Integer ) as Integer
Declare Function GetModuleHandleA Lib "Kernel32" ( name as Integer ) as Integer
// First, get the HINSTANCE of this application so we can
// use it to create a window
dim hInstance as Integer
hInstance = GetModuleHandleA( 0 )
Const WS_CHILD = &h40000000
Const WS_BORDER = &h00800000
Const WS_VISIBLE = &h10000000
dim flags as Integer
if System.IsFunctionAvailable( "CreateWindowW", "User32" ) then
mWnd = CreateWindowExW( 0, MONTHCAL_CLASS, 0, _
WS_CHILD + WS_BORDER + WS_VISIBLE + flags, _
0, 0, 0, 0, onWindow.WinHWND, 0, hInstance, 0 )
else
mWnd = CreateWindowExA( 0, MONTHCAL_CLASS, 0, _
WS_CHILD + WS_BORDER + WS_VISIBLE + flags, _
0, 0, 0, 0, onWindow.WinHWND, 0, hInstance, 0 )
end if
// Now we should get the size that is required to
// show the entire calendar
Dim r as new MemoryBlock( 16 )
Dim MCM_GETMINREQRECT as Integer = MCM_FIRST + 9
Call SendMessage( MCM_GETMINREQRECT, 0, MemoryBlockToInteger( r ) )
// Now move the control to the proper place and
// give it the proper size
Declare Sub SetWindowPos Lib "User32" ( hwnd as Integer, after as Integer, _
x as Integer, y as Integer, width as Integer, height as Integer, flags as Integer )
Const SWP_NOZORDER = &h4
SetWindowPos( mWnd, 0, x, y, r.Long( 8 ), r.Long( 12 ), SWP_NOZORDER )
#else
#pragma unused onWindow
#pragma unused x
#pragma unused y
#endif
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Sub Destructor()
#if TargetWin32
Declare Sub DestroyWindow Lib "User32" ( hwnd as Integer )
if mWnd <> 0 then
DestroyWindow( mWnd )
mWnd = 0
end
#endif
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Function DisplayToday() As Boolean
Const MCS_NOTODAY = &h10
return TestWindowStyle( MCS_NOTODAY )
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub DisplayToday(assigns set as Boolean)
Const MCS_NOTODAY = &h10
ChangeWindowStyle( MCS_NOTODAY, set )
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Function GetColor(which as Integer) As Color
Dim MCM_GETCOLOR as Integer = MCM_FIRST + 11
return IntToColor( SendMessage( MCM_GETCOLOR, which, 0 ) )
End Function
#tag EndMethod
#tag Method, Flags = &h21
Private Function IntToColor(i as Integer) As Color
dim mb as new MemoryBlock( 4 )
mb.Long( 0 ) = i
return RGB( mb.Byte( 0 ), mb.Byte( 1 ), mb.Byte( 2 ) )
End Function
#tag EndMethod
#tag Method, Flags = &h21
Private Function MemoryBlockToInteger(mb as MemoryBlock) As Integer
dim ret as new MemoryBlock( 4 )
ret.Ptr( 0 ) = mb
return ret.Long( 0 )
End Function
#tag EndMethod
#tag Method, Flags = &h21
Private Function RBDateToSystemTime(d as Date) As MemoryBlock
dim mb as new MemoryBlock( 16 )
mb.Short( 0 ) = d.Year
mb.Short( 2 ) = d.Month
mb.Short( 6 ) = d.Day
return mb
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function SelectedDate() As Date
#if TargetWin32
Dim MCM_GETCURSEL as Integer = MCM_FIRST + 1
dim mb as new MemoryBlock( 16 )
Call SendMessage( MCM_GETCURSEL, 0, MemoryBlockToInteger( mb ) )
return SystemTimeToRBDate( mb )
#endif
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub SelectedDate(assigns d as Date)
Dim MCM_SETCURSEL as Integer = MCM_FIRST + 2
Call SendMessage( MCM_SETCURSEL, 0, MemoryBlockToInteger( RBDateToSystemTime( d ) ) )
End Sub
#tag EndMethod
#tag Method, Flags = &h21
Private Function SendMessage(msg as Integer, wParam as Integer, lParam as Integer) As Integer
#if TargetWin32
Soft Declare Function SendMessageA Lib "User32" ( wnd as Integer, msg as Integer, _
wParam as Integer, lParam as Integer ) as Integer
Soft Declare Function SendMessageW Lib "User32" ( wnd as Integer, msg as Integer, _
wParam as Integer, lParam as Integer ) as Integer
if System.IsFunctionAvailable( "SendMessageW", "User32" ) then
return SendMessageW( mWnd, msg, wParam, lParam )
else
return SendMessageA( mWnd, msg, wParam, lParam )
end if
#else
#pragma unused msg
#pragma unused wParam
#pragma unused lParam
#endif
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub SetColor(which as Integer, assigns c as Color)
Dim MCM_SETCOLOR as Integer = MCM_FIRST + 10
Call SendMessage( MCM_SETCOLOR, which, ColorToInt( c ) )
End Sub
#tag EndMethod
#tag Method, Flags = &h21
Private Function SystemTimeToRBDate(mb as MemoryBlock) As Date
dim d as new Date
d.Year = mb.Short( 0 )
d.Month = mb.Short( 2 )
d.Day = mb.Short( 6 )
return d
End Function
#tag EndMethod
#tag Method, Flags = &h21
Private Function TestWindowStyle(flag as Integer) As Boolean
#if TargetWin32
Dim oldFlags as Integer
Const GWL_STYLE = -16
Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" (hwnd As Integer, _
nIndex As Integer) As Integer
oldFlags = GetWindowLong( mWnd, GWL_STYLE )
if Bitwise.BitAnd( oldFlags, flag ) = flag then
return true
else
return false
end
#else
#pragma unused flag
#endif
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function Today() As Date
#if TargetWin32
Dim MCM_GETTODAY as Integer = MCM_FIRST + 13
dim mb as new MemoryBlock( 16 )
Call SendMessage( MCM_GETTODAY, 0, MemoryBlockToInteger( mb ) )
return SystemTimeToRBDate( mb )
#endif
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub Today(assigns d as Date)
Dim MCM_SETTODAY as Integer = MCM_FIRST + 12
Call SendMessage( MCM_SETTODAY, 0, MemoryBlockToInteger( RBDateToSystemTime( d ) ) )
End Sub
#tag EndMethod
#tag Property, Flags = &h21
Private mWnd As Integer
#tag EndProperty
#tag Constant, Name = kBackgroundColor, Type = Integer, Dynamic = False, Default = \"0", Scope = Public
#tag EndConstant
#tag Constant, Name = kMonthBackgroundColor, Type = Integer, Dynamic = False, Default = \"4", Scope = Public
#tag EndConstant
#tag Constant, Name = kTextColor, Type = Integer, Dynamic = False, Default = \"1", Scope = Public
#tag EndConstant
#tag Constant, Name = kTitleColor, Type = Integer, Dynamic = False, Default = \"2", Scope = Public
#tag EndConstant
#tag Constant, Name = kTitleTextColor, Type = Integer, Dynamic = False, Default = \"3", Scope = Public
#tag EndConstant
#tag Constant, Name = kTrailingTextColor, Type = Integer, Dynamic = False, Default = \"5", Scope = Public
#tag EndConstant
#tag Constant, Name = MCM_FIRST, Type = Integer, Dynamic = False, Default = \"&h1000", Scope = Private
#tag EndConstant
#tag ViewBehavior
#tag ViewProperty
Name="Index"
Visible=true
Group="ID"
InitialValue="-2147483648"
InheritedFrom="Object"
#tag EndViewProperty
#tag ViewProperty
Name="Left"
Visible=true
Group="Position"
InitialValue="0"
InheritedFrom="Object"
#tag EndViewProperty
#tag ViewProperty
Name="Name"
Visible=true
Group="ID"
InheritedFrom="Object"
#tag EndViewProperty
#tag ViewProperty
Name="Super"
Visible=true
Group="ID"
InheritedFrom="Object"
#tag EndViewProperty
#tag ViewProperty
Name="Top"
Visible=true
Group="Position"
InitialValue="0"
InheritedFrom="Object"
#tag EndViewProperty
#tag EndViewBehavior
End Class
#tag EndClass
| REALbasic | 5 | bskrtich/WFS | Windows Functionality Suite/UI Extras/Classes/CalendarWFS.rbbas | [
"MIT"
] |
package com.baeldung.springsecuredsockets.config;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
public class WebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) throws ServletException {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.register(AppConfig.class);
context.setServletContext(container);
ServletRegistration.Dynamic servlet = container.addServlet("dispatcher", new DispatcherServlet(context));
servlet.setLoadOnStartup(1);
servlet.addMapping("/");
}
} | Java | 4 | DBatOWL/tutorials | spring-security-modules/spring-security-web-sockets/src/main/java/com/baeldung/springsecuredsockets/config/WebAppInitializer.java | [
"MIT"
] |
/* 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.
==============================================================================*/
#include "tensorflow/compiler/xla/client/lib/dynamic_shaped_ops.h"
#include "absl/algorithm/container.h"
#include "absl/types/span.h"
#include "tensorflow/compiler/xla/client/xla_builder.h"
#include "tensorflow/compiler/xla/literal_util.h"
#include "tensorflow/compiler/xla/shape_util.h"
namespace xla {
namespace {
// Given a list of shapes, create a shape whose dimensions are largest among all
// inputs.
//
// e.g.,
// shape_a = f32[10, 50]
// shape_b = f32[100, 10]
//
// result = f32[max(shape_a[0], shape_b[0]), max(shape_a[1], shape_b[1])]
// = f32[100, 50]
Shape FindMaxShape(absl::Span<const Shape*> shapes) {
CHECK(!shapes.empty());
if (shapes[0]->IsTuple()) {
// Recurse into sub-element.
std::vector<Shape> results;
results.reserve(shapes[0]->tuple_shapes_size());
for (int64_t i = 0; i < shapes[0]->tuple_shapes_size(); ++i) {
std::vector<const Shape*> subshapes;
subshapes.reserve(shapes.size());
for (int64_t j = 0; j < shapes.size(); ++j) {
subshapes.push_back(&shapes[j]->tuple_shapes(i));
}
results.push_back(FindMaxShape(absl::MakeSpan(subshapes)));
}
return ShapeUtil::MakeTupleShape(results);
}
Shape result = *shapes[0];
for (const Shape* shape : shapes) {
CHECK(result.rank() == shape->rank());
for (int64_t dim = 0; dim < result.rank(); ++dim) {
if (shape->dimensions(dim) > result.dimensions(dim)) {
result.set_dimensions(dim, shape->dimensions(dim));
}
}
}
return result;
}
XlaOp ReconsileBranchDifference(const Shape& left_branch_shape,
const Shape& right_branch_shape,
XlaOp left_root) {
if (left_branch_shape.IsTuple()) {
// Invariant sanity check -- Left branch and right branch need to have
// compatible shapes.
CHECK(right_branch_shape.IsTuple() &&
left_branch_shape.tuple_shapes_size() ==
right_branch_shape.tuple_shapes_size());
// Recurse into sub-element.
std::vector<XlaOp> results;
results.reserve(left_branch_shape.tuple_shapes_size());
for (int64_t i = 0; i < left_branch_shape.tuple_shapes_size(); ++i) {
XlaOp sub_tuple = GetTupleElement(left_root, i);
XlaOp elem = ReconsileBranchDifference(left_branch_shape.tuple_shapes(i),
right_branch_shape.tuple_shapes(i),
sub_tuple);
results.push_back(elem);
}
return Tuple(left_root.builder(), results);
}
XlaOp result = left_root;
// Invariant sanity check -- Left branch and right branch need to have
// compatible shapes.
CHECK(!right_branch_shape.IsTuple());
CHECK(left_branch_shape.rank() == right_branch_shape.rank());
for (int64_t dim = 0; dim < left_branch_shape.rank(); ++dim) {
XlaOp original_dim = GetDimensionSize(result, dim);
if (left_branch_shape.dimensions(dim) <
right_branch_shape.dimensions(dim)) {
int64_t diff = right_branch_shape.dimensions(dim) -
left_branch_shape.dimensions(dim);
result = PadInDim(
result, Zero(result.builder(), left_branch_shape.element_type()), dim,
0, diff);
}
if (left_branch_shape.dimensions(dim) !=
right_branch_shape.dimensions(dim)) {
result = SetDimensionSize(result, original_dim, dim);
}
}
return result;
}
} // namespace
XlaOp DynamicConditional(XlaBuilder* builder, XlaOp predicate,
XlaOp true_operand,
const XlaComputation& true_computation,
XlaOp false_operand,
const XlaComputation& false_computation) {
return builder->ReportErrorOrReturn([&]() -> StatusOr<XlaOp> {
auto true_shape =
true_computation.GetProgramShape().ConsumeValueOrDie().result();
auto false_shape =
false_computation.GetProgramShape().ConsumeValueOrDie().result();
if (ShapeUtil::Compatible(true_shape, false_shape)) {
return xla::Conditional(predicate, true_operand, true_computation,
false_operand, false_computation);
}
auto reconsile_branch = [](const Shape& root_shape,
const Shape& operand_shape,
const Shape& reference_root_shape,
const XlaComputation& computation) {
xla::XlaBuilder builder("dynamic_builder");
auto param = xla::Parameter(&builder, 0, operand_shape, "param");
auto call = Call(&builder, computation, {param});
ReconsileBranchDifference(root_shape, reference_root_shape, call);
return builder.Build();
};
TF_ASSIGN_OR_RETURN(
auto true_computation_rewritten,
reconsile_branch(true_shape,
builder->GetShape(true_operand).ValueOrDie(),
false_shape, true_computation));
TF_ASSIGN_OR_RETURN(
auto false_computation_rewritten,
reconsile_branch(false_shape,
builder->GetShape(false_operand).ValueOrDie(),
true_shape, false_computation));
return xla::Conditional(predicate, true_operand, true_computation_rewritten,
false_operand, false_computation_rewritten);
});
}
XlaOp DynamicConditional(
XlaBuilder* builder, XlaOp branch_index,
absl::Span<const XlaComputation* const> branch_computations,
absl::Span<const XlaOp> branch_operands) {
return builder->ReportErrorOrReturn([&]() -> StatusOr<XlaOp> {
std::vector<Shape> root_shapes;
root_shapes.reserve(branch_computations.size());
for (int64_t i = 0; i < branch_computations.size(); ++i) {
TF_ASSIGN_OR_RETURN(auto program_shape,
branch_computations[i]->GetProgramShape());
root_shapes.push_back(program_shape.result());
}
TF_RET_CHECK(!root_shapes.empty());
bool all_shapes_compatible =
absl::c_all_of(root_shapes, [&](const Shape& shape) {
return ShapeUtil::Compatible(root_shapes[0], shape);
});
if (all_shapes_compatible) {
// All shapes are compatible, fall back to static case.
return xla::Conditional(branch_index, branch_computations,
branch_operands);
}
std::vector<const Shape*> root_shapes_ptrs;
root_shapes_ptrs.reserve(root_shapes.size());
for (int64_t i = 0; i < root_shapes.size(); ++i) {
root_shapes_ptrs.push_back(&root_shapes[i]);
}
Shape max_shape = FindMaxShape(absl::MakeSpan(root_shapes_ptrs));
auto reconsile_branch = [](const Shape& root_shape,
const Shape& operand_shape,
const Shape& reference_root_shape,
const XlaComputation& computation) {
xla::XlaBuilder builder("dynamic_builder");
auto param = xla::Parameter(&builder, 0, operand_shape, "param");
auto call = Call(&builder, computation, {param});
ReconsileBranchDifference(root_shape, reference_root_shape, call);
return builder.Build();
};
std::vector<XlaComputation> rewritten_computations;
rewritten_computations.reserve(branch_computations.size());
for (int64_t i = 0; i < branch_computations.size(); ++i) {
TF_ASSIGN_OR_RETURN(Shape branch_operand_shape,
builder->GetShape(branch_operands[i]));
TF_ASSIGN_OR_RETURN(auto rewritten,
reconsile_branch(root_shapes[i], branch_operand_shape,
max_shape, *branch_computations[i]));
rewritten_computations.push_back(std::move(rewritten));
}
std::vector<const XlaComputation*> rewritten_computation_ptrs;
rewritten_computation_ptrs.reserve(branch_computations.size());
for (int64_t i = 0; i < branch_computations.size(); ++i) {
rewritten_computation_ptrs.push_back(&rewritten_computations[i]);
}
return xla::Conditional(branch_index, rewritten_computation_ptrs,
branch_operands);
});
}
StatusOr<XlaOp> SetDimensionSizeWithRebound(ValueInference* value_inference,
XlaOp operand, XlaOp dimension_size,
int64_t dimension) {
auto inferred_bound_status_or = value_inference->AnalyzeConstant(
dimension_size, xla::ValueInferenceMode::kUpperBound);
auto dynamism_status_or = value_inference->AnalyzeIsDynamic(dimension_size);
TF_RETURN_IF_ERROR(inferred_bound_status_or.status());
TF_RETURN_IF_ERROR(dynamism_status_or.status());
if (inferred_bound_status_or->AllValid()) {
int64_t inferred_bound = inferred_bound_status_or->Get<int32>({}).value();
TF_ASSIGN_OR_RETURN(auto* shape_ptr,
operand.builder()->GetShapePtr(operand));
// Found a tighter bound, do a slice.
if (shape_ptr->dimensions(dimension) > inferred_bound) {
operand = xla::SliceInDim(operand, 0, inferred_bound, 1, dimension);
}
}
if (dynamism_status_or->Get<bool>({})) {
// dimension size is dynamic, make output dynamic by calling set dimension
// size.
operand = xla::SetDimensionSize(operand, dimension_size, dimension);
}
return operand;
}
StatusOr<XlaOp> SetAllDimensionSizes(ValueInference* value_inference,
XlaOp operand, XlaOp size_vector) {
auto builder = value_inference->builder();
TF_RETURN_IF_ERROR(builder->GetCurrentStatus());
TF_ASSIGN_OR_RETURN(auto shape_ptr, builder->GetShapePtr(operand));
for (int64_t i = 0; i < shape_ptr->rank(); ++i) {
// If a dimension is dynamic, call set-dimension-size on the output.
auto dim_size = xla::Slice(size_vector, {i}, {i + 1}, {1});
dim_size = xla::Reshape(dim_size, {});
dim_size = xla::ConvertElementType(dim_size, xla::S32);
TF_ASSIGN_OR_RETURN(auto dynamism,
value_inference->AnalyzeIsDynamic(dim_size));
if (dynamism.Get<bool>({})) {
operand = xla::SetDimensionSize(operand, dim_size, i);
}
}
return operand;
}
} // namespace xla
| C++ | 5 | vixadd/tensorflow | tensorflow/compiler/xla/client/lib/dynamic_shaped_ops.cc | [
"Apache-2.0"
] |
<?xml version='1.0' encoding='UTF-8'?>
<Project Type="Project" LVVersion="17008000">
<Property Name="NI.LV.All.SourceOnly" Type="Bool">true</Property>
<Property Name="NI.Project.Description" Type="Str"></Property>
<Item Name="My Computer" Type="My Computer">
<Property Name="server.app.propertiesEnabled" Type="Bool">true</Property>
<Property Name="server.control.propertiesEnabled" Type="Bool">true</Property>
<Property Name="server.tcp.enabled" Type="Bool">false</Property>
<Property Name="server.tcp.port" Type="Int">0</Property>
<Property Name="server.tcp.serviceName" Type="Str">My Computer/VI Server</Property>
<Property Name="server.tcp.serviceName.default" Type="Str">My Computer/VI Server</Property>
<Property Name="server.vi.callsEnabled" Type="Bool">true</Property>
<Property Name="server.vi.propertiesEnabled" Type="Bool">true</Property>
<Property Name="specify.custom.address" Type="Bool">false</Property>
<Item Name="Menus" Type="Folder">
<Item Name="functions_ni_lib_Compiled_HTML_Menu_Tool.mnu" Type="Document" URL="../Menus/functions_ni_lib_Compiled_HTML_Menu_Tool.mnu"/>
</Item>
<Item Name="project" Type="Folder">
<Item Name="_Compiled HTML Menu Tool" Type="Folder">
<Item Name="HTML Help Source" Type="Folder">
<Item Name="css" Type="Folder">
<Item Name="expandable_tree.css" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/css/expandable_tree.css"/>
<Item Name="VSsystemexplorer.css" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/css/VSsystemexplorer.css"/>
</Item>
<Item Name="js" Type="Folder">
<Item Name="arraytools.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/arraytools.js"/>
<Item Name="checkinstalled.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/checkinstalled.js"/>
<Item Name="common.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/common.js"/>
<Item Name="cssframes.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/cssframes.js"/>
<Item Name="domtools.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/domtools.js"/>
<Item Name="dynamiccontent.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/dynamiccontent.js"/>
<Item Name="dynamicjumps.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/dynamicjumps.js"/>
<Item Name="dynamiclinks.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/dynamiclinks.js"/>
<Item Name="expandable_tree.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/expandable_tree.js"/>
<Item Name="feedbacklink.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/feedbacklink.js"/>
<Item Name="Globals.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/Globals.js"/>
<Item Name="initpagedyn.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/initpagedyn.js"/>
<Item Name="launchhelp.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/launchhelp.js"/>
<Item Name="linking.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/linking.js"/>
<Item Name="objectnames.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/objectnames.js"/>
<Item Name="osbrowser.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/osbrowser.js"/>
<Item Name="pdf.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/pdf.js"/>
<Item Name="polyviselect.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/polyviselect.js"/>
<Item Name="stylesheets.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/stylesheets.js"/>
<Item Name="variables.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/variables.js"/>
<Item Name="web.js" Type="Document" URL="../project/_Compiled HTML Menu Tool/HTML Help Source/js/web.js"/>
</Item>
</Item>
<Item Name="Wizard" Type="Folder">
<Item Name="Copy Template Files.vi" Type="VI" URL="../project/_Compiled HTML Menu Tool/Wizard/Copy Template Files.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Create HTML Files.vi" Type="VI" URL="../project/_Compiled HTML Menu Tool/Wizard/Create HTML Files.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="New CHM Wizard.vi" Type="VI" URL="../project/_Compiled HTML Menu Tool/Wizard/New CHM Wizard.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Wizard State.ctl" Type="VI" URL="../project/_Compiled HTML Menu Tool/Wizard/Wizard State.ctl">
<Property Name="marked" Type="Int">0</Property>
</Item>
</Item>
<Item Name="Build CHM.vi" Type="VI" URL="../project/_Compiled HTML Menu Tool/Build CHM.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="html_template.htm" Type="Document" URL="../project/_Compiled HTML Menu Tool/html_template.htm"/>
</Item>
<Item Name="Compiled Help Menu Wizard.vi" Type="VI" URL="../project/Compiled Help Menu Wizard.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
</Item>
<Item Name="vi.lib" Type="Folder">
<Item Name="CHM Generator" Type="Folder">
<Item Name="CHM Generator.lvclass" Type="LVClass" URL="../vi.lib/CHM Generator/CHM Generator.lvclass"/>
</Item>
<Item Name="Keyed Value Tree" Type="Folder">
<Item Name="Keyed Value Tree.lvclass" Type="LVClass" URL="../vi.lib/Keyed Value Tree/Keyed Value Tree.lvclass"/>
</Item>
<Item Name="Load CHM Page.vi" Type="VI" URL="../vi.lib/Load CHM Page.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
</Item>
<Item Name="Post-Build Action.vi" Type="VI" URL="../Post-Build Action.vi"/>
<Item Name="Dependencies" Type="Dependencies">
<Item Name="vi.lib" Type="Folder">
<Item Name="8.6CompatibleGlobalVar.vi" Type="VI" URL="/<vilib>/Utility/config.llb/8.6CompatibleGlobalVar.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Check if File or Folder Exists.vi" Type="VI" URL="/<vilib>/Utility/libraryn.llb/Check if File or Folder Exists.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Clear Errors.vi" Type="VI" URL="/<vilib>/Utility/error.llb/Clear Errors.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Compare Two Paths.vi" Type="VI" URL="/<vilib>/Utility/libraryn.llb/Compare Two Paths.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Error Cluster From Error Code.vi" Type="VI" URL="/<vilib>/Utility/error.llb/Error Cluster From Error Code.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Get File Extension.vi" Type="VI" URL="/<vilib>/Utility/libraryn.llb/Get File Extension.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Get System Directory.vi" Type="VI" URL="/<vilib>/Utility/sysdir.llb/Get System Directory.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="List Directory and LLBs.vi" Type="VI" URL="/<vilib>/Utility/libraryn.llb/List Directory and LLBs.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="NI_FileType.lvlib" Type="Library" URL="/<vilib>/Utility/lvfile.llb/NI_FileType.lvlib"/>
<Item Name="NI_LVConfig.lvlib" Type="Library" URL="/<vilib>/Utility/config.llb/NI_LVConfig.lvlib"/>
<Item Name="NI_PackedLibraryUtility.lvlib" Type="Library" URL="/<vilib>/Utility/LVLibp/NI_PackedLibraryUtility.lvlib"/>
<Item Name="Recursive File List.vi" Type="VI" URL="/<vilib>/Utility/libraryn.llb/Recursive File List.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Space Constant.vi" Type="VI" URL="/<vilib>/dlg_ctls.llb/Space Constant.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="System Directory Type.ctl" Type="VI" URL="/<vilib>/Utility/sysdir.llb/System Directory Type.ctl">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="System Exec.vi" Type="VI" URL="/<vilib>/Platform/system.llb/System Exec.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="Trim Whitespace.vi" Type="VI" URL="/<vilib>/Utility/error.llb/Trim Whitespace.vi">
<Property Name="marked" Type="Int">0</Property>
</Item>
<Item Name="whitespace.ctl" Type="VI" URL="/<vilib>/Utility/error.llb/whitespace.ctl">
<Property Name="marked" Type="Int">0</Property>
</Item>
</Item>
<Item Name="Copy Built Files.vi" Type="VI" URL="../../../../shared/Copy Built Files.vi"/>
</Item>
<Item Name="Build Specifications" Type="Build">
<Item Name="Move Source" Type="Source Distribution">
<Property Name="Bld_autoIncrement" Type="Bool">true</Property>
<Property Name="Bld_buildCacheID" Type="Str">{5CA91CF1-7D39-47D0-B5A7-AB3A2ADC64AC}</Property>
<Property Name="Bld_buildSpecName" Type="Str">Move Source</Property>
<Property Name="Bld_excludedDirectory[0]" Type="Path">vi.lib</Property>
<Property Name="Bld_excludedDirectory[0].pathType" Type="Str">relativeToAppDir</Property>
<Property Name="Bld_excludedDirectory[1]" Type="Path">resource/objmgr</Property>
<Property Name="Bld_excludedDirectory[1].pathType" Type="Str">relativeToAppDir</Property>
<Property Name="Bld_excludedDirectory[2]" Type="Path">/C/ProgramData/National Instruments/InstCache/17.0</Property>
<Property Name="Bld_excludedDirectory[3]" Type="Path">/C/Users/nitest/Documents/LabVIEW Data/2017(32-bit)/ExtraVILib</Property>
<Property Name="Bld_excludedDirectory[4]" Type="Path">instr.lib</Property>
<Property Name="Bld_excludedDirectory[4].pathType" Type="Str">relativeToAppDir</Property>
<Property Name="Bld_excludedDirectory[5]" Type="Path">user.lib</Property>
<Property Name="Bld_excludedDirectory[5].pathType" Type="Str">relativeToAppDir</Property>
<Property Name="Bld_excludedDirectoryCount" Type="Int">6</Property>
<Property Name="Bld_excludeDependentDLLs" Type="Bool">true</Property>
<Property Name="Bld_excludeDependentPPLs" Type="Bool">true</Property>
<Property Name="Bld_localDestDir" Type="Path">../Built</Property>
<Property Name="Bld_localDestDirType" Type="Str">relativeToCommon</Property>
<Property Name="Bld_postActionVIID" Type="Ref">/My Computer/Post-Build Action.vi</Property>
<Property Name="Bld_previewCacheID" Type="Str">{C9CD229C-BA96-4A0A-9BAD-03C275F15C94}</Property>
<Property Name="Bld_removeVIObj" Type="Int">1</Property>
<Property Name="Bld_version.build" Type="Int">7</Property>
<Property Name="Bld_version.major" Type="Int">1</Property>
<Property Name="Destination[0].destName" Type="Str">Destination Directory</Property>
<Property Name="Destination[0].path" Type="Path">../Built</Property>
<Property Name="Destination[0].preserveHierarchy" Type="Bool">true</Property>
<Property Name="Destination[1].destName" Type="Str">Support Directory</Property>
<Property Name="Destination[1].path" Type="Path">../Built/data</Property>
<Property Name="Destination[2].destName" Type="Str">API Directory</Property>
<Property Name="Destination[2].path" Type="Path">../Built/vi.lib/NI/Compiled HTML Menu Tool</Property>
<Property Name="Destination[2].preserveHierarchy" Type="Bool">true</Property>
<Property Name="Destination[3].destName" Type="Str">Project Directory</Property>
<Property Name="Destination[3].path" Type="Path">../Built/project</Property>
<Property Name="Destination[3].preserveHierarchy" Type="Bool">true</Property>
<Property Name="Destination[4].destName" Type="Str">Menus Directory</Property>
<Property Name="Destination[4].path" Type="Path">../Built/Menus/Categories/VeriStand Development Tools</Property>
<Property Name="Destination[4].preserveHierarchy" Type="Bool">true</Property>
<Property Name="DestinationCount" Type="Int">5</Property>
<Property Name="Source[0].itemID" Type="Str">{58FAC1B9-93ED-4A0F-B797-22C7C543C20B}</Property>
<Property Name="Source[0].type" Type="Str">Container</Property>
<Property Name="Source[1].destinationIndex" Type="Int">0</Property>
<Property Name="Source[1].itemID" Type="Ref">/My Computer/Post-Build Action.vi</Property>
<Property Name="Source[1].sourceInclusion" Type="Str">Exclude</Property>
<Property Name="Source[1].type" Type="Str">VI</Property>
<Property Name="Source[2].Container.applyDestination" Type="Bool">true</Property>
<Property Name="Source[2].Container.applyInclusion" Type="Bool">true</Property>
<Property Name="Source[2].Container.depDestIndex" Type="Int">0</Property>
<Property Name="Source[2].destinationIndex" Type="Int">4</Property>
<Property Name="Source[2].itemID" Type="Ref">/My Computer/Menus</Property>
<Property Name="Source[2].sourceInclusion" Type="Str">Include</Property>
<Property Name="Source[2].type" Type="Str">Container</Property>
<Property Name="Source[3].Container.applyDestination" Type="Bool">true</Property>
<Property Name="Source[3].Container.applyInclusion" Type="Bool">true</Property>
<Property Name="Source[3].Container.depDestIndex" Type="Int">0</Property>
<Property Name="Source[3].destinationIndex" Type="Int">3</Property>
<Property Name="Source[3].itemID" Type="Ref">/My Computer/project</Property>
<Property Name="Source[3].sourceInclusion" Type="Str">Include</Property>
<Property Name="Source[3].type" Type="Str">Container</Property>
<Property Name="Source[4].Container.applyDestination" Type="Bool">true</Property>
<Property Name="Source[4].Container.applyInclusion" Type="Bool">true</Property>
<Property Name="Source[4].Container.depDestIndex" Type="Int">0</Property>
<Property Name="Source[4].destinationIndex" Type="Int">2</Property>
<Property Name="Source[4].itemID" Type="Ref">/My Computer/vi.lib</Property>
<Property Name="Source[4].sourceInclusion" Type="Str">Include</Property>
<Property Name="Source[4].type" Type="Str">Container</Property>
<Property Name="SourceCount" Type="Int">5</Property>
</Item>
</Item>
</Item>
</Project>
| LabVIEW | 1 | phutanu/niveristand-custom-device-development-tools | html-help-tools/Source/Compiled HTML Menu Tool/Compile HTML Menu Tool.lvproj | [
"MIT"
] |
def show_index_colors [] {
let prefix = "48;5;"
echo 1..256 | each { |idx|
let cr = ($"($idx) % 16" | math eval)
let color = $"(ansi -e $prefix)($idx)m"
let padded_number = ($"($idx)" | str lpad -l 3 -c '0')
if $cr == 0 {
$"($color)($padded_number) (ansi -e 0m)(char newline)"
} {
$"($color)($padded_number) (ansi -e 0m)"
}
} | str collect
}
show_index_colors
| Nu | 4 | x3rAx/nu_scripts | coloring/nu_index_bg.nu | [
"MIT"
] |
#!/bin/sh
th waifu2x.lua -m scale -i images/miku_small.png -o images/miku_small_waifu2x.png
th waifu2x.lua -m noise_scale -noise_level 1 -i images/miku_small_noisy.png -o images/miku_small_noisy_waifu2x.png
th waifu2x.lua -m noise_scale -noise_level 1 -i images/miku_CC_BY-NC_noisy.jpg -o images/miku_CC_BY-NC_noisy_waifu2x.png
th waifu2x.lua -m noise -noise_level 2 -i images/miku_noisy.png -o images/miku_noisy_waifu2x.png
th waifu2x.lua -m noise -noise_level 2 -i images/lena.png -o images/lena_waifu2x_art_noise2.png
th waifu2x.lua -m scale -i images/tone.png -o images/tone_waifu2x.png
th waifu2x.lua -m scale -model_dir models/upconv_7/photo -i images/lena.png -o images/lena_waifu2x_photo.png
th waifu2x.lua -m noise_scale -noise_level 3 -model_dir models/upconv_7/photo -i images/lena.png -o images/lena_waifu2x_photo_noise3.png
th waifu2x.lua -m scale -model_dir models/upconv_7/photo -i images/city.jpg -o images/city_waifu2x_photo.png
| Shell | 3 | Nyanarchy/waifu2x | images/gen.sh | [
"MIT"
] |
#version 3.7;
global_settings {max_trace_level 40 }
#include "colors.inc"
#include "shapes.inc"
#ifdef (cl_x) #declare CamLoc=<cl_x,cl_y,cl_z>; #else #declare CamLoc=<0,0,-4.3>; #end // Camera Location
#ifdef (lk_x) #declare LookAt=<lk_x,lk_y,lk_z>; #else #declare LookAt=<0,0,0>; #end // Look at
#ifdef (cs_x) #declare CamSky=<cs_x, 1, 0>; #else #declare CamSky=<0,1,0>; #end // Camera Sky
#declare CamDir = vnormalize(LookAt - CamLoc);
#declare CamR = vnormalize(vcross(CamSky,CamDir));
#declare CamUp = vnormalize(vcross(CamDir,CamR));
#ifdef (cam_a) #declare CamA = cam_a; #else #declare CamA = 1; #end // Aspect ratio
#ifdef (cam_z) #declare CamZ = cam_z; #else #declare CamZ = 1.5; #end // Zoom
#ifdef (bg_sc) #declare BgSc = bg_sc; #else #declare BgSc = 3; #end // Background scale
#ifndef (IOR) #declare IOR = 1.5; #end // Index of refraction
#ifndef (Trans) #declare Trans = 1; #end // Transmit
#ifndef (Dim) #declare Dim = 1; #end // Ambient intensity
camera {
location CamLoc
direction CamDir * CamZ
right CamR * CamA
up CamUp
}
#macro OrientZ(p1,p2,cs)
#local nz = vnormalize(p2-p1);
#local nx = vnormalize(vcross(cs,nz));
#local ny = vcross(nz,nx);
matrix <nx.x, nx.y, nx.z,
ny.x, ny.y, ny.z,
nz.x, nz.y, nz.z,
p1.x, p1.y, p1.z>
#end
#ifdef (Calib) // Render objects with graycode patterns
#declare pigmentStructure = pigment {
#if (clock <= 2)
#if (clock = 1) #declare mask = 1; #end color White
#else
image_map { png concat(${ImageName}, str(clock-2,1,0), ".png") map_type 0 interpolate 2 }
#end
}
#else
#declare pigmentImage = pigment {
#ifdef (mask)
color White
#else
#ifdef (rho) color White #else image_map { jpeg ${ImageName} map_type 0 interpolate 2 } #end
#end
}
#end
box { <0,0,0> <1,1,0.01>
#ifdef (Calib)
pigment { pigmentStructure }
finish { ambient 1 }
#else
pigment { pigmentImage }
finish { ambient Dim }
#end
translate <-0.5,-0.5,0>
scale <CamA, 1, 1>
translate <0, 0, CamZ>
scale BgSc
OrientZ(CamLoc,LookAt,CamSky)
}
#ifndef (Empty)
object {
shape
#ifdef (mask)
pigment {color Black}
#else
texture {
pigment{
color filter 1
#ifdef (Calib) transmit 1 #else transmit Trans #end
}
}
interior {
ior IOR
#ifndef (Calib)
#ifdef (FadeD) fade_distance FadeD fade_power FadeP #end
#end
}
#end
#ifdef (SC) scale SC #end
#ifdef (RotZ) rotate z*RotZ #end
#ifdef (RotY) rotate y*RotY #end
#ifdef (TX) translate x*TX #end
#ifdef (TY) translate y*TY #end
#ifdef (TZ) translate z*TZ #end
}
#end
| POV-Ray SDL | 4 | guanyingc/TOM-Net_Rendering | data/template.pov | [
"MIT"
] |
@import "ui-variables";
@tooltipBorderColor: rgba(54, 56, 57, 0.9);
@tooltipBackground: -webkit-gradient(linear, left top, left bottom, from(rgba(99, 102, 103, 0.9)), to(rgba(82, 85, 86, 0.9)));
.scroll-tooltip {
background: @tooltipBackground;
color: white;
box-shadow: 0 2px 7px rgba(0, 0, 0, 0.25);
padding: @padding-base-vertical @padding-base-horizontal @padding-base-vertical @padding-base-horizontal;
border: 1px solid @tooltipBorderColor;
border-radius: @border-radius-base;
transform: translate(-15px, 0);
position: relative;
white-space:nowrap;
pointer-events: none;
}
.scroll-tooltip:after, .scroll-tooltip:before {
left: 100%;
top: 50%;
border: solid transparent;
content: " ";
height: 0;
width: 0;
position: absolute;
pointer-events: none;
}
.scroll-tooltip:after {
border-color: transparent;
border-left-color: lighten(rgba(99, 102, 103, 1), 3%);
border-width: 8px;
margin-top: -8px;
}
.scroll-tooltip:before {
border-color: transparent;
border-left-color: darken(@tooltipBorderColor, 20%);
border-width: 9px;
margin-top: -9px;
}
.scroll-region {
::-webkit-scrollbar {
display: none;
}
position:relative;
.scroll-region-content {
position: absolute;
height: 100%;
width: 100%;
overflow-y: scroll;
overflow-x: hidden;
z-index: 1; // Important so that content does not repaint with container
}
.scroll-region-content-inner {
transform:translate3d(0,0,0);
}
}
.scroll-region.scrolling {
.scroll-region-content-inner {
pointer-events: none;
}
}
.scrollbar-track {
position: relative;
opacity: 0;
transition: opacity 0.3s;
transition-delay: 0.5s;
padding:3px;
width:17px;
background: @list-bg;
border-left: 1px solid @border-color-divider;
&:hover {
opacity: 1;
transition-delay: 0s;
}
&.scrolling {
opacity: 1;
transition-delay: 0s;
}
&.with-ticks {
opacity: 1;
transition-delay: 0s;
}
&.dragging {
opacity: 1;
.scrollbar-handle {
cursor: default;
background-color: lighten(@gray, 30%);
border:1px solid lighten(@gray, 20%);
.tooltip {
opacity: 1;
display:block;
}
}
}
/* Used to read the track height with padding applied. */
.scrollbar-track-inner {
height:100%;
}
.scrollbar-handle {
background-color: lighten(@gray, 40%);
border:1px solid lighten(@gray, 30%);
border-radius:8px;
.tooltip {
opacity: 0;
display:none;
transition: opacity 0.3s;
top: 50%;
transform: translate(-100%, -50%);
position: absolute;
pointer-events: none;
}
}
.scrollbar-ticks {
position: absolute;
top: 0;
left: 0;
right: 0;
bottom: 0;
z-index: 2;
.t {
&.match {
background: @text-color-search-current-match;
z-index: 2;
}
position: absolute;
width: 90%;
left: 5%;
height: 2px;
background: @text-color-search-match;
box-shadow: 0 0.5px 0.5px rgba(0,0,0,0.25);
}
}
}
body.platform-win32 {
.scroll-tooltip {
border-radius: 0;
}
.scrollbar-track {
.scrollbar-handle {
border-radius: 0;
}
}
}
| Less | 3 | cnheider/nylas-mail | packages/client-app/static/components/scroll-region.less | [
"MIT"
] |
<?Lassoscript
if(!(lasso_tagexists('xs_isError')));
define_tag('isError',
-namespace='xs_',
-priority='replace');
// ----------------------------------------------------
if((Error_CurrentError(-ErrorCode)));
$gv_error += (Error_CurrentError) + '<br />';
else((File_CurrentError(-ErrorCode)));
$gv_error += (File_CurrentError) + '<br />';
/if;
// ----------------------------------------------------
/define_tag;
/if;
?> | Lasso | 1 | subethaedit/SubEthaEd | Documentation/ModeDevelopment/Reference Files/LassoScript-HTML/itpage/LassoStartup/xs_isError.lasso | [
"MIT"
] |
CREATE TABLE `tb_aidhgjhqzp` (
`col_wtsgpcyuec` time(6) DEFAULT NULL,
`col_ouqqfnoijf` tinyint(142) unsigned DEFAULT '1',
`col_jsjfylwbsu` time(3) NOT NULL,
`col_wcosqedhbh` tinytext,
`col_cvzuqkfnnp` tinytext CHARACTER SET latin1,
`col_dpnzvoemce` smallint(146) unsigned zerofill DEFAULT NULL,
`col_wisgyhivgt` enum('enum_or_set_0','enum_or_set_1','enum_or_set_2') DEFAULT 'enum_or_set_0'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
| SQL | 3 | yuanweikang2020/canal | parse/src/test/resources/ddl/alter/mysql_39.sql | [
"Apache-2.0"
] |
label ccc4022:
#modewin
if _in_replay:
jump MIKISCENE001
call gl(0,"bgcc0003b")
call vsp(0,1)
call vsp(1,0)
with Pixellate(300.0*2/1000.0,5)
太一 "「いってぇぇぇ……」"
play bgm "bgm/bgm021.ogg"
"疼痛に叩き起こされた。"
太一 "「はっ、ここはマイシークレットルーム？（俺の秘密の部屋？）」"
"あ、服も制服じゃなくなってる。"
"怪我も手当てされてる。しかもいい仕事で。"
"曜子ちゃん……死んだんだよな。"
call gl(1,"TCYM0000c|TCYM0000")
call gp(1,t=center)#x=180
call vsp(1,1)
with dissolve
voice "vfCCC4022mki000"
美希 "「あ、おはようございます」"
"美希が入ってきた。"
太一 "「キミはミッチー！？」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki001"
美希 "「ミッチーです。だいぶ強引ですが」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki002"
美希 "「この家、なにも食べ物ないんですね。近所から米とみそを盗んでしまいました」"
太一 "「あー、睦美さんなかなか料理する暇ないからね」"
"必要な分だけ買ってきて作るのだ。"
call gl(1,"TCYM0002c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki003"
美希 "「痛みます？」"
太一 "「痛いよー」"
"泣いた。"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki004"
美希 "「あー、よしよし。はい、生理薬です」"
太一 "「いらんわい！」"
"投げ捨てた。"
call gl(1,"TCYM0002c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki005"
美希 "「いや、鎮痛効果あるので……これ」"
太一 "「あ、そーなんだ、ごめん」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki006"
美希 "「料理作りました」"
太一 "「……この星形の巨大こんぺいとうのような物体は？」"
"いびつすぎて、滅茶苦茶美しいものに仕上がってる。"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki007"
美希 "「握り飯です」"
太一 "「才能なさすぎて天才の域に入ってるね」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki008"
美希 "「え……？」"
太一 "「どう握ったらこんな形になるんだ」"
voice "vfCCC4022mki009"
美希 "「ふつーに」"
太一 "「神秘的な握り飯だな」"
"食ってみる。"
太一 "「うわ、うまい」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki010"
美希 "「具はいくら」"
太一 "「……ほう」"
"塩味が強い。"
"血の足りない体に、染み渡る。"
"たちまち三つともたいらげた。"
"みそ汁は一気のみ。"
太一 "「……ふうぅ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki011"
美希 "「お粗末様です」"
太一 "「傷は痛むが、Ｈは可だ、美希」"
voice "vfCCC4022mki012"
美希 "「少しは疑問に思ってくださいよ」"
太一 "「……じゃあ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki013"
美希 "「じゃあなのか……」"
太一 "「どうして俺のこと生かしてるの？」"
call gl(1,"TCYM0021c|TCYM0021")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki014"
美希 "「……んー、なんとか暴走がおさまっていたっぽいのと……あと」"
voice "vfCCC4022mki015"
美希 "「全部知った先輩と、話をしたかったから……かな」"
太一 "「あのさ、気絶させられる前に……」"
call gl(1,"TCYM0004c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki016"
美希 "「わわーわー！ あれナシ！」"
"手をばたばた振る。"
voice "vfCCC4022mki017"
美希 "「あの時は殺す気だったんですますから！」"
太一 "「……もう聞いちゃったしなぁ」"
call gl(1,"TCYM0041c|TCYM0041")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki018"
美希 "「う、ううう～」"
"顔が赤い。"
太一 "「羞恥の感情はあるようだ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki019"
美希 "「そりゃ、喜怒哀楽はありますよ」"
voice "vfCCC4022mki020"
美希 "「他人に対して無関心なだけです、ぷい」"
"自分でぷいと言って、美希はそっぽを向いた。"
太一 "「遊び相手にされてるだけだと思ってた」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki021"
美希 "「……それもあるですさ」"
"あるんかい。"
太一 "「なあ……もしかしてこの世界って、生きてるの今二人だけか？」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki022"
美希 "「さくらばせんぱい……」"
太一 "「あいつ野たれ死ぬだろ。たぶん。もう死んでるかもしれん。転んで荷物に頭打って……とかで」"
voice "vfCCC4022mki023"
美希 "「……ありそう」"
太一 "「少なくなったなぁ」"
voice "vfCCC4022mki024"
美希 "「来週になれば、また全員復活です」"
太一 "「俺も祠にいれば、今の自分を保てるわけ？」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki025"
美希 "「はい、そーですよ。今の自分で生きますか？」"
太一 "「うーん」"
太一 "「今週の記憶は、ちとつらいものがあるなぁ」"
太一 "「……なんつうか、みんな死んでるのに平気って部分でさ」"
美希 "「…………」"
太一 "「心がな、泣かないのよ」"
太一 "「……それは、忘れてもいいかなって思うよ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki027"
美希 "「そうですね」"
太一 "「もし世界が繰り返しなら……幾度となく暴走して、人を傷つけるかもしれないだろ？」"
太一 "「友達や家族や仲間や好きな相手をさ」"
太一 "「何度も何度も殺して……その記憶を持ったまま生きるって……」"
太一 "「きっと、心が壊れる」"
太一 "「もう壊れてるけど、もっと壊れる」"
太一 "「心が死ぬね」"
"そこまで言って、美希に示唆していることに気づく。"
太一 "「あ、ごめん……」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki028"
美希 "「いーえー」"
voice "vfCCC4022mki029"
美希 "「実際、そんなことになってます」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki030"
美希 "「ひどいときなんか、暴走した先輩から逃げるために、みんなを犠牲にしたこともありましたよ」"
太一 "「あー、それはすまなんだ。俺の不徳のいたすところだ」"
太一 "「まあ自分が可愛いのは正常だろ。いいんじゃないか？」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki031"
美希 "「……でも」"
太一 "「そりゃ自己犠牲もいいけど、そんな美しいものにばかりなってられん」"
太一 "「美しさを強要する世界だったんだよな」"
太一 "「俺はさ、世界に受け入れてもらうために、一生懸命フレンドリーでいようとしたけど……何年も頑張って、なにも変われないでいるんだ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki032"
美希 "「……そうですかぁ」"
太一 "「なんかな、そういうのを好きになってくれるヤツもいるってのは、ありがたいことだよな」"
call gl(1,"TCYM0002c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki033"
美希 "「…………ぁぅ」"
太一 "「遊紗ちゃん、おぼえてるだろ？」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki034"
美希 "「はい」"
太一 "「どうしてあの娘、いなくなったと思う？」"
"整った造作が、わずかに位置を変えて、見事に疑問を表現した。"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki035"
美希 "「先輩にひどいことされた？」"
太一 "「当たり」"
太一 "「結局、俺は彼女に着飾った表面だけを見せてたからさ」"
太一 "「……ショックだったんだろうね」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki036"
美希 "「七度」"
太一 "「え？」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki037"
美希 "「わたしいつも霧ちんを利用してるんですけど、本人にそれがばれた回数です」"
太一 "「……けっこう多いね」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki038"
美希 "「ヘマ多いんで」"
太一 "「そういや、月曜のキックの鋭かったこと」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki039"
美希 "「えはは」"
太一 "「ずっと一人でサバイバルしてれば、体の使い方もうまくなるやなー」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki040"
美希 "「自分の才能に酔いしれますよ」"
太一 "「……で、霧ちんはどうだった？」"
call gl(1,"TCYM0003c|TCYM0003")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki041"
美希 "「いやあ」"
"にへーと笑う。"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki042"
美希 "「もう最初は呆然自失で。あとは……」"
"翳る。"
call gl(1,"TCYM0002c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki043"
美希 "「……まー、相応の対応を受けました」"
太一 "「つらい？」"
voice "vfCCC4022mki044"
美希 "「……つらい……ような気がします」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki045"
美希 "「どうでもいいって気持ちもありますが」"
voice "vfCCC4022mki046"
美希 "「でも習慣づくんですよね。今までペアだったんだから、ずっとペアでもいいじゃん、みたいな」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki047"
美希 "「……気持ちも」"
太一 "「俺も似たようなものだなあ」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki048"
美希 "「いやー、生きるって……」"
太一 "「難しいね……」"
call gl(1,"TCYM0002c|TCYM0002")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki049"
美希 "「はぃ……」"
"ダブルしんみり。"
太一 "「で、どうする？ これから？」"
call gl(1,"TCYM0000c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki050"
美希 "「ああ、そうですねぇ」"
voice "vfCCC4022mki051"
美希 "「どっちにしろ、明日の昼には祠にいたいですから」"
太一 "「俺はその世界のリセットっての、体験してみるわ」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki052"
美希 "「はい、じゃあわたしは……」"
"しばらくためらってから、美希は身を寄せてきた。"
"回避した。"
hide pic1
with dissolve
voice "vfCCC4022mki053"
美希 "「がふっ」"
"寝台に突っ伏す美希。"
call gl(1,"TCYM0041c|TCYM0041")
call gp(1,t=center)
call vsp(1,1)
with dissolve
voice "vfCCC4022mki054"
美希 "「あー……あんたな」"
太一 "「すまん、つい」"
voice "vfCCC4022mki055"
美希 "「ダイナシだ……」"
call gl(1,"TCYM0001c|TCYM0000")
call vsp(1,1)
with dissolve
voice "vfCCC4022mki056"
美希 "「帰ります。先輩はそこの金庫にあるわたしの想像を絶するレベルのＨな本でひとりえっちでもしててください」"
"知ってる！"
"いやそれよりも。"
太一 "「待て待て」"
"手首をつかんで。"
hide pic1
with dissolve
"引き寄せる。"
voice "vfCCC4022mki057"
美希 "「うっ？」"
jump N_MIKISCENE001
label MIKISCENE001:
play bgm "bgm/bgm021.ogg"
label N_MIKISCENE001:
call gl(0,"evcc0019")
call vsp(0,1)
with ImageDissolve("sys/EFMSK_22_MSK.bmp",time=1)
"すぐ腕の中。"
太一 "「すまん、つい力が入った」"
voice "vfCCC4022mki058"
美希 "「……全然ろまんちっくじゃない……」"
太一 "「ワイルドが売りだ」"
voice "vfCCC4022mki059"
美希 "「わいるどでもない……うそつき、広告にいつわりあり」"
太一 "「そう言うな」"
voice "vfCCC4022mki060"
美希 "「……はー、もういいです、ロマンスは」"
太一 "「そんなもんだ、世の中」"
"美希は一つ大人になった。"
太一 "「暗いけど平気？」"
voice "vfCCC4022mki061"
美希 "「……暗い方がいいに決まってる……」"
"俺にはたいして関係ないんだけど。"
"衣服をはだける。"
voice "vfCCC4022mki062"
美希 "「は、はやいし手際いいしで……泣きそうなんですけど」"
太一 "「女の子を脱がせる技術に、怠りない」"
voice "vfCCC4022mki063"
美希 "「最悪だ……」"
voice "vfCCC4022mki064"
美希 "「脱がせる前に……」"
太一 "「ん」"
"唇。"
"触れあわせる。"
"つかず離れず、こすりつけた。"
voice "vfCCC4022mki065"
美希 "「ん……ん……」"
"軽いリップトーク。"
"舌を入れて、歯茎をあたりをぞろっと舐めた。"
voice "vfCCC4022mki066"
美希 "「ふやぁっ？？？」"
"口元を手で押さえて、目を白黒させている。"
"あとちょっと泣いてた。"
太一 "「そういうものだ」"
voice "vfCCC4022mki067"
美希 "「そうなんですか……」"
太一 "「抵抗をやめて、口をあけたまえ」"
"二度目。押しつける。"
voice "vfCCC4022mki068"
美希 "「んむ……あ……んっ、んん……ふぁふぁ……んんん…………っふぅ」"
voice "vfCCC4022mki069"
美希 "「あ……服脱がされてる……」"
"美希が口元にこぼした唾液を、さっと舐めとってから。"
"首筋に。"
voice "vfCCC4022mki070"
美希 "「うひっ……ひゃあぁぁ」"
"上半身をきゅっと縮め、美希はこそばゆげな声を発した。"
"腕をかいくぐって、胸にも触れる。"
voice "vfCCC4022mki071"
美希 "「あ……」"
"驚いたようだが、抵抗はない。"
"首筋を唇と鼻で愛撫しながら、胸にタッチしていく。"
"俺の知っている美希より、少し膨らんだ胸。"
voice "vfCCC4022mki072"
美希 "「ひゃ……ん、んん、くすぐっ、たい……」"
voice "vfCCC4022mki073"
美希 "「ん、んー、んん……ぁ……」"
"可愛い。"
"キスマークつけたれ。"
voice "vfCCC4022mki074"
美希 "「あっ、いたぁい……」"
"どうせ二人しかいないんだし（桜庭除）。"
"胸を包み込むように揉む。"
"……というほど容積はないのだが、マッサージするように暖める。"
voice "vfCCC4022mki075"
美希 "「ん……」"
太一 "「くすぐったい？」"
voice "vfCCC4022mki076"
美希 "「……そんなに……」"
太一 "「すぐ慣れるよ」"
voice "vfCCC4022mki077"
美希 "「ん、んんっ……あん……」"
"鎖骨を甘噛しつつ、清らかな美希の上体に、マークをつけていく。"
"美希は少し慣れてきたのか、強ばりが抜けていく。"
"俺の動きの邪魔にならないよう、従順に。"
voice "vfCCC4022mki078"
美希 "「ひう……あんっ、あ……きゃ……ん…………んんん……せんぱい……」"
太一 "「抱きついてていいから」"
"そう言うと、腕が背中のあたりをきゅっと掴んできた。"
太一 "「俺も美希に抱きつくんだ」"
voice "vfCCC4022mki079"
美希 "「きゃ……んんんんんっ」"
"またキスマーク。"
"跡を残すことが、興奮を呼ぶ。"
"征服欲だろうか。"
"それもまた、人との繋がりを意味している。"
太一 "「どう？」"
voice "vfCCC4022mki080"
美希 "「……きもちいい……せんぱいのさわりかた……」"
voice "vfCCC4022mki081"
美希 "「くび、すごくきもちいいみたいです……わたし……」"
太一 "「じゃもっとキスするよ」"
"首と鎖骨の間にある溝が、男にはない涼しげなラインを持っている。"
"舌を伸ばして、その美しい匙に乗せた。"
voice "vfCCC4022mki082"
美希 "「ううっ、んっ、きゃんっ……んっ、はぁ、はんっ……」"
"指を下方に。"
"贅肉のない腹筋をなぞって、へそをくすぐる。"
voice "vfCCC4022mki083"
美希 "「ああああ……ああ……だめ、せんぱい……おへそ入れちゃだめぇ……」"
"入れると思っているのだろうか。"
"笑いを噛み殺して、さらに下に持って行く。"
voice "vfCCC4022mki084"
美希 "「あ…………」"
"強ばる。"
太一 "「大丈夫」"
"そう囁くと、耳に舌を入れる。"
voice "vfCCC4022mki085"
美希 "「んんっ！ ん……や、だめ、なめないで、そんなこと……ん……あっ」"
"指が茂みを通過する。"
"ん、茂み。"
"引き返して、その感触を楽しむ。"
voice "vfCCC4022mki086"
美希 "「た、ただのえっちな毛です……ああ……あんっ」"
太一 "「ここの毛までえっちなんだ？」"
"少し意地悪に言う。"
voice "vfCCC4022mki087"
美希 "「……いじわる～……」"
太一 "「ははは」"
"しばらく、そのさらっとした毛を指先に巻きつけて遊ぶ。"
"耳をくわえる。"
voice "vfCCC4022mki088"
美希 "「きゃっ？ や……や……」"
"ぞわっと首筋に鳥肌が立った。"
"あー、耳か。"
"噛む。"
"コリコリとした感触。"
voice "vfCCC4022mki089"
美希 "「うううっ、ううううう～～～～～っ」"
"さーっと額に汗が浮かぶ。"
"感じすぎるみたいだ。"
"軽いキスをして、また胸元に戻る。"
voice "vfCCC4022mki090"
美希 "「ふぁ、はぁはぁ……せんぱい……たいち……せんぱい……」"
"ぎゅっと。"
"背中の手が、衣服をつかむ。"
"……背中を引っかかれそうだった。"
"指をストン、と脚の付け根に落とす。"
voice "vfCCC4022mki091"
美希 "「……ぁ……」"
"人差し指の腹が、ぴったりとその切れ目を覆った。"
"中心線が、じっとりと熱い。"
"そして。"
太一 "「濡れてる」"
voice "vfCCC4022mki092"
美希 "「……濡れてます」"
"さする。"
voice "vfCCC4022mki093"
美希 "「うっ、うううう……あうっ……あんっ……はぁぁぁ、入る、入り……そうです……」"
太一 "「うん、入るね」"
"指先が絡みだす。"
"開いた粘膜と、体液とで、まぜこぜになっていく。"
"蜘蛛の脚を連想して蠢かせる。"
call gl(0,"evcc0019a")
call vsp(0,1)
with Dissolve(500.0/1000.0)
voice "vfCCC4022mki094"
美希 "「ひゃうっ！」"
"美希の膝頭が、跳ね上がってこつんと脇腹を叩く。"
voice "vfCCC4022mki095"
美希 "「だめ、ひらいたら、垂れそう……垂れちゃうっ」"
太一 "「いいんだって」"
"音を立てて顎を吸った。"
voice "vfCCC4022mki096"
美希 "「やん……だめです……ぜんぶ、きもちいい……から……」"
"美希の性器と、俺の指が癒着していく。"
"るつぼをかき回す五本の棒きれ。"
"とけて、どろどろになってしまう。"
voice "vfCCC4022mki097"
美希 "「はっ、はっ、、あ、んん……んっ、は、入って……きてるぅ……くんっ」"
"暴れる脚。"
"さらに指を使う。"
"性器の唾液が塊になって転がり出た。"
"それはてのひらにたまって、指の股からシーツに垂れた。"
voice "vfCCC4022mki098"
美希 "「ああぁぁぁ……」"
"羞恥のため息をつく。"
太一 "「エッチなおもらし」"
voice "vfCCC4022mki099"
美希 "「……う……」"
"潤んだ瞳が俺を射抜く。"
"ありとあらゆる許容がそこにあった。"
voice "vfCCC4022mki100"
美希 "「うん、おもらし……しました……」"
voice "vfCCC4022mki101"
美希 "「先輩も、ここで……おもらしするんですよね？」"
太一 "「……」"
"なんというか。"
"キスをした。"
voice "vfCCC4022mki102"
美希 "「んっ、んんんんっ、んふっ……んっ、れっ……あつぃ……せんぱい、あつい……んるっ……んんん、んーんんん……」"
"深々としたキス。"
"美希とまざりたくなってくる。"
"粘膜だけでは物足りないと思える。"
"指が美希の内部をかきまわす。"
"細かな襞。"
"指の腹で縦方向にこする。"
voice "vfCCC4022mki103"
美希 "「んんんんんんんんんんんっ！？」"
"腰が跳ねる。"
"指を接着させたまま。"
voice "vfCCC4022mki104"
美希 "「んっ、んむ、んんん、ちゅ、ちゅ、んんんんっ」"
"美希が舌を吸ってきた。"
"任せてみる。"
"舌で飴玉を舐め転がすみたいに、大切に扱ってくる。"
voice "vfCCC4022mki105"
美希 "「ん、んゅ……んっ、んんっ、はっ、はふ……ん……」"
"静かに腰が落ちていく。"
"小さな臀部が、しんなりとシーツに落ちた。"
voice "vfCCC4022mki106"
美希 "「ふぁ……つめたい……？」"
太一 "「美希のだよ」"
"優しく教えてやる。結果的には意地悪だ。"
"美希の顔は、全身の血液をかき集めたような色になった。"
voice "vfCCC4022mki107"
美希 "「もう……ぼろぼろ」"
太一 "「きれいだよ」"
voice "vfCCC4022mki108"
美希 "「……だいすきです」"
太一 "「ん」"
"中指で膣内をなぞっていく。"
"丁寧に丁寧に。"
"美希自身の体液を塗布するように。"
voice "vfCCC4022mki109"
美希 "「うっ、う……ふぁっ、ああ、んっ、くんっ……」"
"ぴくぴくと腰が跳ねる。"
"花弁が喘ぐように、ひくついていた。"
"垂れた愛液は、後ろの穴まで濡らしてしまう。"
"指を入れているだけで気持ちいい。"
"……腰が疼くほどの劣情が、俺自身を固めた。"
"指を使って、リング状の入口をこねる。"
voice "vfCCC4022mki110"
美希 "「うわ……なんか、なんか……だめ、だめっ、なんかぁ、だめっ！ せんぱいっ、危ない、そこ危ない、ふあぁぁぁんっ！」"
"おかしなことを言っている。"
"指を素早く震わせた。"
"ざらざらの入口近くを往復した。"
"美希の四肢が持ち上がる。"
"折った脚と後頭部を端に置き、背筋が弧を描く。"
voice "vfCCC4022mki111"
美希 "「あっ、だめ、あっ、ああっ、んっ、はんっ……あーっ、あーっ」"
"それでも指をちくちくと動かす。"
voice "vfCCC4022mki112"
美希 "「……………………」"
"三秒ほど美希は言葉も呼吸も失った。"
"そして。"
voice "vfCCC4022mki113"
美希 "「ああっ、あっ、あっ、あっ、ああぁっ、んっ、あっ、あああぁあぁぁぁぁっ―――っ！」"
"指がきゅっと絞られた。"
"収縮している。"
"包み込んで、ゆるめる。その繰り返し。"
voice "vfCCC4022mki114"
美希 "「はー……はっ、はー……あ…………んっ……」"
"ゆっくりとさすってみる。"
voice "vfCCC4022mki115"
美希 "「ひっ、うあっ、だめぇぇ……」"
"本気で逃げようとする。"
"指を抜いた。"
"荒い呼吸で精一杯の唇を、軽く吸う。"
voice "vfCCC4022mki116"
美希 "「う……はふ……はうん……」"
"ほとんど無意識に、美希はあてがわれた唇を求めた。"
"顔を離すと、失意の吐息。"
"ほとんどぐったりとした美希。"
call gl(0,"bgcc0000d")
call vsp(0,1)
with Dissolve(500.0/1000.0)
"うつぶせにして、衣服を脱がせた。"
"美希の尻が当たっていた場所に、山形の染みができていた。"
"臀部の窪みをつたいのぼった愛液と、汗。"
"興奮しないわけがない。"
voice "vfCCC4022mki117"
美希 "「はー、はー、はー……」"
"ゆっくりと呼吸を落とし、眠りに就こうとしている美希。"
"その背後から、そっと覆い被さる。"
"腕をまわして、腰をくいと浮かせた。"
voice "vfCCC4022mki118"
美希 "「……はぁ……はん……せん、ぱい？」"
"自分が伏せていることに気づく。"
太一 "「いるよ」"
voice "vfCCC4022mki119"
美希 "「ん～」"
"すぐ背後から囁くと、美希は甘く鳴いた。"
"長い愛撫で開き気味の部分に、潜り込んでいった。"
call gl(0,"evcc0020")
call vsp(0,1)
with Dissolve(500.0/1000.0)
voice "vfCCC4022mki120"
美希 "「……んんんっ……うー、ううううーっ」"
"抵抗感に呻く。"
"けれど潤いが助けた。"
"スーっと自然な感じで、奥に触れた。"
"途中、かすかなとっかかりが、美希の純潔だったのだろう。"
voice "vfCCC4022mki121"
美希 "「あ、あああ、あ……」"
"びっくりしている。"
"ぽっかりと開いた口。"
"震える声が漏る。"
"腰を前後に滑らせる。"
"まとわりつく内壁。"
"隙間なく、締めてくる。"
"その狭い道を確かめる。"
voice "vfCCC4022mki122"
美希 "「あう、あっ、ううっ……おお、きいっ」"
"狭いからか。"
"美希にとっては、よりきつく感じるに違いない。"
"腰をことさらゆるりと奥に押し込む。"
"先端はしこりのある部分に触れていた。"
太一 "「……ぴったりだ。美希と俺の」"
voice "vfCCC4022mki123"
美希 "「いやぁ……恥ずかしい……」"
"竿が濡れる。"
"内部が分泌物を増した。"
"角度が良かったのか、ほとんど一直線に繋がっている気がする。"
"くわえられた根本まで、暖かく、きつい。"
"動く。"
"最初はゆっくり。"
"次第にはやく。"
"連結棒の動きで。"
voice "vfCCC4022mki124"
美希 "「あ……ああ、んっ、あっ、あっ、あっあっあっあっ……っ！」"
"小突くたびの、可愛らしいスタッカート。"
"細切りの悲鳴が、甲高くトーンアップしていく。"
voice "vfCCC4022mki125"
美希 "「ふぁ、あっ、あっあっあっ、あぁぁ、んっ、ひゃんっ……ん～っ！！」"
"すぐに唾液をこぼした。"
"快活な美希がほつれると、甘露な少女の性が、浮き彫りにされた。"
voice "vfCCC4022mki126"
美希 "「あぁぁ、あおぉっ、あ、くっ、あんっ、あぁんっ！」"
"一回り小振りな尻が、骨盤を受け止める。"
"打擲しているような倒錯さえある。"
"しなやかな背中が、動きにあわせて揺らぐ。"
"肩胛骨が限界まで張って、沈む。"
"美希が片腕を突っ張ると、そのタイミングも左右で異なる。"
"美しい。"
"触れてみる。"
"濡れていた。"
"粒子を思わせれる小粒の汗だった。"
"指先は尾てい骨まで滑り落ちた。"
voice "vfCCC4022mki127"
美希 "「きゃうっっっっっっっ！！」"
"大きな反応。"
"膣が強く反応した。"
"締まる。締まる。締まる。"
"三度にわけて、圧力がかかった。"
voice "vfCCC4022mki128"
美希 "「わぅっ、うぁぁぁぁ……」"
"潤いすぎた部分から、果汁が雫になって滴った。"
"ぽたぽたという音が、耳に届くほど。"
"大量に『おもらし』をしたようだ。"
太一 "「美希……」"
"うぬぼれそうになる。"
"嫌われていたら、こんな反応はされない。"
"こんな汚い俺でも。"
"美希は好いてくれているのかもしれない。"
"その好きの意味は、おそらく世間一般とは微妙に違う。"
"けれど。"
"俺でも得られる、かけがえのないものだ。"
"激情が弾けた。"
"もっと繋がりたい。もっと！"
voice "vfCCC4022mki129"
美希 "「ふうっ、はっ、はんっ、あんっ、あっ、あっ、はんっ、はぁんっ！ んっく……ひ、ぅんっ、んっ……うわぁ、せんぱぁい！」"
"美希がシーツを握り込む。"
"俺が美希に、肉の楔を打ち込むのと同じ理由で。"
"腰を宛う。"
"文字を描く。"
voice "vfCCC4022mki130"
美希 "「……あおっ！？」"
"軽いビブラートのかかった喘ぎ声。"
"同時に、美希は片脚を一直線にした。引きつった。"
"まっすぐに伸ばし、なお直線を求めるほどに。"
"文字を描き続ける。"
"前後の動きもまじえて。"
voice "vfCCC4022mki131"
美希 "「うっ、ううう、あ゛、あいっ、んんんん、んんんんんん～～～～～～～っっっ！！」"
"小さな尻がぶるぶる震えた。"
"後部の窄まりまで、動転して伸縮している。"
"クラウチングスタートを低くした体勢で、美希は呻く。"
"俺が入ると、腰の重みで美希は折れる。"
"が、筆先が膣内に文を綴ると、たちまち尻を上向きにして身をくの字に持ち上げた。"
voice "vfCCC4022mki132"
美希 "「はっ、はんっ、せんぱい、だめ、危ない、あぶ……あああ、あっ、あおっ、おっ……お゛っ」"
"肺腑を絞って、声を放りだす。"
"そんな潰れた声も、俺には甘美なものだ。"
"ますます聞きたくなる。"
"力強く律動する。"
voice "vfCCC4022mki133"
美希 "「おっ、あっ、おぉぉっ……き、ひぃぃ……うぐっ、ぐっ、ん゛っ……んんんんんっ！」"
"美希は枕を噛んだ。"
"下品な声を押し殺す。"
"顎の下に手をまわし、そっと持ち上げた。"
voice "vfCCC4022mki134"
美希 "「ふぁ？」"
"枕から外す。"
太一 "「声、出して」"
voice "vfCCC4022mki135"
美希 "「でも……ひくっ」"
"官能のしゃっくりに合わせて、下肢がきゅっと一度だけ締まる。"
太一 "「声、聞きたいから」"
"美希の頭部に鼻を埋めた。"
"柔軟な髪質をかきわけて、頭皮を舐めた。"
voice "vfCCC4022mki136"
美希 "「は、はずかしい声が……」"
太一 "「だめ？」"
voice "vfCCC4022mki137"
美希 "「……はい」"
"観念して目を閉じる。"
"美希は自ら、腰を背後に突き出す。"
"俺も身をよじるようにして、噛み合わせた。"
"完全に密着した下半身を、互いの汗がぴたりと吸着させる。"
太一 "「動くよ？」"
voice "vfCCC4022mki138"
美希 "「……あ……あ、あ……」"
"一度一度、角度の違う往来。"
"それだけで美希のうなじが総毛立つ。"
"こんなに感じるものだろうか。"
"美希もまた……俺と同じ渇望を持っているのかも知れない。"
"繋がりたいから。"
voice "vfCCC4022mki139"
美希 "「ふぁっ、はんっ、あっ、あっ、あぁぁ……はんっ、んぁっ！」"
voice "vfCCC4022mki140"
美希 "「いや、だめ、あぶない、い゛っ……だめ、だめっ、もうだめ、もうだめぇっ！」"
"まだだ。"
"まだ完全に一つになってない。"
voice "vfCCC4022mki141"
美希 "「あうっ、あ、あっあっあっ、あああ～～～～～っ、あーーー、んっ、んんんんっ、あぅああぁぁぁ～～～～～ッッッ！」"
"性の奏法はレガートへと移った。"
"ひとつづきになった美希の声。"
"途中のかすかな空白で、美希は大きく息を吸う。"
"もっと。もっと―――"
voice "vfCCC4022mki142"
美希 "「うぅぅ、あー、あああぁぁぁ……あはぁっ、はん、はっ……だめぇぇ、深すぎて……だめぇぇぇぇ」"
"スタミナが失われて、美希の声は呻くようなものになっていく。"
"だが感度が落ちない。"
voice "vfCCC4022mki143"
美希 "「ひうっ！？」"
"規則正しい動きにときおり腰文字をまぜると、全身で跳躍しようとする。"
voice "vfCCC4022mki144"
美希 "「あ、あ、あ……だっ……」"
"不意に全身が痙攣した。"
voice "vfCCC4022mki145"
美希 "「あ……………………～～～～～～～～～～ッッッ！！」"
"今でと違うのは、背中の躍動でわかった。"
"一歩遅れて、猛烈な痙攣が内部にも起こった。"
太一 "「う……」"
"秒間に幾度も波打つ、細かな収縮。"
"膣壁の縦横に入り乱れて、全体を搾ってくる。"
"美希の支配さえ脱して、暴れる。"
voice "vfCCC4022mki146"
美希 "「あくっ……ひぁ……あっ……はっ、はっ……」"
"主である美希は、感覚の爆発を受け入れるしかなかった。"
"やがて。"
"自らの体重を思い出して、美希は崩れかかる。"
"下腹に手を入れて支えた。"
"腹筋が一定間隔で、ひくひくとわなないていた。"
"動く。"
voice "vfCCC4022mki147"
美希 "「ひ……い、いま動かれたら…………死にそうです……」"
"どうすることもできない。"
"動きはじきに激しさを増す。"
voice "vfCCC4022mki148"
美希 "「ああぁぁぁ……」"
"絶望の吐息。"
"興奮はしている。"
"けれど、終わりが見えない。"
"傷口の痛みが、俺を微妙に抑制していた。"
"体を揺するごとに全身を駆ける矢傷の悲鳴。"
"でも。"
"美希の内部に出さないことには、終われない。"
"壁に擦りつけていく。"
voice "vfCCC4022mki149"
美希 "「だ、だめぇ、そこっ……あっあっあっああっ……あぅあ……だめ！ はやすぎるのだめっ」"
"そんなことを言われたら。"
voice "vfCCC4022mki150"
美希 "「あうっ、あっ、うっ、うあっ……痺れっ……て……アアァァァッ」"
"声のリズムも崩れている。"
voice "vfCCC4022mki151"
美希 "「先輩、せんぱっ、はー、はぁぁ、あうっ、あぁあぁぁぁぁ」"
"顔が見えないのが不安なのか。"
voice "vfCCC4022mki152"
美希 "「せんぱい、せんぱ、たいち先輩……」"
"頭髪に鼻先を入れてやる。"
"すぐ背後にいると教えてやる。"
"美希のふんわりとした香りと、性器をがんじがらめにする感触が、渾然となって脳を痺れさせる。"
"細かな襞に覆われた内部を、最大のストロークで出入りする。"
voice "vfCCC4022mki153"
美希 "「わ、わかんない……も、わかんないっ……あぁ……だめ、だめだめ、せんぱい、だめっ」"
"呟くような声。"
"もうぐったりとしたいのに、刺激があってできない。"
"そんな感じ。"
"俺はますます興奮して、深い挿入を続ける。"
"根本まで入れる時、包みながら全体をこする細かなヒダ。"
"溶けそうだ。"
"なくなって、美希の子宮に流れ込んでしまう。"
"そんな錯覚。"
voice "vfCCC4022mki154"
美希 "「すごぃ、すごいよぉぉぉ……おかしくなっちゃう……」"
"俺もうおかしくなってる。"
"唐突に、性器のふもとが疼く。"
"快楽が苦痛を上回りだした。"
太一 "「あ……いけるかも」"
voice "vfCCC4022mki155"
美希 "「……いって、くださ、い……」"
"苦しげに言う。"
太一 "「美希もいこ？」"
voice "vfCCC4022mki156"
美希 "「うぅぅ、むり、むりです……」"
太一 "「だめ、美希もいくの」"
"左右に振る。"
voice "vfCCC4022mki157"
美希 "「ひっ……そ、その動きだめぇ……息できなくなっちゃう……」"
太一 "「こう？」"
voice "vfCCC4022mki158"
美希 "「あーだめえぇ！」"
"二人の結合部がよじれて、連結が外れる。"
太一 "「あ……美希……」"
"抜けたとたん、ぺたりと突っ伏す。"
"可哀相だけど。"
"腰を上げて、再び挿れた。"
voice "vfCCC4022mki159"
美希 "「ううう……」"
"耳が赤い。"
"汗も全身から。"
"体力が違うから、どうしても美希に負担がかかる。"
"腰で押しつぶす。"
voice "vfCCC4022mki160"
美希 "「あ……うう……」"
"熱くぬかるんだそこを、貪る。"
voice "vfCCC4022mki161"
美希 "「あ……も、いく……」"
太一 "「え、いくの？」"
voice "vfCCC4022mki162"
美希 "「いっ……くぅ……」"
"ぐーんと尻が反る。"
"下から俺の腰を持ち上げた。"
"根本から締められた。"
"快楽が増すが、まだ達することはできない。"
voice "vfCCC4022mki163"
美希 "「はーっ、はーっ……」"
"息が荒い。"
"動く。"
voice "vfCCC4022mki164"
美希 "「あー、はぁ……はっ……せんぱっ……ううう！」"
"美希の活力を搾り取っていく。"
voice "vfCCC4022mki165"
美希 "「あ、だめ、だめ、いく、い―――」"
"痙攣。"
"ただ震えるだけの活力しかなくなった。"
"四肢を暴れさせなければ、官能は体内を荒れ狂って、美希はますます追い立てられる。"
voice "vfCCC4022mki166"
美希 "「あっ、また、またいく……」"
"何度目だろう。"
"美希はもう止まらなくなっていた。"
voice "vfCCC4022mki167"
美希 "「あう……」"
"また言葉もなく達する。"
"俺の官能も、少しずつ満ちつつある。"
"じき吐き出せそうだった。"
voice "vfCCC4022mki168"
美希 "「だ、だめです、あ……」"
"巾着が締められる。"
"その圧力さえも利用して、動く。"
voice "vfCCC4022mki169"
美希 "「ううううう」"
"美希にはつらい仕打ち。"
"けれど。"
"こうせずにはいられない。"
voice "vfCCC4022mki170"
美希 "「……だめ……しぬ……しにそう……ッッッ！」"
"不規則な収縮が、何十回目かの刺激を加えてきた。"
"ああ―――"
"俺の終わりは来た。"
"力強く揺すって、最後は奥に筒先を当てた。"
"出す。"
call gl(5,"bgcc0000e")
call gl(0,"evcc0020a")
call vsp(5,1)
with dissolve
call vsp(0,1)
call vsp(5,0)
with Dissolve(500.0/1000.0)
voice "vfCCC4022mki171"
美希 "「はぁぁぁ……ぁ……ぅ……」"
"美希の膣が、それを嚥下する。"
"ひくつく壁が、喉の動きにも似て。"
"俺を誘う。"
voice "vfCCC4022mki172"
美希 "「はっ、はっ、はっ……はぅっ……はわっ……うぅぅ……」"
"繋がったまま、二人で横たわった。"
voice "vfCCC4022mki173"
美希 "「は、はっ、はっ……はぁ」"
"言葉をかわすゆとりはない。"
"美希はこのまま眠りそうだった。"
太一 "「……美希」"
"抱きしめて、唇の触れるすべての部分にキスをした。"
"そして俺も、そのまま目を閉じた。"
stop bgm
call gl(0,"bgcc0000d")
call vsp(0,1)
with Dissolve(500.0/1000.0)
pause (1000.0/1000.0)
pause (1000.0/1000.0)
return
# | Ren'Py | 3 | fossabot/cross-channel_chinese-localization_project | AllPlatforms/scripts/ccc/ccc4022.rpy | [
"Apache-2.0"
] |
'reach 0.1';
export const main = Reach.App(() => {
init();
// Not used for this example
});
| RenderScript | 2 | AwolDes/reach-lang | examples/transfer-from-zero/index.rsh | [
"Apache-2.0"
] |
# Copyright 2017 gRPC 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.
cdef void _store_c_metadata(
metadata, grpc_metadata **c_metadata, size_t *c_count) except *
cdef void _release_c_metadata(grpc_metadata *c_metadata, int count) except *
cdef tuple _metadatum(grpc_slice key_slice, grpc_slice value_slice)
cdef tuple _metadata(grpc_metadata_array *c_metadata_array)
| Cython | 4 | samotarnik/grpc | src/python/grpcio/grpc/_cython/_cygrpc/metadata.pxd.pxi | [
"Apache-2.0"
] |
import { AppPage } from './app.po';
describe('forms-overvoew App', () => {
let page: AppPage;
beforeEach(() => {
page = new AppPage();
});
it('should display a title', async () => {
await page.navigateTo();
expect(await page.getTitleText()).toEqual('Forms Overview');
});
});
| TypeScript | 4 | John-Cassidy/angular | aio/content/examples/forms-overview/e2e/src/app.e2e-spec.ts | [
"MIT"
] |
MACCHINA(1)
# NAME
macchina - A system information frontend, with an (unhealthy) emphasis on
performance.
# SYNOPSIS
*macchina* [FLAGS]
# FLAGS
*-d, --doctor*
Checks the system for failures.
*-e, --export-config*
Prints a template configuration file to stdout.
*-c, --config*=_FILE_
Specify a custom path to a configuration file.
This is helpful in cases where macchina fails to parse the configuration
file from the default path, i.e. *$XDG_CONFIG_HOME/macchina/macchina.toml*.
*-t, --theme*=_THEME_
Specify the name of the theme to use.
You should verify whether macchina was able to find your
theme with *--list-themes*.
*-l, --list-themes*
Lists all available themes.
Themes are *TOML* files which must be placed in *$XDG_CONFIG_HOME/macchina/themes*.
Whatever this flag returns to the console can be used with the *--theme* flag.
*-i, --interface*=_IF_NAME_
Specify the network interface for the LocalIP readout, e.g. "wlan0", "eth0".
*-s, --current-shell*
Toggles between the current shell, i.e. the parent of the terminal emulator, or the default one.
*-C, --logical-cores*
Toggles between logical and physical cores for the Processor readout.
*-K, --long-kernel*
Lengthens kernel output.
*-S, --long-shell*
Lengthens shell output.
*-U, --long-uptime*
Lengthens uptime output.
*-h, --help*
Prints help information.
*-v, --version*
Prints version information.
*-o, --show*
Display only the specified readouts.
Possible values are (case-sensitive):
- Host
- Machine
- Kernel
- Distribution
- OperatingSystem
- DesktopEnvironment
- WindowManager
- Packages
- Shell
- Terminal
- LocalIP
- Backlight
- Resolution
- Uptime
- Processor
- ProcessorLoad
- Memory
- Battery
*--ascii-artists*
Lists the original artists of the ASCII art used by macchina.
# SEE ALSO
macchina(7)
# AUTHORS
Written and maintained by the Macchina-CLI team:
- Aziz Ben Ali <ba.tahaaziz@gmail.com>
- Uttarayan Mondal <email@uttarayan.me>
- Marvin Haschker <marvin@haschker.me>
# RESOURCES
This project is hosted at *https://github.com/Macchina-CLI/macchina*.
| SuperCollider | 4 | Macchina-CLI/macchina | doc/macchina.1.scd | [
"MIT"
] |
$(header)
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
LIBRARY work;
USE work.muon_types.ALL;
PACKAGE $(particle)_setup IS
$(eta_4)
$(phi_l_4)
$(phi_h_4)
$(eta_3)
$(phi_l_3)
$(phi_h_3)
$(eta_2_s)
$(phi_l_2_s)
$(phi_h_2_s)
$(eta_2_wsc)
$(phi_l_2_wsc)
$(phi_h_2_wsc)
$(delta_eta)
$(delta_phi)
$(eta_1_s)
$(phi_l_1_s)
$(phi_h_1_s)
END $(particle)_setup;
| VHDL | 2 | ckamtsikis/cmssw | L1TriggerConfig/L1GtConfigProducers/data/VhdlTemplates/Templates/muon_setup.vhd | [
"Apache-2.0"
] |
scriptname SKI_QuestBase extends Quest hidden
; -------------------------------------------------------------------------------------------------
; Version Tracking
;
; Quest implements
; GetVersion, to return the static version number
; OnVersionUpdate to handle the updating
; Update process is triggered by calling CheckVersion()
int property CurrentVersion auto hidden
function CheckVersion()
int version = GetVersion()
if (CurrentVersion < version)
OnVersionUpdateBase(version)
OnVersionUpdate(version)
CurrentVersion = version
endIf
endFunction
int function GetVersion()
return 1
endFunction
event OnVersionUpdateBase(int a_version)
endEvent
event OnVersionUpdate(int a_version)
endEvent
; -------------------------------------------------------------------------------------------------
; Reload Events
;
; Helper to add reload event to quest script.
; 1. Create quest
; 2. Add player alias to quest
; 3. Attach SKI_PlayerLoadGameAlias to player alias
event OnGameReload()
endEvent | Papyrus | 4 | pragasette/skyui | dist/Data/Scripts/Source/SKI_QuestBase.psc | [
"Unlicense",
"MIT"
] |
// run-rustfix
// See https://github.com/rust-lang/rust/issues/87955
#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
#[derive(Debug)]
struct Foo(i32);
impl Drop for Foo {
fn drop(&mut self) {
println!("{:?} dropped", self.0);
}
}
fn main() {
let a = (Foo(0), Foo(1));
let _ = || dbg!(a.0);
//~^ ERROR: drop order
//~| NOTE: will only capture `a.0`
//~| NOTE: for more information, see
//~| HELP: add a dummy let to cause `a` to be fully captured
}
//~^ NOTE: dropped here
| Rust | 4 | ohno418/rust | src/test/ui/closures/2229_closure_analysis/migrations/macro.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
/* @generated */
digraph cfg {
"kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_1" [label="1: Start __infer_globals_initializer_zero_init::X::kMaxKeys\nFormals: \nLocals: \n " color=yellow style=filled]
"kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_1" -> "kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_3" ;
"kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_2" [label="2: Exit __infer_globals_initializer_zero_init::X::kMaxKeys \n " color=yellow style=filled]
"kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_3" [label="3: DeclStmt \n VARIABLE_DECLARED(#GB<codetoanalyze/cpp/frontend/initialization/zero_init.cpp|const|ice>$zero_init::X::kMaxKeys:unsigned int const ); [line 13, column 3]\n *&#GB<codetoanalyze/cpp/frontend/initialization/zero_init.cpp|const|ice>$zero_init::X::kMaxKeys:unsigned int const =(unsigned int const )(1 << 16) [line 13, column 3]\n " shape="box"]
"kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_3" -> "kMaxKeys#X#__infer_globals_initializer_zero_init.cd983beeff3879de64cad137bc5d5f8c_2" ;
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_1" [label="1: Start zero_init::X::X\nFormals: this:zero_init::X*\nLocals: \n " color=yellow style=filled]
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_1" -> "X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_3" ;
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_2" [label="2: Exit zero_init::X::X \n " color=yellow style=filled]
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_3" [label="3: Constructor Init \n n$1=*&this:zero_init::X* [line 15, column 19]\n " shape="box"]
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_3" -> "X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_4" ;
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_4" [label="4: Constructor Init \n n$2=_fun___infer_zero_initialization(n$1.keys_:void*[65536*8]) [line 15, column 25]\n " shape="box"]
"X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_4" -> "X#X#zero_init#{1033941805165496697}.3e028b90ab5a1fd0dcfcba16724dcbde_2" ;
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_1" [label="1: Start zero_init::Y::Y\nFormals: this:zero_init::Y*\nLocals: \n " color=yellow style=filled]
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_1" -> "Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_3" ;
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_2" [label="2: Exit zero_init::Y::Y \n " color=yellow style=filled]
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_3" [label="3: Constructor Init \n n$1=*&this:zero_init::Y* [line 22, column 19]\n " shape="box"]
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_3" -> "Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_4" ;
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_4" [label="4: Constructor Init \n *n$1.keys_[0]:void*=null [line 22, column 25]\n *n$1.keys_[1]:void*=null [line 22, column 25]\n *n$1.keys_[2]:void*=null [line 22, column 25]\n " shape="box"]
"Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_4" -> "Y#Y#zero_init#{13622159389561709274}.656a0f0a779ff30f458eb0e0e36e2f3e_2" ;
}
| Graphviz (DOT) | 2 | livinlife6751/infer | infer/tests/codetoanalyze/cpp/frontend/initialization/zero_init.cpp.dot | [
"MIT"
] |
<!DOCTYPE html>
sdsd | Latte | 0 | arusinha/incubator-netbeans | php/php.latte/test/unit/data/testfiles/lexer/top/testIssue214777.latte | [
"Apache-2.0"
] |
redo-always
echo a | redo-stamp
echo a > $3
| Stata | 0 | BlameJohnny/redo | t/s60-stamp/a.do | [
"Apache-2.0"
] |
import m from 'path'
export = m
| TypeScript | 1 | hanneslund/next.js | packages/next/shared/lib/isomorphic/path.d.ts | [
"MIT"
] |
// run
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import "fmt"
func f(x uint64) uint64 {
s := "\x04"
c := s[0]
return x - x<<c<<4
}
func g(x uint32) uint32 {
s := "\x04"
c := s[0]
return x - x<<c<<4
}
func main() {
if want, got := uint64(0xffffffffffffff01), f(1); want != got {
panic(fmt.Sprintf("want %x got %x", want, got))
}
if want, got := uint32(0xffffff01), g(1); want != got {
panic(fmt.Sprintf("want %x got %x", want, got))
}
}
| Go | 3 | SSSDNSY/go | test/fixedbugs/issue48473.go | [
"BSD-3-Clause"
] |
{
{-# LANGUAGE LambdaCase #-}
module RuleDescription where
import Alice.Margatroid
import Marisa.Kirisame
}
%wrapper "bytestring"
$yasaka_kanako = [a-z]
$moriya_suwako = [A-Z]
tokens :-
<state> {
"kochiya sanae" { simple "Jusei no kokosei" }
$yasaka_kanako { simple "Central Goddess" }
$moriya_suwako { simple "Local Goddess" }
}
@reiuji { simple ReiujiUtsuho }
{
Jojo! This is the last of my hamon!
Take it from meeeeee!
}
| Logos | 3 | safarmer/intellij-haskell | src/test/testData/parsing/RuleDescription.x | [
"Apache-2.0"
] |
public void dispatch(org.apache.skywalking.oap.server.core.source.ISource source) {
${sourcePackage}${source} _source = (${sourcePackage}${source})source;
<#list metrics as metrics>
do${metrics.metricsName}(_source);
</#list>
}
| FreeMarker | 3 | sergicastro/skywalking | oap-server/oal-rt/src/main/resources/code-templates/dispatcher/dispatch.ftl | [
"Apache-2.0",
"BSD-3-Clause"
] |
!https://github.com/tinkerpop/gremlin/raw/master/doc/images/gremlin-kilt.png!
"MapReduce":http://en.wikipedia.org/wiki/MapReduce is a data processing pattern that groups objects under a key (the map and shuffle) and then applies some function to those groupings (the reduce). Gremlin supports this pattern with the @groupBy@ step. We will demonstrate its use over the provided "Grateful Dead song/artist graph":https://github.com/tinkerpop/gremlin/wiki/Defining-a-More-Complex-Property-Graph.
```text
gremlin> g = new TinkerGraph()
==>tinkergraph[vertices:0 edges:0]
gremlin> g.loadGraphML('data/graph-example-2.xml')
==>null
```
The @groupBy@ step can take 2 or 3 function parameters. These functions are:
# *key function*: for the incoming object, generate a key to group it by.
# *value function*: before storing the object under the key, process it to yield the value to be stored.
# *reduce function*: when the stream is empty, apply this function to all the values stored at each key.
h2. Map and Shuffle in Gremlin
The traversal below will group all the song vertices by whether they are an original or cover song. *NOTE*: the @hasNot('song_type',null)@ is a filter that ensures only song vertices are analyzed. A more efficient expression would be to use an index as opposed to a linear scan and filter.
```text
gremlin> g.V.hasNot('song_type',null).groupBy{it.song_type}{it}.cap.next()
==>cover=[v[332], v[330], v[331], v[336], v[337], v[334], v[335], v[531], v[747], v[746], v[535], v[740], v[538], v[744], v[742], v[3], ...]
==>original=[v[349], v[341], v[343], v[346], v[348], v[4], v[9], v[327], v[390], v[393], v[392], v[395], v[396], v[397], v[398], v[399], ...]
```
It is possible to provide a "richer" value function so that the grouped songs are represented by their name as opposed to their vertex.
```text
gremlin> g.V.hasNot('song_type',null).groupBy{it.song_type}{it.name}.cap.next()
==>cover=[HIDEAWAY, TANGLED UP IN BLUE, SHELTER FROM THE STORM, GOODNIGHT IRENE, CHINESE BONES, NEIGHBORHOOD GIRLS, FOREVER YOUNG, ...]
==>original=[BLACK MUDDY RIVER, ALICE D MILLIONAIRE, ALLIGATOR, AT A SIDING, BARBED WIRE WHIPPING PARTY, BERTHA, HERE COMES SUNSHINE, ...]
```
h2. Map, Shuffle, and Reduce in Gremlin
The reduce function is applied to all the values generated for a key. A simple example is provided which simply counts the number of songs per song type. Before showing a full reduce, see the intermediate results of the map and shuffle.
```text
gremlin> g.V.hasNot('song_type',null).groupBy{it.song_type}{1}.cap.next()
==>cover=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
==>original=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```
Now, a reduce function is added where the 1s are counted.
```text
gremlin> g.V.hasNot('song_type',null).groupBy{it.song_type}{1}{it.size()}.cap.next()
==>cover=313
==>original=184
```
The previous example was for demonstration purposes as the more efficient way to get such count distributions is via @groupCount@.
```text
gremlin> g.V.hasNot('song_type',null).groupCount{it.song_type}.cap.next()
==>cover=313
==>original=184
```
However, here is a reduce-based @groupBy@ traversal that is difficult to achieve any other way. The traversal below provides a nested distribution. It answers the question: "How many songs was a particular artist the primary singer for, for the different song types?"
```text
gremlin> m = g.V.hasNot('song_type',null).groupBy{it.song_type}{it.out('sung_by').next()}{it._().name.groupCount.cap.next()}.cap.next()
==>cover={Unknown=6, Weir=66, John_Fogerty=5, Boz_Scaggs=1, Pigpen_Garcia=1, All=9, Grateful_Dead=1, Garcia=74, Pigpen_Mydland=3, Etta_James=1, None=6, Lesh_Mydland=1, Neal_Cassady=1, Pigpen_Weir_Mydland=2, Weir_Garcia=1, Donna=4, Elvin_Bishop=4, Joey_Covington=2, Hall_and_Oates=2, Bob_Dylan=22, Pigpen?=1, Pigpen=29, Welnick=9, Garcia_Weir=3, Jorma_Kaukonen=4, Allman_Brothers=1, Neville_Brothers=2, Mydland=6, Stephen_Stills=2, Hornsby=2, Bo_Diddley=6, Spencer_Davis=2, Joan_Baez=10, Jon_Hendricks=2, Beach_Boys=3, Suzanne_Vega=2, Weir_Mydland=2, Pigpen_Weir=8, Neil_Young=1, Lesh=6}
==>original={Weir_Wasserman=1, Mydland_Lesh=1, Lesh_Hart_Kreutzmann=1, Weir=33, Weir_Hart_Welnick=1, Welnick_Bralove=1, Grateful_Dead=15, Garcia_Dawson=1, Garcia=71, Weir_Hart=3, Garcia_Lesh=3, Garcia_Lesh_Weir=1, Hunter=3, Weir_Bralove=1, Pigpen=7, Welnick=1, Donna_Godchaux=2, Hart=2, Mydland=12, Lesh_Pigpen=1, Hornsby=1, Keith_Godchaux=1, instrumental=1, Garcia_Kreutzmann=2, Hart_Kreutzmann=2, Weir_Mydland=1, Garcia_Weir_Lesh=1, Lesh=13, Weir_Kreutzmann=1}
```
The resultant "nested distribution" map can then be analyzed by walking the nested map. In the example below, we see that Jerry Garcia sung 71 of the original Grateful Dead songs.
```text
gremlin> m.original
==>Weir_Wasserman=1
==>Mydland_Lesh=1
==>Lesh_Hart_Kreutzmann=1
==>Weir=33
==>Weir_Hart_Welnick=1
==>Welnick_Bralove=1
==>Grateful_Dead=15
==>Garcia_Dawson=1
==>Garcia=71
...
gremlin> m.original.Garcia
==>71
```
Moreover, to demonstrate the flexibility of this pattern, these nested maps can be sorted.
```text
gremlin> m.original.sort{a,b -> b.value <=> a.value}[0..4]
==>Garcia=71
==>Weir=33
==>Grateful_Dead=15
==>Lesh=13
==>Mydland=12
```
Finally, note that such nesting can happen indefinitely by simply repeating this pattern within itself. | Textile | 5 | echinopsii/net.echinopsii.3rdparty.gremlin | doc/MapReduce-Pattern.textile | [
"BSD-3-Clause"
] |
// pp-exact
mod m {
pub trait Tr {
type Ts: super::Tu;
}
}
trait Tu {
fn dummy() {}
}
fn foo<T: m::Tr>() { <T as m::Tr>::Ts::dummy(); }
fn main() {}
| Rust | 3 | ohno418/rust | src/test/pretty/qpath-associated-type-bound.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
/*
* Copyright (C) 2009-2013 Steve Rowe <sarowe@gmail.com>
* Copyright (C) 2020 Google, LLC.
*
* License: https://opensource.org/licenses/BSD-3-Clause
*
* 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.
* 3. Neither the name of the copyright holder 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 HOLDER 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.
*/
package de.jflex.ucd_generator.scanner;
import java.util.HashSet;
import java.util.Set;
import de.jflex.ucd_generator.ucd.PropertyNames;
import de.jflex.ucd.UcdVersion;
import de.jflex.ucd_generator.ucd.UnicodeData;
import de.jflex.version.Version;
/**
* Scans the PropertyValueAliases(-X.X.X).txt Unicode.org data file format,
* populating unicodeVersion.allPropertyValueAliases.
*/
%%
%final
%class PropertyValueAliasesScanner
%extends AbstractPropertyValueAliasesScanner
%ctorarg UnicodeData unicodeData
%unicode
%eofclose
%state GENERAL_CATEGORY_PROPERTY_VALUE, GENERAL_CATEGORY_ALIAS
%state CCC, PROPERTY_VALUE, ALIAS, NO_ALIAS, ADDITIONAL_ALIASES
%int
%function scan
%init{
super(unicodeData);
%init}
Spaces = [ \t]*
NL = \n | \r | \r\n
ItemSeparator = {Spaces} ";" {Spaces}
// Ext; N ; No ; F ; False
// Ext; Y ; Yes ; T ; True
BinaryValueAliases = {ItemSeparator} "N" {ItemSeparator} "No" {ItemSeparator} "F" {ItemSeparator} "False" |
{ItemSeparator} "Y" {ItemSeparator} "Yes" {ItemSeparator} "T" {ItemSeparator} "True"
%%
<YYINITIAL> {
// ccc; 0; NR ; Not_Reordered
"ccc" {ItemSeparator} { propertyAlias = "ccc";
yybegin(CCC);
}
// gc ; C ; Other # Cc | Cf | Cn | Co | Cs
"gc" {ItemSeparator} { propertyAlias = "gc";
yybegin(GENERAL_CATEGORY_PROPERTY_VALUE);
}
// Ext; N ; No ; F ; False
// Ext; Y ; Yes ; T ; True
[^ \t\r\n;]+ {BinaryValueAliases} { /* Skip binary value aliases */ }
// bc ; AL ; Arabic_Letter
// blk; n/a ; Yijing_Hexagram_Symbols
// dt ; Can ; Canonical ; can
[^ \t\r\n;]+ { propertyAlias = yytext(); }
{ItemSeparator} { yybegin(ALIAS); }
{Spaces} ("#" .*)? {NL} { aliases.clear(); }
}
<CCC> {
[0-9]+ { aliases.add(PropertyNames.normalize(yytext())); }
{ItemSeparator} { yybegin(ALIAS); }
}
// Canonical general category property values are the short forms
<GENERAL_CATEGORY_PROPERTY_VALUE> {
[^ \t\r\n;#]+ { propertyValue = yytext(); }
{ItemSeparator} { yybegin(GENERAL_CATEGORY_ALIAS); }
}
// Long form general category property values are aliases
<GENERAL_CATEGORY_ALIAS> {
[^ \t\r\n;#]+ { aliases.add(PropertyNames.normalize(yytext())); }
{ItemSeparator} { yybegin(ADDITIONAL_ALIASES); }
}
<ALIAS> {
[Nn] "/" [Aa] { }
[^ \t\r\n;#]+ { aliases.add(PropertyNames.normalize(yytext())); }
{ItemSeparator} { yybegin(PROPERTY_VALUE); }
}
<PROPERTY_VALUE> {
[^ \t\r\n;#]+ { propertyValue = yytext(); }
{ItemSeparator} { yybegin(ADDITIONAL_ALIASES); }
<GENERAL_CATEGORY_ALIAS> {
<ADDITIONAL_ALIASES> {
{Spaces} ("#" .*)? {NL} { addPropertyValueAliases();
yybegin(YYINITIAL);
}
<<EOF>> { addPropertyValueAliases(); return 0; }
}
}
}
<ADDITIONAL_ALIASES> {
[^ \t\r\n;#]+ { aliases.add(PropertyNames.normalize(yytext())); }
{ItemSeparator} { }
}
| JFlex | 4 | WeDoSoftware/jflex | java/de/jflex/ucd_generator/scanner/PropertyValueAliasesScanner.flex | [
"BSD-3-Clause"
] |
<!DOCTYPE html>
<style>
body {
margin: 0;
padding: 0;
}
#box {
background: red;
position: absolute;
top: 0;
left: 0;
width: 100px;
height: 100px;
}
#box.green { background: green; }
#box.blue { background: blue; }
</style>
<body>
<div id="box" onclick="setColor('green');" ondblclick="setColor('blue');"></div>
<script>
function setColor(c) {
document.getElementById('box').className = c;
}
</script>
| HTML | 4 | gmierz/selenium | lib/test/data/actions/click.html | [
"Apache-2.0"
] |
- owner = activity_owner(activity)
- action = "#{activity_action(owner, "add")} member"
- created_at = activity.created_at
- role = "role #{activity.parameters[:role]}"
- team = activity_team(activity)
- if activity.recipient
= CSV.generate_line(['team', team, action, activity.recipient.display_username, owner, created_at, role])
- elsif activity.parameters[:team_user]
= CSV.generate_line(['team', team, action, activity.parameters[:team_user], owner, created_at, role])
- else
= CSV.generate_line(['team', team, action, "a user", owner, created_at, role])
| Slim | 3 | xybots/Portus | app/views/public_activity/team/_add_member.csv.slim | [
"Apache-2.0"
] |
# Generated by Makefile. Do not edit.
CC = icl
CXX = $(CC)
CFLAGS = /nologo /Wall /wd4464 /wd4514
CXXFLAGS = $(CFLAGS)
TESTS = \
array-param.exe array-param-cpp.exe \
assume.exe assume-cpp.exe \
cast.exe cast-cpp.exe \
concat.exe concat-cpp.exe \
const.exe const-cpp.exe \
constant.exe constant-cpp.exe \
deprecated.exe deprecated-cpp.exe \
empty-bases.exe empty-bases-cpp.exe \
fallthrough.exe fallthrough-cpp.exe \
flags.exe flags-cpp.exe \
inline.exe inline-cpp.exe \
likely.exe likely-cpp.exe \
malloc.exe malloc-cpp.exe \
message.exe message-cpp.exe \
noinline.exe noinline-cpp.exe \
no-escape.exe no-escape-cpp.exe \
no-return.exe no-return-cpp.exe \
non-null.exe non-null-cpp.exe \
predict.exe predict-cpp.exe \
printf-format.exe printf-format-cpp.exe \
pure.exe pure-cpp.exe \
require.exe require-cpp.exe \
restrict.exe restrict-cpp.exe \
returns-non-null.exe returns-non-null-cpp.exe \
sentinel.exe sentinel-cpp.exe \
static-assert.exe static-assert-cpp.exe \
stringify.exe stringify-cpp.exe \
unknown-cpp-attributes.exe unknown-cpp-attributes-cpp.exe \
unknown-pragmas.exe unknown-pragmas-cpp.exe \
unavailable.exe unavailable-cpp.exe \
unreachable.exe unreachable-cpp.exe \
visibility.exe visibility-cpp.exe \
warn.exe warn-cpp.exe \
warn-unused-result.exe warn-unused-result-cpp.exe \
$(NULL)
TESTS = \
array-param.exe array-param-cpp.exe \
assume.exe assume-cpp.exe \
cast.exe cast-cpp.exe \
concat.exe concat-cpp.exe \
const.exe const-cpp.exe \
constant.exe constant-cpp.exe \
deprecated.exe deprecated-cpp.exe \
empty-bases.exe empty-bases-cpp.exe \
fallthrough.exe fallthrough-cpp.exe \
flags.exe flags-cpp.exe \
inline.exe inline-cpp.exe \
likely.exe likely-cpp.exe \
malloc.exe malloc-cpp.exe \
message.exe message-cpp.exe \
noinline.exe noinline-cpp.exe \
no-escape.exe no-escape-cpp.exe \
no-return.exe no-return-cpp.exe \
non-null.exe non-null-cpp.exe \
predict.exe predict-cpp.exe \
printf-format.exe printf-format-cpp.exe \
pure.exe pure-cpp.exe \
require.exe require-cpp.exe \
restrict.exe restrict-cpp.exe \
returns-non-null.exe returns-non-null-cpp.exe \
sentinel.exe sentinel-cpp.exe \
static-assert.exe static-assert-cpp.exe \
stringify.exe stringify-cpp.exe \
unknown-cpp-attributes.exe unknown-cpp-attributes-cpp.exe \
unknown-pragmas.exe unknown-pragmas-cpp.exe \
unavailable.exe unavailable-cpp.exe \
unreachable.exe unreachable-cpp.exe \
visibility.exe visibility-cpp.exe \
warn.exe warn-cpp.exe \
warn-unused-result.exe warn-unused-result-cpp.exe \
$(NULL)
CLEANFILES = $(TESTS) \
array-param.cpp array-param.obj array-param.lib array-param-cpp.exp array-param-cpp.lib \
assume.cpp assume.obj assume.lib assume-cpp.exp assume-cpp.lib \
cast.cpp cast.obj cast.lib cast-cpp.exp cast-cpp.lib \
concat.cpp concat.obj concat.lib concat-cpp.exp concat-cpp.lib \
const.cpp const.obj const.lib const-cpp.exp const-cpp.lib \
constant.cpp constant.obj constant.lib constant-cpp.exp constant-cpp.lib \
deprecated.cpp deprecated.obj deprecated.lib deprecated-cpp.exp deprecated-cpp.lib \
empty-bases.cpp empty-bases.obj empty-bases.lib empty-bases-cpp.exp empty-bases-cpp.lib \
fallthrough.cpp fallthrough.obj fallthrough.lib fallthrough-cpp.exp fallthrough-cpp.lib \
flags.cpp flags.obj flags.lib flags-cpp.exp flags-cpp.lib \
inline.cpp inline.obj inline.lib inline-cpp.exp inline-cpp.lib \
likely.cpp likely.obj likely.lib likely-cpp.exp likely-cpp.lib \
malloc.cpp malloc.obj malloc.lib malloc-cpp.exp malloc-cpp.lib \
message.cpp message.obj message.lib message-cpp.exp message-cpp.lib \
noinline.cpp noinline.obj noinline.lib noinline-cpp.exp noinline-cpp.lib \
no-escape.cpp no-escape.obj no-escape.lib no-escape-cpp.exp no-escape-cpp.lib \
no-return.cpp no-return.obj no-return.lib no-return-cpp.exp no-return-cpp.lib \
non-null.cpp non-null.obj non-null.lib non-null-cpp.exp non-null-cpp.lib \
predict.cpp predict.obj predict.lib predict-cpp.exp predict-cpp.lib \
printf-format.cpp printf-format.obj printf-format.lib printf-format-cpp.exp printf-format-cpp.lib \
pure.cpp pure.obj pure.lib pure-cpp.exp pure-cpp.lib \
require.cpp require.obj require.lib require-cpp.exp require-cpp.lib \
restrict.cpp restrict.obj restrict.lib restrict-cpp.exp restrict-cpp.lib \
returns-non-null.cpp returns-non-null.obj returns-non-null.lib returns-non-null-cpp.exp returns-non-null-cpp.lib \
sentinel.cpp sentinel.obj sentinel.lib sentinel-cpp.exp sentinel-cpp.lib \
static-assert.cpp static-assert.obj static-assert.lib static-assert-cpp.exp static-assert-cpp.lib \
stringify.cpp stringify.obj stringify.lib stringify-cpp.exp stringify-cpp.lib \
unknown-cpp-attributes.cpp unknown-cpp-attributes.obj unknown-cpp-attributes.lib unknown-cpp-attributes-cpp.exp unknown-cpp-attributes-cpp.lib \
unknown-pragmas.cpp unknown-pragmas.obj unknown-pragmas.lib unknown-pragmas-cpp.exp unknown-pragmas-cpp.lib \
unavailable.cpp unavailable.obj unavailable.lib unavailable-cpp.exp unavailable-cpp.lib \
unreachable.cpp unreachable.obj unreachable.lib unreachable-cpp.exp unreachable-cpp.lib \
visibility.cpp visibility.obj visibility.lib visibility-cpp.exp visibility-cpp.lib \
warn.cpp warn.obj warn.lib warn-cpp.exp warn-cpp.lib \
warn-unused-result.cpp warn-unused-result.obj warn-unused-result.lib warn-unused-result-cpp.exp warn-unused-result-cpp.lib \
$(NULL)
all: $(TESTS)
clean:
del /Q $(CLEANFILES)
array-param.exe: array-param.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
array-param.cpp: array-param.c
copy /Y $(?) $(@) >NUL
array-param-cpp.exe: array-param.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
assume.exe: assume.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
assume.cpp: assume.c
copy /Y $(?) $(@) >NUL
assume-cpp.exe: assume.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
cast.exe: cast.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
cast.cpp: cast.c
copy /Y $(?) $(@) >NUL
cast-cpp.exe: cast.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
concat.exe: concat.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
concat.cpp: concat.c
copy /Y $(?) $(@) >NUL
concat-cpp.exe: concat.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
const.exe: const.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
const.cpp: const.c
copy /Y $(?) $(@) >NUL
const-cpp.exe: const.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
constant.exe: constant.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
constant.cpp: constant.c
copy /Y $(?) $(@) >NUL
constant-cpp.exe: constant.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
deprecated.exe: deprecated.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
deprecated.cpp: deprecated.c
copy /Y $(?) $(@) >NUL
deprecated-cpp.exe: deprecated.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
empty-bases.exe: empty-bases.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
empty-bases.cpp: empty-bases.c
copy /Y $(?) $(@) >NUL
empty-bases-cpp.exe: empty-bases.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
fallthrough.exe: fallthrough.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
fallthrough.cpp: fallthrough.c
copy /Y $(?) $(@) >NUL
fallthrough-cpp.exe: fallthrough.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
flags.exe: flags.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
flags.cpp: flags.c
copy /Y $(?) $(@) >NUL
flags-cpp.exe: flags.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
inline.exe: inline.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
inline.cpp: inline.c
copy /Y $(?) $(@) >NUL
inline-cpp.exe: inline.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
likely.exe: likely.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
likely.cpp: likely.c
copy /Y $(?) $(@) >NUL
likely-cpp.exe: likely.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
malloc.exe: malloc.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
malloc.cpp: malloc.c
copy /Y $(?) $(@) >NUL
malloc-cpp.exe: malloc.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
message.exe: message.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
message.cpp: message.c
copy /Y $(?) $(@) >NUL
message-cpp.exe: message.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
noinline.exe: noinline.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
noinline.cpp: noinline.c
copy /Y $(?) $(@) >NUL
noinline-cpp.exe: noinline.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
no-escape.exe: no-escape.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
no-escape.cpp: no-escape.c
copy /Y $(?) $(@) >NUL
no-escape-cpp.exe: no-escape.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
no-return.exe: no-return.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
no-return.cpp: no-return.c
copy /Y $(?) $(@) >NUL
no-return-cpp.exe: no-return.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
non-null.exe: non-null.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
non-null.cpp: non-null.c
copy /Y $(?) $(@) >NUL
non-null-cpp.exe: non-null.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
predict.exe: predict.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
predict.cpp: predict.c
copy /Y $(?) $(@) >NUL
predict-cpp.exe: predict.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
printf-format.exe: printf-format.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
printf-format.cpp: printf-format.c
copy /Y $(?) $(@) >NUL
printf-format-cpp.exe: printf-format.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
pure.exe: pure.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
pure.cpp: pure.c
copy /Y $(?) $(@) >NUL
pure-cpp.exe: pure.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
require.exe: require.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
require.cpp: require.c
copy /Y $(?) $(@) >NUL
require-cpp.exe: require.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
restrict.exe: restrict.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
restrict.cpp: restrict.c
copy /Y $(?) $(@) >NUL
restrict-cpp.exe: restrict.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
returns-non-null.exe: returns-non-null.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
returns-non-null.cpp: returns-non-null.c
copy /Y $(?) $(@) >NUL
returns-non-null-cpp.exe: returns-non-null.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
sentinel.exe: sentinel.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
sentinel.cpp: sentinel.c
copy /Y $(?) $(@) >NUL
sentinel-cpp.exe: sentinel.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
static-assert.exe: static-assert.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
static-assert.cpp: static-assert.c
copy /Y $(?) $(@) >NUL
static-assert-cpp.exe: static-assert.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
stringify.exe: stringify.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
stringify.cpp: stringify.c
copy /Y $(?) $(@) >NUL
stringify-cpp.exe: stringify.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
unknown-cpp-attributes.exe: unknown-cpp-attributes.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
unknown-cpp-attributes.cpp: unknown-cpp-attributes.c
copy /Y $(?) $(@) >NUL
unknown-cpp-attributes-cpp.exe: unknown-cpp-attributes.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
unknown-pragmas.exe: unknown-pragmas.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
unknown-pragmas.cpp: unknown-pragmas.c
copy /Y $(?) $(@) >NUL
unknown-pragmas-cpp.exe: unknown-pragmas.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
unavailable.exe: unavailable.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
unavailable.cpp: unavailable.c
copy /Y $(?) $(@) >NUL
unavailable-cpp.exe: unavailable.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
unreachable.exe: unreachable.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
unreachable.cpp: unreachable.c
copy /Y $(?) $(@) >NUL
unreachable-cpp.exe: unreachable.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
visibility.exe: visibility.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
visibility.cpp: visibility.c
copy /Y $(?) $(@) >NUL
visibility-cpp.exe: visibility.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
warn.exe: warn.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
warn.cpp: warn.c
copy /Y $(?) $(@) >NUL
warn-cpp.exe: warn.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
warn-unused-result.exe: warn-unused-result.c
$(CC) $(CFLAGS) /Fe$(@) $(?)
warn-unused-result.cpp: warn-unused-result.c
copy /Y $(?) $(@) >NUL
warn-unused-result-cpp.exe: warn-unused-result.cpp
$(CXX) $(CXXFLAGS) /Fe$(@) $(?)
| Clean | 3 | Keithcat1/synthizer | third_party/hedley/test/Makefile.icl | [
"Unlicense"
] |
Ground val2 = 42
| Ioke | 0 | olabini/ioke | test/load2.ik | [
"ICU",
"MIT"
] |
{% extends "included_base.html" %}
{% block content %}
content
{{ block.super }}
{% endblock %}
{% block error_here %}
error here
{% url "nonexistent_url" %}
{% endblock %}
| HTML | 3 | jpmallarino/django | tests/template_tests/templates/included_content.html | [
"BSD-3-Clause",
"0BSD"
] |
import * as React from 'react';
import clsx from 'clsx';
import PropTypes from 'prop-types';
import useTreeItem from './useTreeItem';
/**
* @ignore - internal component.
*/
const TreeItemContent = React.forwardRef(function TreeItemContent(props, ref) {
const {
classes,
className,
displayIcon,
expansionIcon,
icon: iconProp,
label,
nodeId,
onClick,
onMouseDown,
...other
} = props;
const {
disabled,
expanded,
selected,
focused,
handleExpansion,
handleSelection,
preventSelection,
} = useTreeItem(nodeId);
const icon = iconProp || expansionIcon || displayIcon;
const handleMouseDown = (event) => {
preventSelection(event);
if (onMouseDown) {
onMouseDown(event);
}
};
const handleClick = (event) => {
handleExpansion(event);
handleSelection(event);
if (onClick) {
onClick(event);
}
};
return (
/* eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions -- Key event is handled by the TreeView */
<div
className={clsx(className, classes.root, {
[classes.expanded]: expanded,
[classes.selected]: selected,
[classes.focused]: focused,
[classes.disabled]: disabled,
})}
onClick={handleClick}
onMouseDown={handleMouseDown}
ref={ref}
{...other}
>
<div className={classes.iconContainer}>{icon}</div>
<div className={classes.label}>{label}</div>
</div>
);
});
TreeItemContent.propTypes = {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the d.ts file and run "yarn proptypes" |
// ----------------------------------------------------------------------
/**
* Override or extend the styles applied to the component.
* See [CSS API](#css) below for more details.
*/
classes: PropTypes.object,
/**
* className applied to the root element.
*/
className: PropTypes.string,
/**
* The icon to display next to the tree node's label. Either a parent or end icon.
*/
displayIcon: PropTypes.node,
/**
* The icon to display next to the tree node's label. Either an expansion or collapse icon.
*/
expansionIcon: PropTypes.node,
/**
* The icon to display next to the tree node's label.
*/
icon: PropTypes.node,
/**
* The tree node label.
*/
label: PropTypes.node,
/**
* The id of the node.
*/
nodeId: PropTypes.string.isRequired,
/**
* @ignore
*/
onClick: PropTypes.func,
/**
* @ignore
*/
onMouseDown: PropTypes.func,
};
export default TreeItemContent;
| JavaScript | 5 | good-gym/material-ui | packages/material-ui-lab/src/TreeItem/TreeItemContent.js | [
"MIT"
] |
Feature: data
Background: Prepare space
Given a graph with space named "nba"
Scenario: list, set, map
When executing query:
"""
RETURN size(LIST[]) AS a, size(SET{}) AS b, size(MAP{}) AS c
"""
Then the result should be, in any order, with relax comparison:
| a | b | c |
| 0 | 0 | 0 |
When executing query:
"""
RETURN 1 IN LIST[] AS a, "Tony" IN SET{} AS b, "a" IN MAP{} AS c
"""
Then the result should be, in any order, with relax comparison:
| a | b | c |
| false | false | false |
When executing query:
"""
RETURN LIST[1, 2] AS a, SET{1, 2, 1} AS b, MAP{a:1, b:2} AS c, MAP{a: LIST[1,2], b: SET{1,2,1}, c: "hee"} AS d
"""
Then the result should be, in any order, with relax comparison:
| a | b | c | d |
| [1, 2] | {1, 2} | {a:1, b:2} | {a: [1, 2], b: {2, 1}, c: "hee"} |
When executing query:
"""
RETURN 1 IN LIST[1, 2] AS a, 2 IN SET{1, 2, 1} AS b, "a" IN MAP{a:1, b:2} AS c, MAP{a: LIST[1,2], b: SET{1,2,1}, c: "hee"}["b"] AS d
"""
Then the result should be, in any order, with relax comparison:
| a | b | c | d |
| true | true | true | {2, 1} |
When executing query:
"""
RETURN [], {}, {}
"""
Then a SyntaxError should be raised at runtime:
When executing query:
"""
RETURN [1, 2] AS a, {1, 2, 1} AS b, {a:1, b:2} AS c
"""
Then the result should be, in any order, with relax comparison:
| a | b | c |
| [1, 2] | {1, 2} | {a:1, b:2} |
When executing query:
"""
RETURN 2 IN [1, 2] AS a, 2 IN {1, 2, 1} AS b, "b" IN MAP{a:1, b:2} AS c
"""
Then the result should be, in any order, with relax comparison:
| a | b | c |
| true | true | true |
| Cucumber | 4 | liuqian1990/nebula | tests/tck/features/basic/data.feature | [
"Apache-2.0"
] |
# <API name>
<API description>
# Data Structures
## User (object)
- ta1: 1,2,3 (array, sample)
- ta2: *1,2,3* (array) - not parsed correctly
- ta3: *1*,*2*,*3* (array) - array of "string samples"
- ta4 (array)
- sample: 1,2,3
- ta5 (array)
- sample
- 1
- 2
- 3
| API Blueprint | 1 | darkcl/drafter | test/fixtures/mson/typed-array-sample.apib | [
"MIT"
] |
// TODO: Check that string literals are concatenated correctly
#include <console>
#define d1\
print("ok")
#define d2 \
print("ok")
#warning this is\
warning 1
#warning this is\
warning 2
#warning this is \
warning 3
#warning this is \
warning 4
// single-line comments can span \
//multiple lines if you really want it
// no they can't, only with more //s.
#pragma deprecated don't\
use \
this \
function\
please
f() {}
main() {
d1;
d2;
f();
}
| PAWN | 3 | pawn-lang/pawn | source/compiler/tests/gh_217.pwn | [
"Zlib"
] |
using Uno;
using Uno.Graphics;
using Uno.Platform;
using Uno.Collections;
using Uno.Compiler.ExportTargetInterop;
namespace Android
{
public extern(android) delegate void ActivityResultCallback(int resultCode, Java.Object intent, object info);
public extern(!android) delegate void ActivityResultCallback(int resultCode, object intent, object info);
[ForeignInclude(Language.Java, "android.app.Activity", "android.content.Intent")]
public static extern(android) class ActivityUtils
{
static int _requestID = 0;
static Java.Object _intentListener;
static Dictionary<int, ActivityResultCallback> _pendingResults;
static Dictionary<int, object> _pendingInfos;
public static event Action<int, int, Java.Object> Results;
static ActivityUtils()
{
if (_intentListener == null)
{
_pendingResults = new Dictionary<int, ActivityResultCallback>();
_pendingInfos = new Dictionary<int, object>();
_intentListener = Init();
}
}
[Foreign(Language.Java)]
static Java.Object Init()
@{
com.fuse.Activity.ResultListener l = new com.fuse.Activity.ResultListener() {
@Override public boolean onResult(int requestCode, int resultCode, android.content.Intent data) {
return @{OnReceived(int,int,Java.Object):Call(requestCode, resultCode, data)};
}
};
com.fuse.Activity.subscribeToResults(l);
return l;
@}
[Foreign(Language.Java)]
public static Java.Object GetRootActivity()
@{
return com.fuse.Activity.getRootActivity();
@}
[Foreign(Language.Java)]
public static void StartActivity(Java.Object _intent)
@{
Activity a = com.fuse.Activity.getRootActivity();
a.startActivity((Intent)_intent);
@}
public static void StartActivity(Java.Object intent, ActivityResultCallback callback)
{
StartActivity(intent, callback, null);
}
public static void StartActivity(Java.Object intent, ActivityResultCallback callback, object info)
{
_requestID += 1; // note that unless >0 the requestID is not returned
_pendingResults[_requestID] = callback;
_pendingInfos[_requestID] = info;
StartForResultJava(_requestID, intent);
}
[Foreign(Language.Java)]
static void StartForResultJava(int id, Java.Object _intent)
@{
Activity a = com.fuse.Activity.getRootActivity();
a.startActivityForResult((Intent)_intent, id);
@}
static bool OnReceived(int requestCode, int resultCode, Java.Object data)
{
// fire for people expecting results
if (_pendingResults.ContainsKey(requestCode))
{
var callback = _pendingResults[requestCode];
_pendingResults.Remove(requestCode);
var info = _pendingInfos[requestCode];
_pendingInfos.Remove(requestCode);
callback(resultCode, data, info);
}
// fire for people listening to every result
var handler = Results;
if (handler != null)
handler(requestCode, resultCode, data);
return false;
}
}
public static extern(!android) class ActivityUtils
{
public static object GetRootActivity()
{
debug_log "Android ActivityUtils is an android only api and as such cannot be used from this backend";
return null;
}
public static void StartActivity(object intent)
{
debug_log "Android ActivityUtils is an android only api and as such cannot be used from this backend";
}
public static void StartActivity(object intent, ActivityResultCallback callback, object info=null)
{
debug_log "Android ActivityUtils is an android only api and as such cannot be used from this backend";
}
}
}
| Uno | 4 | helilabs/fuselibs | Source/Android.ActivityUtils/ActivityUtils.uno | [
"MIT"
] |
# from http://www.gnuplotting.org/tag/png/
set style line 1 lc rgb '#8b1a0e' pt 1 ps 1 lt 1 lw 2 # --- red
set style line 2 lc rgb '#5e9c36' pt 6 ps 1 lt 1 lw 2 # --- green
set style line 11 lc rgb '#808080' lt 1
set border 3 back ls 11
set tics nomirror
set style line 12 lc rgb '#808080' lt 0 lw 1
set grid back ls 12
set terminal svg size 480,320 font 'Verdana,10'
set xrange [1:500]
set xlabel 'length'
set ylabel 'p(length)'
set key right center
a = 0
cumsum(x)=(a=a+x,a)
| Gnuplot | 3 | DanielMabadeje/Artificial-Intelligence-Deep-Learning-Machine-Learning-Tutorials | Projects/hackernews-comments/data/length-distr.plot | [
"Apache-2.0"
] |
<html><body bgcolor="#2F3236"><center><div><iframe width="1280" height="720" src="https://www.youtube.com/embed/wArxEk0Rxhc?autoplay=1" frameborder="0" allowfullscreen></iframe></div></center></body></html> | HTML | 1 | OsmanDere/metasploit-framework | data/exploits/firefox_smil_uaf/post.html | [
"BSD-2-Clause",
"BSD-3-Clause"
] |
package com.alibaba.json.bvt.issue_1300;
import com.alibaba.fastjson.serializer.CollectionCodec;
import com.alibaba.fastjson.serializer.SerializeConfig;
import junit.framework.TestCase;
import java.util.LinkedList;
/**
* Created by wenshao on 06/08/2017.
*/
public class Issue1375 extends TestCase {
public void test_issue() throws Exception {
assertSame(CollectionCodec.instance
, SerializeConfig.getGlobalInstance()
.getObjectWriter(LinkedList.class));
}
}
| Java | 3 | Czarek93/fastjson | src/test/java/com/alibaba/json/bvt/issue_1300/Issue1375.java | [
"Apache-2.0"
] |
.class Landroid/support/constraint/solver/widgets/ConstraintTableLayout$VerticalSlice;
.super Ljava/lang/Object;
.source "ConstraintTableLayout.java"
# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
value = Landroid/support/constraint/solver/widgets/ConstraintTableLayout;
.end annotation
.annotation system Ldalvik/annotation/InnerClass;
accessFlags = 0x0
name = "VerticalSlice"
.end annotation
# instance fields
.field alignment:I
.field left:Landroid/support/constraint/solver/widgets/ConstraintWidget;
.field padding:I
.field right:Landroid/support/constraint/solver/widgets/ConstraintWidget;
.field final synthetic this$0:Landroid/support/constraint/solver/widgets/ConstraintTableLayout;
# direct methods
.method constructor <init>(Landroid/support/constraint/solver/widgets/ConstraintTableLayout;)V
.registers 3
.param p1, "this$0" # Landroid/support/constraint/solver/widgets/ConstraintTableLayout;
.line 45
iput-object p1, p0, Landroid/support/constraint/solver/widgets/ConstraintTableLayout$VerticalSlice;->this$0:Landroid/support/constraint/solver/widgets/ConstraintTableLayout;
invoke-direct {p0}, Ljava/lang/Object;-><init>()V
.line 48
const/4 v0, 0x1
iput v0, p0, Landroid/support/constraint/solver/widgets/ConstraintTableLayout$VerticalSlice;->alignment:I
return-void
.end method
| Smali | 2 | BearerPipelineTest/google-ctf | 2020/quals/reversing-android/src/android/support/constraint/solver/widgets/ConstraintTableLayout$VerticalSlice.smali | [
"Apache-2.0"
] |
import "ecere"
enum EquaError : uint16 { noError, solutionFound, divideByZero, methodNotComplete, errorInMethod, logError, sqrtError, trigonometry, huge };
struct Equation
{
float var[27];
EquaError solve(const char * method, uint16 num, float x, float * y)
{
char str[256], *fn;
uint16 s, p, c=0;
float space[26], *dest, source;
short neg=1;
*y=0;
while(method[c])
{
for(p=0; ((method[c]!=';')&&(method[c]!='\\')&&method[c]); p++, c++)
str[p]=method[c];
str[p]=0; p=0; if(method[c]=='\\')c++;
if(!str[0]&&(method[c]==';')) return solutionFound;
//Destination
if((str[p]>='a')&&(str[p]<='z'))
{
s=(uint16)(str[p]-'a'); if(s>25) return errorInMethod;
if(str[1]==':')
{
if(s==num) dest=y; else continue;
}
else
dest=&space[s];
}
else if((str[p]>='A')&&(str[p]<='Z'))
{
s=(uint16)(str[p]-'A'); if(s>25) return errorInMethod;
dest=&var[s];
}
p+=2;
//Source if not a function
if(str[p]=='-') {neg=-1; p++;} else neg=1;
if(str[p]=='#')
source=x;
else if((str[p]>='a')&&(str[p]<='z'))
{
s=(uint16)(str[p]-'a'); if(s>25) return errorInMethod;
source=space[s];
}
else if((str[p]>='A')&&(str[p]<='Z'))
{
s=(uint16)(str[p]-'A'); if(s>25) return errorInMethod;
source=var[s];
}
else
source=(float)strtod(str+2, null);
switch(str[1])
{
case ':': case '=': *dest =neg*source; break;
case '+': *dest+=neg*source; break;
case '-': *dest-=neg*source; break;
case '*': *dest*=neg*source; break;
case '/':
if(!source) return divideByZero;
*dest/=neg*source; break;
case '_':
fn=strstr(str+2,"_")+1;
//***************************************
// MATHS FUNCTIONS //
//***************************************
if(!strcmp(fn,"abs"))
{
*dest=(float)fabs(*dest);
}
if(!strcmp(fn,"mod"))
{
if(!source)return divideByZero;
*dest=(float)fmod(*dest, source);
}
if(!strcmp(fn,"pow"))
{
if(source==0.5)
{
if(*dest<0) return sqrtError;
*dest=(float)sqrt(*dest);
}
else
*dest=(float)pow(*dest,source);
}
if(!strcmp(fn,"sqrt"))
{
if(*dest<0) return sqrtError;
*dest=(float)sqrt(*dest);
}
if(!strcmp(fn,"log"))
{
if(*dest<=0) return logError;
if((source<=0)||(source==1))
return logError;
*dest=(float)(log10(*dest)/log10(source));
}
if(!strcmp(fn,"sin"))
{
*dest=(float)sin(*dest);
}
if(!strcmp(fn,"cos"))
{
*dest=(float)cos(*dest);
}
if(!strcmp(fn,"tan"))
{
*dest=(float)tan(*dest);
}
if(!strcmp(fn,"asin"))
{
if((*dest<-1)||(*dest>1)) return trigonometry;
*dest=(float)asin(*dest);
}
if(!strcmp(fn,"acos"))
{
if((*dest<-1)||(*dest>1)) return trigonometry;
*dest=(float)acos(*dest);
}
if(!strcmp(fn,"atan"))
{
*dest=(float)atan(*dest);
}
break;
}
if(method[c]==';')
{
if(Abs(*dest)>32767) return huge; else return solutionFound;
}
}
return methodNotComplete;
}
void graph(Surface surface, char * method, uint16 numSolutions, float scaleX, float scaleY, byte graph, byte color, ColorAlpha * palette)
{
uint16 s;
float ex,ey;
float x,y;
surface.SetForeground(palette[graph]);
surface.HLine(0,surface.width-1,surface.height/2);
surface.VLine(0,surface.height-1,surface.width/2);
for(x=scaleX; x<surface.width; x+=scaleX)
surface.VLine(surface.height/2-1,surface.height/2+1,(int)x);
for(y=scaleY; y<surface.height; y+=scaleY)
surface.HLine(surface.width/2-1,surface.width/2+1,(int)y);
surface.DrawLine(
surface.width/2, 0,
surface.width/2-(int)scaleY/2,(int)scaleY/2);
surface.DrawLine(
surface.width/2, 0,
surface.width/2+(int)scaleY/2,(int)scaleY/2);
surface.DrawLine(
surface.width-1, surface.height/2,
surface.width-1-(int)scaleX/2, surface.height/2-(int)scaleX/2);
surface.DrawLine(
surface.width-1, surface.height/2,
surface.width-1-(int)scaleX/2, surface.height/2+(int)scaleX/2);
surface.foreground = palette[color];
for(x=0; x<surface.width; x+=0.1)
{
ex=(x-surface.width/2)/scaleX;
for(s = 0; s < numSolutions; s++)
{
if(solve(method,s,ex,&ey)==solutionFound)
{
y=-ey*scaleY+surface.height/2;
if((y<surface.height)&&(y>=0))
surface.PutPixel((int)x,(int)y);
}
}
}
}
};
| eC | 4 | mingodad/ecere-sdk | samples/guiAndGfx/EquaGraph/equation.ec | [
"BSD-3-Clause"
] |
// Copyright 2018 The Go 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 "go_asm.h"
#include "textflag.h"
// memequal(p, q unsafe.Pointer, size uintptr) bool
TEXT runtime·memequal(SB), NOSPLIT, $0-25
Get SP
I64Load a+0(FP)
I64Load b+8(FP)
I64Load size+16(FP)
Call memeqbody<>(SB)
I64Store8 ret+24(FP)
RET
// memequal_varlen(a, b unsafe.Pointer) bool
TEXT runtime·memequal_varlen(SB), NOSPLIT, $0-17
Get SP
I64Load a+0(FP)
I64Load b+8(FP)
I64Load 8(CTXT) // compiler stores size at offset 8 in the closure
Call memeqbody<>(SB)
I64Store8 ret+16(FP)
RET
// params: a, b, len
// ret: 0/1
TEXT memeqbody<>(SB), NOSPLIT, $0-0
Get R0
Get R1
I64Eq
If
I64Const $1
Return
End
loop:
Loop
Get R2
I64Eqz
If
I64Const $1
Return
End
Get R0
I32WrapI64
I64Load8U $0
Get R1
I32WrapI64
I64Load8U $0
I64Ne
If
I64Const $0
Return
End
Get R0
I64Const $1
I64Add
Set R0
Get R1
I64Const $1
I64Add
Set R1
Get R2
I64Const $1
I64Sub
Set R2
Br loop
End
UNDEF
| GAS | 2 | SSSDNSY/go | src/internal/bytealg/equal_wasm.s | [
"BSD-3-Clause"
] |
import { useState } from 'react'
import styles from '../styles.module.css'
export default function Index() {
const [response, setResponse] = useState()
const makeRequest = async () => {
const res = await fetch('/api/user')
setResponse({
status: res.status,
body: await res.json(),
limit: res.headers.get('X-RateLimit-Limit'),
remaining: res.headers.get('X-RateLimit-Remaining'),
})
}
return (
<main className={styles.container}>
<h1>Next.js API Routes Rate Limiting</h1>
<p>
This example uses <code className={styles.inlineCode}>lru-cache</code>{' '}
to implement a simple rate limiter for API routes (Serverless
Functions).
</p>
<button onClick={() => makeRequest()}>Make Request</button>
<code className={styles.code}>
<div>
<b>Status Code: </b>
{response?.status || 'None'}
</div>
<div>
<b>Request Limit: </b>
{response?.limit || 'None'}
</div>
<div>
<b>Remaining Requests: </b>
{response?.remaining || 'None'}
</div>
<div>
<b>Body: </b>
{JSON.stringify(response?.body) || 'None'}
</div>
</code>
<div className={styles.links}>
<a href="#">View Source</a>
{' | '}
<a href="#">Deploy You Own ▲</a>
</div>
</main>
)
}
| JavaScript | 4 | blomqma/next.js | examples/api-routes-rate-limit/pages/index.js | [
"MIT"
] |
/*##############################################################################
HPCC SYSTEMS software Copyright (C) 2012 HPCC Systems®.
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.
############################################################################## */
IMPORT std;
unsigned numRecs := 10000 : STORED('numRecs');
rec1 := RECORD
string20 key;
END;
seed := dataset([{'[A]\n'}], rec1);
rec1 addNodeNum(rec1 L, unsigned4 c) := TRANSFORM
SELF.key := (string) c;
SELF := L;
END;
one_per_node := DISTRIBUTE(NORMALIZE(seed, CLUSTERSIZE, addNodeNum(LEFT, COUNTER)),(unsigned)key);
rec1 generatePseudoRandom(rec1 L, unsigned4 c) := TRANSFORM
SELF.key := '['+(string17) RANDOM()+']\n';
END;
bigstream := NORMALIZE(one_per_node, numRecs*(Std.System.Thorlib.node()+1), generatePseudoRandom(LEFT, COUNTER));
deskew := DISTRIBUTE(bigstream, SKEW(0.1));
SEQUENTIAL(
IF (COUNT(bigstream) = COUNT(NOFOLD(deskew)),
OUTPUT('Count after de-skew matched'),
FAIL('ERROR: Count after de-skew did not match!')
)
);
| ECL | 4 | miguelvazq/HPCC-Platform | testing/regress/ecl/distskew.ecl | [
"Apache-2.0"
] |
Red/System [
Title: "Red/System float32! datatype tests"
Author: "Peter W A Wood"
File: %float32-test.reds
Version: 0.1.0
Tabs: 4
Rights: "Copyright (C) 2012-2015 Peter W A Wood. All rights reserved."
License: "BSD-3 - https://github.com/red/red/blob/origin/BSD-3-License.txt"
]
#include %../../../../quick-test/quick-test.reds
~~~start-file~~~ "float32"
===start-group=== "float32 assignment"
--test-- "float32-1"
f: as float32! 100.0
--assert f = as float32! 100.0
--test-- "float32-2"
f: as float32! 1.222090944E+33
--assert f = as float32! 1.222090944E+33
--test-- "float32-3"
f: as float32! 9.99999E-25
--assert f = as float32! 9.99999E-25
--test-- "float32-4"
f: as float32! 1.0
f1: f
--assert f1 = as float32! 1.0
--test-- "float32-5"
f: as float32! 2147483647.0
f1: f
--assert f1 = as float32! 2147483647.99999
===end-group===
===start-group=== "float argument to external function"
pi64: 3.14159265358979323846
--test-- "float32-ext-1"
--assert (as float32! -1.0) = as-float32 cos pi64
--test-- "float32-ext-2"
--assertf32~= (as float32! 0.00) (as float32! sin pi64) 0.1E-7
--test-- "float32-ext-3"
--assert (as float32! -1.0) = as-float32 cos 3.1415927
===end-group===
===start-group=== "float32 function arguments"
ff: func [
fff [float32!]
ffg [float32!]
return: [integer!]
/local
ffl [float32!]
][
ffl: fff
if ffl <> fff [return 1]
ffl: ffg
if ffl <> ffg [return 2]
1
]
--test-- "float32-func-args-1"
--assert 1 = ff as float32! 1.0 as float32! 2.0
--test-- "float32-func-args-2"
--assert 1 = ff as float32! 1.222090944E+33 as float32! 9.99999E-25
===end-group===
===start-group=== "float32 locals"
local-float: func [n [float32!] return: [float32!] /local p][p: n p]
--test-- "float32-loc-1"
pi64: 3.14159265358979
pi32: local-float as float32! 3.1415927
--assert pi32 = as float32! 3.1415927
--assert (as float32! -1.0) = as-float32 cos pi64
--assert (as float32! -1.0) = local-float as-float32 cos pi64
--test-- "float32-loc-2"
f: local-float pi32
--assert pi32 = local-float f
--test-- "float32-loc-3"
local-float2: func [
n [float32!] return: [float32!] /local p
][
p: n local-float p
]
pi32: local-float2 as float32! 3.1415927
--assert (as float32! 3.1415927) = local-float2 pi32
--assert (as float32! -1.0) = local-float2 as-float32 cos pi64
f: local-float2 pi32
--assert pi32 = local-float2 f
--test-- "float32-loc-4"
local-float3: func [
n [float32!] return: [float32!] /local p [float32!]
][
p: n local-float p
]
pi32: local-float3 as float32! 3.1415927
--assert (as float32! 3.1415927) = local-float3 pi32
--assert (as float32! -1.0) = local-float3 as-float32 cos pi64
f: local-float3 pi32
--assert pi32 = local-float3 f
--test-- "float32-loc-5"
local-float4: func [n [float32!] return: [float32!] /local r p][p: n p]
--assert (as float32! 3.1415927) = local-float4 pi32
--assert (as float32! -1.0) = local-float4 as-float32 cos pi64
f: local-float4 pi32
--assert pi32 = local-float4 f
--test-- "float32-loc-6"
local-float5: func [n [float32!] return: [float32!] /local r p][p: n local-float p]
--assert (as float32! 3.1415927) = local-float5 pi32
--assert (as float32! -1.0) = local-float5 as-float32 cos pi64
f: local-float5 pi32
--assert pi32 = local-float5 f
===end-group===
===start-group=== "float32 function return"
ff1: func [
ff1i [integer!]
return: [float32!]
][
as float32! switch ff1i [
1 [1.0]
2 [1.222090944E+33]
3 [9.99999E-30]
]
]
--test-- "float32 return 1"
--assert (as float32! 1.0) = ff1 1
--test-- "float32 return 2"
--assert (as float32! 1.222090944E+33) = ff1 2
--test-- "float32 return 3"
--assert (as float32! 9.99999E-30) = ff1 3
===end-group===
===start-group=== "float32 struct!"
--test-- "float32-struct-1"
sf1: declare struct! [
a [float32!]
]
--assert (as float32! 0.0) = sf1/a
--test-- "float32-struct-2"
sf2: declare struct! [
a [float32!]
]
sf2/a: as float32! 1.222090944E+33
--assert (as float32! 1.222090944E+33) = sf2/a
sf3: declare struct! [
a [float32!]
b [float32!]
]
--test-- "float32-struct-3"
sf3/a: as float32! 1.222090944E+33
sf3/b: as float32! 9.99999E-25
--assert (as float32! 1.222090944E+33) = sf3/a
--assert (as float32! 9.99999E-25) = sf3/b
--test-- "float32-struct-4"
sf4: declare struct! [
c [byte!]
a [float32!]
l [logic!]
b [float32!]
]
sf4/a: as float32! 1.222090944E+33
sf4/b: as float32! 9.99999E-25
--assert (as float32! 1.222090944E+33) = sf4/a
--assert (as float32! 9.99999E-25) = sf4/b
===end-group===
===start-group=== "float32 pointers"
--test-- "float32-point-1"
pi32: as float32! 3.1415927
p: declare pointer! [float32!]
p/value: as float32! 3.1415927
--assert pi32 = p/value
===end-group===
===start-group=== "expressions with returned float values"
fe1: function [
return: [float32!]
][
as float32! 1.0
]
fe2: function [
return: [float32!]
][
as float32! 2.0
]
--test-- "ewrfv0"
--assertf32~= as float32! 1.0 (fe1 * as float32! 1.0) as float32! 0.1E-3
--test-- "ewrfv1"
--assertf32~= as float32! 1.0 (as float32! 1.0) * fe1 as float32! 0.1E-3
--test-- "ewrfv2"
--assertf32~= as float32! 0.5 (fe1 / fe2) as float32! 0.1E-3
===end-group===
===start-group=== "float32 arguments to typed functions"
fatf1: function [
[typed]
count [integer!]
list [typed-float32!]
return: [float32!]
][
list/value
]
fatf2: function [
[typed]
count [integer!]
list [typed-float32!]
return: [float32!]
/local
a [float32!]
b [float32!]
][
a: list/value
list: list + 1
b: list/value
a + b
]
--test-- "fatf-1"
--assert (as float32! 2.0) = (fatf1 as float32! 2.0)
--test-- "fatf-2"
--assert (as float32! 2.0) = ((fatf1 as float32! 1.0) + (fatf1 as float32! 1.0))
--test-- "fatf-3"
--assert (as float32! 3.0) = fatf2 [as float32! 1.0 as float32! 2.0]
===end-group===
===start-group=== "Casting float! arguments to float32!"
cfaf1: function [
a [float!]
return: [float32!]
][
as float32! a
]
cfaf2: function [
a [float!]
b [float!]
return: [float32!]
][
(as float32! a) + (as float32! b)
]
--test-- "cfaf1"
--assert (as float32! 1.0) = cfaf1 1.0
--test-- "cfaf2"
--assertf32~= (as float32! 3.0) (cfaf2 1.0 2.0) (as float32! 0.1e-7)
===end-group===
===start-group=== "calculations"
fcfoo: func [a [float32!] return: [float32!]][a]
fcptr: declare struct! [a [float32!]]
fcptr/a: as float32! 3.0
fc2: as float32! 3.0
--test-- "fc-1"
fc1: as float32! 2.0
fc1: fc1 / (fc1 - as float32! 1.0)
--assertf32~= as float32! 2.0 fc1 as float32! 0.1E-7
--test-- "fc-2"
--assert (as float32! 5.0) - (as float32! 3.0) = as float32! 2.0 ;-- imm/imm
--test-- "fc-3"
--assert (as float32! 5.0) - fc2 = as float32! 2.0 ;-- imm/ref
--test-- "fc-4"
--assert (as float32! 5.0) - (fcfoo as float32! 3.0) = as float32! 2.0 ;-- imm/reg(block!)
--test-- "fc-5"
--assertf32~= (as float32! 5.0) - fcptr/a as float32! 2.0 as float32! 1E-10 ;-- imm/reg(path!)
--test-- "fc-6"
--assert fc2 - (as float32! 5.0) = as float32! -2.0 ;-- ref/imm
--test-- "fc-7"
--assert fc2 - (fcfoo as float32! 5.0) = as float32! -2.0 ;-- ref/reg(block!)
--test-- "fc-8"
--assert fc2 - fcptr/a = as float32! 0.0 ;-- ref/reg(path!)
--test-- "fc-9"
--assertf32~= (fcfoo as float32! 5.0) - as float32! 3.0 as float32! 2.0 as float32! 1E-10 ;-- reg(block!)/imm
--test-- "fc-10"
--assert (fcfoo as float32! 5.0) - (fcfoo as float32! 3.0) = as float32! 2.0 ;-- reg(block!)/reg(block!)
--test-- "fc-11"
--assert (fcfoo as float32! 5.0) - fcptr/a = as float32! 2.0 ;-- reg(block!)/reg(path!)
--test-- "fc-12"
--assert fcptr/a - (fcfoo as float32! 5.0) = as float32! -2.0 ;-- reg(path!)/reg(block!)
--test-- "#4038"
RECT_F4038: alias struct! [
left [float32!]
top [float32!]
right [float32!]
bottom [float32!]
]
test4038: func [/local rc [RECT_F4038 value]][
rc/right: as float32! 0.0
--assert rc/right = as float32! 0.0
rc/right: rc/right + as float32! (1 + 2)
--assert rc/right = as float32! 3.0
]
test4038
===end-group===
===start-group=== "Float special values"
--test-- "fsp-1"
;; FIXME: float comparisons
;fp-1: as-float32 1.#NAN --assert fp-1 = as-float32 1.#NAN
;fp-1: as-float32 1.#INF --assert fp-1 = as-float32 1.#INF
;fp-1: as-float32 +1.#INF --assert fp-1 = as-float32 1.#INF
;fp-1: as-float32 -1.#INF --assert fp-1 = as-float32 -1.#INF
--test-- "fsp-2"
fp-2: as-float32 -0.0 --assert fp-2 = as-float32 -0.0
--assert (as-float32 1.0) + (as-float32 -0.0) = as-float32 1.0
--assert (as-float32 -1.0) * (as-float32 0.0) = as-float32 -0.0
--test-- "fsp-3"
fsp-3: func [f [float32!] return: [float32!]][f]
--assert (as-float32 -0.0) = fsp-3 as-float32 -0.0
===end-group===
===start-group=== "implicit literal type casting of function arguments"
--test-- "fiitc1"
flitc1-f: function [
x [float32!]
y [float!]
z [float32!]
return: [float32!]
][
x + z
]
--assert (as float32! 4.00) = flitc1-f 1.00 2.00 3.00
===end-group===
===start-group=== "IEEE754 compliance in NaN handling - float32! type"
;-- vars list:
; nan +inf -inf zero one two five
; failed b i f g
; any1-fail all1-fail f-yes f-not fi-yes fi-not
; cmp= cmp< cmp> icmp= icmp< icmp> ecmp= ecmp< ecmp>
nan: as float32! 0.0 / 0.0
+inf: as float32! 1.0 / 0.0
-inf: as float32! -1.0 / 0.0
zero: as float32! 0.0
one: as float32! 1.0
two: as float32! 2.0
five: as float32! 5.0
;; check point 1 - assertions -- only in manual test files `nan-tests-manual*.reds`
;; check point 2 - if's
--test-- "if nan 1"
failed: no if nan = nan [failed: yes]
--assert not failed
--test-- "if nan 2"
failed: no if nan = one [failed: yes]
--assert not failed
--test-- "if nan 3"
failed: no if nan < nan [failed: yes]
--assert not failed
--test-- "if nan 4"
failed: no if nan < one [failed: yes]
--assert not failed
--test-- "if nan 5"
failed: no if one < nan [failed: yes]
--assert not failed
--test-- "if nan 6"
failed: no if two < one [failed: yes]
--assert not failed
--test-- "if nan 7"
failed: no if one < nan [failed: yes]
--assert not failed
--test-- "if nan 8"
failed: yes if one = one [failed: no]
--assert not failed
--test-- "if nan 9"
failed: yes if one < two [failed: no]
--assert not failed
--test-- "if nan 10"
failed: yes if nan <> nan [failed: no]
--assert not failed
--test-- "if nan 11"
failed: no if not (one = one) [failed: yes]
--assert not failed
--test-- "if nan 12"
failed: no if not (one <> nan) [failed: yes]
--assert not failed
--test-- "if nan 13"
failed: no if not (nan <> nan) [failed: yes]
--assert not failed
;; ... unless's
--test-- "unless nan 1"
failed: no unless one = one [failed: yes]
--assert not failed
--test-- "unless nan 2"
failed: no unless one <> nan [failed: yes]
--assert not failed
--test-- "unless nan 3"
failed: no unless nan <> nan [failed: yes]
--assert not failed
;; check point 3 - either's
--test-- "either nan 1"
failed: yes either one = one [failed: no][1]
--assert not failed
--test-- "either nan 2"
failed: yes either one < two [failed: no][1]
--assert not failed
--test-- "either nan 3"
failed: yes either two > one [failed: no][1]
--assert not failed
--test-- "either nan 4"
failed: yes either nan = nan [1][failed: no]
--assert not failed
--test-- "either nan 5"
failed: yes either nan = one [1][failed: no]
--assert not failed
--test-- "either nan 6"
failed: yes either one = nan [1][failed: no]
--assert not failed
--test-- "either nan 7"
failed: yes either one < one [1][failed: no]
--assert not failed
--test-- "either nan 8"
failed: yes either one < nan [1][failed: no]
--assert not failed
--test-- "either nan 9"
failed: yes either nan < one [1][failed: no]
--assert not failed
--test-- "either nan 10"
failed: yes either one > one [1][failed: no]
--assert not failed
--test-- "either nan 11"
failed: yes either one > nan [1][failed: no]
--assert not failed
--test-- "either nan 12"
failed: yes either nan > one [1][failed: no]
--assert not failed
--test-- "either nan 13"
failed: yes either one <> one [1][failed: no]
--assert not failed
--test-- "either nan 14"
failed: yes either nan <> nan [failed: no][1]
--assert not failed
--test-- "either nan 15"
failed: yes either one <> nan [failed: no][1]
--assert not failed
--test-- "either nan 16"
failed: yes either nan <> one [failed: no][1]
--assert not failed
--test-- "either nan 17"
failed: yes either one <> two [failed: no][1]
--assert not failed
;; check point 4 - case's
--test-- "case nan 1"
failed: yes case [one = one [failed: no] true [1]]
--assert not failed
--test-- "case nan 2"
failed: yes case [one < two [failed: no] true [1]]
--assert not failed
--test-- "case nan 3"
failed: yes case [two > one [failed: no] true [1]]
--assert not failed
--test-- "case nan 4"
failed: yes case [nan = nan [1] true [failed: no]]
--assert not failed
--test-- "case nan 5"
failed: yes case [nan = one [1] true [failed: no]]
--assert not failed
--test-- "case nan 6"
failed: yes case [one = nan [1] true [failed: no]]
--assert not failed
--test-- "case nan 7"
failed: yes case [one < one [1] true [failed: no]]
--assert not failed
--test-- "case nan 8"
failed: yes case [one < nan [1] true [failed: no]]
--assert not failed
--test-- "case nan 9"
failed: yes case [nan < one [1] true [failed: no]]
--assert not failed
--test-- "case nan 10"
failed: yes case [one > one [1] true [failed: no]]
--assert not failed
--test-- "case nan 11"
failed: yes case [one > nan [1] true [failed: no]]
--assert not failed
--test-- "case nan 12"
failed: yes case [nan > one [1] true [failed: no]]
--assert not failed
--test-- "case nan 13"
failed: yes case [one <> one [1] true [failed: no]]
--assert not failed
--test-- "case nan 14"
failed: yes case [nan <> nan [failed: no] true [1]]
--assert not failed
--test-- "case nan 15"
failed: yes case [one <> nan [failed: no] true [1]]
--assert not failed
--test-- "case nan 16"
failed: yes case [nan <> one [failed: no] true [1]]
--assert not failed
--test-- "case nan 17"
failed: yes case [one <> two [failed: no] true [1]]
--assert not failed
--test-- "case nan 18"
failed: yes case [
nan = nan [1]
nan > one [1]
one > nan [1]
one = one [failed: no]
]
--assert not failed
;; check point 5 - until's end-condition
--test-- "until nan 1"
i: 0 f: five g: zero
until [
i: i + 1
f: f - 1.0
g: zero / f
g <> zero
]
--assert i = 5
--test-- "until nan 2"
i: 0 f: five
until [
i: i + 1
f: f - 1.0
zero / f <> zero
]
--assert i = 5
--test-- "until nan 3"
i: 0 f: five
until [
i: i + 1
f: f - 1.0
not (zero / f <= +inf)
]
--assert i = 5
--test-- "until nan 4"
i: 0 f: five
until [
i: i + 1
f: f - 1.0
not (f * +inf <= +inf)
]
--assert i = 5
;; check point 6 - while's enter-condition
--test-- "while nan 1"
i: 0 f: five g: zero
while [g = zero] [i: i + 1 f: f - 1.0 g: zero / f]
--assert i = 5
--test-- "while nan 2"
i: 0 f: five g: zero
while [g <= +inf] [i: i + 1 f: f - 1.0 g: zero / f]
--assert i = 5
--test-- "while nan 3"
i: 0 f: five g: zero
while [g >= -inf] [i: i + 1 f: f - 1.0 g: zero / f]
--assert i = 5
--test-- "while nan 4"
i: 0 f: five g: zero
while [-inf <= g] [i: i + 1 f: f - 1.0 g: zero / f]
--assert i = 5
--test-- "while nan 5"
i: 0 f: five g: zero
while [+inf >= g] [i: i + 1 f: f - 1.0 g: zero / f]
--assert i = 5
;; check point 7 - all's
--test-- "all nan 1"
failed: no
all1-fail: func [][failed: yes]
all [zero = zero zero < one one < two one <> nan nan <> nan nan = nan all1-fail]
--assert not failed
--test-- "all nan 2"
failed: no if all [zero = zero zero < one one < two one <> nan nan <> nan nan = nan][failed: yes]
--assert not failed
--test-- "all nan 3"
failed: no unless all [zero = zero zero < one one < two one <> nan nan <> nan] [failed: yes]
--assert not failed
--test-- "all nan 4"
failed: yes either all [one = one] [failed: no][1]
--assert not failed
--test-- "all nan 5"
failed: yes either all [one < two] [failed: no][1]
--assert not failed
--test-- "all nan 6"
failed: yes either all [two > one] [failed: no][1]
--assert not failed
--test-- "all nan 7"
failed: yes either all [nan = nan] [1][failed: no]
--assert not failed
--test-- "all nan 8"
failed: yes either all [nan = one] [1][failed: no]
--assert not failed
--test-- "all nan 9"
failed: yes either all [one = nan] [1][failed: no]
--assert not failed
--test-- "all nan 10"
failed: yes either all [one < one] [1][failed: no]
--assert not failed
--test-- "all nan 11"
failed: yes either all [one < nan] [1][failed: no]
--assert not failed
--test-- "all nan 12"
failed: yes either all [nan < one] [1][failed: no]
--assert not failed
--test-- "all nan 13"
failed: yes either all [one > one] [1][failed: no]
--assert not failed
--test-- "all nan 14"
failed: yes either all [one > nan] [1][failed: no]
--assert not failed
--test-- "all nan 15"
failed: yes either all [nan > one] [1][failed: no]
--assert not failed
--test-- "all nan 16"
failed: yes either all [one <> one] [1][failed: no]
--assert not failed
--test-- "all nan 17"
failed: yes either all [nan <> nan] [failed: no][1]
--assert not failed
--test-- "all nan 18"
failed: yes either all [one <> nan] [failed: no][1]
--assert not failed
--test-- "all nan 19"
failed: yes either all [nan <> one] [failed: no][1]
--assert not failed
--test-- "all nan 20"
failed: yes either all [one <> two] [failed: no][1]
--assert not failed
--test-- "all nan 21"
failed: yes b: all [nan = nan] unless b [failed: no]
--assert not failed
--test-- "all nan 22"
failed: yes b: all [one < nan] unless b [failed: no]
--assert not failed
--test-- "all nan 23"
failed: yes b: all [one > nan] unless b [failed: no]
--assert not failed
--test-- "all nan 24"
failed: yes b: all [one = one] if b [failed: no]
--assert not failed
;; ... any's
--test-- "any nan 1"
failed: no
any1-fail: func [][failed: yes]
any [zero <> zero zero > one one > two one = nan nan = nan nan <> nan any1-fail]
--assert not failed
--test-- "any nan 2"
failed: no
unless any [zero <> zero zero > one one > two one = nan nan = nan nan <> nan][
failed: yes
]
--assert not failed
--test-- "any nan 3"
failed: no
either any [zero <> zero zero > one one > two one = nan nan = nan] [failed: yes] [1]
--assert not failed
--test-- "any nan 4"
failed: yes either any [one = one] [failed: no][1]
--assert not failed
--test-- "any nan 5"
failed: yes either any [one < two] [failed: no][1]
--assert not failed
--test-- "any nan 6"
failed: yes either any [two > one] [failed: no][1]
--assert not failed
--test-- "any nan 7"
failed: yes either any [nan = nan] [1][failed: no]
--assert not failed
--test-- "any nan 8"
failed: yes either any [nan = one] [1][failed: no]
--assert not failed
--test-- "any nan 9"
failed: yes either any [one = nan] [1][failed: no]
--assert not failed
--test-- "any nan 10"
failed: yes either any [one < one] [1][failed: no]
--assert not failed
--test-- "any nan 11"
failed: yes either any [one < nan] [1][failed: no]
--assert not failed
--test-- "any nan 12"
failed: yes either any [nan < one] [1][failed: no]
--assert not failed
--test-- "any nan 13"
failed: yes either any [one > one] [1][failed: no]
--assert not failed
--test-- "any nan 14"
failed: yes either any [one > nan] [1][failed: no]
--assert not failed
--test-- "any nan 15"
failed: yes either any [nan > one] [1][failed: no]
--assert not failed
--test-- "any nan 16"
failed: yes either any [one <> one] [1][failed: no]
--assert not failed
--test-- "any nan 17"
failed: yes either any [nan <> nan] [failed: no][1]
--assert not failed
--test-- "any nan 18"
failed: yes either any [one <> nan] [failed: no][1]
--assert not failed
--test-- "any nan 19"
failed: yes either any [nan <> one] [failed: no][1]
--assert not failed
--test-- "any nan 20"
failed: yes either any [one <> two] [failed: no][1]
--assert not failed
--test-- "any nan 21"
failed: yes b: any [nan = nan] unless b [failed: no]
--assert not failed
--test-- "any nan 22"
failed: yes b: any [one < nan] unless b [failed: no]
--assert not failed
--test-- "any nan 23"
failed: yes b: any [one > nan] unless b [failed: no]
--assert not failed
--test-- "any nan 24"
failed: yes b: any [one = one] if b [failed: no]
--assert not failed
--test-- "any nan 25"
failed: yes b: any [nan = nan one = one] if b [failed: no]
--assert not failed
;; check point 8 - functions with logic arguments from nan comparison
f-yes: func [cond [logic!] msg [c-string!]] [ if cond [failed: no]]
f-not: func [cond [logic!] msg [c-string!]] [unless cond [failed: no]]
--test-- "func nan 1"
failed: yes f-yes nan <> nan "nan <> nan"
--assert not failed
--test-- "func nan 2"
failed: yes f-yes one <> nan "one <> nan"
--assert not failed
--test-- "func nan 3"
failed: yes f-yes not (nan = nan) "not nan = nan"
--assert not failed
--test-- "func nan 4"
failed: yes f-yes not (one = nan) "not one = nan"
--assert not failed
--test-- "func nan 5"
failed: yes f-not nan = nan "nan = nan"
--assert not failed
--test-- "func nan 6"
failed: yes f-not nan = one "nan = one"
--assert not failed
--test-- "func nan 7"
failed: yes f-not one = nan "one = nan"
--assert not failed
--test-- "func nan 8"
failed: yes f-not nan < one "nan < one"
--assert not failed
--test-- "func nan 9"
failed: yes f-not one < nan "one < nan"
--assert not failed
--test-- "func nan 10"
failed: yes f-not nan > one "nan > one"
--assert not failed
--test-- "func nan 11"
failed: yes f-not one > nan "one > nan"
--assert not failed
;; ... functions with integer arguments from nan comparison
fi-yes: func [i [integer!] msg [c-string!]] [if i = 1 [failed: no]]
fi-not: func [i [integer!] msg [c-string!]] [if i = 0 [failed: no]]
--test-- "func nan 12"
failed: yes fi-yes as-integer nan <> nan "nan <> nan"
--assert not failed
--test-- "func nan 13"
failed: yes fi-yes as-integer one <> nan "one <> nan"
--assert not failed
--test-- "func nan 14"
failed: yes fi-yes as-integer not (nan = nan) "not nan = nan"
--assert not failed
--test-- "func nan 15"
failed: yes fi-yes as-integer not (one = nan) "not one = nan"
--assert not failed
--test-- "func nan 16"
failed: yes fi-not as-integer nan = nan "nan = nan"
--assert not failed
--test-- "func nan 17"
failed: yes fi-not as-integer nan = one "nan = one"
--assert not failed
--test-- "func nan 18"
failed: yes fi-not as-integer one = nan "one = nan"
--assert not failed
--test-- "func nan 19"
failed: yes fi-not as-integer nan < one "nan < one"
--assert not failed
--test-- "func nan 20"
failed: yes fi-not as-integer one < nan "one < nan"
--assert not failed
--test-- "func nan 21"
failed: yes fi-not as-integer nan > one "nan > one"
--assert not failed
--test-- "func nan 22"
failed: yes fi-not as-integer one > nan "one > nan"
--assert not failed
;; check point 9 - logic return values from nan comparison
cmp=: func [a [float32!] b [float32!] return: [logic!]] [a = b]
cmp<: func [a [float32!] b [float32!] return: [logic!]] [a < b]
cmp>: func [a [float32!] b [float32!] return: [logic!]] [a > b]
--test-- "func nan 23"
failed: yes unless cmp= nan nan [failed: no]
--assert not failed
--test-- "func nan 24"
failed: yes unless cmp= one nan [failed: no]
--assert not failed
--test-- "func nan 25"
failed: yes unless cmp< one nan [failed: no]
--assert not failed
--test-- "func nan 26"
failed: yes unless cmp< nan one [failed: no]
--assert not failed
--test-- "func nan 27"
failed: yes unless cmp> one nan [failed: no]
--assert not failed
--test-- "func nan 28"
failed: yes unless cmp> nan one [failed: no]
--assert not failed
--test-- "func nan 29"
failed: yes if cmp= one one [failed: no]
--assert not failed
--test-- "func nan 30"
failed: yes if cmp< one two [failed: no]
--assert not failed
--test-- "func nan 31"
failed: yes if cmp> two one [failed: no]
--assert not failed
;; ... integer return values from nan comparison
icmp=: func [a [float32!] b [float32!] return: [integer!]] [as integer! a = b]
icmp<: func [a [float32!] b [float32!] return: [integer!]] [as integer! a < b]
icmp>: func [a [float32!] b [float32!] return: [integer!]] [as integer! a > b]
--test-- "func nan 32"
failed: yes unless 0 <> icmp= nan nan [failed: no]
--assert not failed
--test-- "func nan 33"
failed: yes unless 0 <> icmp= one nan [failed: no]
--assert not failed
--test-- "func nan 34"
failed: yes unless 0 <> icmp< one nan [failed: no]
--assert not failed
--test-- "func nan 35"
failed: yes unless 0 <> icmp< nan one [failed: no]
--assert not failed
--test-- "func nan 36"
failed: yes unless 0 <> icmp> one nan [failed: no]
--assert not failed
--test-- "func nan 37"
failed: yes unless 0 <> icmp> nan one [failed: no]
--assert not failed
--test-- "func nan 38"
failed: yes unless 1 <> icmp= one one [failed: no]
--assert not failed
--test-- "func nan 39"
failed: yes unless 1 <> icmp< one two [failed: no]
--assert not failed
--test-- "func nan 40"
failed: yes unless 1 <> icmp> two one [failed: no]
--assert not failed
;; check point 10 - assignment to logic/integer variables
--test-- "assign nan 1"
failed: yes b: nan = nan unless b [failed: no]
--assert not failed
--test-- "assign nan 2"
failed: yes b: one < nan unless b [failed: no]
--assert not failed
--test-- "assign nan 3"
failed: yes b: one > nan unless b [failed: no]
--assert not failed
--test-- "assign nan 4"
failed: yes b: nan < one unless b [failed: no]
--assert not failed
--test-- "assign nan 5"
failed: yes b: nan > one unless b [failed: no]
--assert not failed
--test-- "assign nan 6"
failed: yes b: one = one if b [failed: no]
--assert not failed
--test-- "assign nan 7"
failed: yes b: nan <> nan if b [failed: no]
--assert not failed
--test-- "assign nan 8"
failed: yes i: as integer! nan = nan if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 9"
failed: yes i: as integer! one < nan if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 10"
failed: yes i: as integer! one > nan if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 11"
failed: yes i: as integer! nan < one if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 12"
failed: yes i: as integer! nan > one if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 13"
failed: yes i: as integer! one = one if i <> 0 [failed: no]
--assert not failed
--test-- "assign nan 14"
failed: yes i: as integer! nan <> nan if i <> 0 [failed: no]
--assert not failed
--test-- "assign nan 15"
failed: yes i: as integer! (nan = nan) if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 16"
failed: yes i: as integer! (one < nan) if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 17"
failed: yes i: as integer! (one > nan) if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 18"
failed: yes i: as integer! (nan < one) if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 19"
failed: yes i: as integer! (nan > one) if i = 0 [failed: no]
--assert not failed
--test-- "assign nan 10"
failed: yes i: as integer! (one = one) if i <> 0 [failed: no]
--assert not failed
--test-- "assign nan 20"
failed: yes i: as integer! (nan <> nan) if i <> 0 [failed: no]
--assert not failed
;; FIXME: cannot test case return until #810 is resolved
;; check point 11 - case & switch logic return values from nan comparison
; --test-- "case return nan 1"
; failed: yes b: case [true [one <> one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 2"
; failed: yes b: case [true [one <> two]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 3"
; failed: yes b: case [true [nan <> nan]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 4"
; failed: yes b: case [true [one <> nan]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 5"
; failed: yes b: case [true [nan <> one]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 6"
; failed: yes b: case [true [one = one]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 7"
; failed: yes b: case [true [one = two]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 8"
; failed: yes b: case [true [nan = nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 9"
; failed: yes b: case [true [one = nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 10"
; failed: yes b: case [true [nan = one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 11"
; failed: yes b: case [true [one < one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 12"
; failed: yes b: case [true [one < two]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 13"
; failed: yes b: case [true [nan < nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 14"
; failed: yes b: case [true [one < nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 15"
; failed: yes b: case [true [nan < one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 16"
; failed: yes b: case [true [one > one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 17"
; failed: yes b: case [true [one > two]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 18"
; failed: yes b: case [true [nan > nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 19"
; failed: yes b: case [true [one > nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 20"
; failed: yes b: case [true [nan > one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 21"
; failed: yes b: case [true [one <= one]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 22"
; failed: yes b: case [true [one <= two]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 23"
; failed: yes b: case [true [nan <= nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 24"
; failed: yes b: case [true [one <= nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 25"
; failed: yes b: case [true [nan <= one]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 26"
; failed: yes b: case [true [one >= one]] if b [failed: no]
; --assert not failed
; --test-- "case return nan 27"
; failed: yes b: case [true [one >= two]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 28"
; failed: yes b: case [true [nan >= nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 29"
; failed: yes b: case [true [one >= nan]] unless b [failed: no]
; --assert not failed
; --test-- "case return nan 30"
; failed: yes b: case [true [nan >= one]] unless b [failed: no]
; --assert not failed
--test-- "switch return nan 1"
failed: yes b: switch 1 [1 [one <> one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 2"
failed: yes b: switch 1 [1 [one <> two]] if b [failed: no]
--assert not failed
--test-- "switch return nan 3"
failed: yes b: switch 1 [1 [nan <> nan]] if b [failed: no]
--assert not failed
--test-- "switch return nan 4"
failed: yes b: switch 1 [1 [one <> nan]] if b [failed: no]
--assert not failed
--test-- "switch return nan 5"
failed: yes b: switch 1 [1 [nan <> one]] if b [failed: no]
--assert not failed
--test-- "switch return nan 6"
failed: yes b: switch 1 [1 [one = one]] if b [failed: no]
--assert not failed
--test-- "switch return nan 7"
failed: yes b: switch 1 [1 [one = two]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 8"
failed: yes b: switch 1 [1 [nan = nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 9"
failed: yes b: switch 1 [1 [one = nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 10"
failed: yes b: switch 1 [1 [nan = one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 11"
failed: yes b: switch 1 [1 [one < one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 12"
failed: yes b: switch 1 [1 [one < two]] if b [failed: no]
--assert not failed
--test-- "switch return nan 13"
failed: yes b: switch 1 [1 [nan < nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 14"
failed: yes b: switch 1 [1 [one < nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 15"
failed: yes b: switch 1 [1 [nan < one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 16"
failed: yes b: switch 1 [1 [one > one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 17"
failed: yes b: switch 1 [1 [one > two]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 18"
failed: yes b: switch 1 [1 [nan > nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 19"
failed: yes b: switch 1 [1 [one > nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 20"
failed: yes b: switch 1 [1 [nan > one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 21"
failed: yes b: switch 1 [1 [one <= one]] if b [failed: no]
--assert not failed
--test-- "switch return nan 22"
failed: yes b: switch 1 [1 [one <= two]] if b [failed: no]
--assert not failed
--test-- "switch return nan 23"
failed: yes b: switch 1 [1 [nan <= nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 24"
failed: yes b: switch 1 [1 [one <= nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 25"
failed: yes b: switch 1 [1 [nan <= one]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 26"
failed: yes b: switch 1 [1 [one >= one]] if b [failed: no]
--assert not failed
--test-- "switch return nan 27"
failed: yes b: switch 1 [1 [one >= two]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 28"
failed: yes b: switch 1 [1 [nan >= nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 29"
failed: yes b: switch 1 [1 [one >= nan]] unless b [failed: no]
--assert not failed
--test-- "switch return nan 30"
failed: yes b: switch 1 [1 [nan >= one]] unless b [failed: no]
--assert not failed
;; check point 12 - inlined nans in any/all
--test-- "inlined nan 1"
failed: yes unless all [zero / zero <= +inf] [failed: no]
--assert not failed
--test-- "inlined nan 2"
failed: yes unless all [true zero / zero <= +inf] [failed: no]
--assert not failed
--test-- "inlined nan 3"
failed: yes unless all [zero / zero <= +inf true] [failed: no]
--assert not failed
--test-- "inlined nan 4"
failed: yes unless any [zero / zero <= +inf] [failed: no]
--assert not failed
--test-- "inlined nan 5"
failed: yes unless any [zero / zero <= +inf 1 = 2] [failed: no]
--assert not failed
--test-- "inlined nan 6"
failed: yes if any [true zero / zero <= +inf] [failed: no]
--assert not failed
--test-- "inlined nan 7"
failed: yes if any [zero / zero <= +inf true] [failed: no]
--assert not failed
;; check point 13 - funcs ending in either returning logic, passed out of the func
ecmp=: func [c [logic!] a [float32!] b [float32!] return: [logic!]] [either c [a = b][a <> b]]
ecmp<: func [c [logic!] a [float32!] b [float32!] return: [logic!]] [either c [a < b][a >= b]]
ecmp>: func [c [logic!] a [float32!] b [float32!] return: [logic!]] [either c [a > b][a <= b]]
--test-- "return either logic nan 1"
failed: yes unless ecmp= yes nan nan [failed: no]
--assert not failed
--test-- "return either logic nan 2"
failed: yes if ecmp= no nan nan [failed: no]
--assert not failed
--test-- "return either logic nan 3"
failed: yes unless ecmp= yes one nan [failed: no]
--assert not failed
--test-- "return either logic nan 4"
failed: yes if ecmp= no one nan [failed: no]
--assert not failed
--test-- "return either logic nan 5"
failed: yes unless ecmp< yes two one [failed: no]
--assert not failed
--test-- "return either logic nan 6"
failed: yes unless ecmp< no one two [failed: no]
--assert not failed
--test-- "return either logic nan 7"
failed: yes unless ecmp< yes one nan [failed: no]
--assert not failed
--test-- "return either logic nan 8"
failed: yes unless ecmp< no one nan [failed: no]
--assert not failed
--test-- "return either logic nan 9"
failed: yes unless ecmp< yes nan one [failed: no]
--assert not failed
--test-- "return either logic nan 10"
failed: yes unless ecmp< no nan one [failed: no]
--assert not failed
--test-- "return either logic nan 11"
failed: yes unless ecmp> yes one nan [failed: no]
--assert not failed
--test-- "return either logic nan 12"
failed: yes unless ecmp> no one nan [failed: no]
--assert not failed
--test-- "return either logic nan 13"
failed: yes unless ecmp> yes nan one [failed: no]
--assert not failed
--test-- "return either logic nan 14"
failed: yes unless ecmp> no nan one [failed: no]
--assert not failed
===end-group===
===start-group=== "Arithmetic and comparison"
--test-- "float-auto-1"
--assertf32~= as float32! 2147483.0 (( as float32! 0.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-2"
f32-i: as float32! 0.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-3"
--assertf32~= as float32! 3.0 (( as float32! 0.0 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-4"
f32-i: as float32! 0.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-5"
--assertf32~= as float32! 5.0 (( as float32! 0.0 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-6"
f32-i: as float32! 0.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-7"
--assertf32~= as float32! 456.789 (( as float32! 0.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-8"
f32-i: as float32! 0.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-9"
--assertf32~= as float32! 123456.7 (( as float32! 0.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-10"
f32-i: as float32! 0.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-11"
--assertf32~= as float32! 1.222944E+22 (( as float32! 0.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-12"
f32-i: as float32! 0.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-13"
--assertf32~= as float32! 9.99999E-7 (( as float32! 0.0 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-14"
f32-i: as float32! 0.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-15"
--assertf32~= as float32! 7.7E+18 (( as float32! 0.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-16"
f32-i: as float32! 0.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-17"
--assertf32~= as float32! 1.222944E+22 (( as float32! -2147483.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-18"
f32-i: as float32! -2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-19"
--assertf32~= as float32! 7.69999999999785E+18 (( as float32! -2147483.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-20"
f32-i: as float32! -2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-21"
--assertf32~= as float32! 2147483.0 (( as float32! 2147483.0 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-22"
f32-i: as float32! 2147483.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-23"
--assertf32~= as float32! 4294966.0 (( as float32! 2147483.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-24"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4294966.0 f32-k as float32! 1E-6
--test-- "float-auto-25"
--assertf32~= as float32! 2147482.0 (( as float32! 2147483.0 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-26"
f32-i: as float32! 2147483.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-27"
--assertf32~= as float32! 2147486.0 (( as float32! 2147483.0 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-28"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-29"
--assertf32~= as float32! 2147476.0 (( as float32! 2147483.0 ) + ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-30"
f32-i: as float32! 2147483.0
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-31"
--assertf32~= as float32! 2147488.0 (( as float32! 2147483.0 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-32"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-33"
--assertf32~= as float32! 2147939.789 (( as float32! 2147483.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-34"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-35"
--assertf32~= as float32! 2270939.7 (( as float32! 2147483.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-36"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-37"
--assertf32~= as float32! 1.222944E+22 (( as float32! 2147483.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-38"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-39"
--assertf32~= as float32! 2147483.000001 (( as float32! 2147483.0 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-40"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-41"
--assertf32~= as float32! 7.70000000000215E+18 (( as float32! 2147483.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-42"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-43"
--assertf32~= as float32! 2147482.0 (( as float32! -1.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-44"
f32-i: as float32! -1.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-45"
--assertf32~= as float32! 2.0 (( as float32! -1.0 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-46"
f32-i: as float32! -1.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-47"
--assertf32~= as float32! 4.0 (( as float32! -1.0 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-48"
f32-i: as float32! -1.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-49"
--assertf32~= as float32! 455.789 (( as float32! -1.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-50"
f32-i: as float32! -1.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 455.789 f32-k as float32! 1E-6
--test-- "float-auto-51"
--assertf32~= as float32! 123455.7 (( as float32! -1.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-52"
f32-i: as float32! -1.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123455.7 f32-k as float32! 1E-6
--test-- "float-auto-53"
--assertf32~= as float32! 1.222944E+22 (( as float32! -1.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-54"
f32-i: as float32! -1.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-55"
--assertf32~= as float32! 7.7E+18 (( as float32! -1.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-56"
f32-i: as float32! -1.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-57"
--assertf32~= as float32! 3.0 (( as float32! 3.0 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-58"
f32-i: as float32! 3.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-59"
--assertf32~= as float32! 2147486.0 (( as float32! 3.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-60"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-61"
--assertf32~= as float32! 2.0 (( as float32! 3.0 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-62"
f32-i: as float32! 3.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-63"
--assertf32~= as float32! 6.0 (( as float32! 3.0 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-64"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-65"
--assertf32~= as float32! 8.0 (( as float32! 3.0 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-66"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 8.0 f32-k as float32! 1E-6
--test-- "float-auto-67"
--assertf32~= as float32! 459.789 (( as float32! 3.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-68"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 459.789 f32-k as float32! 1E-6
--test-- "float-auto-69"
--assertf32~= as float32! 123459.7 (( as float32! 3.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-70"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123459.7 f32-k as float32! 1E-6
--test-- "float-auto-71"
--assertf32~= as float32! 1.222944E+22 (( as float32! 3.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-72"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-73"
--assertf32~= as float32! 3.000000999999 (( as float32! 3.0 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-74"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-75"
--assertf32~= as float32! 7.7E+18 (( as float32! 3.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-76"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-77"
--assertf32~= as float32! 2147476.0 (( as float32! -7.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-78"
f32-i: as float32! -7.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-79"
--assertf32~= as float32! 449.789 (( as float32! -7.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-80"
f32-i: as float32! -7.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 449.789 f32-k as float32! 1E-6
--test-- "float-auto-81"
--assertf32~= as float32! 123449.7 (( as float32! -7.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-82"
f32-i: as float32! -7.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123449.7 f32-k as float32! 1E-6
--test-- "float-auto-83"
--assertf32~= as float32! 1.222944E+22 (( as float32! -7.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-84"
f32-i: as float32! -7.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-85"
--assertf32~= as float32! 7.7E+18 (( as float32! -7.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-86"
f32-i: as float32! -7.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-87"
--assertf32~= as float32! 5.0 (( as float32! 5.0 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-88"
f32-i: as float32! 5.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-89"
--assertf32~= as float32! 2147488.0 (( as float32! 5.0 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-90"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-91"
--assertf32~= as float32! 4.0 (( as float32! 5.0 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-92"
f32-i: as float32! 5.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-93"
--assertf32~= as float32! 8.0 (( as float32! 5.0 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-94"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 8.0 f32-k as float32! 1E-6
--test-- "float-auto-95"
--assertf32~= as float32! 10.0 (( as float32! 5.0 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-96"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 10.0 f32-k as float32! 1E-6
--test-- "float-auto-97"
--assertf32~= as float32! 461.789 (( as float32! 5.0 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-98"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 461.789 f32-k as float32! 1E-6
--test-- "float-auto-99"
--assertf32~= as float32! 123461.7 (( as float32! 5.0 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-100"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123461.7 f32-k as float32! 1E-6
--test-- "float-auto-101"
--assertf32~= as float32! 1.222944E+22 (( as float32! 5.0 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-102"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-103"
--assertf32~= as float32! 5.000000999999 (( as float32! 5.0 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-104"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-105"
--assertf32~= as float32! 7.7E+18 (( as float32! 5.0 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-106"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-107"
--assertf32~= as float32! 456.789 (( as float32! 456.789 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-108"
f32-i: as float32! 456.789
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-109"
--assertf32~= as float32! 2147939.789 (( as float32! 456.789 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-110"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-111"
--assertf32~= as float32! 455.789 (( as float32! 456.789 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-112"
f32-i: as float32! 456.789
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 455.789 f32-k as float32! 1E-6
--test-- "float-auto-113"
--assertf32~= as float32! 459.789 (( as float32! 456.789 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-114"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 459.789 f32-k as float32! 1E-6
--test-- "float-auto-115"
--assertf32~= as float32! 449.789 (( as float32! 456.789 ) + ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-116"
f32-i: as float32! 456.789
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 449.789 f32-k as float32! 1E-6
--test-- "float-auto-117"
--assertf32~= as float32! 461.789 (( as float32! 456.789 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-118"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 461.789 f32-k as float32! 1E-6
--test-- "float-auto-119"
--assertf32~= as float32! 913.578 (( as float32! 456.789 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-120"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 913.578 f32-k as float32! 1E-6
--test-- "float-auto-121"
--assertf32~= as float32! 123913.489 (( as float32! 456.789 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-122"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123913.489 f32-k as float32! 1E-6
--test-- "float-auto-123"
--assertf32~= as float32! 1.222944E+22 (( as float32! 456.789 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-124"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-125"
--assertf32~= as float32! 456.789000999999 (( as float32! 456.789 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-126"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789000999999 f32-k as float32! 1E-6
--test-- "float-auto-127"
--assertf32~= as float32! 7.7E+18 (( as float32! 456.789 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-128"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-129"
--assertf32~= as float32! 123456.7 (( as float32! 123456.7 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-130"
f32-i: as float32! 123456.7
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-131"
--assertf32~= as float32! 2270939.7 (( as float32! 123456.7 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-132"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-133"
--assertf32~= as float32! 123455.7 (( as float32! 123456.7 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-134"
f32-i: as float32! 123456.7
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123455.7 f32-k as float32! 1E-6
--test-- "float-auto-135"
--assertf32~= as float32! 123459.7 (( as float32! 123456.7 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-136"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123459.7 f32-k as float32! 1E-6
--test-- "float-auto-137"
--assertf32~= as float32! 123449.7 (( as float32! 123456.7 ) + ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-138"
f32-i: as float32! 123456.7
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123449.7 f32-k as float32! 1E-6
--test-- "float-auto-139"
--assertf32~= as float32! 123461.7 (( as float32! 123456.7 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-140"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123461.7 f32-k as float32! 1E-6
--test-- "float-auto-141"
--assertf32~= as float32! 123913.489 (( as float32! 123456.7 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-142"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 123913.489 f32-k as float32! 1E-6
--test-- "float-auto-143"
--assertf32~= as float32! 246913.4 (( as float32! 123456.7 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-144"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 246913.4 f32-k as float32! 1E-6
--test-- "float-auto-145"
--assertf32~= as float32! 1.222944E+22 (( as float32! 123456.7 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-146"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-147"
--assertf32~= as float32! 123456.700001 (( as float32! 123456.7 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-148"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.700001 f32-k as float32! 1E-6
--test-- "float-auto-149"
--assertf32~= as float32! 7.70000000000012E+18 (( as float32! 123456.7 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-150"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000012E+18 f32-k as float32! 1E-6
--test-- "float-auto-151"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-152"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-153"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-154"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-155"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-156"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-157"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-158"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-159"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-160"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-161"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-162"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-163"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-164"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-165"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-166"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-167"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-168"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-169"
--assertf32~= as float32! 2.445888E+22 (( as float32! 1.222944E+22 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-170"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.445888E+22 f32-k as float32! 1E-6
--test-- "float-auto-171"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-172"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-173"
--assertf32~= as float32! 1.223714E+22 (( as float32! 1.222944E+22 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-174"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.223714E+22 f32-k as float32! 1E-6
--test-- "float-auto-175"
--assertf32~= as float32! 9.99999E-7 (( as float32! 9.99999E-7 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-176"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-177"
--assertf32~= as float32! 2147483.000001 (( as float32! 9.99999E-7 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-178"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-179"
--assertf32~= as float32! 3.000000999999 (( as float32! 9.99999E-7 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-180"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-181"
--assertf32~= as float32! 5.000000999999 (( as float32! 9.99999E-7 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-182"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-183"
--assertf32~= as float32! 456.789000999999 (( as float32! 9.99999E-7 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-184"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789000999999 f32-k as float32! 1E-6
--test-- "float-auto-185"
--assertf32~= as float32! 123456.700001 (( as float32! 9.99999E-7 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-186"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.700001 f32-k as float32! 1E-6
--test-- "float-auto-187"
--assertf32~= as float32! 1.222944E+22 (( as float32! 9.99999E-7 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-188"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-189"
--assertf32~= as float32! 1.999998E-6 (( as float32! 9.99999E-7 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-190"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.999998E-6 f32-k as float32! 1E-6
--test-- "float-auto-191"
--assertf32~= as float32! 7.7E+18 (( as float32! 9.99999E-7 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-192"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-193"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-194"
f32-i: as float32! 7.7E+18
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-195"
--assertf32~= as float32! 7.69999999999785E+18 (( as float32! 7.7E+18 ) + ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-196"
f32-i: as float32! 7.7E+18
f32-j: as float32! -2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-197"
--assertf32~= as float32! 7.70000000000215E+18 (( as float32! 7.7E+18 ) + ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-198"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-199"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-200"
f32-i: as float32! 7.7E+18
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-201"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-202"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-203"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-204"
f32-i: as float32! 7.7E+18
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-205"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-206"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-207"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-208"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-209"
--assertf32~= as float32! 7.70000000000012E+18 (( as float32! 7.7E+18 ) + ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-210"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000012E+18 f32-k as float32! 1E-6
--test-- "float-auto-211"
--assertf32~= as float32! 1.223714E+22 (( as float32! 7.7E+18 ) + ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-212"
f32-i: as float32! 7.7E+18
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.223714E+22 f32-k as float32! 1E-6
--test-- "float-auto-213"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) + ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-214"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-215"
--assertf32~= as float32! 1.54E+19 (( as float32! 7.7E+18 ) + ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-216"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.54E+19 f32-k as float32! 1E-6
--test-- "float-auto-217"
--assertf32~= as float32! 2147483.0 (( as float32! 0.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-218"
f32-i: as float32! 0.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-219"
--assertf32~= as float32! 1.0 (( as float32! 0.0 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-220"
f32-i: as float32! 0.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-221"
--assertf32~= as float32! 7.0 (( as float32! 0.0 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-222"
f32-i: as float32! 0.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-223"
--assertf32~= as float32! 2147483.0 (( as float32! 2147483.0 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-224"
f32-i: as float32! 2147483.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-225"
--assertf32~= as float32! 4294966.0 (( as float32! 2147483.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-226"
f32-i: as float32! 2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 4294966.0 f32-k as float32! 1E-6
--test-- "float-auto-227"
--assertf32~= as float32! 2147484.0 (( as float32! 2147483.0 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-228"
f32-i: as float32! 2147483.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147484.0 f32-k as float32! 1E-6
--test-- "float-auto-229"
--assertf32~= as float32! 2147480.0 (( as float32! 2147483.0 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-230"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147480.0 f32-k as float32! 1E-6
--test-- "float-auto-231"
--assertf32~= as float32! 2147490.0 (( as float32! 2147483.0 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-232"
f32-i: as float32! 2147483.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147490.0 f32-k as float32! 1E-6
--test-- "float-auto-233"
--assertf32~= as float32! 2147478.0 (( as float32! 2147483.0 ) - ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-234"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147478.0 f32-k as float32! 1E-6
--test-- "float-auto-235"
--assertf32~= as float32! 2147026.211 (( as float32! 2147483.0 ) - ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-236"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147026.211 f32-k as float32! 1E-6
--test-- "float-auto-237"
--assertf32~= as float32! 2024026.3 (( as float32! 2147483.0 ) - ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-238"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2024026.3 f32-k as float32! 1E-6
--test-- "float-auto-239"
--assertf32~= as float32! 2147482.999999 (( as float32! 2147483.0 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-240"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147482.999999 f32-k as float32! 1E-6
--test-- "float-auto-241"
--assertf32~= as float32! 2147482.0 (( as float32! -1.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-242"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-243"
--assertf32~= as float32! 6.0 (( as float32! -1.0 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-244"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-245"
--assertf32~= as float32! 3.0 (( as float32! 3.0 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-246"
f32-i: as float32! 3.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-247"
--assertf32~= as float32! 2147486.0 (( as float32! 3.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-248"
f32-i: as float32! 3.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-249"
--assertf32~= as float32! 4.0 (( as float32! 3.0 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-250"
f32-i: as float32! 3.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-251"
--assertf32~= as float32! 10.0 (( as float32! 3.0 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-252"
f32-i: as float32! 3.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 10.0 f32-k as float32! 1E-6
--test-- "float-auto-253"
--assertf32~= as float32! 2.999999000001 (( as float32! 3.0 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-254"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2.999999000001 f32-k as float32! 1E-6
--test-- "float-auto-255"
--assertf32~= as float32! 2147476.0 (( as float32! -7.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-256"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-257"
--assertf32~= as float32! 5.0 (( as float32! 5.0 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-258"
f32-i: as float32! 5.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-259"
--assertf32~= as float32! 2147488.0 (( as float32! 5.0 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-260"
f32-i: as float32! 5.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-261"
--assertf32~= as float32! 6.0 (( as float32! 5.0 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-262"
f32-i: as float32! 5.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-263"
--assertf32~= as float32! 2.0 (( as float32! 5.0 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-264"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-265"
--assertf32~= as float32! 12.0 (( as float32! 5.0 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-266"
f32-i: as float32! 5.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 12.0 f32-k as float32! 1E-6
--test-- "float-auto-267"
--assertf32~= as float32! 4.999999000001 (( as float32! 5.0 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-268"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 4.999999000001 f32-k as float32! 1E-6
--test-- "float-auto-269"
--assertf32~= as float32! 456.789 (( as float32! 456.789 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-270"
f32-i: as float32! 456.789
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-271"
--assertf32~= as float32! 2147939.789 (( as float32! 456.789 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-272"
f32-i: as float32! 456.789
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-273"
--assertf32~= as float32! 457.789 (( as float32! 456.789 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-274"
f32-i: as float32! 456.789
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 457.789 f32-k as float32! 1E-6
--test-- "float-auto-275"
--assertf32~= as float32! 453.789 (( as float32! 456.789 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-276"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 453.789 f32-k as float32! 1E-6
--test-- "float-auto-277"
--assertf32~= as float32! 463.789 (( as float32! 456.789 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-278"
f32-i: as float32! 456.789
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 463.789 f32-k as float32! 1E-6
--test-- "float-auto-279"
--assertf32~= as float32! 451.789 (( as float32! 456.789 ) - ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-280"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 451.789 f32-k as float32! 1E-6
--test-- "float-auto-281"
--assertf32~= as float32! 456.788999000001 (( as float32! 456.789 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-282"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 456.788999000001 f32-k as float32! 1E-6
--test-- "float-auto-283"
--assertf32~= as float32! 123456.7 (( as float32! 123456.7 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-284"
f32-i: as float32! 123456.7
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-285"
--assertf32~= as float32! 2270939.7 (( as float32! 123456.7 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-286"
f32-i: as float32! 123456.7
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-287"
--assertf32~= as float32! 123457.7 (( as float32! 123456.7 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-288"
f32-i: as float32! 123456.7
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123457.7 f32-k as float32! 1E-6
--test-- "float-auto-289"
--assertf32~= as float32! 123453.7 (( as float32! 123456.7 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-290"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123453.7 f32-k as float32! 1E-6
--test-- "float-auto-291"
--assertf32~= as float32! 123463.7 (( as float32! 123456.7 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-292"
f32-i: as float32! 123456.7
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123463.7 f32-k as float32! 1E-6
--test-- "float-auto-293"
--assertf32~= as float32! 123451.7 (( as float32! 123456.7 ) - ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-294"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123451.7 f32-k as float32! 1E-6
--test-- "float-auto-295"
--assertf32~= as float32! 122999.911 (( as float32! 123456.7 ) - ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-296"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 122999.911 f32-k as float32! 1E-6
--test-- "float-auto-297"
--assertf32~= as float32! 123456.699999 (( as float32! 123456.7 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-298"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 123456.699999 f32-k as float32! 1E-6
--test-- "float-auto-299"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-300"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-301"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-302"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-303"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-304"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-305"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-306"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-307"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-308"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-309"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-310"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-311"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-312"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-313"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-314"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-315"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-316"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-317"
--assertf32~= as float32! 1.222944E+22 (( as float32! 1.222944E+22 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-318"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-319"
--assertf32~= as float32! 1.222174E+22 (( as float32! 1.222944E+22 ) - ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-320"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222174E+22 f32-k as float32! 1E-6
--test-- "float-auto-321"
--assertf32~= as float32! 9.99999E-7 (( as float32! 9.99999E-7 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-322"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-323"
--assertf32~= as float32! 2147483.000001 (( as float32! 9.99999E-7 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-324"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-325"
--assertf32~= as float32! 1.000000999999 (( as float32! 9.99999E-7 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-326"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-327"
--assertf32~= as float32! 7.000000999999 (( as float32! 9.99999E-7 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-328"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-329"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! 0.0 ) ) as float32! 1E-6
--test-- "float-auto-330"
f32-i: as float32! 7.7E+18
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-331"
--assertf32~= as float32! 7.70000000000215E+18 (( as float32! 7.7E+18 ) - ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-332"
f32-i: as float32! 7.7E+18
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-333"
--assertf32~= as float32! 7.69999999999785E+18 (( as float32! 7.7E+18 ) - ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-334"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-335"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-336"
f32-i: as float32! 7.7E+18
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-337"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-338"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-339"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-340"
f32-i: as float32! 7.7E+18
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-341"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-342"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-343"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-344"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-345"
--assertf32~= as float32! 7.69999999999988E+18 (( as float32! 7.7E+18 ) - ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-346"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.69999999999988E+18 f32-k as float32! 1E-6
--test-- "float-auto-347"
--assertf32~= as float32! 7.7E+18 (( as float32! 7.7E+18 ) - ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-348"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-349"
--assertf32~= as float32! 4611683235289.0 (( as float32! -2147483.0 ) * ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-350"
f32-i: as float32! -2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4611683235289.0 f32-k as float32! 1E-6
--test-- "float-auto-351"
--assertf32~= as float32! 2147483.0 (( as float32! -2147483.0 ) * ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-352"
f32-i: as float32! -2147483.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-353"
--assertf32~= as float32! 15032381.0 (( as float32! -2147483.0 ) * ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-354"
f32-i: as float32! -2147483.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15032381.0 f32-k as float32! 1E-6
--test-- "float-auto-355"
--assertf32~= as float32! 4611683235289.0 (( as float32! 2147483.0 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-356"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4611683235289.0 f32-k as float32! 1E-6
--test-- "float-auto-357"
--assertf32~= as float32! 6442449.0 (( as float32! 2147483.0 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-358"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6442449.0 f32-k as float32! 1E-6
--test-- "float-auto-359"
--assertf32~= as float32! 10737415.0 (( as float32! 2147483.0 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-360"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 10737415.0 f32-k as float32! 1E-6
--test-- "float-auto-361"
--assertf32~= as float32! 980946612.087 (( as float32! 2147483.0 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-362"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 980946612.087 f32-k as float32! 1E-6
--test-- "float-auto-363"
--assertf32~= as float32! 265121164486.1 (( as float32! 2147483.0 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-364"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 265121164486.1 f32-k as float32! 1E-6
--test-- "float-auto-365"
--assertf32~= as float32! 2.626251449952E+28 (( as float32! 2147483.0 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-366"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.626251449952E+28 f32-k as float32! 1E-6
--test-- "float-auto-367"
--assertf32~= as float32! 2.147480852517 (( as float32! 2147483.0 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-368"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.147480852517 f32-k as float32! 1E-6
--test-- "float-auto-369"
--assertf32~= as float32! 1.65356191E+25 (( as float32! 2147483.0 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-370"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.65356191E+25 f32-k as float32! 1E-6
--test-- "float-auto-371"
--assertf32~= as float32! 2147483.0 (( as float32! -1.0 ) * ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-372"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-373"
--assertf32~= as float32! 1.0 (( as float32! -1.0 ) * ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-374"
f32-i: as float32! -1.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-375"
--assertf32~= as float32! 7.0 (( as float32! -1.0 ) * ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-376"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-377"
--assertf32~= as float32! 6442449.0 (( as float32! 3.0 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-378"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6442449.0 f32-k as float32! 1E-6
--test-- "float-auto-379"
--assertf32~= as float32! 9.0 (( as float32! 3.0 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-380"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.0 f32-k as float32! 1E-6
--test-- "float-auto-381"
--assertf32~= as float32! 15.0 (( as float32! 3.0 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-382"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15.0 f32-k as float32! 1E-6
--test-- "float-auto-383"
--assertf32~= as float32! 1370.367 (( as float32! 3.0 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-384"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 1370.367 f32-k as float32! 1E-6
--test-- "float-auto-385"
--assertf32~= as float32! 370370.1 (( as float32! 3.0 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-386"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 370370.1 f32-k as float32! 1E-6
--test-- "float-auto-387"
--assertf32~= as float32! 3.668832E+22 (( as float32! 3.0 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-388"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.668832E+22 f32-k as float32! 1E-6
--test-- "float-auto-389"
--assertf32~= as float32! 2.999997E-6 (( as float32! 3.0 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-390"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.999997E-6 f32-k as float32! 1E-6
--test-- "float-auto-391"
--assertf32~= as float32! 2.31E+19 (( as float32! 3.0 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-392"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.31E+19 f32-k as float32! 1E-6
--test-- "float-auto-393"
--assertf32~= as float32! 15032381.0 (( as float32! -7.0 ) * ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-394"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15032381.0 f32-k as float32! 1E-6
--test-- "float-auto-395"
--assertf32~= as float32! 7.0 (( as float32! -7.0 ) * ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-396"
f32-i: as float32! -7.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-397"
--assertf32~= as float32! 49.0 (( as float32! -7.0 ) * ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-398"
f32-i: as float32! -7.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 49.0 f32-k as float32! 1E-6
--test-- "float-auto-399"
--assertf32~= as float32! 10737415.0 (( as float32! 5.0 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-400"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 10737415.0 f32-k as float32! 1E-6
--test-- "float-auto-401"
--assertf32~= as float32! 15.0 (( as float32! 5.0 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-402"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15.0 f32-k as float32! 1E-6
--test-- "float-auto-403"
--assertf32~= as float32! 25.0 (( as float32! 5.0 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-404"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 25.0 f32-k as float32! 1E-6
--test-- "float-auto-405"
--assertf32~= as float32! 2283.945 (( as float32! 5.0 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-406"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 2283.945 f32-k as float32! 1E-6
--test-- "float-auto-407"
--assertf32~= as float32! 617283.5 (( as float32! 5.0 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-408"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 617283.5 f32-k as float32! 1E-6
--test-- "float-auto-409"
--assertf32~= as float32! 6.11472E+22 (( as float32! 5.0 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-410"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 6.11472E+22 f32-k as float32! 1E-6
--test-- "float-auto-411"
--assertf32~= as float32! 4.999995E-6 (( as float32! 5.0 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-412"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.999995E-6 f32-k as float32! 1E-6
--test-- "float-auto-413"
--assertf32~= as float32! 3.85E+19 (( as float32! 5.0 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-414"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.85E+19 f32-k as float32! 1E-6
--test-- "float-auto-415"
--assertf32~= as float32! 980946612.087 (( as float32! 456.789 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-416"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 980946612.087 f32-k as float32! 1E-6
--test-- "float-auto-417"
--assertf32~= as float32! 1370.367 (( as float32! 456.789 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-418"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1370.367 f32-k as float32! 1E-6
--test-- "float-auto-419"
--assertf32~= as float32! 2283.945 (( as float32! 456.789 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-420"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2283.945 f32-k as float32! 1E-6
--test-- "float-auto-421"
--assertf32~= as float32! 208656.190521 (( as float32! 456.789 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-422"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 208656.190521 f32-k as float32! 1E-6
--test-- "float-auto-423"
--assertf32~= as float32! 56393662.5363 (( as float32! 456.789 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-424"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 56393662.5363 f32-k as float32! 1E-6
--test-- "float-auto-425"
--assertf32~= as float32! 5.58627366816E+24 (( as float32! 456.789 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-426"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.58627366816E+24 f32-k as float32! 1E-6
--test-- "float-auto-427"
--assertf32~= as float32! 4.56788543211E-4 (( as float32! 456.789 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-428"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.56788543211E-4 f32-k as float32! 1E-6
--test-- "float-auto-429"
--assertf32~= as float32! 3.5172753E+21 (( as float32! 456.789 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-430"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.5172753E+21 f32-k as float32! 1E-6
--test-- "float-auto-431"
--assertf32~= as float32! 265121164486.1 (( as float32! 123456.7 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-432"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 265121164486.1 f32-k as float32! 1E-6
--test-- "float-auto-433"
--assertf32~= as float32! 370370.1 (( as float32! 123456.7 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-434"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 370370.1 f32-k as float32! 1E-6
--test-- "float-auto-435"
--assertf32~= as float32! 617283.5 (( as float32! 123456.7 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-436"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 617283.5 f32-k as float32! 1E-6
--test-- "float-auto-437"
--assertf32~= as float32! 56393662.5363 (( as float32! 123456.7 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-438"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 56393662.5363 f32-k as float32! 1E-6
--test-- "float-auto-439"
--assertf32~= as float32! 15241556774.89 (( as float32! 123456.7 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-440"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 15241556774.89 f32-k as float32! 1E-6
--test-- "float-auto-441"
--assertf32~= as float32! 1.509806305248E+27 (( as float32! 123456.7 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-442"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.509806305248E+27 f32-k as float32! 1E-6
--test-- "float-auto-443"
--assertf32~= as float32! 0.1234565765433 (( as float32! 123456.7 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-444"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 0.1234565765433 f32-k as float32! 1E-6
--test-- "float-auto-445"
--assertf32~= as float32! 9.5061659E+23 (( as float32! 123456.7 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-446"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.5061659E+23 f32-k as float32! 1E-6
--test-- "float-auto-447"
--assertf32~= as float32! 2.626251449952E+28 (( as float32! 1.222944E+22 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-448"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.626251449952E+28 f32-k as float32! 1E-6
--test-- "float-auto-449"
--assertf32~= as float32! 3.668832E+22 (( as float32! 1.222944E+22 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-450"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.668832E+22 f32-k as float32! 1E-6
--test-- "float-auto-451"
--assertf32~= as float32! 6.11472E+22 (( as float32! 1.222944E+22 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-452"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6.11472E+22 f32-k as float32! 1E-6
--test-- "float-auto-453"
--assertf32~= as float32! 5.58627366816E+24 (( as float32! 1.222944E+22 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-454"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.58627366816E+24 f32-k as float32! 1E-6
--test-- "float-auto-455"
--assertf32~= as float32! 1.509806305248E+27 (( as float32! 1.222944E+22 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-456"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.509806305248E+27 f32-k as float32! 1E-6
--test-- "float-auto-457"
--assertf32~= as float32! 1.222942777056E+16 (( as float32! 1.222944E+22 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-458"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.222942777056E+16 f32-k as float32! 1E-6
--test-- "float-auto-459"
--assertf32~= as float32! 2.147480852517 (( as float32! 9.99999E-7 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-460"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.147480852517 f32-k as float32! 1E-6
--test-- "float-auto-461"
--assertf32~= as float32! 2.999997E-6 (( as float32! 9.99999E-7 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-462"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.999997E-6 f32-k as float32! 1E-6
--test-- "float-auto-463"
--assertf32~= as float32! 4.999995E-6 (( as float32! 9.99999E-7 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-464"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.999995E-6 f32-k as float32! 1E-6
--test-- "float-auto-465"
--assertf32~= as float32! 4.56788543211E-4 (( as float32! 9.99999E-7 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-466"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.56788543211E-4 f32-k as float32! 1E-6
--test-- "float-auto-467"
--assertf32~= as float32! 0.1234565765433 (( as float32! 9.99999E-7 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-468"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 0.1234565765433 f32-k as float32! 1E-6
--test-- "float-auto-469"
--assertf32~= as float32! 1.222942777056E+16 (( as float32! 9.99999E-7 ) * ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-470"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.222942777056E+16 f32-k as float32! 1E-6
--test-- "float-auto-471"
--assertf32~= as float32! 9.99998000001E-13 (( as float32! 9.99999E-7 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-472"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.99998000001E-13 f32-k as float32! 1E-6
--test-- "float-auto-473"
--assertf32~= as float32! 7699992300000.0 (( as float32! 9.99999E-7 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-474"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 7699992300000.0 f32-k as float32! 1E-6
--test-- "float-auto-475"
--assertf32~= as float32! 1.65356191E+25 (( as float32! 7.7E+18 ) * ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-476"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.65356191E+25 f32-k as float32! 1E-6
--test-- "float-auto-477"
--assertf32~= as float32! 2.31E+19 (( as float32! 7.7E+18 ) * ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-478"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.31E+19 f32-k as float32! 1E-6
--test-- "float-auto-479"
--assertf32~= as float32! 3.85E+19 (( as float32! 7.7E+18 ) * ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-480"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.85E+19 f32-k as float32! 1E-6
--test-- "float-auto-481"
--assertf32~= as float32! 3.5172753E+21 (( as float32! 7.7E+18 ) * ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-482"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.5172753E+21 f32-k as float32! 1E-6
--test-- "float-auto-483"
--assertf32~= as float32! 9.5061659E+23 (( as float32! 7.7E+18 ) * ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-484"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.5061659E+23 f32-k as float32! 1E-6
--test-- "float-auto-485"
--assertf32~= as float32! 7699992300000.0 (( as float32! 7.7E+18 ) * ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-486"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 7699992300000.0 f32-k as float32! 1E-6
--test-- "float-auto-487"
--assertf32~= as float32! 5.929E+37 (( as float32! 7.7E+18 ) * ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-488"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.929E+37 f32-k as float32! 1E-6
--test-- "float-auto-489"
--assertf32~= as float32! 1.0 (( as float32! -2147483.0 ) / ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-490"
f32-i: as float32! -2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-491"
--assertf32~= as float32! 2147483.0 (( as float32! -2147483.0 ) / ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-492"
f32-i: as float32! -2147483.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-493"
--assertf32~= as float32! 306783.285714286 (( as float32! -2147483.0 ) / ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-494"
f32-i: as float32! -2147483.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 306783.285714286 f32-k as float32! 1E-6
--test-- "float-auto-495"
--assertf32~= as float32! 1.0 (( as float32! 2147483.0 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-496"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-497"
--assertf32~= as float32! 715827.666666667 (( as float32! 2147483.0 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-498"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 715827.666666667 f32-k as float32! 1E-6
--test-- "float-auto-499"
--assertf32~= as float32! 429496.6 (( as float32! 2147483.0 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-500"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 429496.6 f32-k as float32! 1E-6
--test-- "float-auto-501"
--assertf32~= as float32! 4701.25813012135 (( as float32! 2147483.0 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-502"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 4701.25813012135 f32-k as float32! 1E-6
--test-- "float-auto-503"
--assertf32~= as float32! 17.3946249980762 (( as float32! 2147483.0 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-504"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 17.3946249980762 f32-k as float32! 1E-6
--test-- "float-auto-505"
--assertf32~= as float32! 1.75599455085433E-16 (( as float32! 2147483.0 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-506"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.75599455085433E-16 f32-k as float32! 1E-6
--test-- "float-auto-507"
--assertf32~= as float32! 2147485147485.15 (( as float32! 2147483.0 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-508"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 2147485147485.15 f32-k as float32! 1E-6
--test-- "float-auto-509"
--assertf32~= as float32! 2.78893896103896E-13 (( as float32! 2147483.0 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-510"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.78893896103896E-13 f32-k as float32! 1E-6
--test-- "float-auto-511"
--assertf32~= as float32! 4.65661427820383E-7 (( as float32! -1.0 ) / ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-512"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.65661427820383E-7 f32-k as float32! 1E-6
--test-- "float-auto-513"
--assertf32~= as float32! 1.0 (( as float32! -1.0 ) / ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-514"
f32-i: as float32! -1.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-515"
--assertf32~= as float32! 0.142857142857143 (( as float32! -1.0 ) / ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-516"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 0.142857142857143 f32-k as float32! 1E-6
--test-- "float-auto-517"
--assertf32~= as float32! 1.39698428346115E-6 (( as float32! 3.0 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-518"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.39698428346115E-6 f32-k as float32! 1E-6
--test-- "float-auto-519"
--assertf32~= as float32! 1.0 (( as float32! 3.0 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-520"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-521"
--assertf32~= as float32! 0.6 (( as float32! 3.0 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-522"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 0.6 f32-k as float32! 1E-6
--test-- "float-auto-523"
--assertf32~= as float32! 6.56758372027347E-3 (( as float32! 3.0 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-524"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.56758372027347E-3 f32-k as float32! 1E-6
--test-- "float-auto-525"
--assertf32~= as float32! 2.4300017739013E-5 (( as float32! 3.0 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-526"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.4300017739013E-5 f32-k as float32! 1E-6
--test-- "float-auto-527"
--assertf32~= as float32! 2.45309678938692E-22 (( as float32! 3.0 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-528"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.45309678938692E-22 f32-k as float32! 1E-6
--test-- "float-auto-529"
--assertf32~= as float32! 3000003.000003 (( as float32! 3.0 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-530"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 3000003.000003 f32-k as float32! 1E-6
--test-- "float-auto-531"
--assertf32~= as float32! 3.8961038961039E-19 (( as float32! 3.0 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-532"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.8961038961039E-19 f32-k as float32! 1E-6
--test-- "float-auto-533"
--assertf32~= as float32! 3.25962999474268E-6 (( as float32! -7.0 ) / ( as float32! -2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-534"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.25962999474268E-6 f32-k as float32! 1E-6
--test-- "float-auto-535"
--assertf32~= as float32! 7.0 (( as float32! -7.0 ) / ( as float32! -1.0 ) ) as float32! 1E-6
--test-- "float-auto-536"
f32-i: as float32! -7.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-537"
--assertf32~= as float32! 1.0 (( as float32! -7.0 ) / ( as float32! -7.0 ) ) as float32! 1E-6
--test-- "float-auto-538"
f32-i: as float32! -7.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-539"
--assertf32~= as float32! 2.32830713910192E-6 (( as float32! 5.0 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-540"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.32830713910192E-6 f32-k as float32! 1E-6
--test-- "float-auto-541"
--assertf32~= as float32! 1.66666666666667 (( as float32! 5.0 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-542"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.66666666666667 f32-k as float32! 1E-6
--test-- "float-auto-543"
--assertf32~= as float32! 1.0 (( as float32! 5.0 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-544"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-545"
--assertf32~= as float32! 1.09459728671225E-2 (( as float32! 5.0 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-546"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.09459728671225E-2 f32-k as float32! 1E-6
--test-- "float-auto-547"
--assertf32~= as float32! 4.05000295650216E-5 (( as float32! 5.0 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-548"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.05000295650216E-5 f32-k as float32! 1E-6
--test-- "float-auto-549"
--assertf32~= as float32! 4.0884946489782E-22 (( as float32! 5.0 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-550"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.0884946489782E-22 f32-k as float32! 1E-6
--test-- "float-auto-551"
--assertf32~= as float32! 5000005.000005 (( as float32! 5.0 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-552"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 5000005.000005 f32-k as float32! 1E-6
--test-- "float-auto-553"
--assertf32~= as float32! 6.49350649350649E-19 (( as float32! 5.0 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-554"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.49350649350649E-19 f32-k as float32! 1E-6
--test-- "float-auto-555"
--assertf32~= as float32! 2.12709017952645E-4 (( as float32! 456.789 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-556"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.12709017952645E-4 f32-k as float32! 1E-6
--test-- "float-auto-557"
--assertf32~= as float32! 152.263 (( as float32! 456.789 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-558"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 152.263 f32-k as float32! 1E-6
--test-- "float-auto-559"
--assertf32~= as float32! 91.3578 (( as float32! 456.789 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-560"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 91.3578 f32-k as float32! 1E-6
--test-- "float-auto-561"
--assertf32~= as float32! 1.0 (( as float32! 456.789 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-562"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-563"
--assertf32~= as float32! 3.69999360099533E-3 (( as float32! 456.789 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-564"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.69999360099533E-3 f32-k as float32! 1E-6
--test-- "float-auto-565"
--assertf32~= as float32! 3.73515876442421E-20 (( as float32! 456.789 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-566"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.73515876442421E-20 f32-k as float32! 1E-6
--test-- "float-auto-567"
--assertf32~= as float32! 456789456.789457 (( as float32! 456.789 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-568"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 456789456.789457 f32-k as float32! 1E-6
--test-- "float-auto-569"
--assertf32~= as float32! 5.93232467532468E-17 (( as float32! 456.789 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-570"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.93232467532468E-17 f32-k as float32! 1E-6
--test-- "float-auto-571"
--assertf32~= as float32! 5.74890231959927E-2 (( as float32! 123456.7 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-572"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.74890231959927E-2 f32-k as float32! 1E-6
--test-- "float-auto-573"
--assertf32~= as float32! 41152.2333333333 (( as float32! 123456.7 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-574"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 41152.2333333333 f32-k as float32! 1E-6
--test-- "float-auto-575"
--assertf32~= as float32! 24691.34 (( as float32! 123456.7 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-576"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 24691.34 f32-k as float32! 1E-6
--test-- "float-auto-577"
--assertf32~= as float32! 270.270737692895 (( as float32! 123456.7 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-578"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 270.270737692895 f32-k as float32! 1E-6
--test-- "float-auto-579"
--assertf32~= as float32! 1.0 (( as float32! 123456.7 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-580"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-581"
--assertf32~= as float32! 1.00950411466101E-17 (( as float32! 123456.7 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-582"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.00950411466101E-17 f32-k as float32! 1E-6
--test-- "float-auto-583"
--assertf32~= as float32! 123456823456.823 (( as float32! 123456.7 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-584"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 123456823456.823 f32-k as float32! 1E-6
--test-- "float-auto-585"
--assertf32~= as float32! 1.60333376623377E-14 (( as float32! 123456.7 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-586"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.60333376623377E-14 f32-k as float32! 1E-6
--test-- "float-auto-587"
--assertf32~= as float32! 5.69477849184371E+15 (( as float32! 1.222944E+22 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-588"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.69477849184371E+15 f32-k as float32! 1E-6
--test-- "float-auto-589"
--assertf32~= as float32! 4.07648E+21 (( as float32! 1.222944E+22 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-590"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.07648E+21 f32-k as float32! 1E-6
--test-- "float-auto-591"
--assertf32~= as float32! 2.445888E+21 (( as float32! 1.222944E+22 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-592"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.445888E+21 f32-k as float32! 1E-6
--test-- "float-auto-593"
--assertf32~= as float32! 2.67726236840204E+19 (( as float32! 1.222944E+22 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-594"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.67726236840204E+19 f32-k as float32! 1E-6
--test-- "float-auto-595"
--assertf32~= as float32! 9.90585363127315E+16 (( as float32! 1.222944E+22 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-596"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 9.90585363127315E+16 f32-k as float32! 1E-6
--test-- "float-auto-597"
--assertf32~= as float32! 1.0 (( as float32! 1.222944E+22 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-598"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-599"
--assertf32~= as float32! 1.22294522294522E+28 (( as float32! 1.222944E+22 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-600"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.22294522294522E+28 f32-k as float32! 1E-6
--test-- "float-auto-601"
--assertf32~= as float32! 1588.23896103896 (( as float32! 1.222944E+22 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-602"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1588.23896103896 f32-k as float32! 1E-6
--test-- "float-auto-603"
--assertf32~= as float32! 4.65660962158955E-13 (( as float32! 9.99999E-7 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-604"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.65660962158955E-13 f32-k as float32! 1E-6
--test-- "float-auto-605"
--assertf32~= as float32! 3.33333E-7 (( as float32! 9.99999E-7 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-606"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.33333E-7 f32-k as float32! 1E-6
--test-- "float-auto-607"
--assertf32~= as float32! 1.999998E-7 (( as float32! 9.99999E-7 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-608"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.999998E-7 f32-k as float32! 1E-6
--test-- "float-auto-609"
--assertf32~= as float32! 2.18919238422992E-9 (( as float32! 9.99999E-7 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-610"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.18919238422992E-9 f32-k as float32! 1E-6
--test-- "float-auto-611"
--assertf32~= as float32! 8.0999978129984E-12 (( as float32! 9.99999E-7 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-612"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 8.0999978129984E-12 f32-k as float32! 1E-6
--test-- "float-auto-613"
--assertf32~= as float32! 8.17698112096711E-29 (( as float32! 9.99999E-7 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-614"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 8.17698112096711E-29 f32-k as float32! 1E-6
--test-- "float-auto-615"
--assertf32~= as float32! 1.0 (( as float32! 9.99999E-7 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-616"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-617"
--assertf32~= as float32! 1.2987E-25 (( as float32! 9.99999E-7 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-618"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.2987E-25 f32-k as float32! 1E-6
--test-- "float-auto-619"
--assertf32~= as float32! 3585592994216.95 (( as float32! 7.7E+18 ) / ( as float32! 2147483.0 ) ) as float32! 1E-6
--test-- "float-auto-620"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3585592994216.95 f32-k as float32! 1E-6
--test-- "float-auto-621"
--assertf32~= as float32! 2.56666666666667E+18 (( as float32! 7.7E+18 ) / ( as float32! 3.0 ) ) as float32! 1E-6
--test-- "float-auto-622"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.56666666666667E+18 f32-k as float32! 1E-6
--test-- "float-auto-623"
--assertf32~= as float32! 1.54E+18 (( as float32! 7.7E+18 ) / ( as float32! 5.0 ) ) as float32! 1E-6
--test-- "float-auto-624"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.54E+18 f32-k as float32! 1E-6
--test-- "float-auto-625"
--assertf32~= as float32! 1.68567982153686E+16 (( as float32! 7.7E+18 ) / ( as float32! 456.789 ) ) as float32! 1E-6
--test-- "float-auto-626"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.68567982153686E+16 f32-k as float32! 1E-6
--test-- "float-auto-627"
--assertf32~= as float32! 62370045530133.2 (( as float32! 7.7E+18 ) / ( as float32! 123456.7 ) ) as float32! 1E-6
--test-- "float-auto-628"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 62370045530133.2 f32-k as float32! 1E-6
--test-- "float-auto-629"
--assertf32~= as float32! 6.29628175942643E-4 (( as float32! 7.7E+18 ) / ( as float32! 1.222944E+22 ) ) as float32! 1E-6
--test-- "float-auto-630"
f32-i: as float32! 7.7E+18
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.29628175942643E-4 f32-k as float32! 1E-6
--test-- "float-auto-631"
--assertf32~= as float32! 7.7000077000077E+24 (( as float32! 7.7E+18 ) / ( as float32! 9.99999E-7 ) ) as float32! 1E-6
--test-- "float-auto-632"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 7.7000077000077E+24 f32-k as float32! 1E-6
--test-- "float-auto-633"
--assertf32~= as float32! 1.0 (( as float32! 7.7E+18 ) / ( as float32! 7.7E+18 ) ) as float32! 1E-6
--test-- "float-auto-634"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
float-auto-test-func: func [
/local
f32-i [float32!]
f32-j [float32!]
f32-k [float32!]
][
--test-- "float-auto-635"
f32-i: as float32! 0.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-636"
f32-i: as float32! 0.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-637"
f32-i: as float32! 0.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-638"
f32-i: as float32! 0.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-639"
f32-i: as float32! 0.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-640"
f32-i: as float32! 0.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-641"
f32-i: as float32! 0.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-642"
f32-i: as float32! 0.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-643"
f32-i: as float32! -2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-644"
f32-i: as float32! -2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-645"
f32-i: as float32! 2147483.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-646"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4294966.0 f32-k as float32! 1E-6
--test-- "float-auto-647"
f32-i: as float32! 2147483.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-648"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-649"
f32-i: as float32! 2147483.0
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-650"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-651"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-652"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-653"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-654"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-655"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-656"
f32-i: as float32! -1.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-657"
f32-i: as float32! -1.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-658"
f32-i: as float32! -1.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-659"
f32-i: as float32! -1.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 455.789 f32-k as float32! 1E-6
--test-- "float-auto-660"
f32-i: as float32! -1.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123455.7 f32-k as float32! 1E-6
--test-- "float-auto-661"
f32-i: as float32! -1.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-662"
f32-i: as float32! -1.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-663"
f32-i: as float32! 3.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-664"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-665"
f32-i: as float32! 3.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-666"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-667"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 8.0 f32-k as float32! 1E-6
--test-- "float-auto-668"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 459.789 f32-k as float32! 1E-6
--test-- "float-auto-669"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123459.7 f32-k as float32! 1E-6
--test-- "float-auto-670"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-671"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-672"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-673"
f32-i: as float32! -7.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-674"
f32-i: as float32! -7.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 449.789 f32-k as float32! 1E-6
--test-- "float-auto-675"
f32-i: as float32! -7.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123449.7 f32-k as float32! 1E-6
--test-- "float-auto-676"
f32-i: as float32! -7.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-677"
f32-i: as float32! -7.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-678"
f32-i: as float32! 5.0
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-679"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-680"
f32-i: as float32! 5.0
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-681"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 8.0 f32-k as float32! 1E-6
--test-- "float-auto-682"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 10.0 f32-k as float32! 1E-6
--test-- "float-auto-683"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 461.789 f32-k as float32! 1E-6
--test-- "float-auto-684"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123461.7 f32-k as float32! 1E-6
--test-- "float-auto-685"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-686"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-687"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-688"
f32-i: as float32! 456.789
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-689"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-690"
f32-i: as float32! 456.789
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 455.789 f32-k as float32! 1E-6
--test-- "float-auto-691"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 459.789 f32-k as float32! 1E-6
--test-- "float-auto-692"
f32-i: as float32! 456.789
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 449.789 f32-k as float32! 1E-6
--test-- "float-auto-693"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 461.789 f32-k as float32! 1E-6
--test-- "float-auto-694"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 913.578 f32-k as float32! 1E-6
--test-- "float-auto-695"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123913.489 f32-k as float32! 1E-6
--test-- "float-auto-696"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-697"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789000999999 f32-k as float32! 1E-6
--test-- "float-auto-698"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-699"
f32-i: as float32! 123456.7
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-700"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-701"
f32-i: as float32! 123456.7
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123455.7 f32-k as float32! 1E-6
--test-- "float-auto-702"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123459.7 f32-k as float32! 1E-6
--test-- "float-auto-703"
f32-i: as float32! 123456.7
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123449.7 f32-k as float32! 1E-6
--test-- "float-auto-704"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 123461.7 f32-k as float32! 1E-6
--test-- "float-auto-705"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 123913.489 f32-k as float32! 1E-6
--test-- "float-auto-706"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 246913.4 f32-k as float32! 1E-6
--test-- "float-auto-707"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-708"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.700001 f32-k as float32! 1E-6
--test-- "float-auto-709"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000012E+18 f32-k as float32! 1E-6
--test-- "float-auto-710"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-711"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-712"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-713"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-714"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-715"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-716"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-717"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-718"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-719"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 2.445888E+22 f32-k as float32! 1E-6
--test-- "float-auto-720"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-721"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.223714E+22 f32-k as float32! 1E-6
--test-- "float-auto-722"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-723"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-724"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 3.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-725"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 5.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-726"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 456.789000999999 f32-k as float32! 1E-6
--test-- "float-auto-727"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 123456.700001 f32-k as float32! 1E-6
--test-- "float-auto-728"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-729"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.999998E-6 f32-k as float32! 1E-6
--test-- "float-auto-730"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-731"
f32-i: as float32! 7.7E+18
f32-j: as float32! 0.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-732"
f32-i: as float32! 7.7E+18
f32-j: as float32! -2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-733"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-734"
f32-i: as float32! 7.7E+18
f32-j: as float32! -1.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-735"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-736"
f32-i: as float32! 7.7E+18
f32-j: as float32! -7.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-737"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-738"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-739"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.70000000000012E+18 f32-k as float32! 1E-6
--test-- "float-auto-740"
f32-i: as float32! 7.7E+18
f32-j: as float32! 1.222944E+22
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.223714E+22 f32-k as float32! 1E-6
--test-- "float-auto-741"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i + f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-742"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i + f32-j
--assertf32~= as float32! 1.54E+19 f32-k as float32! 1E-6
--test-- "float-auto-743"
f32-i: as float32! 0.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-744"
f32-i: as float32! 0.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-745"
f32-i: as float32! 0.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-746"
f32-i: as float32! 2147483.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-747"
f32-i: as float32! 2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 4294966.0 f32-k as float32! 1E-6
--test-- "float-auto-748"
f32-i: as float32! 2147483.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147484.0 f32-k as float32! 1E-6
--test-- "float-auto-749"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147480.0 f32-k as float32! 1E-6
--test-- "float-auto-750"
f32-i: as float32! 2147483.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147490.0 f32-k as float32! 1E-6
--test-- "float-auto-751"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147478.0 f32-k as float32! 1E-6
--test-- "float-auto-752"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147026.211 f32-k as float32! 1E-6
--test-- "float-auto-753"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2024026.3 f32-k as float32! 1E-6
--test-- "float-auto-754"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147482.999999 f32-k as float32! 1E-6
--test-- "float-auto-755"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147482.0 f32-k as float32! 1E-6
--test-- "float-auto-756"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-757"
f32-i: as float32! 3.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 3.0 f32-k as float32! 1E-6
--test-- "float-auto-758"
f32-i: as float32! 3.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147486.0 f32-k as float32! 1E-6
--test-- "float-auto-759"
f32-i: as float32! 3.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 4.0 f32-k as float32! 1E-6
--test-- "float-auto-760"
f32-i: as float32! 3.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 10.0 f32-k as float32! 1E-6
--test-- "float-auto-761"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 2.999999000001 f32-k as float32! 1E-6
--test-- "float-auto-762"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147476.0 f32-k as float32! 1E-6
--test-- "float-auto-763"
f32-i: as float32! 5.0
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 5.0 f32-k as float32! 1E-6
--test-- "float-auto-764"
f32-i: as float32! 5.0
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147488.0 f32-k as float32! 1E-6
--test-- "float-auto-765"
f32-i: as float32! 5.0
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 6.0 f32-k as float32! 1E-6
--test-- "float-auto-766"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2.0 f32-k as float32! 1E-6
--test-- "float-auto-767"
f32-i: as float32! 5.0
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 12.0 f32-k as float32! 1E-6
--test-- "float-auto-768"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 4.999999000001 f32-k as float32! 1E-6
--test-- "float-auto-769"
f32-i: as float32! 456.789
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 456.789 f32-k as float32! 1E-6
--test-- "float-auto-770"
f32-i: as float32! 456.789
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147939.789 f32-k as float32! 1E-6
--test-- "float-auto-771"
f32-i: as float32! 456.789
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 457.789 f32-k as float32! 1E-6
--test-- "float-auto-772"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 453.789 f32-k as float32! 1E-6
--test-- "float-auto-773"
f32-i: as float32! 456.789
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 463.789 f32-k as float32! 1E-6
--test-- "float-auto-774"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 451.789 f32-k as float32! 1E-6
--test-- "float-auto-775"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 456.788999000001 f32-k as float32! 1E-6
--test-- "float-auto-776"
f32-i: as float32! 123456.7
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123456.7 f32-k as float32! 1E-6
--test-- "float-auto-777"
f32-i: as float32! 123456.7
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2270939.7 f32-k as float32! 1E-6
--test-- "float-auto-778"
f32-i: as float32! 123456.7
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123457.7 f32-k as float32! 1E-6
--test-- "float-auto-779"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123453.7 f32-k as float32! 1E-6
--test-- "float-auto-780"
f32-i: as float32! 123456.7
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123463.7 f32-k as float32! 1E-6
--test-- "float-auto-781"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 123451.7 f32-k as float32! 1E-6
--test-- "float-auto-782"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 122999.911 f32-k as float32! 1E-6
--test-- "float-auto-783"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 123456.699999 f32-k as float32! 1E-6
--test-- "float-auto-784"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-785"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-786"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-787"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-788"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-789"
f32-i: as float32! 1.222944E+22
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-790"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-791"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-792"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-793"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222944E+22 f32-k as float32! 1E-6
--test-- "float-auto-794"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.222174E+22 f32-k as float32! 1E-6
--test-- "float-auto-795"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 9.99999E-7 f32-k as float32! 1E-6
--test-- "float-auto-796"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 2147483.000001 f32-k as float32! 1E-6
--test-- "float-auto-797"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 1.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-798"
f32-i: as float32! 9.99999E-7
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.000000999999 f32-k as float32! 1E-6
--test-- "float-auto-799"
f32-i: as float32! 7.7E+18
f32-j: as float32! 0.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-800"
f32-i: as float32! 7.7E+18
f32-j: as float32! -2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.70000000000215E+18 f32-k as float32! 1E-6
--test-- "float-auto-801"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.69999999999785E+18 f32-k as float32! 1E-6
--test-- "float-auto-802"
f32-i: as float32! 7.7E+18
f32-j: as float32! -1.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-803"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-804"
f32-i: as float32! 7.7E+18
f32-j: as float32! -7.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-805"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-806"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-807"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.69999999999988E+18 f32-k as float32! 1E-6
--test-- "float-auto-808"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i - f32-j
--assertf32~= as float32! 7.7E+18 f32-k as float32! 1E-6
--test-- "float-auto-809"
f32-i: as float32! -2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4611683235289.0 f32-k as float32! 1E-6
--test-- "float-auto-810"
f32-i: as float32! -2147483.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-811"
f32-i: as float32! -2147483.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15032381.0 f32-k as float32! 1E-6
--test-- "float-auto-812"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4611683235289.0 f32-k as float32! 1E-6
--test-- "float-auto-813"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6442449.0 f32-k as float32! 1E-6
--test-- "float-auto-814"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 10737415.0 f32-k as float32! 1E-6
--test-- "float-auto-815"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 980946612.087 f32-k as float32! 1E-6
--test-- "float-auto-816"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 265121164486.1 f32-k as float32! 1E-6
--test-- "float-auto-817"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.626251449952E+28 f32-k as float32! 1E-6
--test-- "float-auto-818"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.147480852517 f32-k as float32! 1E-6
--test-- "float-auto-819"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.65356191E+25 f32-k as float32! 1E-6
--test-- "float-auto-820"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-821"
f32-i: as float32! -1.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-822"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-823"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6442449.0 f32-k as float32! 1E-6
--test-- "float-auto-824"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.0 f32-k as float32! 1E-6
--test-- "float-auto-825"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15.0 f32-k as float32! 1E-6
--test-- "float-auto-826"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 1370.367 f32-k as float32! 1E-6
--test-- "float-auto-827"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 370370.1 f32-k as float32! 1E-6
--test-- "float-auto-828"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.668832E+22 f32-k as float32! 1E-6
--test-- "float-auto-829"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.999997E-6 f32-k as float32! 1E-6
--test-- "float-auto-830"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.31E+19 f32-k as float32! 1E-6
--test-- "float-auto-831"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15032381.0 f32-k as float32! 1E-6
--test-- "float-auto-832"
f32-i: as float32! -7.0
f32-j: as float32! -1.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-833"
f32-i: as float32! -7.0
f32-j: as float32! -7.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 49.0 f32-k as float32! 1E-6
--test-- "float-auto-834"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 10737415.0 f32-k as float32! 1E-6
--test-- "float-auto-835"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 15.0 f32-k as float32! 1E-6
--test-- "float-auto-836"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 25.0 f32-k as float32! 1E-6
--test-- "float-auto-837"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 2283.945 f32-k as float32! 1E-6
--test-- "float-auto-838"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 617283.5 f32-k as float32! 1E-6
--test-- "float-auto-839"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 6.11472E+22 f32-k as float32! 1E-6
--test-- "float-auto-840"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.999995E-6 f32-k as float32! 1E-6
--test-- "float-auto-841"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.85E+19 f32-k as float32! 1E-6
--test-- "float-auto-842"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 980946612.087 f32-k as float32! 1E-6
--test-- "float-auto-843"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1370.367 f32-k as float32! 1E-6
--test-- "float-auto-844"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2283.945 f32-k as float32! 1E-6
--test-- "float-auto-845"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 208656.190521 f32-k as float32! 1E-6
--test-- "float-auto-846"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 56393662.5363 f32-k as float32! 1E-6
--test-- "float-auto-847"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.58627366816E+24 f32-k as float32! 1E-6
--test-- "float-auto-848"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.56788543211E-4 f32-k as float32! 1E-6
--test-- "float-auto-849"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.5172753E+21 f32-k as float32! 1E-6
--test-- "float-auto-850"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 265121164486.1 f32-k as float32! 1E-6
--test-- "float-auto-851"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 370370.1 f32-k as float32! 1E-6
--test-- "float-auto-852"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 617283.5 f32-k as float32! 1E-6
--test-- "float-auto-853"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 56393662.5363 f32-k as float32! 1E-6
--test-- "float-auto-854"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 15241556774.89 f32-k as float32! 1E-6
--test-- "float-auto-855"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.509806305248E+27 f32-k as float32! 1E-6
--test-- "float-auto-856"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 0.1234565765433 f32-k as float32! 1E-6
--test-- "float-auto-857"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.5061659E+23 f32-k as float32! 1E-6
--test-- "float-auto-858"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.626251449952E+28 f32-k as float32! 1E-6
--test-- "float-auto-859"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.668832E+22 f32-k as float32! 1E-6
--test-- "float-auto-860"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 6.11472E+22 f32-k as float32! 1E-6
--test-- "float-auto-861"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.58627366816E+24 f32-k as float32! 1E-6
--test-- "float-auto-862"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.509806305248E+27 f32-k as float32! 1E-6
--test-- "float-auto-863"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.222942777056E+16 f32-k as float32! 1E-6
--test-- "float-auto-864"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.147480852517 f32-k as float32! 1E-6
--test-- "float-auto-865"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.999997E-6 f32-k as float32! 1E-6
--test-- "float-auto-866"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.999995E-6 f32-k as float32! 1E-6
--test-- "float-auto-867"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 4.56788543211E-4 f32-k as float32! 1E-6
--test-- "float-auto-868"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 0.1234565765433 f32-k as float32! 1E-6
--test-- "float-auto-869"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.222942777056E+16 f32-k as float32! 1E-6
--test-- "float-auto-870"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.99998000001E-13 f32-k as float32! 1E-6
--test-- "float-auto-871"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 7699992300000.0 f32-k as float32! 1E-6
--test-- "float-auto-872"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 1.65356191E+25 f32-k as float32! 1E-6
--test-- "float-auto-873"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 2.31E+19 f32-k as float32! 1E-6
--test-- "float-auto-874"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.85E+19 f32-k as float32! 1E-6
--test-- "float-auto-875"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i * f32-j
--assertf32~= as float32! 3.5172753E+21 f32-k as float32! 1E-6
--test-- "float-auto-876"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i * f32-j
--assertf32~= as float32! 9.5061659E+23 f32-k as float32! 1E-6
--test-- "float-auto-877"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i * f32-j
--assertf32~= as float32! 7699992300000.0 f32-k as float32! 1E-6
--test-- "float-auto-878"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i * f32-j
--assertf32~= as float32! 5.929E+37 f32-k as float32! 1E-6
--test-- "float-auto-879"
f32-i: as float32! -2147483.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-880"
f32-i: as float32! -2147483.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2147483.0 f32-k as float32! 1E-6
--test-- "float-auto-881"
f32-i: as float32! -2147483.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 306783.285714286 f32-k as float32! 1E-6
--test-- "float-auto-882"
f32-i: as float32! 2147483.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-883"
f32-i: as float32! 2147483.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 715827.666666667 f32-k as float32! 1E-6
--test-- "float-auto-884"
f32-i: as float32! 2147483.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 429496.6 f32-k as float32! 1E-6
--test-- "float-auto-885"
f32-i: as float32! 2147483.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 4701.25813012135 f32-k as float32! 1E-6
--test-- "float-auto-886"
f32-i: as float32! 2147483.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 17.3946249980762 f32-k as float32! 1E-6
--test-- "float-auto-887"
f32-i: as float32! 2147483.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.75599455085433E-16 f32-k as float32! 1E-6
--test-- "float-auto-888"
f32-i: as float32! 2147483.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 2147485147485.15 f32-k as float32! 1E-6
--test-- "float-auto-889"
f32-i: as float32! 2147483.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.78893896103896E-13 f32-k as float32! 1E-6
--test-- "float-auto-890"
f32-i: as float32! -1.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.65661427820383E-7 f32-k as float32! 1E-6
--test-- "float-auto-891"
f32-i: as float32! -1.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-892"
f32-i: as float32! -1.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 0.142857142857143 f32-k as float32! 1E-6
--test-- "float-auto-893"
f32-i: as float32! 3.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.39698428346115E-6 f32-k as float32! 1E-6
--test-- "float-auto-894"
f32-i: as float32! 3.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-895"
f32-i: as float32! 3.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 0.6 f32-k as float32! 1E-6
--test-- "float-auto-896"
f32-i: as float32! 3.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.56758372027347E-3 f32-k as float32! 1E-6
--test-- "float-auto-897"
f32-i: as float32! 3.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.4300017739013E-5 f32-k as float32! 1E-6
--test-- "float-auto-898"
f32-i: as float32! 3.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.45309678938692E-22 f32-k as float32! 1E-6
--test-- "float-auto-899"
f32-i: as float32! 3.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 3000003.000003 f32-k as float32! 1E-6
--test-- "float-auto-900"
f32-i: as float32! 3.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.8961038961039E-19 f32-k as float32! 1E-6
--test-- "float-auto-901"
f32-i: as float32! -7.0
f32-j: as float32! -2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.25962999474268E-6 f32-k as float32! 1E-6
--test-- "float-auto-902"
f32-i: as float32! -7.0
f32-j: as float32! -1.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 7.0 f32-k as float32! 1E-6
--test-- "float-auto-903"
f32-i: as float32! -7.0
f32-j: as float32! -7.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-904"
f32-i: as float32! 5.0
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.32830713910192E-6 f32-k as float32! 1E-6
--test-- "float-auto-905"
f32-i: as float32! 5.0
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.66666666666667 f32-k as float32! 1E-6
--test-- "float-auto-906"
f32-i: as float32! 5.0
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-907"
f32-i: as float32! 5.0
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.09459728671225E-2 f32-k as float32! 1E-6
--test-- "float-auto-908"
f32-i: as float32! 5.0
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.05000295650216E-5 f32-k as float32! 1E-6
--test-- "float-auto-909"
f32-i: as float32! 5.0
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.0884946489782E-22 f32-k as float32! 1E-6
--test-- "float-auto-910"
f32-i: as float32! 5.0
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 5000005.000005 f32-k as float32! 1E-6
--test-- "float-auto-911"
f32-i: as float32! 5.0
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.49350649350649E-19 f32-k as float32! 1E-6
--test-- "float-auto-912"
f32-i: as float32! 456.789
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.12709017952645E-4 f32-k as float32! 1E-6
--test-- "float-auto-913"
f32-i: as float32! 456.789
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 152.263 f32-k as float32! 1E-6
--test-- "float-auto-914"
f32-i: as float32! 456.789
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 91.3578 f32-k as float32! 1E-6
--test-- "float-auto-915"
f32-i: as float32! 456.789
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-916"
f32-i: as float32! 456.789
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.69999360099533E-3 f32-k as float32! 1E-6
--test-- "float-auto-917"
f32-i: as float32! 456.789
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.73515876442421E-20 f32-k as float32! 1E-6
--test-- "float-auto-918"
f32-i: as float32! 456.789
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 456789456.789457 f32-k as float32! 1E-6
--test-- "float-auto-919"
f32-i: as float32! 456.789
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.93232467532468E-17 f32-k as float32! 1E-6
--test-- "float-auto-920"
f32-i: as float32! 123456.7
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.74890231959927E-2 f32-k as float32! 1E-6
--test-- "float-auto-921"
f32-i: as float32! 123456.7
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 41152.2333333333 f32-k as float32! 1E-6
--test-- "float-auto-922"
f32-i: as float32! 123456.7
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 24691.34 f32-k as float32! 1E-6
--test-- "float-auto-923"
f32-i: as float32! 123456.7
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 270.270737692895 f32-k as float32! 1E-6
--test-- "float-auto-924"
f32-i: as float32! 123456.7
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-925"
f32-i: as float32! 123456.7
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.00950411466101E-17 f32-k as float32! 1E-6
--test-- "float-auto-926"
f32-i: as float32! 123456.7
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 123456823456.823 f32-k as float32! 1E-6
--test-- "float-auto-927"
f32-i: as float32! 123456.7
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.60333376623377E-14 f32-k as float32! 1E-6
--test-- "float-auto-928"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 5.69477849184371E+15 f32-k as float32! 1E-6
--test-- "float-auto-929"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.07648E+21 f32-k as float32! 1E-6
--test-- "float-auto-930"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.445888E+21 f32-k as float32! 1E-6
--test-- "float-auto-931"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.67726236840204E+19 f32-k as float32! 1E-6
--test-- "float-auto-932"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 9.90585363127315E+16 f32-k as float32! 1E-6
--test-- "float-auto-933"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-934"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.22294522294522E+28 f32-k as float32! 1E-6
--test-- "float-auto-935"
f32-i: as float32! 1.222944E+22
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1588.23896103896 f32-k as float32! 1E-6
--test-- "float-auto-936"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 4.65660962158955E-13 f32-k as float32! 1E-6
--test-- "float-auto-937"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3.33333E-7 f32-k as float32! 1E-6
--test-- "float-auto-938"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.999998E-7 f32-k as float32! 1E-6
--test-- "float-auto-939"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.18919238422992E-9 f32-k as float32! 1E-6
--test-- "float-auto-940"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 8.0999978129984E-12 f32-k as float32! 1E-6
--test-- "float-auto-941"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 8.17698112096711E-29 f32-k as float32! 1E-6
--test-- "float-auto-942"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
--test-- "float-auto-943"
f32-i: as float32! 9.99999E-7
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.2987E-25 f32-k as float32! 1E-6
--test-- "float-auto-944"
f32-i: as float32! 7.7E+18
f32-j: as float32! 2147483.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 3585592994216.95 f32-k as float32! 1E-6
--test-- "float-auto-945"
f32-i: as float32! 7.7E+18
f32-j: as float32! 3.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 2.56666666666667E+18 f32-k as float32! 1E-6
--test-- "float-auto-946"
f32-i: as float32! 7.7E+18
f32-j: as float32! 5.0
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.54E+18 f32-k as float32! 1E-6
--test-- "float-auto-947"
f32-i: as float32! 7.7E+18
f32-j: as float32! 456.789
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.68567982153686E+16 f32-k as float32! 1E-6
--test-- "float-auto-948"
f32-i: as float32! 7.7E+18
f32-j: as float32! 123456.7
f32-k: f32-i / f32-j
--assertf32~= as float32! 62370045530133.2 f32-k as float32! 1E-6
--test-- "float-auto-949"
f32-i: as float32! 7.7E+18
f32-j: as float32! 1.222944E+22
f32-k: f32-i / f32-j
--assertf32~= as float32! 6.29628175942643E-4 f32-k as float32! 1E-6
--test-- "float-auto-950"
f32-i: as float32! 7.7E+18
f32-j: as float32! 9.99999E-7
f32-k: f32-i / f32-j
--assertf32~= as float32! 7.7000077000077E+24 f32-k as float32! 1E-6
--test-- "float-auto-951"
f32-i: as float32! 7.7E+18
f32-j: as float32! 7.7E+18
f32-k: f32-i / f32-j
--assertf32~= as float32! 1.0 f32-k as float32! 1E-6
]
float-auto-test-func
--test-- "float-auto-952"
--assert true = ( (as float32! 0.0 ) = (as float32! 0.0 ) )
--test-- "float-auto-953"
--assert false = ( (as float32! -2147483.0 ) = (as float32! -2147485.147483 ) )
--test-- "float-auto-954"
--assert false = ( (as float32! 2147483.0 ) = (as float32! 2147485.147483 ) )
--test-- "float-auto-955"
--assert false = ( (as float32! -1.0 ) = (as float32! -1.000001 ) )
--test-- "float-auto-956"
--assert false = ( (as float32! 3.0 ) = (as float32! 3.000003 ) )
--test-- "float-auto-957"
--assert false = ( (as float32! -7.0 ) = (as float32! -7.000007 ) )
--test-- "float-auto-958"
--assert false = ( (as float32! 5.0 ) = (as float32! 5.000005 ) )
--test-- "float-auto-959"
--assert false = ( (as float32! 456.789 ) = (as float32! 456.789456789 ) )
--test-- "float-auto-960"
--assert false = ( (as float32! 123456.7 ) = (as float32! 123456.8234567 ) )
--test-- "float-auto-961"
--assert false = ( (as float32! 1.222944E+22 ) = (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-962"
--assert false = ( (as float32! 9.99999E-7 ) = (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-963"
--assert false = ( (as float32! 7.7E+18 ) = (as float32! 7.7000077E+18 ) )
--test-- "float-auto-964"
--assert false = ( (as float32! 0.0 ) <> (as float32! 0.0 ) )
--test-- "float-auto-965"
--assert true = ( (as float32! -2147483.0 ) <> (as float32! -2147485.147483 ) )
--test-- "float-auto-966"
--assert true = ( (as float32! 2147483.0 ) <> (as float32! 2147485.147483 ) )
--test-- "float-auto-967"
--assert true = ( (as float32! -1.0 ) <> (as float32! -1.000001 ) )
--test-- "float-auto-968"
--assert true = ( (as float32! 3.0 ) <> (as float32! 3.000003 ) )
--test-- "float-auto-969"
--assert true = ( (as float32! -7.0 ) <> (as float32! -7.000007 ) )
--test-- "float-auto-970"
--assert true = ( (as float32! 5.0 ) <> (as float32! 5.000005 ) )
--test-- "float-auto-971"
--assert true = ( (as float32! 456.789 ) <> (as float32! 456.789456789 ) )
--test-- "float-auto-972"
--assert true = ( (as float32! 123456.7 ) <> (as float32! 123456.8234567 ) )
--test-- "float-auto-973"
--assert true = ( (as float32! 1.222944E+22 ) <> (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-974"
--assert true = ( (as float32! 9.99999E-7 ) <> (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-975"
--assert true = ( (as float32! 7.7E+18 ) <> (as float32! 7.7000077E+18 ) )
--test-- "float-auto-976"
--assert false = ( (as float32! 0.0 ) < (as float32! 0.0 ) )
--test-- "float-auto-977"
--assert false = ( (as float32! -2147483.0 ) < (as float32! -2147485.147483 ) )
--test-- "float-auto-978"
--assert true = ( (as float32! 2147483.0 ) < (as float32! 2147485.147483 ) )
--test-- "float-auto-979"
--assert false = ( (as float32! -1.0 ) < (as float32! -1.000001 ) )
--test-- "float-auto-980"
--assert true = ( (as float32! 3.0 ) < (as float32! 3.000003 ) )
--test-- "float-auto-981"
--assert false = ( (as float32! -7.0 ) < (as float32! -7.000007 ) )
--test-- "float-auto-982"
--assert true = ( (as float32! 5.0 ) < (as float32! 5.000005 ) )
--test-- "float-auto-983"
--assert true = ( (as float32! 456.789 ) < (as float32! 456.789456789 ) )
--test-- "float-auto-984"
--assert true = ( (as float32! 123456.7 ) < (as float32! 123456.8234567 ) )
--test-- "float-auto-985"
--assert true = ( (as float32! 1.222944E+22 ) < (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-986"
--assert true = ( (as float32! 9.99999E-7 ) < (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-987"
--assert true = ( (as float32! 7.7E+18 ) < (as float32! 7.7000077E+18 ) )
--test-- "float-auto-988"
--assert false = ( (as float32! 0.0 ) > (as float32! 0.0 ) )
--test-- "float-auto-989"
--assert true = ( (as float32! -2147483.0 ) > (as float32! -2147485.147483 ) )
--test-- "float-auto-990"
--assert false = ( (as float32! 2147483.0 ) > (as float32! 2147485.147483 ) )
--test-- "float-auto-991"
--assert true = ( (as float32! -1.0 ) > (as float32! -1.000001 ) )
--test-- "float-auto-992"
--assert false = ( (as float32! 3.0 ) > (as float32! 3.000003 ) )
--test-- "float-auto-993"
--assert true = ( (as float32! -7.0 ) > (as float32! -7.000007 ) )
--test-- "float-auto-994"
--assert false = ( (as float32! 5.0 ) > (as float32! 5.000005 ) )
--test-- "float-auto-995"
--assert false = ( (as float32! 456.789 ) > (as float32! 456.789456789 ) )
--test-- "float-auto-996"
--assert false = ( (as float32! 123456.7 ) > (as float32! 123456.8234567 ) )
--test-- "float-auto-997"
--assert false = ( (as float32! 1.222944E+22 ) > (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-998"
--assert false = ( (as float32! 9.99999E-7 ) > (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-999"
--assert false = ( (as float32! 7.7E+18 ) > (as float32! 7.7000077E+18 ) )
--test-- "float-auto-1000"
--assert true = ( (as float32! 0.0 ) >= (as float32! 0.0 ) )
--test-- "float-auto-1001"
--assert true = ( (as float32! -2147483.0 ) >= (as float32! -2147485.147483 ) )
--test-- "float-auto-1002"
--assert false = ( (as float32! 2147483.0 ) >= (as float32! 2147485.147483 ) )
--test-- "float-auto-1003"
--assert true = ( (as float32! -1.0 ) >= (as float32! -1.000001 ) )
--test-- "float-auto-1004"
--assert false = ( (as float32! 3.0 ) >= (as float32! 3.000003 ) )
--test-- "float-auto-1005"
--assert true = ( (as float32! -7.0 ) >= (as float32! -7.000007 ) )
--test-- "float-auto-1006"
--assert false = ( (as float32! 5.0 ) >= (as float32! 5.000005 ) )
--test-- "float-auto-1007"
--assert false = ( (as float32! 456.789 ) >= (as float32! 456.789456789 ) )
--test-- "float-auto-1008"
--assert false = ( (as float32! 123456.7 ) >= (as float32! 123456.8234567 ) )
--test-- "float-auto-1009"
--assert false = ( (as float32! 1.222944E+22 ) >= (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-1010"
--assert false = ( (as float32! 9.99999E-7 ) >= (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-1011"
--assert false = ( (as float32! 7.7E+18 ) >= (as float32! 7.7000077E+18 ) )
--test-- "float-auto-1012"
--assert true = ( (as float32! 0.0 ) <= (as float32! 0.0 ) )
--test-- "float-auto-1013"
--assert false = ( (as float32! -2147483.0 ) <= (as float32! -2147485.147483 ) )
--test-- "float-auto-1014"
--assert true = ( (as float32! 2147483.0 ) <= (as float32! 2147485.147483 ) )
--test-- "float-auto-1015"
--assert false = ( (as float32! -1.0 ) <= (as float32! -1.000001 ) )
--test-- "float-auto-1016"
--assert true = ( (as float32! 3.0 ) <= (as float32! 3.000003 ) )
--test-- "float-auto-1017"
--assert false = ( (as float32! -7.0 ) <= (as float32! -7.000007 ) )
--test-- "float-auto-1018"
--assert true = ( (as float32! 5.0 ) <= (as float32! 5.000005 ) )
--test-- "float-auto-1019"
--assert true = ( (as float32! 456.789 ) <= (as float32! 456.789456789 ) )
--test-- "float-auto-1020"
--assert true = ( (as float32! 123456.7 ) <= (as float32! 123456.8234567 ) )
--test-- "float-auto-1021"
--assert true = ( (as float32! 1.222944E+22 ) <= (as float32! 1.222945222944E+22 ) )
--test-- "float-auto-1022"
--assert true = ( (as float32! 9.99999E-7 ) <= (as float32! 9.99999999999E-7 ) )
--test-- "float-auto-1023"
--assert true = ( (as float32! 7.7E+18 ) <= (as float32! 7.7000077E+18 ) )
===end-group===
~~~end-file~~~
| Red | 5 | GalenIvanov/red | system/tests/source/units/float32-test.reds | [
"BSL-1.0",
"BSD-3-Clause"
] |
#! /bin/sh -e
# DP: Emit cld instruction when stringops are used (i386).
dir=
if [ $# -eq 3 -a "$2" = '-d' ]; then
pdir="-d $3"
dir="$3/"
elif [ $# -ne 1 ]; then
echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
exit 1
fi
case "$1" in
-patch)
patch $pdir -f --no-backup-if-mismatch -p0 < $0
;;
-unpatch)
patch $pdir -f --no-backup-if-mismatch -R -p0 < $0
;;
*)
echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
exit 1
esac
exit 0
2008-03-06 Uros Bizjak <ubizjak@gmail.com>
* config/i386/i386.h (TARGET_CLD): New define.
(struct machine_function): Add needs_cld field.
(ix86_current_function_needs_cld): New define.
* config/i386/i386.md (UNSPEC_CLD): New unspec volatile constant.
("cld"): New isns pattern.
("strmov_singleop"): Set ix86_current_function_needs_cld flag.
("rep_mov"): Ditto.
("strset_singleop"): Ditto.
("rep_stos"): Ditto.
("cmpstrnqi_nz_1"): Ditto.
("cmpstrnqi_1"): Ditto.
("strlenqi_1"): Ditto.
* config/i386/i386.c (ix86_expand_prologue): Emit cld insn for
TARGET_CLD when ix86_current_function_needs_cld is set.
Index: gcc/config/i386/i386.h
===================================================================
--- gcc/config/i386/i386.h (revision 132966)
+++ gcc/config/i386/i386.h (working copy)
@@ -388,6 +388,7 @@ extern unsigned int ix86_arch_features[X
extern int x86_prefetch_sse;
+#define TARGET_CLD 1
#define TARGET_ABM x86_abm
#define TARGET_CMPXCHG16B x86_cmpxchg16b
#define TARGET_POPCNT x86_popcnt
@@ -2446,8 +2447,9 @@ struct machine_function GTY(())
int save_varrargs_registers;
int accesses_prev_frame;
int optimize_mode_switching[MAX_386_ENTITIES];
- /* Set by ix86_compute_frame_layout and used by prologue/epilogue expander to
- determine the style used. */
+ int needs_cld;
+ /* Set by ix86_compute_frame_layout and used by prologue/epilogue
+ expander to determine the style used. */
int use_fast_prologue_epilogue;
/* Number of saved registers USE_FAST_PROLOGUE_EPILOGUE has been computed
for. */
@@ -2467,6 +2469,7 @@ struct machine_function GTY(())
#define ix86_stack_locals (cfun->machine->stack_locals)
#define ix86_save_varrargs_registers (cfun->machine->save_varrargs_registers)
#define ix86_optimize_mode_switching (cfun->machine->optimize_mode_switching)
+#define ix86_current_function_needs_cld (cfun->machine->needs_cld)
#define ix86_tls_descriptor_calls_expanded_in_cfun \
(cfun->machine->tls_descriptor_call_expanded_p)
/* Since tls_descriptor_call_expanded is not cleared, even if all TLS
Index: gcc/config/i386/i386.md
===================================================================
--- gcc/config/i386/i386.md (revision 132966)
+++ gcc/config/i386/i386.md (working copy)
@@ -205,6 +205,7 @@
(UNSPECV_XCHG 12)
(UNSPECV_LOCK 13)
(UNSPECV_PROLOGUE_USE 14)
+ (UNSPECV_CLD 15)
])
;; Constants to represent pcomtrue/pcomfalse variants
@@ -18519,6 +18520,14 @@
;; Block operation instructions
+(define_insn "cld"
+ [(unspec_volatile [(const_int 0)] UNSPECV_CLD)]
+ ""
+ "cld"
+ [(set_attr "length" "1")
+ (set_attr "length_immediate" "0")
+ (set_attr "modrm" "0")])
+
(define_expand "movmemsi"
[(use (match_operand:BLK 0 "memory_operand" ""))
(use (match_operand:BLK 1 "memory_operand" ""))
@@ -18591,7 +18600,7 @@
(set (match_operand 2 "register_operand" "")
(match_operand 5 "" ""))])]
"TARGET_SINGLE_STRINGOP || optimize_size"
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*strmovdi_rex_1"
[(set (mem:DI (match_operand:DI 2 "register_operand" "0"))
@@ -18708,7 +18717,7 @@
(match_operand 3 "memory_operand" ""))
(use (match_dup 4))])]
""
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*rep_movdi_rex64"
[(set (match_operand:DI 2 "register_operand" "=c") (const_int 0))
@@ -18868,7 +18877,7 @@
(set (match_operand 0 "register_operand" "")
(match_operand 3 "" ""))])]
"TARGET_SINGLE_STRINGOP || optimize_size"
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*strsetdi_rex_1"
[(set (mem:DI (match_operand:DI 1 "register_operand" "0"))
@@ -18962,7 +18971,7 @@
(use (match_operand 3 "register_operand" ""))
(use (match_dup 1))])]
""
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*rep_stosdi_rex64"
[(set (match_operand:DI 1 "register_operand" "=c") (const_int 0))
@@ -19138,7 +19147,7 @@
(clobber (match_operand 1 "register_operand" ""))
(clobber (match_dup 2))])]
""
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*cmpstrnqi_nz_1"
[(set (reg:CC FLAGS_REG)
@@ -19185,7 +19194,7 @@
(clobber (match_operand 1 "register_operand" ""))
(clobber (match_dup 2))])]
""
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*cmpstrnqi_1"
[(set (reg:CC FLAGS_REG)
@@ -19254,7 +19263,7 @@
(clobber (match_operand 1 "register_operand" ""))
(clobber (reg:CC FLAGS_REG))])]
""
- "")
+ "ix86_current_function_needs_cld = 1;")
(define_insn "*strlenqi_1"
[(set (match_operand:SI 0 "register_operand" "=&c")
Index: gcc/config/i386/i386.c
===================================================================
--- gcc/config/i386/i386.c (revision 132966)
+++ gcc/config/i386/i386.c (working copy)
@@ -6498,6 +6498,10 @@ ix86_expand_prologue (void)
emit_insn (gen_prologue_use (pic_offset_table_rtx));
emit_insn (gen_blockage ());
}
+
+ /* Emit cld instruction if stringops are used in the function. */
+ if (TARGET_CLD && ix86_current_function_needs_cld)
+ emit_insn (gen_cld ());
}
/* Emit code to restore saved registers using MOV insns. First register
| Darcs Patch | 4 | JrCs/opendreambox | recipes/gcc/gcc-4.3.4/debian/gcc-i386-emit-cld.dpatch | [
"MIT"
] |
#include <PJONOverSampling.h>
uint16_t packet;
uint8_t bus_id[] = {0, 0, 0, 1};
PJONOverSampling bus(bus_id, 45);
void error_handler(uint8_t code, uint16_t data, void *custom_pointer) {
if(code == PJON_CONNECTION_LOST) {
Serial.print("Connection with device ID ");
Serial.print(bus.packets[data].content[0], DEC);
Serial.print(" - ");
Serial.print(micros());
Serial.println(" is lost.");
}
if(code == PJON_PACKETS_BUFFER_FULL) {
Serial.print("Packet buffer is full, has now a length of ");
Serial.println(data, DEC);
Serial.println("Possible wrong bus configuration!");
Serial.println("higher PJON_MAX_PACKETS if necessary.");
}
if(code == PJON_CONTENT_TOO_LONG) {
Serial.print("Content is too long, length: ");
Serial.println(data);
}
};
void setup() {
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW); // Initialize LED 13 to be off
/* When using more than one pin always use pins connected to
a different port group to avoid cross-talk. */
bus.strategy.set_pins(7, 12);
bus.set_error(error_handler);
bus.begin();
packet = bus.send_repeatedly(44, "B", 1, 2000000);
/* Send B to device 44 every 2 seconds.
Try to avoid to consinuosly jam the entire zone around you.
Consider that many appliances and remotes around you are affected by
PJON packet flooding occurring in this sketch, for this reason try to
run your tests for short timeframes.
DO NOT FORGET THIS SKETCH TRANSMITTING ALL DAY LONG :) */
};
void loop() {
bus.update();
bus.receive(50000); // Receive for 50 milliseconds
};
| Arduino | 4 | jcallano/PJON | examples/ARDUINO/Network/OverSampling/HalfDuplex/Transmitter/Transmitter.ino | [
"Apache-2.0"
] |
export default withAppContainer(
withAuth(
class BuyDomains extends React.Component {
something = ({url}) => {
}
}
)
)
| JavaScript | 3 | blomqma/next.js | packages/next-codemod/transforms/__testfixtures__/url-to-withrouter/no-transform-method.output.js | [
"MIT"
] |
>+>+>+[->[>]+[->[>]+[->[>]+[<]+<]+<]+<]
[ https://sites.google.com/site/res0001/surpassing-graham-s-number
https://sites.google.com/site/res0001/f
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Notes (RDB)
The code above is in brainfuck and appears to only need tape to the right.
The number of instructions is 39.
The number of cells used is the same ... 118842243771396506390315925502
Adding a ">+" on the start gives the "Y" value below.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Author: r.e.s. (res0001@gmail.com)
Date: 2005-06-11
=====================================================
A family of F programs giving lower bounds on Sigma_F
=====================================================
The F programming language is described in detail in the appendix
of the article https://sites.google.com/site/res0001/F/Rado_Sigma.txt,
which presents a proof that Sigma_F is not a computable function.
(The webfolder https://sites.google.com/site/res0001/F contains other
F-related material as well.)
Sigma_F is a Busy Beaver function for F programs, defined as follows
in the spirit of Rado's original Busy Beaver TM model:
The memory model for F in this context assumes memory is a bitstring
that's finite but unbounded both to the right *and* to the left.
Sigma_F(n)(n = 1, 2, ...) is defined as the maximum number of 1's
that can be in final memory when an n-instruction F-program halts,
starting with all-0 memory.
Note that, like Rado's Sigma for TMs, Sigma_F is such that
(1) Memory (cf binary tape) is unbounded in both directions.
(2) Sigma_F counts all the 1's (not necessarily contiguous,
and irrespective of which bit is current) in final memory.
Recursion for the family of programs A(i)
-----------------------------------------
Define programs A(i)(i = 1, 2, 3, ...) recursively as follows:
N(i) := '+>+>...+>+' (with n(i) +'s, and n(i) a positive integer)
A(1) := N(1) '[<]'
A(i) := N(i) '[+>[>]' A(i-1) '+<]' (i > 1)
where concatenation is indicated by the spaces between strings.
Thus A(i) is a function of the i numbers n(i),n(i-1),...,n(1), say
A(i)[n(i),n(i-1),...,n(1)]. Note that i is the bracket-nesting
"depth" in A(i).
Recursion for the output of the programs A(i)
---------------------------------------------
Let [n(i),...,n(1)]p denote the number of 1's produced by program
A(i)[n(i),...,n(1)] when applied to memory 1^p (0); that is, when
the current bit is a 0 preceded by a block of p 1's. The effect
on memory is then seen to be
A(i)[n(i),...,n(1)]: 1^p (0) |--> (0) 1^[n(i),...,n(1)]p
and inspection of the program recursion shows that for all i > 1,
[n(i), ..., n(1)]0 = 1 + [n(i-1), ..., n(1)]([n(i)-1, ..., n(1)]0)
[1, n(i-1), ..., n(1)]0 = 1 + [n(i-1), ..., n(1)]0
[n(i), ..., n(1)]p = [n(i)+p, ..., n(1)]0
[n(1)]p = n(1) + p.
These relations recursively define [n(i),...,n(1)]p for all values
of n(i),...,n(1),p, and lead as follows to some explicit formulas:
[n]0 = n
[m,n]0
= 1 + [n][m-1,n]0
= 1 + n + [m-1,n]0
= (1+n)*(m-1) + [1,n]0
= (1+n )*(m-1) + 1 + [n]0
= m*(n+1) <-- note * is multiplication
[k,m,n]0
= 1 + [m,n][k-1,m,n]0
= 1 + [m,n](1 + [m,n][k-2,m,n]0)
= 1 + [m,n](1 + [m,n](1 + ... + [m,n](1+[m,n][1,m,n]0)...)))
= 1 + [m,n](1 + [m,n](1 + ... + [m,n](1+[m,n](1+[m,n]0)...)))
= 1 + [m,n](1 + [m,n](1 + ... + [m,n](1+[m,n](1+m*(n+1))...)))
= 1 + [m,n](1 + [m,n](1 + ... + [m,n](1+[m+1+m*(n+1))*(n+1),n]0)...)))
= (m*(n+1) + 1)*((n+1)^(k-1) + (n+1)^(k-2) + ... + 1)
= (m*(n+1) + 1)*((n+1)^k - 1) / n
> (n+1)^k*m <-- note ^ is exponentiation
[j,k,m,n]0
= 1 + [k,m,n][j-1,k,m,n]0
= 1 + [k + [j-1,k,m,n]0, m, n]0
= 1 + (m*(n+1) + 1)*((n+1)^(k'-1) + ...)
where k' = k + [j-1,k,m,n]0
= k + 1 + (m*(n+1) + 1)*((n+1)^(k''-1) + ...)
k''= k + [j-2,k,m,n]0
etc., giving
[j,k,m,n]0
> ((n+1)^^j)^Q*Q <-- note ^^ is tetration
where Q = (n+1)^k*m.
[i,j,k,m,n]0
= 1 + [j,k,m,n][i-1,j,k,m,n]0
= 1 + [j + [i-1,j,k,m,n]0, k, m, n]0
> ((n+1)^^^i)^^Q^Q*Q <-- etc. for ^^^, ^^^^, ...
where Q = (n+1)^^j^k*m.
Recursion for the length of the programs A(i)
---------------------------------------------
Letting L(i) = L(i)[n(i),n(i-1),...,n(1)] be the length of A(i),
the recursion for A(i) leads immediately to
L(1) = 2*(n(1)+1)
L(i) = 2*(n(i)+4) + L(i-1) (i>1)
giving the explicit formula
L(i) = 2*( n(i) + n(i-1) + ... + n(1) + 4*i - 3 ) (i >= 1).
Examples
--------
The program of depth=3 with arguments n(3)=4, n(2)=1, n(1)=2, is
A(3)[4,1,2] = '+>+>+>+ [+>[>] + [+>[>] +>+ [<]+<] +<]'
having length
L(3)[4,1,2] = 2*(4+1+2 + 4*3 - 3) = 32
and producing a number of 1's equal to
[4,1,2]0 = (3*1+1)*(3^4-1)/2 = 160. Hence Sigma_F(32) >= 160.
The programs A(i)(i>1) provide the lower bounds on Sigma_F in the
following table (each program of depth i > 1 is an A(i), or is an
A(i) with a single '+' appended):
length depth #1's output program
------ ----- ----------- ------------------------------------------
1 0 1 +
2 0 1 +>
3 0 2 +>+
4 0 2 +>+>
5 0 3 +>+>+
6 0 3 +>+>+>
...
19 0 10 +>+>+>+>+>+>+>+>+>+
20 0 10 +>+>+>+>+>+>+>+>+>+>
21 0 11 +>+>+>+>+>+>+>+>+>+>+
22 2 12 +>+>+>+[+>[>]+>+[<]+<]
23 2 13 +>+>+>+[+>[>]+>+[<]+<]+
24 2 16 +>+>+>+[+>[>]+>+>+[<]+<]
25 2 17 +>+>+>+[+>[>]+>+>+[<]+<]+
26 2 20 +>+>+>+[+>[>]+>+>+>+[<]+<]
27 2 21 +>+>+>+[+>[>]+>+>+>+[<]+<]+
28 2 25 +>+>+>+>+[+>[>]+>+>+>+[<]+<]
29 2 26 +>+>+>+>+[+>[>]+>+>+>+[<]+<]+
30 3 52 +>+>+[+>[>]+[+>[>]+>+[<]+<]+<]
31 3 53 +>+>+[+>[>]+[+>[>]+>+[<]+<]+<]+
32 3 160 +>+>+>+[+>[>]+[+>[>]+>+[<]+<]+<]
33 3 161 +>+>+>+[+>[>]+[+>[>]+>+[<]+<]+<]+
34 3 484 +>+>+>+>+[+>[>]+[+>[>]+>+[<]+<]+<]
35 3 485 +>+>+>+>+[+>[>]+[+>[>]+>+[<]+<]+<]+
36 3 1705 +>+>+>+>+[+>[>]+[+>[>]+>+>+[<]+<]+<]
37 3 1706 +>+>+>+>+[+>[>]+[+>[>]+>+>+[<]+<]+<]+
38 4 X +>+>+[+>[>]+[+>[>]+[+>[>]+[<]+<]+<]+<]
39 4 X+1 +>+>+[+>[>]+[+>[>]+[+>[>]+[<]+<]+<]+<]+
40 4 Y +>+>+>+[+>[>]+[+>[>]+[+>[>]+[<]+<]+<]+<]
...
where X = 3*(2^(3*(2^5-1)+2)-1)+1
= 3*(2^95-1)+1 = 118842243771396506390315925502
> 10^29
X+1 = 118842243771396506390315925503
Y = 3*(2^(X+1)-1)+1
= 3*(2^118842243771396506390315925503-1)+1
> 10^10^28
Open questions (among many):
(1) What is the shortest Busy Beaver of depth > 1 that is neither an
A(i) nor an A(i) '+' ?
(2) What is the shortest Busy Beaver of odd length not ending in a '+'?
]
| Brainfuck | 3 | RubenNL/brainheck | examples/busy-beaver-overflow.bf | [
"Apache-2.0"
] |
$(OBJDIR)/alpha.cmi: $(OBJDIR)/pretty.cmi
| D | 2 | heechul/crest-z3 | cil/obj/.depend/alpha.di | [
"BSD-3-Clause"
] |
"""
DerivedClass
"""
import System
import System.Xml.Serialization from System.Xml
import BooCompiler.Tests.SupportingClasses from BooCompiler.Tests
class C:
[XmlInclude(DerivedClass)]
def GetItem() as BaseClass:
pass
GetItem = typeof(C).GetMethod("GetItem")
xmlinc as XmlIncludeAttribute = Attribute.GetCustomAttribute(GetItem, XmlIncludeAttribute)
print(xmlinc.Type.Name)
| Boo | 3 | popcatalin81/boo | tests/testcases/integration/attributes/attributes-3.boo | [
"BSD-3-Clause"
] |
(defn sum-range [n]
(sum (range 1 (+ 1 n))))
(defn wesley-safadao [day month year]
(setv safadeza
(+ (sum-range month)
(* (/ year 100)
(- 50 day))))
(setv anjo (- 100 safadeza))
{ :safado safadeza :anjo anjo })
(defn say-safadeza [day month year]
(setv result (wesley-safadao day month year))
(setv safado (:safado result))
(setv anjo (:anjo result))
(print (.format "Você é {0}% safado e {0}% anjo" safado anjo)))
| Hy | 4 | mabrasil/safadometro | hy/wesley-safadao.hy | [
"MIT"
] |
use("ispec")
SequenceTester = Origin mimic do(
mimic!(Mixins Sequenced)
val = [1,2,3,4,5,6,7,8]
len = 8
seq = method(
s = Sequence mimic
s val = @val
s index = 0
s len = @len
s next = method(
result = @val[@index]
@index++
result
)
s next? = method(@index < @len)
s reset! = method(@index = 0)
s
)
)
SequenceHelper = Origin mimic do(
initialize = method(@called = false)
mapped = macro(@called = true. @callInfo = call. 42)
collected = macro(@called = true. @callInfo = call. 42)
filtered = macro(@called = true. @callInfo = call. 42)
selected = macro(@called = true. @callInfo = call. 42)
grepped = macro(@called = true. @callInfo = call. 42)
zipped = macro(@called = true. @callInfo = call. 42)
dropped = macro(@called = true. @callInfo = call. 42)
droppedWhile = macro(@called = true. @callInfo = call. 42)
rejected = macro(@called = true. @callInfo = call. 42)
consed = macro(@called = true. @callInfo = call. 42)
sliced = macro(@called = true. @callInfo = call. 42)
)
describe(Mixins,
describe(Mixins Sequenced,
it("should be Enumerable",
;; gymnastics necessary since we don't have the should method or mimics method on Mixins
(Reflector other:mimics(Mixins Sequenced)[1] == Mixins Enumerable) should be true
)
describe("each",
it("should be implemented in terms of 'seq'",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
seqObj mock!(:next?) andReturn(false)
x mock!(:seq) andReturn(seqObj)
x each(42)
)
it("should be possible to call with one message chain that will be applied to all arguments",
Ground y = []
Ground xs = method(y << self)
SequenceTester each(xs)
y should == [1,2,3,4,5,6,7,8]
x = 0
SequenceTester each(nil. x++)
x should == 8
)
it("should be possible to call with one argument name and code that will be applied to all arguments",
y = []
SequenceTester each(x, y << x)
y should == [1,2,3,4,5,6,7,8]
)
it("should be possible to call with two argument names and code that will be applied to all arguments",
y = []
SequenceTester each(i, x, y << [i, x])
y should == [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8]]
)
it("should return the object",
(SequenceTester each(x, x)) should be(SequenceTester)
)
it("should establish a lexical context when invoking the methods. this context will be the same for all invocations.",
SequenceTester each(x_list, blarg=32)
cell?(:x_list) should be false
cell?(:blarg) should be false
x=14
SequenceTester each(x, blarg=32)
x should == 14
)
it("should return a Sequence if called with no arguments",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x each should be same(seqObj)
)
)
describe("mapped",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x mapped(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("collected",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x collected(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("filtered",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x filtered(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("selected",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x selected(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("grepped",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x grepped(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("interpose",
it("should return a new sequence",
[1,2,3] interpose(42) should mimic(Sequence)
)
it("should return a sequence that has the element interposed",
[1,2,3] interpose(42) asList should == [1,42,2,42,3]
)
)
describe("interleave",
it("should create a new sequence",
[1,2,3] interleave(1..5) should mimic(Sequence)
)
it("should take an enumerable",
[1,2,3] interleave(5..15) asList should == [1,5,2,6,3,7]
)
it("should take a seq",
[1,2,3] interleave((5..15) seq) asList should == [1,5,2,6,3,7]
)
it("should only take as many elements as needed from the self",
[1,2,3,4,5,6] interleave([10,11]) asList should == [1,10,2,11]
)
it("should only take as many elements as needed from the argument",
[1,2] interleave([10,11,12,13,14,15]) asList should == [1,10,2,11]
)
it("should interleave the elements of the argument with the elements of the sequence",
["foo", "bar", "quux"] interleave(1..3) asList should == ["foo", 1, "bar", 2, "quux", 3]
)
)
describe("zipped",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x zipped(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("dropped",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x dropped(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("droppedWhile",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x droppedWhile(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("rejected",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x rejected(foo, bar x * 43) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['foo, '(bar x * 43)]
)
)
describe("consed",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x consed(3) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['3]
)
)
describe("sliced",
it("should resend the call with all arguments to the result of calling seq",
x = Origin mimic
x mimic!(Mixins Sequenced)
seqObj = SequenceHelper mimic
x mock!(:seq) andReturn(seqObj)
x sliced(3) should == 42
seqObj called should be true
seqObj callInfo arguments should == ['3]
)
)
)
)
describe(Sequence,
it("should be Enumerable",
Sequence should mimic(Mixins Enumerable)
)
describe("each",
it("should start from the point where the sequence is right now",
xx = SequenceTester seq
xx next should == 1
y = []
xx each(x, y << x)
y should == [2,3,4,5,6,7,8]
)
it("should be possible to give it just a message chain",
Ground y = []
Ground xs = method(y << self)
SequenceTester seq each(xs)
y should == [1,2,3,4,5,6,7,8]
x = 0
SequenceTester seq each(nil. x++)
x should == 8
)
it("should be possible to give it an argument name and code",
y = []
SequenceTester seq each(x, y << x)
y should == [1,2,3,4,5,6,7,8]
)
it("should return the sequence",
y = SequenceTester seq
(y each(x, x)) should be(y)
)
it("should establish a lexical context when invoking the methods. this context will be the same for all invocations.",
SequenceTester seq each(x_list, blarg = 32)
cell?(:x_list) should be false
cell?(:blarg) should be false
x = 14
SequenceTester seq each(x, blarg = 32)
x should == 14
)
it("should be possible to give it an extra argument to get the index",
y = []
SequenceTester seq each(i, x, y << [i, x])
y should == [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8]]
)
)
describe("mapped",
it("should create a new Sequence Map with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3], len: 3) seq
val = ss mapped(*2)
val should mimic(Sequence Map)
val wrappedSequence should be same(ss)
val messages should == ['(*2)]
)
it("should map the objects",
ss = SequenceTester with(val: [1,2,3], len: 3) seq
ss mapped(*2) asList should == [2,4,6]
ss = SequenceTester with(val: [1,2,3], len: 3) seq
ss mapped(x, x*2) asList should == [2,4,6]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
ss mapped((x,y), [x+1, y-1]) asList should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
ss mapped((x,y,_), cell?(:"_") should not be true. [x, y]) asList should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
ss mapped((x,_,y), cell?(:"_") should not be true. [x, y]) asList should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
ss mapped((x,_,y,_,q), cell?(:"_") should not be true. [x, y, q]) asList should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
ss mapped(
(v, (v2, _, v3)), cell?(:"_") should be false. [v, v2, v3]) asList should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq mapped((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq mapped((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq mapped((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq mapped((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq mapped((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq mapped((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("collected",
it("should create a new Sequence Map with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3], len: 3) seq
val = ss collected(*2)
val should mimic(Sequence Map)
val wrappedSequence should be same(ss)
val messages should == ['(*2)]
)
it("should map the objects",
ss = SequenceTester with(val: [1,2,3], len: 3) seq
ss collected(*2) asList should == [2,4,6]
ss = SequenceTester with(val: [1,2,3], len: 3) seq
ss collected(x, x*2) asList should == [2,4,6]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
ss collected((x,y), [x+1, y-1]) asList should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
ss collected((x,y,_), cell?(:"_") should not be true. [x, y]) asList should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
ss collected((x,_,y), cell?(:"_") should not be true. [x, y]) asList should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
ss collected((x,_,y,_,q), cell?(:"_") should not be true. [x, y, q]) asList should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
ss collected(
(v, (v2, _, v3)), cell?(:"_") should be false. [v, v2, v3]) asList should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq collected((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq collected((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq collected((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq collected((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq collected((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq collected((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("filtered",
it("should create a new Sequence Filter with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss filtered(>4)
val should mimic(Sequence Filter)
val wrappedSequence should be same(ss)
val messages should == ['(>4)]
)
it("should filter the objects",
ss = SequenceTester with(val: [true, false, nil, true, false, nil, 1], len: 7) seq
ss filtered asList should == [true, true, 1]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss filtered(>4) asList should == [5,6,7,8]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss filtered(x, x>4) asList should == [5,6,7,8]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
result = []
ss filtered((x,y), result << [x+1, y-1]) asList
result should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
result = []
ss filtered((x,y,_), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
result = []
ss filtered((x,_,y), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
result = []
ss filtered((x,_,y,_,q), cell?(:"_") should not be true. result << [x, y, q]) asList
result should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
result = []
ss filtered(
(v, (v2, _, v3)), cell?(:"_") should be false. result << [v, v2, v3]) asList
result should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq filtered((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq filtered((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq filtered((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq filtered((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq filtered((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq filtered((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("selected",
it("should create a new Sequence Filter with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss selected(>4)
val should mimic(Sequence Filter)
val wrappedSequence should be same(ss)
val messages should == ['(>4)]
)
it("should filter the objects",
ss = SequenceTester with(val: [true, false, nil, true, false, nil, 1], len: 7) seq
ss selected asList should == [true, true, 1]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss selected(>4) asList should == [5,6,7,8]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss selected(x, x>4) asList should == [5,6,7,8]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
result = []
ss selected((x,y), result << [x+1, y-1]) asList
result should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
result = []
ss selected((x,y,_), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
result = []
ss selected((x,_,y), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
result = []
ss selected((x,_,y,_,q), cell?(:"_") should not be true. result << [x, y, q]) asList
result should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
result = []
ss selected(
(v, (v2, _, v3)), cell?(:"_") should be false. result << [v, v2, v3]) asList
result should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq selected((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq selected((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq selected((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq selected((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq selected((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq selected((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("grepped",
it("should create a new Sequence Grep with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss grepped(2..4)
val should mimic(Sequence Grep)
val wrappedSequence should be same(ss)
val messages should == []
val restArguments should == [2..4]
)
it("should grep the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss grepped(2..4) asList should == [2,4]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
result = []
ss grepped(Origin, (x,y), result << [x+1, y-1]. nil) asList
result should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
result = []
ss grepped(Origin, (x,y,_), cell?(:"_") should not be true. result << [x, y]. nil) asList
result should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
result = []
ss grepped(Origin, (x,_,y), cell?(:"_") should not be true. result << [x, y]. nil) asList
result should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
result = []
ss grepped(Origin, (x,_,y,_,q), cell?(:"_") should not be true. result << [x, y, q]. nil) asList
result should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
result = []
ss grepped(Origin,
(v, (v2, _, v3)), cell?(:"_") should be false. result << [v, v2, v3]. nil) asList
result should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq grepped(Origin, (q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq grepped(Origin, (q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq grepped(Origin, (q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq grepped(Origin, (q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq grepped(Origin, (q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq grepped(Origin, (q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("zipped",
it("should create a new Sequence Zip with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
listSeq = [1,2,3,4] seq
val = ss zipped(listSeq)
val should mimic(Sequence Zip)
val wrappedSequence should be same(ss)
val messages should == []
val restArguments[0] should be same(listSeq)
)
it("should zip the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss zipped([1,2,3,4], [55,66,77]) asList should == [[1,1,55], [2,2,66],
[4, 3, 77],
[5, 4, nil], [6, nil, nil],
[7, nil, nil], [8, nil, nil]]
)
)
describe("indexed",
it("should create a new Sequence Index with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss indexed
val should mimic(Sequence Index)
val wrappedSequence should be same(ss)
val messages should == []
)
it("should index the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss indexed asList should == [[0,1], [1,2], [2,4], [3,5], [4,6], [5,7], [6,8]]
)
it("should take an optional from: parameter",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss indexed(from: 10) asList should == [[10,1], [11,2], [12,4], [13,5], [14,6], [15,7], [16,8]]
)
it("should take an optional step: parameter",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss indexed(step: 3) asList should == [[0,1], [3,2], [6,4], [9,5], [12,6], [15,7], [18,8]]
)
)
describe("dropped",
it("should create a new Sequence Drop with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss dropped(3)
val should mimic(Sequence Drop)
val wrappedSequence should be same(ss)
val messages should == []
val restArguments should == [3]
)
it("should drop the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss dropped(3) asList should == [5,6,7,8]
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss dropped(10) asList should == []
)
)
describe("droppedWhile",
it("should create a new Sequence DropWhile with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss droppedWhile(<4)
val should mimic(Sequence DropWhile)
val wrappedSequence should be same(ss)
val messages should == ['(<4)]
)
it("should drop the objects",
ss = SequenceTester with(val: [true, true, 1, false, 2, 3], len: 6) seq
ss droppedWhile asList should == [false, 2,3]
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss droppedWhile(<3) asList should == [4,5,6,7,8]
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss droppedWhile(x, x < 3) asList should == [4,5,6,7,8]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
result = []
ss droppedWhile((x,y), result << [x+1, y-1]) asList
result should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
result = []
ss droppedWhile((x,y,_), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
result = []
ss droppedWhile((x,_,y), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
result = []
ss droppedWhile((x,_,y,_,q), cell?(:"_") should not be true. result << [x, y, q]) asList
result should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
result = []
ss droppedWhile(
(v, (v2, _, v3)), cell?(:"_") should be false. result << [v, v2, v3]) asList
result should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq droppedWhile((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq droppedWhile((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq droppedWhile((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq droppedWhile((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq droppedWhile((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq droppedWhile((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("rejected",
it("should create a new Sequence Reject with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss rejected(>4)
val should mimic(Sequence Reject)
val wrappedSequence should be same(ss)
val messages should == ['(>4)]
)
it("should filter the objects",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss rejected(>4) asList should == [1,2,3,4]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
ss rejected(x, x>4) asList should == [1,2,3,4]
)
it("should be able to destructure on the argument name",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3) seq
result = []
ss rejected((x,y), result << [x+1, y-1]) asList
result should == [[2,1], [3,2], [5,4]]
)
it("should be able to destructure and ignore the rest of something",
ss = SequenceTester with(val: [[1,2,9,10], [2,3,11,12], [4,5,13,14]], len: 3) seq
result = []
ss rejected((x,y,_), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,2], [2,3], [4,5]]
)
it("should be able to destructure and ignore in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9], [2,3,11], [4,5,13]], len: 3) seq
result = []
ss rejected((x,_,y), cell?(:"_") should not be true. result << [x, y]) asList
result should == [[1,9], [2,11], [4,13]]
)
it("should be able to destructure and ignore several times in the middle of the pattern without binding anything",
ss = SequenceTester with(val: [[1,2,9,10,11], [2,3,11,12,13], [4,5,13,14,15]], len: 3) seq
result = []
ss rejected((x,_,y,_,q), cell?(:"_") should not be true. result << [x, y, q]) asList
result should == [[1,9,11], [2,11,13], [4,13,15]]
)
it("should be able to destructure recursively",
ss = SequenceTester with(val: [[[:x, :y, :z], [:q, :r, :p]], [[:b, :c, :d], [:i, :j, :k]], [[:i, :j, :k], [:i2, :j3, :k4]]], len: 3) seq
result = []
ss rejected(
(v, (v2, _, v3)), cell?(:"_") should be false. result << [v, v2, v3]) asList
result should == [[[:x, :y, :z], :q, :p], [[:b, :c, :d], :i, :k], [[:i, :j, :k], :i2, :k4]]
)
it("should report a destructuring match error if destructuring doesn't add upp",
ss = SequenceTester with(val: [[1,2], [2,3], [4,5]], len: 3)
fn(ss seq rejected((q,p,r), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq rejected((q), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq rejected((q,_,r), nil) asList) should signal(Condition Error DestructuringMismatch)
)
it("should report a destructuring match error if recursive destructuring doesn't add upp",
ss = SequenceTester with(val: [[[1,2],[1,2]], [[3,4],[1,2]], [[1,2],[4,5]]], len: 3)
fn(ss seq rejected((q,(p)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq rejected((q,(p,r,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
fn(ss seq rejected((q,(p,_,f)), nil) asList) should signal(Condition Error DestructuringMismatch)
)
)
describe("consed",
it("should create a new Sequence Cons with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss consed(3)
val should mimic(Sequence Cons)
val wrappedSequence should be same(ss)
val messages should == []
val restArguments should == [3]
)
it("should cons the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss consed asList should == [[1,2], [2,4], [4,5], [5,6], [6,7], [7,8]]
ss = SequenceTester with(val: [1,2,4,5,6,7,8], len: 7) seq
ss consed(3) asList should == [[1,2,4], [2,4,5], [4,5,6], [5,6,7], [6,7,8]]
)
)
describe("sliced",
it("should create a new Sequence Slice with the arguments sent to it",
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8], len: 8) seq
val = ss sliced(3)
val should mimic(Sequence Slice)
val wrappedSequence should be same(ss)
val messages should == []
val restArguments should == [3]
)
it("should slice the objects",
ss = SequenceTester with(val: [1,2,4,5,6,7], len: 6) seq
ss sliced asList should == [[1,2], [4,5], [6,7]]
ss = SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq
ss sliced(3) asList should == [[1,2,3], [4,5,6], [7,8,9]]
)
)
describe("+",
it("should return a new sequence that first runs the lhs sequence then the rhs sequence",
([1,2,3] seq + [5, 6, 7, 8] seq) take(5) should == [1,2,3,5,6]
)
)
describe("interpose",
it("should create a new sequence",
[1,2,3] seq interpose(42) should mimic(Sequence)
)
it("should interpose the argument inbetween the elements of the original sequence",
["foo", "bar", "quux"] seq interpose("|") asList should == ["foo", "|", "bar", "|", "quux"]
)
)
describe("%",
it("should create a new sequence",
([1,2,3] seq % 42) should mimic(Sequence)
)
it("should interpose the argument inbetween the elements of the original sequence",
(["foo", "bar", "quux"] seq % "|") asList should == ["foo", "|", "bar", "|", "quux"]
)
)
describe("interleave",
it("should create a new sequence",
[1,2,3] seq interleave(1..5) should mimic(Sequence)
)
it("should take an enumerable",
[1,2,3] seq interleave(5..15) asList should == [1,5,2,6,3,7]
)
it("should take a seq",
[1,2,3] seq interleave((5..15) seq) asList should == [1,5,2,6,3,7]
)
it("should only take as many elements as needed from the self",
[1,2,3,4,5,6] seq interleave([10,11]) asList should == [1,10,2,11]
)
it("should only take as many elements as needed from the argument",
[1,2] seq interleave([10,11,12,13,14,15]) asList should == [1,10,2,11]
)
it("should interleave the elements of the argument with the elements of the sequence",
["foo", "bar", "quux"] seq interleave(1..3) asList should == ["foo", 1, "bar", 2, "quux", 3]
)
)
describe("&",
it("should create a new sequence",
([1,2,3] seq & (1..5)) should mimic(Sequence)
)
it("should take an enumerable",
([1,2,3] seq & (5..15)) asList should == [1,5,2,6,3,7]
)
it("should take a seq",
([1,2,3] seq & (5..15) seq) asList should == [1,5,2,6,3,7]
)
it("should only take as many elements as needed from the self",
([1,2,3,4,5,6] seq & [10,11]) asList should == [1,10,2,11]
)
it("should only take as many elements as needed from the argument",
([1,2] seq & [10,11,12,13,14,15]) asList should == [1,10,2,11]
)
it("should interleave the elements of the argument with the elements of the sequence",
(["foo", "bar", "quux"] seq & (1..3)) asList should == ["foo", 1, "bar", 2, "quux", 3]
)
)
describe("ℕ",
it("should return a Sequence",
Sequence ℕ should mimic(Sequence)
)
it("should return a new infinity sequence every time called",
Sequence ℕ should not be(Sequence ℕ)
)
it("should start from zero",
Sequence ℕ next should == 0
)
it("should use step 1",
xx = Sequence ℕ
xx next should == 0
xx next should == 1
xx next should == 2
)
)
describe("ω",
it("should return a Sequence",
Sequence ω should mimic(Sequence)
)
it("should return a new infinity sequence every time called",
Sequence ω should not be(Sequence ℕ)
)
it("should start from zero",
Sequence ω next should == 0
)
it("should use step 1",
xx = Sequence ω
xx next should == 0
xx next should == 1
xx next should == 2
)
)
describe("infinity",
it("should return a Sequence",
Sequence infinity should mimic(Sequence)
)
it("should return a new infinity sequence every time called",
Sequence infinity should not be(Sequence infinity)
)
it("should default to start from zero",
Sequence infinity next should == 0
)
it("should default to use step 1",
xx = Sequence infinity
xx next should == 0
xx next should == 1
xx next should == 2
)
it("should be possible to define where the sequence starts from",
xx = Sequence infinity(from: 42)
xx next should == 42
xx next should == 43
xx next should == 44
)
it("should be possible to define what step the sequence uses",
xx = Sequence infinity(step: 2)
xx next should == 0
xx next should == 2
xx next should == 4
xx = Sequence infinity(step: -1)
xx next should == 0
xx next should == -1
xx next should == -2
)
)
describe("Filter",
it("should mimic Sequence",
Sequence Filter should mimic(Sequence)
)
it("should take zero arguments and return a sequence with only the true values",
ss = Sequence Filter create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [])
ss next should == 1
ss asList should == [2,3]
ss = Sequence Filter create(SequenceTester with(val: [nil,false,nil], len: 3) seq, Ground, [])
ss next? should be false
ss asList should == []
ss = Sequence Filter create(SequenceTester with(val: [nil,false,true], len: 3) seq, Ground, [])
ss next? should be true
ss asList should == [true]
)
it("should take one argument that ends up being a predicate and return a sequence of the values that is true",
ss = Sequence Filter create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['(>1)])
ss next should == 2
ss asList should == [3]
ss = Sequence Filter create(SequenceTester with(val: [nil,false,nil], len: 3) seq, Ground, ['(nil?)])
ss asList should == [nil, nil]
ss = Sequence Filter create(SequenceTester with(val: [nil,false,true], len: 3) seq, Ground, ['(==2)])
ss next? should be false
ss asList should == []
)
it("should take two arguments that ends up being a predicate and return a sequence of the values that is true",
ss = Sequence Filter create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['x, '(x>1)])
ss next should == 2
ss asList should == [3]
ss = Sequence Filter create(SequenceTester with(val: [nil,false,nil], len: 3) seq, Ground, ['x, '(x nil?)])
ss asList should == [nil, nil]
ss = Sequence Filter create(SequenceTester with(val: [nil,false,true], len: 3) seq, Ground, ['x, '(x==2)])
ss next? should be false
ss asList should == []
)
)
describe("Map",
it("should mimic Sequence",
Sequence Map should mimic(Sequence)
)
it("should be able to take one argument for mapping",
ss = Sequence Map create(SequenceTester seq, Ground, ['(*2)])
ss next should == 2
ss next should == 4
ss asList should == [6, 8, 10, 12, 14, 16]
)
it("should be able to take two arguments for mapping",
ss = Sequence Map create(SequenceTester seq, Ground, ['x, '(x*3)])
ss next should == 3
ss next should == 6
ss asList should == [9, 12, 15, 18, 21, 24]
)
)
describe("Grep",
it("should mimic Sequence",
Sequence Grep should mimic(Sequence)
)
it("should take one argument and return everything that matches with ===",
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, [], 2..5)
ss next should == 2
ss asList should == [3,4,5]
customObj = Origin mimic
customObj === = method(other, (other < 3) || (other > 5))
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, [], customObj)
ss next should == 1
ss next should == 2
ss asList should == [6,7,8,9]
)
it("should take two arguments where the second argument is a message chain and return the result of calling that chain on everything that matches with ===",
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, ['(+ 1)], 2..5)
ss next should == 3
ss asList should == [4,5,6]
customObj = Origin mimic
customObj === = method(other, (other < 3) || (other > 5))
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, ['(+ 1)], customObj)
ss next should == 2
ss next should == 3
ss asList should == [7,8,9,10]
)
it("should take three arguments where the second and third arguments gets turned into a lexical block to apply to all that matches with ===",
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, ['x, '((x + 1) asText)], 2..5)
ss next should == "3"
ss asList should == ["4","5","6"]
customObj = Origin mimic
customObj === = method(other, (other < 3) || (other > 5))
ss = Sequence Grep create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, ['x, '((x + 1) asText)], customObj)
ss next should == "2"
ss next should == "3"
ss asList should == ["7","8","9","10"]
)
)
describe("Index",
it("should mimic Sequence",
Sequence Index should mimic(Sequence)
)
it("should take zero arguments and just index the elements",
ss = Sequence Index create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 0, 1)
ss next should == [0, 1]
ss asList should == [[1,2], [2,3]]
)
)
describe("Zip",
it("should mimic Sequence",
Sequence Zip should mimic(Sequence)
)
it("should take zero arguments and just zip the elements",
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [])
ss next should == [1]
ss asList should == [[2], [3]]
)
it("should take one argument as a list and zip the elements together",
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], [5,6,7])
ss next should == [1,5]
ss asList should == [[2,6], [3,7]]
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], [5,6,7,8])
ss next should == [1,5]
ss asList should == [[2,6], [3,7]]
)
it("should take one argument as a seq and zip the elements together",
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], SequenceTester with(val: [9,10,11], len: 3) seq)
ss next should == [1,9]
ss asList should == [[2,10], [3,11]]
)
it("should supply nils if the second list isn't long enough",
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], [5,6])
ss next should == [1,5]
ss asList should == [[2,6], [3,nil]]
)
it("should zip together several lists",
ss = Sequence Zip create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], [5,6,7], [10,11,12], [15,16,17])
ss next should == [1,5,10,15]
ss asList should == [[2,6,11,16], [3,7,12,17]]
)
)
describe("Drop",
it("should mimic Sequence",
Sequence Drop should mimic(Sequence)
)
it("should return a list without as many elements as requested",
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 0)
ss next should == 1
ss asList should == [2,3]
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 1)
ss next should == 2
ss asList should == [3]
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 2)
ss asList should == [3]
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 3)
ss asList should == []
)
it("should not drop more elements than the length of the collection",
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 4)
ss asList should == []
ss = Sequence Drop create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [], 10)
ss asList should == []
)
)
describe("DropWhile",
it("should mimic Sequence",
Sequence DropWhile should mimic(Sequence)
)
it("should take zero arguments and return everything after the point where a value is true",
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, [])
ss asList should == []
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,nil,false], len: 4) seq, Ground, [])
ss asList should == [nil, false]
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,false,3,4,nil,false], len: 7) seq, Ground, [])
ss asList should == [false,3,4,nil,false]
)
it("should take one argument and apply it as a message chain, return a list with all elements after the block returns false",
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['(<3)])
ss asList should == [3]
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['(!=2)])
ss asList should == [2,3]
)
it("should take two arguments and apply the lexical block created from it, and return a list with all elements after the block returns false",
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['x, '(x<3)])
ss asList should == [3]
ss = Sequence DropWhile create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['x, '(x != 2)])
ss asList should == [2,3]
)
)
describe("Reject",
it("should mimic Sequence",
Sequence Reject should mimic(Sequence)
)
it("should take one argument that ends up being a predicate and return a sequence of the values that is false",
ss = Sequence Reject create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['(>1)])
ss asList should == [1]
ss = Sequence Reject create(SequenceTester with(val: [nil,false,nil], len: 3) seq, Ground, ['(nil?)])
ss asList should == [false]
ss = Sequence Reject create(SequenceTester with(val: [nil,false,true], len: 3) seq, Ground, ['(==2)])
ss next should == nil
ss asList should == [false, true]
)
it("should take two arguments that ends up being a predicate and return a sequence of the values that is false",
ss = Sequence Reject create(SequenceTester with(val: [1,2,3], len: 3) seq, Ground, ['x, '(x>1)])
ss asList should == [1]
ss = Sequence Reject create(SequenceTester with(val: [nil,false,nil], len: 3) seq, Ground, ['x, '(x nil?)])
ss asList should == [false]
ss = Sequence Reject create(SequenceTester with(val: [nil,false,true], len: 3) seq, Ground, ['x, '(x==2)])
ss next should be nil
ss asList should == [false, true]
)
)
describe("Cons",
it("should mimic Sequence",
Sequence Cons should mimic(Sequence)
)
it("should return a consed list with the given length",
ss = Sequence Cons create(SequenceTester with(val: [1,2,3,4], len: 4) seq, Ground, [], 2)
ss next should == [1,2]
ss asList should == [[2,3], [3,4]]
ss = Sequence Cons create(SequenceTester with(val: [1,2,3,4,6], len: 5) seq, Ground, [], 3)
ss next should == [1,2,3]
ss asList should == [[2,3,4], [3,4,6]]
)
)
describe("Slice",
it("should mimic Sequence",
Sequence Slice should mimic(Sequence)
)
it("should return a sliced list with the given length",
ss = Sequence Slice create(SequenceTester with(val: [1,2,3,4,5,6], len: 6) seq, Ground, [], 2)
ss next should == [1,2]
ss asList should == [[3,4], [5,6]]
ss = Sequence Slice create(SequenceTester with(val: [1,2,3,4,5,6,7,8,9], len: 9) seq, Ground, [], 3)
ss next should == [1,2,3]
ss asList should == [[4,5,6], [7,8,9]]
)
)
)
| Ioke | 5 | olabini/ioke | test/sequence_spec.ik | [
"ICU",
"MIT"
] |
<div>Foo</div>
---
<div>Foo</div>
=============================================
ul {
<li>A</li>
<li>B</li>
}
---
ul {
<li>A</li>
<li>B</li>
}
=============================================
<!DOCTYPE html>
<html>
<head></head>
<body>
<input>
</body>
</html>
---
<!DOCTYPE html>
<html>
<head></head>
<body>
<input/>
</body>
</html>
=============================================
define Foo {
<div>Foo</div>
}
---
define Foo {
<div>Foo</div>
}
=============================================
<div>
<mask>
import Foo from 'foo' is json;
</mask>
</div>
---
<div>
<mask>
import Foo from 'foo' is json;
</mask>
</div> | Mask | 0 | atmajs/MaskJS | test/tmpl/stringify/html.mask | [
"MIT"
] |
--TEST--
Check that SplObjectStorage::current() throws when iterator invalid
--CREDITS--
PHPNW Testfest 2009 - Simon Westcott (swestcott@gmail.com)
--FILE--
<?php
$s = new SplObjectStorage();
var_dump($s->valid());
try {
var_dump($s->current());
} catch (RuntimeException $e) {
echo $e->getMessage(), "\n";
}
?>
--EXPECT--
bool(false)
Called current() on invalid iterator
| PHP | 3 | NathanFreeman/php-src | ext/spl/tests/SplObjectStorage_current_empty_storage.phpt | [
"PHP-3.01"
] |
( Generated from test_tuple_assign_in.muv by the MUV compiler. )
( https://github.com/revarbat/pymuv )
: _gen[ -- ret ]
0 var! _i
{ }list var! _out
begin
_i @ 4 <
while
_out @ { "Fee" "Fie" "Foe" "Fum" }list _i @ [] swap []<- _out !
_i ++
repeat
_out @
;
: _listgen[ -- ret ]
{ }list var! _out
0 var! _i
begin
_i @ _i ++ 10 <
while
_out @ _gen swap []<- _out !
repeat
_out @
;
: _main[ _arg -- ret ]
_gen 0 3 [..] array_vals pop
var! _d var! _c var! _b var! _a
_gen 0 3 [..] array_vals pop
_a ! _b ! _c ! _d !
_listgen foreach
0 3 [..] array_vals pop
_d ! _c ! _b ! _a ! pop
{ _a @ _b @ }list array_interpret me @ swap notify
repeat
{ }list _listgen foreach
0 3 [..] array_vals pop
_d ! _c ! _b ! _a ! pop
_a @ _b @ strcmp if
{ _c @ _d @ }list array_interpret swap []<-
then
repeat
;
: __start
"me" match me ! me @ location loc ! trig trigger !
_main
;
| MUF | 3 | revarbat/pymuv | tests/test_tuple_assign_cmp.muf | [
"MIT"
] |
#include-once
#include <GuiConstants.au3>
;~ If Not IsDeclared("WM_COMMAND") Then Global Const $WM_COMMAND = 0x0111
;~ If Not IsDeclared("WM_MOVE") Then Global Const $WM_MOVE = 0x0003
;~ If Not IsDeclared("WM_LBUTTONDOWN") Then Global Const $WM_LBUTTONDOWN = 0x0201
;~ If Not IsDeclared("WM_RBUTTONDOWN") Then Global Const $WM_RBUTTONDOWN = 0x0204
Global $sToolTip_Text[2] = ["You can only type a number here", "Unacceptable Character:"]
Global $sInputs_Array[1]
Global $tInputs_Array[1]
GUIRegisterMsg($WM_COMMAND, "MY_WM_COMMAND")
GUIRegisterMsg($WM_MOVE, "WM_CLEAR_TOOLTIP")
GUIRegisterMsg($WM_LBUTTONDOWN, "WM_CLEAR_TOOLTIP")
GUIRegisterMsg($WM_RBUTTONDOWN, "WM_CLEAR_TOOLTIP")
; $CtrlId must be an ID value, -1 can not be used!
Func _GuiInputSetOnlyNumbers($CtrlId, $tTip = True)
Local $iUbound = UBound($sInputs_Array)
ReDim $sInputs_Array[$iUbound+1]
ReDim $tInputs_Array[$iUbound+1]
$sInputs_Array[$iUbound] = $CtrlId
$tInputs_Array[$iUbound] = $tTip
EndFunc
Func _Input_Changed($hWnd, $CtrlId)
For $i = 1 To UBound($sInputs_Array)-1
if $CtrlId = $sInputs_Array[$i] Then
$boolTip = $tInputs_Array[$i]
ExitLoop
EndIf
Next
if $boolTip Then ToolTip("")
Local $Read_Input = GUICtrlRead($CtrlId)
If StringRegExp($Read_Input, '[^\d-]|[{0-9,1}^\A-][^\d]') Then
$Read_Input = StringRegExpReplace($Read_Input, '[^\d-]|([{0-9,1}^\A-])[^\d]', '\1')
GUICtrlSetData($CtrlId, $Read_Input)
Local $Gui_Get_Pos = WinGetPos($hWnd)
Local $Ctrl_Get_Pos = ControlGetPos($hWnd, "", $CtrlId)
Local Const $SM_CYCAPTION = 4 ; Titlebar height
Local Const $SM_CXFIXEDFRAME = 7 ; Window border size
Local $X_Pos = $Gui_Get_Pos[0] + $Ctrl_Get_Pos[0] + $Ctrl_Get_Pos[2] + GetSystemMetrics($SM_CXFIXEDFRAME)
Local $Y_Pos = $Gui_Get_Pos[1] + $Ctrl_Get_Pos[1] + $Ctrl_Get_Pos[3] + GetSystemMetrics($SM_CYCAPTION)
if $boolTip Then ToolTip($sToolTip_Text[0], $X_Pos, $Y_Pos, $sToolTip_Text[1], 3, 1+4)
if $booltip Then DllCall("user32.dll", "int", "MessageBeep", "int", 0x0)
EndIf
EndFunc
;~ Func _Input_Changed($hWnd, $CtrlId)
;~ ToolTip("")
;~ Local $Read_Input = GUICtrlRead($CtrlId)
;~ If StringRegExp($Read_Input, '[^0-9]') Then
;~ GUICtrlSetData($CtrlId, StringRegExpReplace($Read_Input, '[^0-9]', ''))
;~ Local $Gui_Get_Pos = WinGetPos($hWnd)
;~ Local $Ctrl_Get_Pos = ControlGetPos($hWnd, "", $CtrlId)
;~ Local Const $SM_CYCAPTION = 4 ;Titelbar heigth
;~ Local Const $SM_CXFIXEDFRAME = 7 ;Window border size
;~ Local $X_Pos = $Gui_Get_Pos[0] + $Ctrl_Get_Pos[0] + $Ctrl_Get_Pos[2] + GetSystemMetrics($SM_CXFIXEDFRAME)
;~ Local $Y_Pos = $Gui_Get_Pos[1] + $Ctrl_Get_Pos[1] + $Ctrl_Get_Pos[3] + GetSystemMetrics($SM_CYCAPTION)
;~ ToolTip($sToolTip_Text[0], $X_Pos, $Y_Pos, $sToolTip_Text[1], 3, 1+4)
;~ DllCall("user32.dll", "int", "MessageBeep", "int", 0x0)
;~ EndIf
;~ EndFunc
Func WM_CLEAR_TOOLTIP($hWnd, $iMsg, $wParam, $lParam)
ToolTip("")
Return $GUI_RUNDEFMSG
EndFunc
Func MY_WM_COMMAND($hWnd, $iMsg, $wParam, $lParam)
If $hWnd = 0 Or Not WinExists($hWnd) Then Return $GUI_RUNDEFMSG
Local $nNotifyCode = BitShift($wParam, 16)
Local $nID = BitAND($wParam, 0xFFFF)
Local Const $EN_CHANGE = 0x300
Local Const $EN_UPDATE = 0x400
Local Const $EN_SETFOCUS = 0x100
Local Const $EN_KILLFOCUS = 0x200
For $i = 1 To UBound($sInputs_Array)-1
If $nID = $sInputs_Array[$i] Then
Switch $nNotifyCode
Case $EN_UPDATE ;$EN_CHANGE
_Input_Changed($hWnd, $sInputs_Array[$i])
Case $EN_SETFOCUS, $EN_KILLFOCUS
ToolTip("")
EndSwitch
ExitLoop
EndIf
Next
Return $GUI_RUNDEFMSG
EndFunc
Func GetSystemMetrics($Flag)
Local $iRet = DllCall('user32.dll', 'int', 'GetSystemMetrics', 'int', $Flag)
Return $iRet[0]
EndFunc
| AutoIt | 4 | sdoddler/D-D-Software-Suite | Include/GUIInputSetOnlyNumbers.au3 | [
"Unlicense"
] |
-- sRGB2014.icc
return "\000\000\011\208\000\000\000\000\002\000\000\000\109\110\116\114\082\071\066\032\088\089\090\032\007\223\000\002\000\015\000\000\000\000\000\000\097\099\115\112\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\246\214\000\001\000\000\000\000\211\045\000\000\000\000\061\014\178\222\174\147\151\190\155\103\038\206\140\010\067\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\100\101\115\099\000\000\001\068\000\000\000\099\098\088\089\090\000\000\001\168\000\000\000\020\098\084\082\067\000\000\001\188\000\000\008\012\103\084\082\067\000\000\001\188\000\000\008\012\114\084\082\067\000\000\001\188\000\000\008\012\100\109\100\100\000\000\009\200\000\000\000\136\103\088\089\090\000\000\010\080\000\000\000\020\108\117\109\105\000\000\010\100\000\000\000\020\109\101\097\115\000\000\010\120\000\000\000\036\098\107\112\116\000\000\010\156\000\000\000\020\114\088\089\090\000\000\010\176\000\000\000\020\116\101\099\104\000\000\010\196\000\000\000\012\118\117\101\100\000\000\010\208\000\000\000\135\119\116\112\116\000\000\011\088\000\000\000\020\099\112\114\116\000\000\011\108\000\000\000\055\099\104\097\100\000\000\011\164\000\000\000\044\100\101\115\099\000\000\000\000\000\000\000\009\115\082\071\066\050\048\049\052\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\088\089\090\032\000\000\000\000\000\000\036\160\000\000\015\132\000\000\182\207\099\117\114\118\000\000\000\000\000\000\004\000\000\000\000\005\000\010\000\015\000\020\000\025\000\030\000\035\000\040\000\045\000\050\000\055\000\059\000\064\000\069\000\074\000\079\000\084\000\089\000\094\000\099\000\104\000\109\000\114\000\119\000\124\000\129\000\134\000\139\000\144\000\149\000\154\000\159\000\164\000\169\000\174\000\178\000\183\000\188\000\193\000\198\000\203\000\208\000\213\000\219\000\224\000\229\000\235\000\240\000\246\000\251\001\001\001\007\001\013\001\019\001\025\001\031\001\037\001\043\001\050\001\056\001\062\001\069\001\076\001\082\001\089\001\096\001\103\001\110\001\117\001\124\001\131\001\139\001\146\001\154\001\161\001\169\001\177\001\185\001\193\001\201\001\209\001\217\001\225\001\233\001\242\001\250\002\003\002\012\002\020\002\029\002\038\002\047\002\056\002\065\002\075\002\084\002\093\002\103\002\113\002\122\002\132\002\142\002\152\002\162\002\172\002\182\002\193\002\203\002\213\002\224\002\235\002\245\003\000\003\011\003\022\003\033\003\045\003\056\003\067\003\079\003\090\003\102\003\114\003\126\003\138\003\150\003\162\003\174\003\186\003\199\003\211\003\224\003\236\003\249\004\006\004\019\004\032\004\045\004\059\004\072\004\085\004\099\004\113\004\126\004\140\004\154\004\168\004\182\004\196\004\211\004\225\004\240\004\254\005\013\005\028\005\043\005\058\005\073\005\088\005\103\005\119\005\134\005\150\005\166\005\181\005\197\005\213\005\229\005\246\006\006\006\022\006\039\006\055\006\072\006\089\006\106\006\123\006\140\006\157\006\175\006\192\006\209\006\227\006\245\007\007\007\025\007\043\007\061\007\079\007\097\007\116\007\134\007\153\007\172\007\191\007\210\007\229\007\248\008\011\008\031\008\050\008\070\008\090\008\110\008\130\008\150\008\170\008\190\008\210\008\231\008\251\009\016\009\037\009\058\009\079\009\100\009\121\009\143\009\164\009\186\009\207\009\229\009\251\010\017\010\039\010\061\010\084\010\106\010\129\010\152\010\174\010\197\010\220\010\243\011\011\011\034\011\057\011\081\011\105\011\128\011\152\011\176\011\200\011\225\011\249\012\018\012\042\012\067\012\092\012\117\012\142\012\167\012\192\012\217\012\243\013\013\013\038\013\064\013\090\013\116\013\142\013\169\013\195\013\222\013\248\014\019\014\046\014\073\014\100\014\127\014\155\014\182\014\210\014\238\015\009\015\037\015\065\015\094\015\122\015\150\015\179\015\207\015\236\016\009\016\038\016\067\016\097\016\126\016\155\016\185\016\215\016\245\017\019\017\049\017\079\017\109\017\140\017\170\017\201\017\232\018\007\018\038\018\069\018\100\018\132\018\163\018\195\018\227\019\003\019\035\019\067\019\099\019\131\019\164\019\197\019\229\020\006\020\039\020\073\020\106\020\139\020\173\020\206\020\240\021\018\021\052\021\086\021\120\021\155\021\189\021\224\022\003\022\038\022\073\022\108\022\143\022\178\022\214\022\250\023\029\023\065\023\101\023\137\023\174\023\210\023\247\024\027\024\064\024\101\024\138\024\175\024\213\024\250\025\032\025\069\025\107\025\145\025\183\025\221\026\004\026\042\026\081\026\119\026\158\026\197\026\236\027\020\027\059\027\099\027\138\027\178\027\218\028\002\028\042\028\082\028\123\028\163\028\204\028\245\029\030\029\071\029\112\029\153\029\195\029\236\030\022\030\064\030\106\030\148\030\190\030\233\031\019\031\062\031\105\031\148\031\191\031\234\032\021\032\065\032\108\032\152\032\196\032\240\033\028\033\072\033\117\033\161\033\206\033\251\034\039\034\085\034\130\034\175\034\221\035\010\035\056\035\102\035\148\035\194\035\240\036\031\036\077\036\124\036\171\036\218\037\009\037\056\037\104\037\151\037\199\037\247\038\039\038\087\038\135\038\183\038\232\039\024\039\073\039\122\039\171\039\220\040\013\040\063\040\113\040\162\040\212\041\006\041\056\041\107\041\157\041\208\042\002\042\053\042\104\042\155\042\207\043\002\043\054\043\105\043\157\043\209\044\005\044\057\044\110\044\162\044\215\045\012\045\065\045\118\045\171\045\225\046\022\046\076\046\130\046\183\046\238\047\036\047\090\047\145\047\199\047\254\048\053\048\108\048\164\048\219\049\018\049\074\049\130\049\186\049\242\050\042\050\099\050\155\050\212\051\013\051\070\051\127\051\184\051\241\052\043\052\101\052\158\052\216\053\019\053\077\053\135\053\194\053\253\054\055\054\114\054\174\054\233\055\036\055\096\055\156\055\215\056\020\056\080\056\140\056\200\057\005\057\066\057\127\057\188\057\249\058\054\058\116\058\178\058\239\059\045\059\107\059\170\059\232\060\039\060\101\060\164\060\227\061\034\061\097\061\161\061\224\062\032\062\096\062\160\062\224\063\033\063\097\063\162\063\226\064\035\064\100\064\166\064\231\065\041\065\106\065\172\065\238\066\048\066\114\066\181\066\247\067\058\067\125\067\192\068\003\068\071\068\138\068\206\069\018\069\085\069\154\069\222\070\034\070\103\070\171\070\240\071\053\071\123\071\192\072\005\072\075\072\145\072\215\073\029\073\099\073\169\073\240\074\055\074\125\074\196\075\012\075\083\075\154\075\226\076\042\076\114\076\186\077\002\077\074\077\147\077\220\078\037\078\110\078\183\079\000\079\073\079\147\079\221\080\039\080\113\080\187\081\006\081\080\081\155\081\230\082\049\082\124\082\199\083\019\083\095\083\170\083\246\084\066\084\143\084\219\085\040\085\117\085\194\086\015\086\092\086\169\086\247\087\068\087\146\087\224\088\047\088\125\088\203\089\026\089\105\089\184\090\007\090\086\090\166\090\245\091\069\091\149\091\229\092\053\092\134\092\214\093\039\093\120\093\201\094\026\094\108\094\189\095\015\095\097\095\179\096\005\096\087\096\170\096\252\097\079\097\162\097\245\098\073\098\156\098\240\099\067\099\151\099\235\100\064\100\148\100\233\101\061\101\146\101\231\102\061\102\146\102\232\103\061\103\147\103\233\104\063\104\150\104\236\105\067\105\154\105\241\106\072\106\159\106\247\107\079\107\167\107\255\108\087\108\175\109\008\109\096\109\185\110\018\110\107\110\196\111\030\111\120\111\209\112\043\112\134\112\224\113\058\113\149\113\240\114\075\114\166\115\001\115\093\115\184\116\020\116\112\116\204\117\040\117\133\117\225\118\062\118\155\118\248\119\086\119\179\120\017\120\110\120\204\121\042\121\137\121\231\122\070\122\165\123\004\123\099\123\194\124\033\124\129\124\225\125\065\125\161\126\001\126\098\126\194\127\035\127\132\127\229\128\071\128\168\129\010\129\107\129\205\130\048\130\146\130\244\131\087\131\186\132\029\132\128\132\227\133\071\133\171\134\014\134\114\134\215\135\059\135\159\136\004\136\105\136\206\137\051\137\153\137\254\138\100\138\202\139\048\139\150\139\252\140\099\140\202\141\049\141\152\141\255\142\102\142\206\143\054\143\158\144\006\144\110\144\214\145\063\145\168\146\017\146\122\146\227\147\077\147\182\148\032\148\138\148\244\149\095\149\201\150\052\150\159\151\010\151\117\151\224\152\076\152\184\153\036\153\144\153\252\154\104\154\213\155\066\155\175\156\028\156\137\156\247\157\100\157\210\158\064\158\174\159\029\159\139\159\250\160\105\160\216\161\071\161\182\162\038\162\150\163\006\163\118\163\230\164\086\164\199\165\056\165\169\166\026\166\139\166\253\167\110\167\224\168\082\168\196\169\055\169\169\170\028\170\143\171\002\171\117\171\233\172\092\172\208\173\068\173\184\174\045\174\161\175\022\175\139\176\000\176\117\176\234\177\096\177\214\178\075\178\194\179\056\179\174\180\037\180\156\181\019\181\138\182\001\182\121\182\240\183\104\183\224\184\089\184\209\185\074\185\194\186\059\186\181\187\046\187\167\188\033\188\155\189\021\189\143\190\010\190\132\190\255\191\122\191\245\192\112\192\236\193\103\193\227\194\095\194\219\195\088\195\212\196\081\196\206\197\075\197\200\198\070\198\195\199\065\199\191\200\061\200\188\201\058\201\185\202\056\202\183\203\054\203\182\204\053\204\181\205\053\205\181\206\054\206\182\207\055\207\184\208\057\208\186\209\060\209\190\210\063\210\193\211\068\211\198\212\073\212\203\213\078\213\209\214\085\214\216\215\092\215\224\216\100\216\232\217\108\217\241\218\118\218\251\219\128\220\005\220\138\221\016\221\150\222\028\222\162\223\041\223\175\224\054\224\189\225\068\225\204\226\083\226\219\227\099\227\235\228\115\228\252\229\132\230\013\230\150\231\031\231\169\232\050\232\188\233\070\233\208\234\091\234\229\235\112\235\251\236\134\237\017\237\156\238\040\238\180\239\064\239\204\240\088\240\229\241\114\241\255\242\140\243\025\243\167\244\052\244\194\245\080\245\222\246\109\246\251\247\138\248\025\248\168\249\056\249\199\250\087\250\231\251\119\252\007\252\152\253\041\253\186\254\075\254\220\255\109\255\255\100\101\115\099\000\000\000\000\000\000\000\046\073\069\067\032\054\049\057\054\054\045\050\045\049\032\068\101\102\097\117\108\116\032\082\071\066\032\067\111\108\111\117\114\032\083\112\097\099\101\032\045\032\115\082\071\066\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\088\089\090\032\000\000\000\000\000\000\098\153\000\000\183\133\000\000\024\218\088\089\090\032\000\000\000\000\000\000\000\000\000\080\000\000\000\000\000\000\109\101\097\115\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\088\089\090\032\000\000\000\000\000\000\000\158\000\000\000\164\000\000\000\135\088\089\090\032\000\000\000\000\000\000\111\162\000\000\056\245\000\000\003\144\115\105\103\032\000\000\000\000\067\082\084\032\100\101\115\099\000\000\000\000\000\000\000\045\082\101\102\101\114\101\110\099\101\032\086\105\101\119\105\110\103\032\067\111\110\100\105\116\105\111\110\032\105\110\032\073\069\067\032\054\049\057\054\054\045\050\045\049\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\088\089\090\032\000\000\000\000\000\000\246\214\000\001\000\000\000\000\211\045\116\101\120\116\000\000\000\000\067\111\112\121\114\105\103\104\116\032\073\110\116\101\114\110\097\116\105\111\110\097\108\032\067\111\108\111\114\032\067\111\110\115\111\114\116\105\117\109\044\032\050\048\049\053\000\000\115\102\051\050\000\000\000\000\000\001\012\068\000\000\005\223\255\255\243\038\000\000\007\148\000\000\253\143\255\255\251\161\255\255\253\162\000\000\003\219\000\000\192\117"
| Lua | 0 | Nyanarchy/waifu2x | lib/sRGB2014.lua | [
"MIT"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.