Smol Pretraining
Collection
Curated & High quality Synthetic Textbook Datasets for Pretraining
•
10 items
•
Updated
•
2
text
stringlengths 31
1.04M
|
|---|
// Automatically generated - do not modify!
@file:JsModule("@mui/icons-material/SentimentNeutralRounded")
@file:JsNonModule
package mui.icons.material
@JsName("default")
external val SentimentNeutralRounded: SvgIconComponent
|
data vengeance;
set modstat.vengeance;
tcat=t;
run;
/* Régression linéaire avec structure autorégressive d'ordre 1 hétérogène pour les erreurs */
proc mixed data=vengeance method=reml;
class id tcat;
model vengeance = sexe age vc wom t / solution;
repeated tcat / subject=id type=arh(1) r=1 rcorr=1;
run;
/* Régression linéaire avec variance non-structurée pour les erreurs */
proc mixed data=vengeance method=reml;
class id tcat;
model vengeance = sexe age vc wom t / solution;
repeated tcat / subject=id type=un r=1 rcorr=1;
run;
|
Class {
#name : #FLStandardFileStreamSerializationTest,
#superclass : #FLBasicSerializationTest,
#category : #FuelTests
}
{ #category : #running }
FLStandardFileStreamSerializationTest >> setUp [
super setUp.
self useStandardFileStream
]
|
-- Copyright (c) 2018 Brendan Fennell <bfennell@skynet.ie>
--
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
--
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
--
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
package cpu8080_types is
-- Register Selection
subtype reg_t is unsigned(3 downto 0);
constant REG_B : reg_t := x"0";
constant REG_C : reg_t := x"1";
constant REG_D : reg_t := x"2";
constant REG_E : reg_t := x"3";
constant REG_H : reg_t := x"4";
constant REG_L : reg_t := x"5";
constant REG_M : reg_t := x"6";
constant REG_A : reg_t := x"7";
constant REG_W : reg_t := x"8";
constant REG_Z : reg_t := x"9";
constant REG_ACT : reg_t := x"a";
constant REG_TMP : reg_t := x"b";
constant REG_SPH : reg_t := x"c";
constant REG_SPL : reg_t := x"d";
constant REG_PCH : reg_t := x"e";
constant REG_PCL : reg_t := x"f";
-- Register pair selection
subtype reg_pair_t is unsigned(2 downto 0);
constant REG_PC : reg_pair_t := "000";
constant REG_SP : reg_pair_t := "001";
constant REG_BC : reg_pair_t := "010";
constant REG_DE : reg_pair_t := "011";
constant REG_HL : reg_pair_t := "100";
constant REG_WZ : reg_pair_t := "101";
type regfile_cmd_t is
record
wr : std_logic;
rd : std_logic;
incpc : std_logic;
incrp : std_logic;
decrp : std_logic;
mov : std_logic;
xchg : std_logic;
reg_a : reg_t;
reg_b : reg_t;
end record;
constant regfile_cmd_null_c : regfile_cmd_t := (
wr => '0',
rd => '0',
incpc => '0',
incrp => '0',
decrp => '0',
mov => '0',
xchg => '0',
reg_a => REG_A,
reg_b => REG_B
);
-- ALU flags
type alu_flags_t is
record
carry : std_logic;
aux_carry : std_logic;
zero : std_logic;
parity : std_logic;
sign : std_logic;
end record;
constant alu_flags_null_c : alu_flags_t := (
carry => '0',
aux_carry => '0',
zero => '0',
parity => '0',
sign => '0'
);
type ctrlreg_cmd_t is
record
instr_wr : std_logic;
alu_flags_wr : std_logic;
alu_carry_wr : std_logic;
alu_carry_set : std_logic;
alu_psw_wr : std_logic;
alu_flags_store : std_logic;
inten_set : std_logic;
val : std_logic;
end record;
constant ctrlreg_cmd_null_c : ctrlreg_cmd_t := (
instr_wr => '0',
alu_flags_wr => '0',
alu_carry_wr => '0',
alu_carry_set => '0',
alu_psw_wr => '0',
alu_flags_store => '0',
inten_set => '0',
val => '0'
);
-- REGFILE: data in select
constant REGF_DIN_SEL_MDATA : std_logic_vector(1 downto 0) := "00";
constant REGF_DIN_SEL_ALUO : std_logic_vector(1 downto 0) := "01";
constant REGF_DIN_SEL_CTRLO : std_logic_vector(1 downto 0) := "10";
constant REGF_DIN_SEL_PORTI : std_logic_vector(1 downto 0) := "11";
-- MUNIT: address in select
constant MUNIT_AIN_SEL_PC : std_logic := '0';
constant MUNIT_AIN_SEL_RP : std_logic := '1';
-- MUNIT: data in select
constant MUNIT_DIN_SEL_REGA : std_logic_vector(2 downto 0) := "001";
constant MUNIT_DIN_SEL_REGB : std_logic_vector(2 downto 0) := "010";
constant MUNIT_DIN_SEL_ALUO : std_logic_vector(2 downto 0) := "011";
constant MUNIT_DIN_SEL_CTRLO : std_logic_vector(2 downto 0) := "100";
constant MUNIT_DIN_SEL_PSW : std_logic_vector(2 downto 0) := "101";
-- ALU ops
subtype alu_op_t is unsigned(4 downto 0);
constant alu_op_nop : alu_op_t := "00000";
constant alu_op_add : alu_op_t := "00001";
constant alu_op_adc : alu_op_t := "00010";
constant alu_op_sub : alu_op_t := "00011";
constant alu_op_sbb : alu_op_t := "00100";
constant alu_op_and : alu_op_t := "00101";
constant alu_op_xor : alu_op_t := "00110";
constant alu_op_or : alu_op_t := "00111";
constant alu_op_rlc : alu_op_t := "01000";
constant alu_op_rrc : alu_op_t := "01001";
constant alu_op_ral : alu_op_t := "01010";
constant alu_op_rar : alu_op_t := "01011";
constant alu_op_cma : alu_op_t := "01100";
constant alu_op_daa : alu_op_t := "01101";
constant alu_op_cmp : alu_op_t := "01110";
constant alu_op_dcr : alu_op_t := "01111";
constant alu_op_inr : alu_op_t := "10000";
constant alu_op_ani : alu_op_t := "10001";
type opcode_t is (aci,
adc,
adcm,
add,
addm,
adi,
ana,
anam,
ani,
call,
cc,
cm,
cma,
cmc,
cmp,
cmpm,
cnc,
cnz,
cp,
cpe,
cpi,
cpo,
cz,
daa,
dad,
dcr,
dcrm,
dcx,
di,
ei,
hlt,
inport,
inr,
inrm,
inx,
jc,
jm,
jmp,
jnc,
jnz,
jp,
jpe,
jpo,
jz,
lda,
ldax,
lhld,
lxi,
movr2r,
movr2m,
movm2r,
mvi2r,
mvi2m,
nop,
ora,
oram,
ori,
outport,
pchl,
pop,
poppsw,
push,
pushpsw,
ral,
rar,
rc,
ret,
rlc,
rm,
rnc,
rnz,
rp,
rpe,
rpo,
rrc,
rst0,
rst1,
rst2,
rst3,
rst4,
rst5,
rst6,
rst7,
rz,
sbb,
sbbm,
sbi,
shld,
sphl,
sta,
stax,
stc,
sub,
subm,
sui,
xchg,
xra,
xram,
xri,
xthl,
und
);
end cpu8080_types;
package body cpu8080_types is
end cpu8080_types;
|
{
"name": "rm_title",
"id": "72e42a9d-6d80-451c-90c1-c952e213fcd0",
"creationCodeFile": "",
"inheritCode": false,
"inheritCreationOrder": false,
"inheritLayers": false,
"instanceCreationOrderIDs": [
"71a4209c-6bd2-444d-a837-c9c45f2915d5"
],
"IsDnD": true,
"layers": [
{
"__type": "GMRInstanceLayer_Model:#YoYoStudio.MVCFormat",
"name": "Instances",
"id": "06ba942a-e9b6-4856-9f48-dc1a76e2fb03",
"depth": 0,
"grid_x": 32,
"grid_y": 32,
"hierarchyFrozen": false,
"hierarchyVisible": true,
"inheritLayerDepth": false,
"inheritLayerSettings": false,
"inheritSubLayers": false,
"inheritVisibility": false,
"instances": [
{"name": "inst_71C9A39F","id": "71a4209c-6bd2-444d-a837-c9c45f2915d5","colour": { "Value": 4294967295 },"creationCodeFile": "","creationCodeType": "","ignore": false,"inheritCode": false,"inheritItemSettings": false,"IsDnD": true,"m_originalParentID": "00000000-0000-0000-0000-000000000000","m_serialiseFrozen": false,"modelName": "GMRInstance","name_with_no_file_rename": "inst_71C9A39F","objId": "1060c266-229b-49ba-82c3-da2eb593084a","properties": null,"rotation": 0,"scaleX": 1,"scaleY": 1,"mvc": "1.0","x": 512,"y": 320}
],
"layers": [
],
"m_parentID": "00000000-0000-0000-0000-000000000000",
"m_serialiseFrozen": false,
"modelName": "GMRInstanceLayer",
"mvc": "1.0",
"userdefined_depth": false,
"visible": true
},
{
"__type": "GMRBackgroundLayer_Model:#YoYoStudio.MVCFormat",
"name": "Background",
"id": "fce1528f-2d45-41b5-bea7-98d7b218efbf",
"animationFPS": 15,
"animationSpeedType": "0",
"colour": { "Value": 4294967295 },
"depth": 100,
"grid_x": 32,
"grid_y": 32,
"hierarchyFrozen": false,
"hierarchyVisible": true,
"hspeed": 0,
"htiled": true,
"inheritLayerDepth": false,
"inheritLayerSettings": false,
"inheritSubLayers": false,
"inheritVisibility": false,
"layers": [
],
"m_parentID": "00000000-0000-0000-0000-000000000000",
"m_serialiseFrozen": false,
"modelName": "GMRBackgroundLayer",
"mvc": "1.0",
"spriteId": "90cc149e-e5ef-4c12-bd96-06b816d0088d",
"stretch": false,
"userdefined_animFPS": false,
"userdefined_depth": false,
"visible": true,
"vspeed": 0,
"vtiled": true,
"x": 0,
"y": 0
}
],
"modelName": "GMRoom",
"parentId": "00000000-0000-0000-0000-000000000000",
"physicsSettings": {
"id": "d5272ada-6906-4b4f-85c4-a63acc3d4752",
"inheritPhysicsSettings": false,
"modelName": "GMRoomPhysicsSettings",
"PhysicsWorld": false,
"PhysicsWorldGravityX": 0,
"PhysicsWorldGravityY": 10,
"PhysicsWorldPixToMeters": 0.1,
"mvc": "1.0"
},
"roomSettings": {
"id": "736db588-1f8c-4e97-929b-377b30221c63",
"Height": 768,
"inheritRoomSettings": false,
"modelName": "GMRoomSettings",
"persistent": false,
"mvc": "1.0",
"Width": 1024
},
"mvc": "1.0",
"views": [
{"id": "99685ad0-c768-4dcd-8e46-11ece29eb063","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "6a7d68d3-6025-481c-898e-960f75b1c89c","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "9fc7ff99-6793-400a-84cb-61f2d0250787","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "70f231b1-a694-448f-84b5-bfb6d36ae584","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "9f2f3e33-425d-4780-91c2-835b532f76b5","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "6ed8656b-5982-47fb-8869-030cb9935312","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "438b41cf-996b-4961-96f7-0f20a6817537","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0},
{"id": "93c05eea-6e47-4904-b87e-98012e70f669","hborder": 32,"hport": 768,"hspeed": -1,"hview": 768,"inherit": false,"modelName": "GMRView","objId": "00000000-0000-0000-0000-000000000000","mvc": "1.0","vborder": 32,"visible": false,"vspeed": -1,"wport": 1024,"wview": 1024,"xport": 0,"xview": 0,"yport": 0,"yview": 0}
],
"viewSettings": {
"id": "71e76752-59c4-4fb8-9db0-a06ec4f63200",
"clearDisplayBuffer": true,
"clearViewBackground": false,
"enableViews": false,
"inheritViewSettings": false,
"modelName": "GMRoomViewSettings",
"mvc": "1.0"
}
} |
module Issue478c where
record Ko (Q : Set) : Set₁ where
field
T : Set
foo : (Q : Set)(ko : Ko Q) → Ko.T ko
foo Q ko = Set
-- We should make sure not to destroy printing
-- outside the record module. Type should be
-- printed as it's given: Ko.T ko |
/*
* Copyright (C) 2017-2019 Dremio Corporation
*
* 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.
*/
syntax = "proto3";
option java_package = "com.dremio.service.jobresults";
option optimize_for = SPEED;
option java_generate_equals_and_hash = true;
option java_multiple_files = true;
option java_outer_classname = "JobResultsServiceRPC";
package dremio.jobresults;
import "UserBitShared.proto";
import "GeneralRPC.proto";
import "google/protobuf/empty.proto";
service JobResultsService {
rpc jobResults(stream JobResultsRequest) returns (stream JobResultsResponse);
}
message JobResultsRequest {
exec.shared.QueryData header = 1;
int64 sequenceId = 2;
bytes data = 3;
}
message JobResultsResponse {
exec.rpc.Ack ack = 1;
int64 sequenceId = 2;
}
|
defmodule Hopper.Accounts do
@moduledoc """
The Accounts context.
"""
alias Hopper.Repo
alias Hopper.Rides
alias Hopper.Accounts.User
@doc """
Returns the list of users.
## Examples
iex> list_users()
[%{}, ...]
"""
def list_users do
{:ok, result} =
Repo.query("""
FOR user IN users
let routes = (#{used_routes("user")})
RETURN MERGE(user, { routes })
""")
result
end
@doc """
Gets a single user.
Raises `Ecto.NoResultsError` if the User does not exist.
## Examples
iex> get_user(123)
{:ok %{}}
iex> get_user!(456)
** (Ecto.NoResultsError)
"""
def get_user(id) do
{:ok, result} =
Repo.query("""
let user = DOCUMENT("users/#{id}")
let routes = (#{used_routes("user")})
RETURN MERGE(user, { routes })
""")
{:ok, result |> List.first()}
end
@doc """
Creates a user.
## Examples
iex> create_user(%{field: value})
{:ok, %User{}}
iex> create_user(%{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_user(attrs \\ %{}) do
%User{}
|> User.changeset(attrs)
|> Repo.insert()
end
@doc """
Updates a user.
## Examples
iex> update_user(user, %{field: new_value})
{:ok, %User{}}
iex> update_user(user, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_user(id, attrs) do
%User{}
|> User.changeset(attrs)
|> Repo.update(id)
end
@doc """
Deletes a User.
## Examples
iex> delete_user(id)
:ok
iex> delete_user(user)
{:error, 404}
"""
def delete_user(id) do
Repo.delete(User, id)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking user changes.
## Examples
iex> change_user(user)
%Ecto.Changeset{source: %User{}}
"""
def change_user(%User{} = user) do
User.changeset(user, %{})
end
def create_ride(user_id, %{"used_as" => as, "route_id" => route_id}) do
{:ok, _} = Rides.create_used(%{_from: "users/#{user_id}", _to: "routes/#{route_id}", as: as})
get_user(user_id)
end
defp used_routes(vertex) do
"""
FOR v, e IN 1..1 OUTBOUND #{vertex} used
RETURN MERGE(v, { used_as: e.as })
"""
end
end
|
CREATE DATABASE bitrix;
CREATE USER 'bitrix'@'localhost' IDENTIFIED BY 'Bitrix-123';
GRANT ALL PRIVILEGES ON *.* TO 'bitrix'@'localhost' WITH GRANT OPTION;
CREATE USER 'bitrix'@'%' IDENTIFIED BY 'Bitrix-123';
GRANT ALL PRIVILEGES ON *.* TO 'bitrix'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;
|
pragma solidity ^0.4.23;
import ;
import ;
import ;
import ;
import ;
import ;
contract estateregistry is migratable, erc721token, ownable, metadataholderbase, iestateregistry, estatestorage {
modifier cantransfer(uint256 estateid) {
require(isapprovedorowner(msg.sender, estateid), );
_;
}
modifier onlyregistry() {
require(msg.sender == address(registry), );
_;
}
modifier onlyupdateauthorized(uint256 estateid) {
require(_isupdateauthorized(msg.sender, estateid), );
_;
}
function mint(address to) external onlyregistry returns (uint256) {
return _mintestate(to, );
}
function mint(address to, string metadata) external onlyregistry returns (uint256) {
return _mintestate(to, metadata);
}
function onerc721received(
address ,
uint256 tokenid,
bytes estatetokenidbytes
)
external
onlyregistry
returns (bytes4)
{
uint256 estateid = _bytestouint(estatetokenidbytes);
_pushlandid(estateid, tokenid);
return bytes4(0xf0b9e5ba);
}
function transferland(
uint256 estateid,
uint256 landid,
address destinatary
)
external
cantransfer(estateid)
{
return _transferland(estateid, landid, destinatary);
}
function transfermanylands(
uint256 estateid,
uint256[] landids,
address destinatary
)
external
cantransfer(estateid)
{
uint length = landids.length;
for (uint i = 0; i < length; i++) {
_transferland(estateid, landids[i], destinatary);
}
}
function getlandestateid(uint256 landid) external view returns (uint256) {
return landidestate[landid];
}
function setlandregistry(address _registry) external onlyowner {
require(_registry.iscontract(), );
require(_registry != 0, );
registry = landregistry(_registry);
emit setlandregistry(registry);
}
function ping() external {
registry.ping();
}
function getestatesize(uint256 estateid) external view returns (uint256) {
return estatelandids[estateid].length;
}
function updatemetadata(
uint256 estateid,
string metadata
)
external
onlyupdateauthorized(estateid)
{
_updatemetadata(estateid, metadata);
emit update(
estateid,
ownerof(estateid),
msg.sender,
metadata
);
}
function getmetadata(uint256 estateid) external view returns (string) {
return estatedata[estateid];
}
function setupdateoperator(uint256 estateid, address operator) external cantransfer(estateid) {
updateoperator[estateid] = operator;
emit updateoperator(estateid, operator);
}
function isupdateauthorized(address operator, uint256 estateid) external view returns (bool) {
return _isupdateauthorized(operator, estateid);
}
function initialize(
string _name,
string _symbol,
address _registry
)
public
isinitializer(, )
{
require(_registry != 0, );
erc721token.initialize(_name, _symbol);
ownable.initialize(msg.sender);
registry = landregistry(_registry);
}
function safetransfermanyfrom(address from, address to, uint256[] estateids) public {
safetransfermanyfrom(
from,
to,
estateids,
);
}
function safetransfermanyfrom(
address from,
address to,
uint256[] estateids,
bytes data
)
public
{
for (uint i = 0; i < estateids.length; i++) {
safetransferfrom(
from,
to,
estateids[i],
data
);
}
}
function _mintestate(address to, string metadata) internal returns (uint256) {
require(to != address(0), );
uint256 estateid = _getnewestateid();
_mint(to, estateid);
_updatemetadata(estateid, metadata);
emit createestate(to, estateid, metadata);
return estateid;
}
function _updatemetadata(uint256 estateid, string metadata) internal {
estatedata[estateid] = metadata;
}
function _getnewestateid() internal view returns (uint256) {
return totalsupply().add(1);
}
function _pushlandid(uint256 estateid, uint256 landid) internal {
require(exists(estateid), );
require(landidestate[landid] == 0, );
require(registry.ownerof(landid) == address(this), );
estatelandids[estateid].push(landid);
landidestate[landid] = estateid;
estatelandindex[estateid][landid] = estatelandids[estateid].length;
emit addland(estateid, landid);
}
function _transferland(
uint256 estateid,
uint256 landid,
address destinatary
)
internal
{
require(destinatary != address(0), );
uint256[] storage landids = estatelandids[estateid];
mapping(uint256 => uint256) landindex = estatelandindex[estateid];
require(landindex[landid] != 0, );
uint lastindexinarray = landids.length.sub(1);
uint indexinarray = landindex[landid].sub(1);
uint temptokenid = landids[lastindexinarray];
landindex[temptokenid] = indexinarray.add(1);
landids[indexinarray] = temptokenid;
delete landids[lastindexinarray];
landids.length = lastindexinarray;
landindex[landid] = 0;
landidestate[landid] = 0;
registry.safetransferfrom(this, destinatary, landid);
emit removeland(estateid, landid, destinatary);
}
function _isupdateauthorized(address operator, uint256 estateid) internal view returns (bool) {
return isapprovedorowner(operator, estateid) || updateoperator[estateid] == operator;
}
function _bytestouint(bytes b) internal pure returns (uint256) {
bytes32 out;
for (uint i = 0; i < b.length; i++) {
out |= bytes32(b[i] & 0xff) >> (i * 8);
}
return uint256(out);
}
}
|
;;; vc-darcs-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil nil ("vc-darcs.el") (22995 1690 885331 241000))
;;;***
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; End:
;;; vc-darcs-autoloads.el ends here
|
#!/bin/bash
export dashboard_json=$(cat dashboard.json|tr "\n" " ")
dashboard_json='{"dashboard":'"$dashboard_json"'}'
curl http://admin:admin@localhost:3000/api/dashboards/db -X POST -H 'Content-Type: application/json;charset=UTF8' --data-binary ''"$dashboard_json"''
|
<?php
namespace App\Http\Controllers\Auth;
use App\User;
use Validator;
use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\ThrottlesLogins;
use Illuminate\Foundation\Auth\AuthenticatesAndRegistersUsers;
class AuthController extends Controller
{
/*
|--------------------------------------------------------------------------
| Registration & Login Controller
|--------------------------------------------------------------------------
|
| This controller handles the registration of new users, as well as the
| authentication of existing users. By default, this controller uses
| a simple trait to add these behaviors. Why don't you explore it?
|
*/
use AuthenticatesAndRegistersUsers, ThrottlesLogins;
/**
* Where to redirect users after login / registration.
*
* @var string
*/
protected $redirectTo = '/';
/**
* Create a new authentication controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware($this->guestMiddleware(), ['except' => 'logout']);
}
/**
* Get a validator for an incoming registration request.
*
* @param array $data
* @return \Illuminate\Contracts\Validation\Validator
*/
protected function validator(array $data)
{
return Validator::make($data, [
'name' => 'required|max:255',
'email' => 'required|email|max:255|unique:users',
'password' => 'required|min:6|confirmed',
]);
}
/**
* Create a new user instance after a valid registration.
*
* @param array $data
* @return User
*/
protected function create(array $data)
{
return User::create([
'name' => $data['name'],
'email' => $data['email'],
'password' => bcrypt($data['password']),
]);
}
protected function postLogin(Request $request){
var_dump($request);
}
protected function getLogin(){
return view('login');
}
}
|
---
title: "TP Transcriptome : Analyse de données de puces à ADN"
author: "Vincent Guillemot, Cathy Philippe, Marie-Anne Debily"
date: "23 octobre 2015"
output: pdf_document
---
# Problématique Biologique : la différenciation des kératinocytes
Les kératinocytes subissent en permanence une évolution morphologique témoignant de leur kératinisation sous-tendant le rôle de barrière protectrice (mécanique et chimique) de l'épiderme. Cette évolution se fait de la profondeur vers la superficie et permet de distinguer sur une coupe d'épiderme quatre couches superposées de la profondeur vers la superficie : la couche germinative (ou basale), la couche à épines (ou épineuse), la couche granuleuse et la couche cornée (compacte, puis desquamante) : Figure 1.
\begin{center}
Figure 1 : Structure de l’épiderme.
\end{center}
La **couche germinative ou basale** assure par les mitoses de ses cellules le renouvellement de l'épiderme ; ses cellules, cubiques ou prismatiques, contiennent de nombreux grains de mélanine phagocytés qui permettent à l'épiderme d'assurer son rôle de protection de la lumière et qui sous-tendent le rôle de régulation de la pigmentation cutanée qu'ont les kératinocytes.
Dans la **couche épineuse**, les cellules commencent à s'aplatir, mais le noyau et les organites cytoplasmiques sont intacts, les filaments intermédiaires de kératine groupés en faisceaux denses, les desmosomes normaux.
Dans la **couche granuleuse**, la cellule est très aplatie, le noyau commence à dégénérer et surtout apparaissent au sein des trousseaux de filaments de kératine de nombreux grains de kératohyaline.
Enfin, dans la **couche cornée**, le kératinocyte (qui prend maintenant le nom de cornéocyte) est complètement aplati, le noyau et les organites cytoplasmiques ont totalement disparu et le cytoplasme est rempli de trousseaux fibrillaires formés à partir des filaments de kératine et des grains de kératohyaline. En superficie de la couche cornée, les cornéocytes, se détachent de l'épiderme (desquamation).
Le kératinocyte passe donc d’un état prolifératif dans la couche basale à un état de différenciation terminale dans la couche cornée avant sa mort cellulaire et sa desquamation. Dans la peau, ce cycle de différenciation dure une vingtaine de jours. Ce processus de différenciation peut-être reproduit *in vitro*. Notamment, en culture, les kératinocytes se différencient naturellement à partir du moment où la confluence est atteinte, cette technique a été utilisée pour générer les données que nous allons analyser.
# Objectif
L’objectif du TP est d’analyser la modulation de l'expression des gènes au cours de la différenciation in vitro de kératinocytes humains. Des expériences d'analyse du transcriptome ont été réalisées en utilisant des puces à ADN sur lesquelles ont été déposées des oligonucléotides longs.
Répondez aux questions dans un document Rmarkdown produisant un fichier __PDF__.
Pour afficher l'aide sur la syntaxe de Rmarkdown, cliquez sur le point d'interrogation dans la barre d'outil d'édition.
# Données
Au total les lames contiennent __26495 spots__.
Les cellules ont été cultivées *in vitro* dans des conditions de prolifération (noté P dans le nom de l'échantillon) ou de
différenciation (noté D dans le nom de l'échantillon).
Pour chaque état P ou D, une extraction d'ARN a été faite pour 3 individus différents (I1, I2 et I3). Deux inversions de marquage ont ensuite été réalisées pour chaque échantillon en utilisant une référence commune (le numéro de l'inversion de fluorochrome est noté `_1` ou `_2` dans le nom de l'échantillon et le fluorochrome de l'ARN test est noté `_3` pour Cy3 et `_5` pour Cy5).
# Analyse des données
## 1. Lecture de fichiers de données
> **Question** : Chargez en mémoire les fichiers `data1_R.txt`, `data1_G.txt`, `data2_M.txt`, `data2_A.txt`, `pheno.txt` et `pheno_ds.txt`. Expliquez chacune des options utilisée.
> **Question** : Quelle est la classe des objets chargés en mémoire et quelles en sont les dimensions ? Affichez un extrait de chaque structure.
## 2. Normalisation
`data1_R` contient les intensités brutes dans le fluorochrome Cy5 (Red) pour chaque puce.
`data1_G` contient les intensités brutes dans le fluorochrome Cy3 (Green) pour chaque puce.
`pheno` contient le descriptif des échantillons hybridés sur chaque puce.
Le **MA-plot** est une figure de mérite de l'analyse de données de puces en expression. Le `M`, pour "Minus", correspond à la différence des logarithmes d'intensité entre les deux fluorochromes. Le `A`, pour "Average", correspond à la moyenne des logarithmes d'intensités. Les graphes representent `M(A)` pour chaque spot d'une puce, en nuage de points.
> **Question** : Calculez `M` et `A` pour chaque lame de microarray. Produisez à partir des données fournies les **MA-plots** des données avant normalisation, pour chaque puce. Tracez en rouge la ligne M=0. Donnez les commandes utilisées et expliquez chacune des options utilisées.
Indication : Utilisez la fonction `layout()` pour la mise en page des graphes. Les mettre dans une grille de sorte qu'ils tiennent tous sur la meme page. Utilisez un device __png__, puis incluez-le dans le document Rmarkdown.
> **Question** : Quelle doit être la forme du nuage de points ? Est-ce le cas pour toutes les puces ? Sinon, pourquoi les nuages de points sont-ils déformés ?
`data2_M` contient les `M` normalisés pour chaque puce.
`data2_A` contient les `A` normalisés pour chaque puce.
> **Question** : Produisez les *MA-plots* sur données normalisées pour chaque puce, en utillisant la meme mise en page. Quels sont les changements observés?
Nous allons visualiser la proximité relative des observations, grâce à une __Analyse en Composantes Principales__. Il s'agit d'une méthode d'analyse multivariées par réduction de dimension. Les composantes principales sont des combinaisons linéaires des variables. Elles ont pour contraintes de maximiser la variance entre les observations et d'être orthogonales entre elles. Le nombre de composantes est égal au rang de la matrice des données. On utilise la fonction `prcomp` de `R base`.
> **Question** : Centrez les données à l'aide de la fonction `scale()`. Calculez les composantes grâce à la fonction `prcomp`. Combien y a-t-il de composantes ? Représentez graphiquement les observations en fonction des deux premières composantes, colorez les points en fonction de la colonne "dye" et changez la forme des points (paramètre `pch` de la fonction `plot`) en fonction de la colonne "prodiff" du tableau de données "pheno". Incluez le graphe directement sans passer par un fichier annexe. Que constatez-vous ?
Le biais résiduel se corrige grâce au "dye-swap" (inversion de fluorochrome). Pour chaque comparaison, chaque condition sera marquée une fois en rouge (Cy5) et une fois en vert (Cy3). La moyenne des `M` et des `A`, sur les deux sens de marquage permet d'obtenir une mesure d'intentsité unique corrigée pour le biais d'intensité.
> **Question** : Calculez les `M` et les `A`, sur les deux sens de marquages. Produisez les *MA-plots* correspondants, avec la meme mise en page que les *MA-plots* précedents. Que constatez-vous ?
Il s'agit maintenant de pouvoir comparer toutes les conditions entre elles. Pour pouvoir ultérieurement, appliquer un test statistique, il faut au préalable s'assurer que les distributions les données de chaque conditions sont comparables. Un moyen de s'en assurer est de produire un graphe en boîte à moustaches (`boxplot`), qui visualise pour chaque condition la médiane des `log(intensités des sondes)`, les premier et troisième quartiles ainsi que les queues de distributions. Les données qui nous intéressent sont les `M`, c'est-à-dire la différence d'intensité et donc d'expression entre le fluorochrome, qui marque l'échantillon *test* et celui qui marque l'échantillon *référence*.
> **Question** : Produisez les *boxplots* des données normalisées. Si les conditions sont comparables entre elles, quelle figure doit-on obtenir ? Qu'obtenez-vous ? Quelle est votre conclusion ?
Nous allons procéder à la normalisation des __quantiles__, grâce à la fonction `normalizeBetweenArrays` du package `limma`. Pour cela, sourcez le fichier `biocLite.R`, qui se trouve à l'URL suivante : [http://www.bioconductor.org/](http://www.bioconductor.org/); Installez le package `limma` en utilisant la commande suivante : `biocLite("limma")`.
> **Question** : Chargez le package `limma` dans l'environnement de travail. Affichez l'aide de la fonction `normalizeBetweenArrays`. Procédez à la normalisation. Justifiez les paramètres choisis. Produisez les *boxplots* des données après normalisation des quantiles. Que constatez-vous ?
Les données sont à présent normalisées et prêtes à l'emploi. Le fichier `pheno_ds.txt` contient le descriptif des échantillons une fois normalisés en "dye-swap".
> **Question** : Calculez à nouveau des composantes principales de la matrice des `M` obtenus et représentez graphiquement les observations en fonctions des deux premières composantes principales. La couleur des points s'affichera en fonction de la colonne "ID" du tableau de données `pheno_ds` et la forme des points s'affichera en fonction de la colonne "prodiff". Que constatez-vous?
|
import-module au
. $PSScriptRoot\..\_scripts\all.ps1
$releases = 'https://github.com/extrawurst/gitui/releases'
function global:au_SearchReplace {
@{
".\tools\chocolateyInstall.ps1" = @{
"(^\s*\`$url\s*=\s*)('.*')"= "`$1'$($Latest.URL32)'"
"(^\s*checksum\s*=\s*)('.*')" = "`$1'$($Latest.Checksum32)'"
}
"$($Latest.PackageName).nuspec" = @{
"(\<releaseNotes\>).*?(\</releaseNotes\>)" = "`${1}$($Latest.ReleaseNotes)`$2"
}
#".\legal\VERIFICATION.txt" = @{
# "(?i)(\s+x32:).*" = "`${1} $($Latest.URL32)"
# "(?i)(checksum32:).*" = "`${1} $($Latest.Checksum32)"
# "(?i)(Get-RemoteChecksum).*" = "`${1} $($Latest.URL32)"
#}
}
}
function global:au_BeforeUpdate { Get-RemoteFiles -Purge }
function global:au_AfterUpdate { Set-DescriptionFromReadme -SkipFirst 4 -SkipLast 1 }
function global:au_GetLatest {
$download_page = Invoke-WebRequest -Uri $releases
# $download_page.links uses regex internally and is REAL SLOW when parsing large pages..
$links = $download_page.RawContent.split(@("<a "), [stringsplitoptions]::None) | select -Skip 1
Write-Host " - found $($links.Count) anchor-tags"
$links = $links | % { $_.split(@(">"),2, [stringsplitoptions]::None)[0] } | % { $_.split(@("href="),2, [stringsplitoptions]::None)[1].Substring(1) } | % { $_.split(@(""""), 2, [stringsplitoptions]::None)[0] } | ? {![string]::IsNullOrWhiteSpace($_)}
Write-Host " - found $($links.Count) links"
$re = "gitui-win.tar.gz"
$url = $links | ? { $_ -match $re } | select -First 1
$url = 'https://github.com' + $url
Write-Host "Found url: $url"
$version = $url -split '\/' | select -Last 2 | select -First 1
Write-Host "Found version: $version"
return @{
URL32 = $url
Version = $version.Replace("v", "")
ReleaseNotes = "$releases/tag/${version}"
}
}
update-package -ChecksumFor none -NoReadme |
#lang scribble/acmart @acmsmall @10pt @screen
@(require "main.rkt" "bib.rkt" scriblib/footnote)
@title[#:tag "sec:related"]{Related Work}
Thorn@~cite{wzlov-popl-2010} and StrongScript@~cite{rzv-ecoop-2015} support
a combination of sound concrete types and erased @emph{like} types.
Thorn is a scalable scripting language that compiles to the JVM@~cite{bfnorsvw-oopsla-2009}.
StrongScript extends TypeScript@~cite{bat-ecoop-2014} with concrete types.
Both languages are supported by formal models with proofs of type soundness.
Pyret uses @|sdeep| checks for fixed-size data and @|sshallow| checks for
other data.@note{Personal communication. @shorturl["https://www.pyret.org" "pyret.org"]}
For example, pair types get a @|sdeep| check and function types get a
@|sshallow| check.
Static Python combines @|sshallow| and concrete checks.@note{Personal communication. @shorturl["https://github.com/facebookincubator/cinder" "github.com/facebookincubator/cinder"]}
@|sShallow| checks are the default; concrete data structures are available.
The model in @section-ref{sec:model} builds on the semantic framework
of @citet{gf-icfp-2018}, which is in turn inspired by
@citet{mf-toplas-2009}.
The model is also inspired by the @exact{\kafka} framework, which introduces
four compilers to transform a declarative surface syntax to an evaluation
syntax that makes run-time checks manifest@~cite{clzv-ecoop-2018}.
@; similar acks for implementation (Sam, TR) and evaluation (Takikawa) ?
@; discuss other 3way ideas?
|
with Ada.Finalization; use Ada.Finalization;
package Noreturn4_Pkg is
type Priv is private;
function It return Priv;
function Value (Obj : Priv) return Integer;
function OK (Obj : Priv) return Boolean;
private
type Priv is new Controlled with record
Value : Integer := 15;
end record;
procedure Adjust (Obj : in out Priv);
procedure Finalize (Obj : in out Priv);
end Noreturn4_Pkg;
|
# This file must be used with "source bin/activate.csh" *from csh*.
# You cannot run it directly.
# Created by Davide Di Blasi <davidedb@gmail.com>.
# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate'
# Unset irrelevant variables.
deactivate nondestructive
setenv VIRTUAL_ENV "/Users/mckenziesteenson/Documents/my-project/middleware/venv"
set _OLD_VIRTUAL_PATH="$PATH"
setenv PATH "$VIRTUAL_ENV/bin:$PATH"
set _OLD_VIRTUAL_PROMPT="$prompt"
if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
set prompt = "(venv) $prompt"
endif
alias pydoc python -m pydoc
rehash
|
# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'comic_downloader/version'
Gem::Specification.new do |spec|
spec.name = "comic_downloader"
spec.version = ComicDownloader::VERSION
spec.authors = ["bomb"]
spec.email = ["chen7897499@gmail.com"]
spec.summary = "自用的漫画下载器"
spec.homepage = "https://github.com/chen7897499/comic_downloader"
spec.license = "MIT"
spec.files = `git ls-files -z`.split("\x0")
spec.executables = ["comic_downloader"]
spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
spec.require_paths = ["lib"]
spec.add_development_dependency "bundler", "~> 1.5"
spec.add_development_dependency "rake"
spec.add_runtime_dependency "eventmachine"
spec.add_runtime_dependency "mechanize"
spec.add_runtime_dependency "nokogiri"
spec.add_runtime_dependency "pry"
spec.add_runtime_dependency "pry-byebug"
end
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./IAccessControlClient.sol";
interface IAccessControlManagerProxy is IAccessControlClient {
function initializeRole(bytes32 adminRole, string calldata description)
external
returns (bytes32 role);
function initializeAndGrantRoles(
bytes32[] calldata adminRoles,
string[] calldata descriptions,
address[] calldata accounts
) external returns (bytes32[] memory roles);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
|
# filename: ex301.rq
PREFIX d: <http://learningsparql.com/ns/data#>
PREFIX t: <http://purl.org/tio/ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
SELECT ?timezoneTest ?tzTest
WHERE
{
?mtg t:starts ?startTime .
BIND (timezone(?startTime) AS ?timezoneTest)
BIND (tz(?startTime) AS ?tzTest)
}
|
set BERT_BASE_DIR=C:\Users\michaels\Projects\bert\uncased_L-12_H-768_A-12
set SQUAD_DIR=C:\Users\michaels\Projects\bert\squad11
python run_squad.py ^
--vocab_file=%BERT_BASE_DIR%\vocab.txt ^
--bert_config_file=%BERT_BASE_DIR%\bert_config.json ^
--init_checkpoint=%BERT_BASE_DIR%\bert_model.ckpt ^
--do_train=True ^
--train_file=%SQUAD_DIR%\train-v1.1.json ^
--do_predict=True ^
--predict_file=%SQUAD_DIR%\dev-v1.1.json ^
--train_batch_size=12 ^
--learning_rate=3e-5 ^
--num_train_epochs=2.0 ^
--max_seq_length=384 ^
--doc_stride=128 ^
--output_dir=tmp\squad_base\ |
struct Struct0 {
1: map<double, float> field1
2: binary field2
3: i64 field3
4: float field4
5: string field5
6: i64 field6
7: set<binary> field7
8: i16 field8
9: i16 field9
10: list<double> field10
11: map<float, list<binary>> field11
12: map<i32, float> field12
13: list<list<binary>> field13
14: i32 field14
15: byte field15
16: bool field16
17: binary field17
18: i16 field18
19: list<byte> field19
20: double field20
21: i64 field21
22: bool field22
23: set<i64> field23
24: map<double, binary> field24
25: map<byte, byte> field25
26: map<float, string> field26
27: byte field27
28: bool field28
29: i64 field29
30: map<set<i16>, binary> field30
31: i32 field31
32: i64 field32
33: map<byte, binary> field33
34: binary field34
35: list<i64> field35
36: set<map<bool, i32>> field36
37: map<list<float>, byte> field37
38: bool field38
39: i32 field39
40: byte field40
41: bool field41
42: list<string> field42
43: byte field43
44: binary field44
45: float field45
46: bool field46
47: bool field47
48: byte field48
49: bool field49
50: i64 field50
51: i32 field51
52: i32 field52
53: float field53
54: double field54
55: i64 field55
56: set<float> field56
57: double field57
58: binary field58
59: i32 field59
60: bool field60
61: set<byte> field61
62: i16 field62
63: bool field63
64: map<byte, i16> field64
65: i16 field65
66: float field66
67: float field67
68: map<i64, list<binary>> field68
69: i64 field69
70: bool field70
71: binary field71
72: string field72
73: binary field73
74: i16 field74
75: bool field75
76: double field76
77: bool field77
78: binary field78
79: set<string> field79
80: bool field80
81: map<string, double> field81
82: map<list<bool>, bool> field82
83: map<i64, double> field83
84: i16 field84
85: set<string> field85
86: i32 field86
87: i32 field87
88: list<i32> field88
89: list<string> field89
90: binary field90
91: byte field91
92: list<bool> field92
93: bool field93
94: bool field94
95: bool field95
96: set<i32> field96
97: binary field97
98: binary field98
99: list<double> field99
100: i64 field100
101: set<string> field101
102: list<float> field102
103: i16 field103
104: double field104
105: list<binary> field105
106: i16 field106
107: set<bool> field107
108: list<i32> field108
109: float field109
110: float field110
111: list<float> field111
112: bool field112
113: string field113
114: i32 field114
115: i32 field115
116: i32 field116
117: double field117
118: string field118
119: list<string> field119
120: map<map<double, float>, float> field120
121: i64 field121
122: bool field122
123: list<binary> field123
}
struct Struct1 {
1: set<double> field1
2: Struct0 field2
3: i32 field3
4: binary field4
5: set<bool> field5
6: i32 field6
7: map<i16, byte> field7
8: string field8
9: map<i32, binary> field9
10: i32 field10
11: Struct0 field11
12: i64 field12
13: set<byte> field13
14: list<list<bool>> field14
15: map<i16, i64> field15
16: i64 field16
}
struct Struct2 {
1: i64 field1
2: i16 field2
3: byte field3
4: string field4
5: map<set<i16>, list<set<bool>>> field5
6: list<double> field6
7: set<byte> field7
8: map<double, binary> field8
9: map<i32, float> field9
10: binary field10
11: Struct0 field11
12: i64 field12
13: double field13
14: Struct0 field14
15: i32 field15
16: bool field16
17: i32 field17
18: set<bool> field18
19: list<byte> field19
20: list<string> field20
21: Struct0 field21
22: string field22
23: i16 field23
24: list<i16> field24
25: i16 field25
26: double field26
27: set<i64> field27
28: list<double> field28
29: list<float> field29
30: double field30
31: i64 field31
32: string field32
33: list<byte> field33
34: Struct0 field34
35: Struct1 field35
36: bool field36
37: list<i16> field37
38: i32 field38
39: i32 field39
40: bool field40
41: bool field41
42: i32 field42
43: map<Struct1, float> field43
44: float field44
45: set<binary> field45
46: binary field46
47: set<list<byte>> field47
48: bool field48
49: set<i32> field49
50: bool field50
51: set<i16> field51
52: Struct0 field52
53: list<bool> field53
54: Struct0 field54
55: binary field55
56: i16 field56
57: set<double> field57
58: list<i32> field58
59: list<bool> field59
60: byte field60
61: string field61
62: list<bool> field62
63: i16 field63
64: list<float> field64
65: map<map<Struct0, bool>, i32> field65
66: Struct1 field66
67: list<Struct0> field67
68: list<i64> field68
69: set<string> field69
70: map<double, i64> field70
71: map<float, list<bool>> field71
72: double field72
73: i16 field73
74: list<list<i64>> field74
75: Struct1 field75
76: list<i64> field76
77: string field77
78: double field78
79: map<i16, i16> field79
80: list<i32> field80
81: byte field81
82: map<binary, float> field82
83: i64 field83
84: set<map<bool, binary>> field84
85: byte field85
86: i64 field86
87: bool field87
88: string field88
89: map<bool, string> field89
90: byte field90
91: set<binary> field91
92: map<list<i32>, byte> field92
93: set<i64> field93
94: map<i16, set<i32>> field94
95: set<string> field95
96: map<float, bool> field96
97: Struct0 field97
98: Struct0 field98
99: i32 field99
100: list<float> field100
101: set<Struct0> field101
102: map<bool, i32> field102
103: i16 field103
104: float field104
105: list<float> field105
106: i64 field106
107: Struct0 field107
108: i64 field108
109: i64 field109
110: float field110
111: float field111
112: byte field112
113: i16 field113
114: Struct0 field114
115: set<i64> field115
116: set<byte> field116
117: byte field117
118: map<double, set<i32>> field118
119: byte field119
120: binary field120
121: i16 field121
122: list<Struct1> field122
123: list<string> field123
124: i16 field124
125: i16 field125
126: map<bool, binary> field126
127: Struct1 field127
128: byte field128
129: list<map<bool, float>> field129
130: Struct1 field130
131: double field131
132: i16 field132
133: bool field133
134: i64 field134
135: map<double, binary> field135
136: Struct1 field136
137: Struct0 field137
138: i32 field138
139: Struct0 field139
140: set<byte> field140
141: i64 field141
142: map<i64, i64> field142
143: binary field143
144: i16 field144
}
struct Struct3 {
1: map<bool, float> field1
2: double field2
3: Struct1 field3
4: map<bool, double> field4
5: map<list<byte>, i64> field5
6: binary field6
7: Struct1 field7
8: i64 field8
9: list<i32> field9
10: set<list<string>> field10
11: list<set<i64>> field11
12: set<map<binary, double>> field12
13: string field13
14: Struct0 field14
15: list<set<map<byte, string>>> field15
16: map<Struct0, string> field16
17: list<Struct1> field17
18: string field18
19: map<bool, bool> field19
20: list<bool> field20
21: i64 field21
22: Struct0 field22
23: byte field23
24: set<byte> field24
25: float field25
26: i32 field26
27: double field27
28: set<Struct0> field28
29: Struct2 field29
30: byte field30
31: set<list<bool>> field31
32: list<list<i16>> field32
33: i32 field33
34: Struct1 field34
35: i16 field35
36: bool field36
37: set<float> field37
38: Struct0 field38
39: byte field39
40: list<byte> field40
41: i32 field41
42: set<string> field42
43: Struct1 field43
44: Struct0 field44
45: set<i64> field45
46: float field46
47: i64 field47
48: list<string> field48
49: map<i16, set<i32>> field49
50: bool field50
51: i64 field51
52: i32 field52
53: list<i16> field53
54: Struct0 field54
55: bool field55
56: Struct1 field56
57: i32 field57
58: bool field58
59: string field59
60: i16 field60
61: Struct0 field61
62: set<float> field62
63: set<map<i16, i64>> field63
64: i32 field64
65: Struct1 field65
66: list<string> field66
67: byte field67
68: bool field68
69: float field69
70: float field70
71: bool field71
72: map<map<binary, byte>, binary> field72
73: i32 field73
74: double field74
75: i64 field75
76: i64 field76
77: list<string> field77
78: list<binary> field78
79: string field79
80: bool field80
81: i64 field81
82: map<double, i64> field82
83: map<i64, list<double>> field83
84: byte field84
85: list<bool> field85
86: double field86
87: float field87
88: float field88
89: string field89
90: i32 field90
91: Struct1 field91
92: set<Struct2> field92
93: float field93
94: i16 field94
95: list<double> field95
96: map<i64, map<double, i64>> field96
97: list<binary> field97
98: map<byte, string> field98
99: i32 field99
100: Struct2 field100
101: list<double> field101
102: i16 field102
103: i16 field103
104: list<double> field104
105: binary field105
106: i16 field106
107: float field107
108: double field108
109: float field109
110: double field110
111: map<byte, Struct0> field111
112: float field112
113: double field113
114: float field114
115: bool field115
116: map<bool, i16> field116
117: string field117
118: Struct0 field118
119: map<string, i32> field119
120: i16 field120
121: float field121
122: bool field122
123: byte field123
124: float field124
125: set<i64> field125
126: i32 field126
127: i16 field127
128: bool field128
129: Struct1 field129
130: Struct0 field130
131: binary field131
132: i16 field132
133: list<string> field133
134: i16 field134
135: list<double> field135
136: set<i16> field136
137: set<float> field137
138: map<float, string> field138
139: map<bool, Struct1> field139
140: set<byte> field140
141: set<bool> field141
142: set<float> field142
143: bool field143
144: Struct2 field144
145: float field145
146: i32 field146
147: string field147
148: set<list<byte>> field148
149: list<i16> field149
150: map<string, double> field150
151: map<set<i32>, i16> field151
152: list<byte> field152
153: float field153
154: map<bool, i64> field154
155: list<Struct1> field155
156: float field156
157: map<i16, set<bool>> field157
158: Struct1 field158
159: i32 field159
160: i16 field160
161: Struct2 field161
162: string field162
163: list<Struct1> field163
164: i64 field164
165: float field165
166: Struct0 field166
167: byte field167
168: bool field168
169: map<float, double> field169
170: i32 field170
171: map<list<double>, double> field171
172: string field172
173: list<list<float>> field173
174: string field174
175: i32 field175
176: i32 field176
177: string field177
178: map<i32, string> field178
179: set<set<string>> field179
180: byte field180
}
struct Struct4 {
1: map<double, byte> field1
2: string field2
3: map<double, Struct1> field3
4: map<byte, Struct2> field4
5: binary field5
6: i32 field6
7: map<bool, list<double>> field7
8: bool field8
9: binary field9
10: map<float, byte> field10
11: Struct0 field11
12: list<i64> field12
13: Struct0 field13
14: i64 field14
15: bool field15
16: i64 field16
17: double field17
18: Struct1 field18
19: set<float> field19
20: list<binary> field20
21: map<byte, double> field21
22: list<byte> field22
23: Struct0 field23
24: map<byte, byte> field24
25: byte field25
26: byte field26
27: byte field27
28: map<i16, list<i16>> field28
29: Struct0 field29
30: set<i32> field30
31: map<double, double> field31
32: Struct1 field32
33: i16 field33
34: binary field34
35: set<float> field35
36: float field36
37: list<bool> field37
38: Struct1 field38
39: double field39
40: map<set<float>, set<double>> field40
41: list<string> field41
42: i16 field42
43: i32 field43
44: set<bool> field44
45: string field45
46: list<double> field46
47: map<i16, Struct2> field47
48: set<i16> field48
49: map<map<i32, i32>, i64> field49
50: Struct0 field50
51: i16 field51
52: set<binary> field52
53: bool field53
54: list<binary> field54
55: string field55
56: binary field56
57: list<bool> field57
58: binary field58
59: byte field59
60: byte field60
61: i32 field61
62: Struct1 field62
63: Struct1 field63
64: set<Struct0> field64
65: i32 field65
66: set<bool> field66
67: binary field67
68: map<map<i32, float>, float> field68
69: list<float> field69
70: bool field70
71: bool field71
72: list<i16> field72
73: map<double, Struct1> field73
74: float field74
75: set<map<double, string>> field75
76: set<i32> field76
77: set<byte> field77
78: map<binary, byte> field78
79: map<set<float>, set<map<float, binary>>> field79
80: set<binary> field80
81: map<bool, float> field81
82: i16 field82
83: binary field83
84: byte field84
85: i16 field85
86: map<string, double> field86
87: bool field87
88: list<set<binary>> field88
89: byte field89
90: list<set<i16>> field90
91: bool field91
92: i64 field92
93: i64 field93
94: map<byte, i16> field94
95: binary field95
96: byte field96
97: i16 field97
98: Struct3 field98
99: Struct0 field99
100: map<i16, byte> field100
101: i32 field101
}
struct Struct5 {
1: set<double> field1
2: list<i16> field2
3: i16 field3
4: i64 field4
5: float field5
6: bool field6
7: list<binary> field7
8: i32 field8
9: list<map<double, string>> field9
10: i64 field10
11: map<bool, i64> field11
12: map<binary, set<double>> field12
13: string field13
14: Struct2 field14
15: map<list<bool>, i32> field15
16: i32 field16
17: binary field17
18: i64 field18
19: i16 field19
20: map<i32, map<list<byte>, float>> field20
21: list<bool> field21
22: i16 field22
23: float field23
24: i16 field24
25: Struct1 field25
26: set<string> field26
27: list<list<float>> field27
28: map<i64, byte> field28
29: list<i16> field29
30: set<list<i16>> field30
31: map<set<string>, float> field31
32: bool field32
33: binary field33
34: float field34
35: map<set<i64>, double> field35
36: double field36
37: Struct2 field37
38: bool field38
39: i32 field39
40: i64 field40
41: byte field41
42: list<list<i32>> field42
43: set<map<double, byte>> field43
44: set<map<i16, bool>> field44
45: i32 field45
46: i64 field46
47: Struct2 field47
48: double field48
49: Struct0 field49
50: list<map<byte, i32>> field50
51: list<binary> field51
52: Struct1 field52
53: set<i32> field53
54: list<bool> field54
55: Struct2 field55
56: double field56
57: i64 field57
58: Struct1 field58
59: list<byte> field59
60: map<byte, Struct2> field60
61: i32 field61
62: set<map<double, string>> field62
63: binary field63
64: set<string> field64
65: set<string> field65
66: set<list<string>> field66
67: map<float, string> field67
68: set<i32> field68
69: set<set<binary>> field69
70: set<set<string>> field70
71: i32 field71
72: i64 field72
73: Struct1 field73
74: double field74
75: map<binary, i16> field75
76: string field76
77: map<byte, Struct3> field77
78: set<i16> field78
79: Struct2 field79
80: i16 field80
81: list<Struct0> field81
82: set<byte> field82
83: Struct1 field83
84: map<i64, i16> field84
85: set<byte> field85
86: Struct3 field86
87: binary field87
88: list<byte> field88
89: binary field89
90: Struct1 field90
91: Struct2 field91
92: bool field92
93: list<list<set<binary>>> field93
94: string field94
95: float field95
96: i16 field96
}
struct Struct6 {
1: set<float> field1
2: set<list<Struct1>> field2
3: bool field3
4: byte field4
5: i64 field5
6: list<string> field6
7: string field7
8: i32 field8
9: byte field9
10: Struct4 field10
11: set<byte> field11
12: map<bool, double> field12
13: map<binary, i16> field13
14: byte field14
15: list<Struct3> field15
16: list<Struct3> field16
17: float field17
18: byte field18
19: double field19
20: list<Struct0> field20
21: bool field21
22: map<list<bool>, bool> field22
23: map<i16, i32> field23
24: i64 field24
25: set<set<string>> field25
26: binary field26
27: map<string, Struct3> field27
28: map<list<map<float, i16>>, string> field28
29: map<i32, i64> field29
30: set<Struct3> field30
31: byte field31
32: list<float> field32
33: byte field33
34: string field34
35: i32 field35
36: set<byte> field36
37: list<list<map<float, i16>>> field37
38: list<string> field38
39: binary field39
40: set<i16> field40
41: double field41
42: double field42
43: map<double, i32> field43
44: double field44
45: map<Struct5, map<Struct1, float>> field45
46: bool field46
47: binary field47
48: i32 field48
49: Struct1 field49
50: set<Struct0> field50
51: byte field51
52: set<string> field52
53: list<Struct1> field53
54: double field54
55: map<list<i64>, list<string>> field55
56: binary field56
57: map<double, i64> field57
58: Struct3 field58
59: map<byte, i32> field59
60: map<double, map<binary, i32>> field60
61: i64 field61
62: byte field62
63: Struct0 field63
64: bool field64
65: set<byte> field65
66: set<byte> field66
67: Struct0 field67
68: i64 field68
69: map<i16, Struct2> field69
70: bool field70
71: i64 field71
72: i64 field72
73: Struct3 field73
74: Struct4 field74
75: byte field75
76: bool field76
77: Struct0 field77
78: double field78
79: i32 field79
80: Struct1 field80
81: bool field81
82: map<i64, i16> field82
83: float field83
84: set<i16> field84
85: double field85
86: string field86
87: set<i32> field87
88: list<byte> field88
89: binary field89
90: Struct3 field90
91: Struct0 field91
92: i32 field92
93: double field93
94: byte field94
95: set<float> field95
96: Struct3 field96
97: float field97
98: Struct0 field98
99: list<i64> field99
100: i16 field100
101: map<bool, binary> field101
102: map<byte, float> field102
103: Struct1 field103
}
struct Struct7 {
1: double field1
2: string field2
3: list<float> field3
4: i32 field4
5: i32 field5
6: bool field6
7: byte field7
8: binary field8
9: i64 field9
10: map<float, string> field10
11: binary field11
12: double field12
13: float field13
14: binary field14
15: list<i16> field15
16: set<float> field16
17: i16 field17
18: map<i16, i32> field18
19: binary field19
20: byte field20
21: byte field21
22: i32 field22
23: string field23
24: Struct1 field24
25: float field25
26: set<set<byte>> field26
27: bool field27
28: string field28
29: map<i32, map<set<double>, map<i16, i32>>> field29
30: Struct0 field30
31: double field31
32: map<binary, set<byte>> field32
33: byte field33
34: string field34
35: map<list<i64>, binary> field35
36: i32 field36
37: map<map<i64, byte>, i32> field37
38: string field38
39: map<set<list<i32>>, i32> field39
40: double field40
41: bool field41
42: bool field42
43: float field43
44: Struct1 field44
45: i64 field45
46: map<i32, i32> field46
47: Struct0 field47
48: map<byte, i64> field48
49: set<bool> field49
50: string field50
51: bool field51
52: i64 field52
53: float field53
54: Struct1 field54
55: set<i16> field55
56: list<double> field56
57: set<i64> field57
58: string field58
59: float field59
60: Struct0 field60
61: float field61
62: i64 field62
63: i16 field63
64: i32 field64
65: list<double> field65
66: double field66
67: i64 field67
68: byte field68
69: list<string> field69
70: set<bool> field70
71: Struct1 field71
72: binary field72
73: set<set<string>> field73
74: Struct0 field74
75: binary field75
76: Struct2 field76
77: byte field77
78: set<binary> field78
79: bool field79
80: byte field80
81: i16 field81
82: double field82
83: i16 field83
84: binary field84
85: Struct3 field85
86: list<string> field86
87: map<Struct0, i64> field87
88: byte field88
89: string field89
90: string field90
91: list<float> field91
92: list<bool> field92
93: string field93
94: float field94
95: bool field95
96: string field96
97: list<i16> field97
98: double field98
99: string field99
100: map<i64, map<binary, double>> field100
101: float field101
102: Struct1 field102
103: i64 field103
104: map<binary, i16> field104
105: map<bool, double> field105
106: byte field106
107: i32 field107
108: bool field108
109: Struct2 field109
}
struct Struct8 {
1: list<float> field1
2: Struct3 field2
3: list<binary> field3
4: Struct1 field4
5: set<bool> field5
6: i64 field6
7: map<float, map<i16, i64>> field7
8: list<i16> field8
9: float field9
10: list<bool> field10
11: list<Struct1> field11
12: byte field12
13: Struct1 field13
14: i16 field14
15: i64 field15
16: binary field16
}
struct Struct9 {
1: string field1
2: float field2
3: float field3
4: binary field4
5: byte field5
6: list<bool> field6
7: set<double> field7
8: set<i64> field8
9: Struct0 field9
10: i64 field10
11: float field11
12: map<i16, Struct3> field12
13: Struct0 field13
14: i64 field14
15: Struct2 field15
16: Struct2 field16
17: i32 field17
18: i32 field18
19: list<set<list<double>>> field19
20: double field20
21: bool field21
22: list<i32> field22
23: Struct2 field23
24: binary field24
25: double field25
26: Struct4 field26
27: list<string> field27
28: set<byte> field28
29: set<i32> field29
30: double field30
31: map<double, set<i16>> field31
32: i64 field32
33: byte field33
34: map<bool, i32> field34
35: bool field35
36: map<i64, string> field36
37: bool field37
38: float field38
39: byte field39
40: set<map<bool, i32>> field40
41: map<Struct2, list<byte>> field41
42: i32 field42
43: string field43
44: i64 field44
45: map<binary, float> field45
46: i32 field46
47: double field47
48: map<i64, string> field48
49: Struct2 field49
50: i64 field50
51: byte field51
52: set<set<i16>> field52
53: i16 field53
54: Struct1 field54
55: list<i32> field55
56: binary field56
57: Struct1 field57
58: map<map<i64, byte>, map<bool, binary>> field58
59: string field59
60: set<bool> field60
61: i64 field61
62: map<i16, float> field62
63: set<list<i16>> field63
64: list<i64> field64
65: map<i64, Struct1> field65
66: i64 field66
67: string field67
68: set<float> field68
69: map<set<Struct4>, Struct2> field69
70: set<i32> field70
71: set<set<double>> field71
72: list<float> field72
}
struct Struct10 {
1: string field1
2: double field2
3: float field3
4: set<string> field4
5: map<byte, map<double, bool>> field5
6: binary field6
7: double field7
8: list<float> field8
9: Struct0 field9
10: binary field10
11: i32 field11
12: Struct1 field12
13: double field13
14: i16 field14
15: Struct3 field15
16: set<list<bool>> field16
17: map<Struct1, i64> field17
18: Struct6 field18
19: list<binary> field19
20: double field20
21: list<map<i32, binary>> field21
22: string field22
23: float field23
24: map<i64, bool> field24
25: i64 field25
26: i16 field26
27: list<bool> field27
28: map<binary, string> field28
29: i16 field29
30: set<i16> field30
31: Struct4 field31
32: set<i32> field32
33: byte field33
34: i64 field34
35: list<i32> field35
36: double field36
37: map<string, map<i32, map<double, string>>> field37
38: set<i32> field38
39: bool field39
40: set<string> field40
41: bool field41
42: double field42
43: double field43
44: double field44
45: binary field45
46: i16 field46
47: list<map<double, string>> field47
48: Struct2 field48
49: list<string> field49
50: set<binary> field50
51: Struct6 field51
52: Struct1 field52
53: Struct0 field53
54: double field54
55: byte field55
56: i64 field56
57: map<i32, Struct0> field57
58: i64 field58
59: i16 field59
60: set<double> field60
61: double field61
62: Struct0 field62
63: map<float, float> field63
64: map<float, byte> field64
65: list<float> field65
66: bool field66
67: list<binary> field67
68: list<Struct0> field68
69: set<Struct1> field69
70: list<bool> field70
71: i16 field71
72: Struct7 field72
73: Struct6 field73
74: map<Struct2, binary> field74
75: i64 field75
76: string field76
77: map<i16, binary> field77
78: set<i64> field78
79: map<bool, i64> field79
80: map<Struct3, bool> field80
81: Struct4 field81
82: bool field82
83: Struct5 field83
84: list<string> field84
85: bool field85
86: Struct3 field86
87: i16 field87
88: set<bool> field88
89: Struct0 field89
90: map<Struct1, i16> field90
91: bool field91
92: set<binary> field92
93: map<float, i64> field93
94: list<byte> field94
95: set<bool> field95
96: binary field96
97: i16 field97
98: Struct4 field98
99: set<double> field99
100: string field100
101: set<byte> field101
102: map<string, set<double>> field102
}
struct Struct11 {
1: list<float> field1
2: Struct5 field2
3: Struct8 field3
4: byte field4
5: set<Struct2> field5
6: map<i16, byte> field6
7: map<Struct2, list<i64>> field7
8: map<Struct1, i32> field8
9: list<string> field9
10: map<i16, map<i64, float>> field10
11: Struct5 field11
12: bool field12
13: float field13
14: Struct4 field14
15: string field15
16: byte field16
17: list<bool> field17
18: Struct5 field18
19: byte field19
20: i32 field20
21: byte field21
22: map<list<i32>, set<i32>> field22
23: byte field23
24: float field24
25: Struct6 field25
26: set<bool> field26
27: binary field27
28: bool field28
29: byte field29
30: map<byte, double> field30
31: map<map<float, float>, double> field31
32: Struct6 field32
33: set<byte> field33
34: i64 field34
35: byte field35
36: i16 field36
37: binary field37
38: set<bool> field38
39: i16 field39
40: map<i32, Struct2> field40
41: byte field41
42: bool field42
43: float field43
44: i16 field44
45: i32 field45
46: bool field46
47: map<i16, i16> field47
48: map<byte, binary> field48
49: map<i64, i16> field49
50: list<binary> field50
51: list<bool> field51
52: Struct3 field52
53: binary field53
54: set<float> field54
55: float field55
56: map<i32, i16> field56
57: binary field57
58: double field58
59: byte field59
60: byte field60
61: map<i32, bool> field61
62: string field62
63: map<i32, list<i64>> field63
64: map<set<i32>, byte> field64
65: set<byte> field65
66: bool field66
67: double field67
68: Struct10 field68
69: bool field69
70: list<set<Struct7>> field70
71: list<list<double>> field71
72: binary field72
73: map<float, byte> field73
74: string field74
75: i32 field75
76: bool field76
77: byte field77
78: map<i64, i16> field78
79: string field79
80: list<i16> field80
81: byte field81
82: list<i16> field82
83: byte field83
84: i32 field84
85: map<set<i16>, binary> field85
86: map<string, map<bool, i64>> field86
87: double field87
88: list<i16> field88
89: Struct2 field89
90: i16 field90
91: set<byte> field91
92: i64 field92
93: map<list<i64>, byte> field93
94: list<set<byte>> field94
95: byte field95
96: float field96
97: list<Struct1> field97
98: set<bool> field98
99: i32 field99
100: list<map<bool, bool>> field100
101: float field101
102: list<string> field102
103: string field103
104: set<byte> field104
105: Struct2 field105
106: string field106
107: float field107
108: string field108
109: bool field109
110: map<Struct4, string> field110
111: bool field111
112: list<bool> field112
113: Struct4 field113
114: string field114
115: set<i16> field115
116: byte field116
117: i32 field117
118: map<double, byte> field118
119: bool field119
120: string field120
121: list<Struct0> field121
122: set<set<double>> field122
123: Struct5 field123
124: byte field124
125: float field125
126: map<float, float> field126
127: Struct6 field127
128: map<float, binary> field128
129: byte field129
130: byte field130
131: map<Struct0, byte> field131
132: list<double> field132
133: string field133
134: map<i16, binary> field134
135: double field135
136: list<list<i64>> field136
137: list<double> field137
138: set<double> field138
139: set<double> field139
140: i32 field140
141: Struct1 field141
142: Struct2 field142
143: map<i32, binary> field143
144: map<double, i32> field144
145: Struct5 field145
146: list<i16> field146
147: Struct2 field147
148: string field148
149: set<string> field149
150: double field150
151: Struct0 field151
152: i32 field152
153: list<bool> field153
154: binary field154
155: bool field155
156: Struct1 field156
157: float field157
158: string field158
159: byte field159
160: list<i32> field160
161: Struct0 field161
162: i64 field162
163: string field163
164: Struct7 field164
165: double field165
166: i32 field166
167: Struct7 field167
168: Struct0 field168
169: string field169
170: binary field170
171: Struct1 field171
172: float field172
173: double field173
174: set<i64> field174
175: map<float, i16> field175
176: list<map<i64, bool>> field176
177: set<i16> field177
178: Struct1 field178
179: map<i32, Struct1> field179
180: Struct7 field180
181: map<bool, i16> field181
182: float field182
183: list<string> field183
184: i16 field184
185: Struct3 field185
186: set<Struct3> field186
187: bool field187
188: Struct8 field188
189: Struct0 field189
190: float field190
191: list<i32> field191
192: map<list<string>, list<map<double, byte>>> field192
}
struct Struct12 {
1: bool field1
2: set<set<double>> field2
3: float field3
4: byte field4
5: byte field5
6: map<double, double> field6
7: byte field7
8: double field8
9: Struct10 field9
10: map<string, binary> field10
11: Struct0 field11
12: byte field12
13: set<map<i16, i64>> field13
14: map<i16, list<i16>> field14
15: float field15
16: byte field16
17: bool field17
18: map<i64, i32> field18
19: map<i64, byte> field19
20: Struct6 field20
21: map<list<i32>, list<float>> field21
22: Struct1 field22
23: i32 field23
24: Struct4 field24
25: list<set<i64>> field25
26: Struct3 field26
27: map<byte, binary> field27
28: Struct1 field28
29: string field29
30: double field30
31: map<string, i16> field31
32: i32 field32
33: binary field33
34: binary field34
35: list<i64> field35
36: string field36
37: binary field37
38: i32 field38
39: byte field39
40: byte field40
41: binary field41
42: byte field42
43: Struct10 field43
44: map<byte, i32> field44
45: byte field45
46: Struct4 field46
47: map<double, list<map<double, float>>> field47
48: list<bool> field48
49: Struct2 field49
50: map<i16, Struct5> field50
51: bool field51
52: Struct0 field52
53: map<i32, i16> field53
54: list<i32> field54
55: i64 field55
56: list<binary> field56
57: bool field57
58: byte field58
59: Struct9 field59
60: i16 field60
61: Struct7 field61
62: set<double> field62
63: set<double> field63
64: list<string> field64
65: string field65
66: list<i16> field66
67: list<byte> field67
68: i64 field68
69: list<byte> field69
70: set<i32> field70
71: Struct9 field71
72: map<list<i16>, list<bool>> field72
73: Struct1 field73
74: Struct1 field74
75: i64 field75
76: set<i32> field76
77: i64 field77
78: byte field78
79: i64 field79
80: double field80
81: i16 field81
82: i64 field82
83: byte field83
84: i32 field84
85: map<i64, binary> field85
86: float field86
87: set<i64> field87
88: string field88
89: map<bool, map<double, byte>> field89
90: binary field90
91: bool field91
92: list<i64> field92
93: set<binary> field93
94: set<map<binary, float>> field94
95: float field95
96: list<float> field96
97: string field97
98: string field98
99: i32 field99
100: double field100
}
struct Struct13 {
1: map<double, float> field1
2: list<double> field2
3: set<map<byte, i32>> field3
4: string field4
5: Struct0 field5
6: set<i16> field6
7: map<string, i64> field7
8: list<double> field8
9: double field9
10: map<double, i64> field10
11: binary field11
12: set<i32> field12
13: Struct0 field13
14: double field14
15: set<bool> field15
16: Struct5 field16
17: double field17
18: i16 field18
19: binary field19
20: list<float> field20
21: i64 field21
22: binary field22
23: bool field23
24: float field24
25: i32 field25
26: list<float> field26
27: i32 field27
28: map<list<set<bool>>, bool> field28
29: list<list<i16>> field29
30: bool field30
31: list<list<float>> field31
32: byte field32
33: set<i32> field33
34: float field34
35: byte field35
36: map<list<binary>, map<binary, i64>> field36
37: float field37
38: double field38
39: float field39
40: Struct6 field40
41: set<list<i32>> field41
42: list<bool> field42
43: binary field43
44: list<Struct8> field44
45: float field45
46: list<set<string>> field46
47: set<set<binary>> field47
48: i64 field48
49: byte field49
50: Struct5 field50
51: i64 field51
52: set<bool> field52
53: i16 field53
54: list<binary> field54
55: i64 field55
56: list<Struct0> field56
57: i32 field57
58: Struct2 field58
59: list<binary> field59
60: set<byte> field60
61: list<float> field61
62: list<bool> field62
63: set<i32> field63
64: i32 field64
65: string field65
66: binary field66
67: set<i16> field67
68: binary field68
69: float field69
70: Struct1 field70
71: float field71
72: i32 field72
73: Struct2 field73
74: i64 field74
75: i32 field75
76: map<bool, i64> field76
77: i32 field77
78: list<map<bool, list<float>>> field78
79: list<i32> field79
80: string field80
81: map<Struct8, Struct7> field81
82: bool field82
83: bool field83
84: map<i16, Struct2> field84
85: i16 field85
86: byte field86
87: list<string> field87
88: Struct2 field88
89: float field89
90: float field90
91: list<map<bool, byte>> field91
92: bool field92
93: set<double> field93
94: Struct4 field94
95: bool field95
96: bool field96
97: i16 field97
98: bool field98
99: Struct4 field99
100: set<map<i16, float>> field100
101: binary field101
102: i16 field102
103: map<i16, map<bool, Struct1>> field103
104: i64 field104
105: set<i16> field105
106: double field106
107: set<float> field107
108: set<bool> field108
109: list<map<float, byte>> field109
110: i16 field110
111: Struct1 field111
112: binary field112
113: double field113
114: i16 field114
115: map<list<byte>, i64> field115
116: list<bool> field116
117: binary field117
118: list<binary> field118
119: byte field119
120: double field120
121: i64 field121
122: double field122
123: i32 field123
124: string field124
125: bool field125
126: list<byte> field126
127: string field127
128: string field128
129: Struct4 field129
130: i64 field130
131: string field131
132: Struct2 field132
133: string field133
134: set<map<Struct11, i16>> field134
135: binary field135
136: set<string> field136
137: float field137
138: double field138
139: set<set<double>> field139
140: i64 field140
141: map<bool, float> field141
142: set<list<double>> field142
143: Struct0 field143
144: byte field144
145: set<i64> field145
146: i32 field146
147: double field147
148: Struct4 field148
149: list<byte> field149
150: list<double> field150
151: double field151
152: list<set<i32>> field152
153: string field153
154: set<bool> field154
155: map<i32, set<bool>> field155
156: i64 field156
157: double field157
158: list<list<byte>> field158
159: bool field159
160: double field160
161: double field161
162: set<double> field162
163: binary field163
164: i64 field164
165: binary field165
166: set<float> field166
167: list<i32> field167
168: map<bool, Struct1> field168
169: byte field169
170: binary field170
171: binary field171
172: set<bool> field172
173: bool field173
174: map<i16, list<i64>> field174
175: i32 field175
176: float field176
177: list<float> field177
178: float field178
179: string field179
180: set<set<float>> field180
181: set<list<float>> field181
182: binary field182
183: float field183
184: Struct6 field184
185: set<i64> field185
186: i32 field186
187: double field187
188: list<string> field188
189: float field189
190: double field190
191: Struct0 field191
192: list<byte> field192
193: string field193
194: bool field194
195: list<byte> field195
196: float field196
197: Struct2 field197
198: list<Struct3> field198
199: map<Struct5, binary> field199
200: list<double> field200
201: list<string> field201
202: float field202
203: i16 field203
204: map<i16, set<float>> field204
205: Struct7 field205
206: double field206
207: map<set<byte>, list<float>> field207
208: set<i16> field208
209: set<string> field209
210: Struct7 field210
211: list<float> field211
212: list<byte> field212
213: set<set<set<i64>>> field213
214: list<i32> field214
215: string field215
216: i32 field216
217: set<map<binary, bool>> field217
}
struct Struct14 {
1: i64 field1
2: Struct0 field2
3: i16 field3
4: byte field4
5: double field5
6: binary field6
7: set<i16> field7
8: double field8
9: binary field9
10: Struct1 field10
11: float field11
12: i32 field12
13: float field13
14: double field14
15: bool field15
16: i64 field16
17: i16 field17
18: i64 field18
19: string field19
20: bool field20
21: i16 field21
22: float field22
23: map<i64, map<string, float>> field23
24: binary field24
25: Struct1 field25
26: map<i16, double> field26
27: string field27
28: map<map<list<string>, set<binary>>, string> field28
29: float field29
30: string field30
31: double field31
32: list<set<bool>> field32
33: list<i16> field33
34: binary field34
35: Struct0 field35
36: i32 field36
37: Struct1 field37
38: binary field38
39: i32 field39
40: Struct6 field40
41: Struct1 field41
42: map<i64, i16> field42
43: binary field43
44: set<map<map<i64, Struct8>, i32>> field44
45: i32 field45
46: byte field46
47: Struct5 field47
48: set<binary> field48
49: Struct3 field49
50: map<float, Struct3> field50
51: i32 field51
52: list<i16> field52
53: map<string, string> field53
54: map<Struct2, i32> field54
55: Struct2 field55
56: double field56
57: bool field57
58: list<i32> field58
59: Struct5 field59
60: binary field60
61: bool field61
62: i16 field62
63: list<byte> field63
64: string field64
65: Struct1 field65
66: Struct4 field66
67: byte field67
68: i64 field68
69: set<byte> field69
70: list<bool> field70
71: string field71
72: list<i16> field72
73: set<Struct5> field73
74: Struct5 field74
75: map<i16, byte> field75
76: bool field76
77: set<byte> field77
78: byte field78
79: binary field79
80: double field80
81: bool field81
82: i64 field82
83: set<string> field83
84: Struct5 field84
85: bool field85
86: float field86
87: set<double> field87
88: map<double, float> field88
89: map<set<binary>, binary> field89
90: i64 field90
91: i16 field91
92: map<set<double>, byte> field92
93: bool field93
94: i64 field94
95: list<i64> field95
96: map<Struct6, i64> field96
97: string field97
98: Struct0 field98
99: set<float> field99
100: i64 field100
101: list<bool> field101
102: list<byte> field102
103: i64 field103
104: map<byte, set<float>> field104
105: Struct6 field105
106: byte field106
107: set<float> field107
108: float field108
109: binary field109
110: list<byte> field110
111: set<map<float, i16>> field111
112: list<float> field112
113: list<byte> field113
114: Struct4 field114
115: bool field115
116: i16 field116
117: map<float, float> field117
118: set<byte> field118
119: set<binary> field119
120: set<byte> field120
121: map<Struct0, i32> field121
122: set<byte> field122
123: Struct10 field123
124: float field124
125: string field125
126: bool field126
127: list<map<string, bool>> field127
128: list<double> field128
129: list<byte> field129
130: byte field130
131: string field131
132: map<Struct2, float> field132
133: list<double> field133
134: i64 field134
135: string field135
136: float field136
137: set<bool> field137
138: map<bool, i32> field138
139: double field139
140: string field140
141: binary field141
142: byte field142
143: set<binary> field143
144: map<float, i64> field144
145: i32 field145
146: i16 field146
147: set<list<i32>> field147
148: map<float, list<i32>> field148
149: Struct7 field149
150: byte field150
151: bool field151
152: map<i16, i32> field152
153: byte field153
154: string field154
155: string field155
156: Struct2 field156
157: list<binary> field157
158: Struct6 field158
159: bool field159
160: list<i16> field160
161: list<i64> field161
162: i64 field162
163: binary field163
164: binary field164
165: i64 field165
166: list<binary> field166
167: Struct5 field167
168: map<Struct3, i64> field168
169: map<binary, bool> field169
170: list<double> field170
171: set<i16> field171
172: list<string> field172
173: i32 field173
174: set<i32> field174
175: map<byte, string> field175
176: list<string> field176
177: Struct4 field177
178: Struct10 field178
179: set<i64> field179
180: list<binary> field180
181: byte field181
182: Struct5 field182
183: byte field183
184: binary field184
185: double field185
186: set<float> field186
187: i32 field187
188: Struct0 field188
189: i16 field189
190: float field190
191: Struct2 field191
192: map<list<i16>, byte> field192
193: string field193
194: string field194
195: Struct2 field195
196: map<bool, Struct3> field196
197: bool field197
}
struct Struct15 {
1: Struct6 field1
2: set<i64> field2
3: i32 field3
4: i32 field4
5: binary field5
6: set<byte> field6
7: i16 field7
8: bool field8
9: list<map<set<byte>, i32>> field9
10: i32 field10
11: list<byte> field11
12: bool field12
13: float field13
14: set<list<i16>> field14
15: map<i64, map<set<string>, float>> field15
16: set<i32> field16
17: map<bool, map<i64, float>> field17
18: set<float> field18
19: Struct3 field19
20: set<i16> field20
21: string field21
22: string field22
23: i64 field23
24: binary field24
25: i16 field25
26: list<map<set<i32>, binary>> field26
27: set<map<byte, i64>> field27
28: double field28
29: Struct2 field29
30: Struct3 field30
31: i32 field31
32: float field32
33: i16 field33
34: map<binary, list<i32>> field34
35: i64 field35
36: bool field36
37: list<double> field37
38: double field38
39: float field39
40: string field40
41: double field41
42: Struct5 field42
43: string field43
44: byte field44
45: set<string> field45
46: list<Struct0> field46
47: byte field47
48: i16 field48
49: byte field49
50: list<string> field50
51: set<set<string>> field51
52: bool field52
53: binary field53
54: Struct4 field54
55: binary field55
56: double field56
57: map<i32, float> field57
58: i16 field58
59: list<i32> field59
60: Struct9 field60
61: i16 field61
62: i32 field62
63: list<binary> field63
64: map<map<byte, i32>, i16> field64
65: Struct9 field65
66: Struct8 field66
67: string field67
68: bool field68
69: bool field69
}
struct Struct16 {
1: Struct10 field1
2: map<list<i32>, bool> field2
3: Struct7 field3
4: list<i32> field4
5: i16 field5
6: list<double> field6
7: byte field7
8: i16 field8
9: set<map<i32, i64>> field9
10: byte field10
11: string field11
12: i64 field12
13: i32 field13
14: string field14
15: map<set<bool>, float> field15
16: byte field16
17: float field17
18: i32 field18
19: list<string> field19
20: i16 field20
21: list<float> field21
22: Struct6 field22
23: i16 field23
24: bool field24
25: Struct5 field25
26: set<set<bool>> field26
27: i32 field27
}
struct Struct17 {
1: byte field1
2: list<string> field2
3: binary field3
4: i64 field4
5: i16 field5
6: bool field6
7: map<bool, i32> field7
8: byte field8
9: Struct3 field9
10: map<bool, bool> field10
11: map<Struct3, string> field11
12: set<float> field12
13: double field13
14: map<i16, i64> field14
15: string field15
16: bool field16
17: map<list<bool>, Struct5> field17
18: set<byte> field18
19: double field19
20: map<double, byte> field20
21: i32 field21
22: string field22
23: list<i32> field23
24: list<list<byte>> field24
25: i32 field25
26: bool field26
27: set<float> field27
28: i64 field28
29: list<float> field29
30: list<i16> field30
31: float field31
32: i16 field32
33: Struct11 field33
34: set<double> field34
35: Struct3 field35
36: i64 field36
37: double field37
38: float field38
39: i64 field39
40: list<i16> field40
41: string field41
42: set<double> field42
43: i16 field43
44: Struct1 field44
45: i16 field45
46: i16 field46
47: string field47
48: float field48
49: i64 field49
50: i64 field50
51: double field51
52: set<Struct10> field52
53: set<i32> field53
54: bool field54
55: i64 field55
56: Struct12 field56
57: set<map<float, binary>> field57
58: map<bool, set<string>> field58
59: i32 field59
60: bool field60
61: Struct10 field61
62: i16 field62
63: i32 field63
64: binary field64
65: set<string> field65
66: i32 field66
67: map<i16, binary> field67
68: map<map<list<i16>, binary>, list<byte>> field68
69: string field69
70: float field70
71: float field71
72: i16 field72
73: double field73
74: string field74
75: set<i16> field75
76: i64 field76
77: map<string, set<float>> field77
78: list<float> field78
79: Struct5 field79
80: i64 field80
81: map<Struct0, binary> field81
82: Struct3 field82
83: Struct11 field83
84: map<double, i16> field84
85: i64 field85
86: Struct5 field86
87: set<list<i32>> field87
88: list<set<i64>> field88
89: double field89
90: list<i64> field90
91: map<byte, bool> field91
92: double field92
93: map<i16, i32> field93
94: Struct2 field94
95: string field95
96: byte field96
97: Struct2 field97
98: double field98
99: i64 field99
100: Struct3 field100
101: list<Struct9> field101
102: Struct6 field102
103: byte field103
104: map<byte, i16> field104
105: i32 field105
106: byte field106
107: map<double, list<map<float, byte>>> field107
108: double field108
109: Struct6 field109
110: double field110
111: i16 field111
112: i32 field112
113: i32 field113
114: i64 field114
115: byte field115
116: binary field116
117: set<map<map<binary, binary>, i64>> field117
118: map<i64, string> field118
119: bool field119
120: binary field120
121: float field121
122: i32 field122
123: i32 field123
124: set<set<double>> field124
125: byte field125
126: list<string> field126
127: i16 field127
128: map<i32, double> field128
}
struct Struct18 {
1: Struct0 field1
2: Struct10 field2
3: i64 field3
4: map<Struct3, Struct0> field4
5: i16 field5
6: list<float> field6
7: list<bool> field7
8: i32 field8
9: i16 field9
10: Struct0 field10
11: float field11
12: byte field12
13: set<i16> field13
14: i64 field14
15: i16 field15
16: i16 field16
17: map<bool, string> field17
18: i32 field18
19: i32 field19
20: binary field20
21: set<float> field21
22: i16 field22
23: string field23
24: i32 field24
25: Struct0 field25
26: map<byte, i16> field26
27: binary field27
28: binary field28
29: i32 field29
30: string field30
31: i64 field31
32: map<i32, bool> field32
33: byte field33
34: string field34
35: i64 field35
36: i64 field36
37: Struct2 field37
38: list<bool> field38
39: binary field39
40: map<list<map<byte, i64>>, string> field40
41: bool field41
42: Struct6 field42
43: string field43
44: map<binary, list<list<string>>> field44
45: i64 field45
46: map<i16, i32> field46
47: set<binary> field47
48: set<float> field48
49: Struct0 field49
50: list<Struct3> field50
51: map<i64, list<string>> field51
52: i64 field52
53: bool field53
54: set<binary> field54
55: string field55
56: set<float> field56
57: string field57
58: double field58
59: bool field59
60: set<Struct1> field60
61: set<byte> field61
62: set<i16> field62
63: set<string> field63
64: Struct8 field64
65: Struct8 field65
66: i16 field66
67: double field67
68: map<list<byte>, set<float>> field68
69: list<i64> field69
70: i64 field70
71: list<map<i16, string>> field71
72: list<map<string, byte>> field72
73: byte field73
74: list<set<string>> field74
75: list<list<double>> field75
76: map<double, list<i64>> field76
77: i32 field77
78: string field78
79: bool field79
80: set<set<i64>> field80
81: double field81
82: float field82
83: Struct9 field83
84: Struct9 field84
85: i64 field85
86: binary field86
87: i32 field87
88: float field88
89: map<byte, byte> field89
90: map<i16, list<float>> field90
91: i16 field91
92: i64 field92
93: i64 field93
94: map<float, Struct5> field94
95: list<binary> field95
96: float field96
97: Struct8 field97
98: map<byte, string> field98
99: i16 field99
100: map<byte, string> field100
101: map<bool, i64> field101
102: i16 field102
103: byte field103
104: set<i16> field104
105: string field105
106: set<string> field106
107: binary field107
108: Struct8 field108
109: byte field109
110: set<binary> field110
111: Struct2 field111
112: string field112
113: set<map<binary, i32>> field113
114: i64 field114
115: Struct3 field115
116: set<i16> field116
117: float field117
118: list<map<byte, double>> field118
119: string field119
120: binary field120
121: i64 field121
122: set<list<map<float, double>>> field122
123: list<map<string, byte>> field123
124: set<byte> field124
125: i16 field125
126: map<string, i32> field126
127: byte field127
128: i32 field128
129: Struct11 field129
130: double field130
131: byte field131
132: Struct7 field132
133: i32 field133
134: double field134
135: byte field135
136: double field136
137: binary field137
138: i64 field138
139: binary field139
140: i64 field140
141: float field141
142: bool field142
143: i16 field143
144: map<Struct4, i64> field144
145: list<float> field145
146: i16 field146
147: Struct9 field147
148: map<Struct0, double> field148
149: float field149
150: bool field150
151: set<byte> field151
152: map<i64, list<i64>> field152
153: bool field153
154: byte field154
155: i32 field155
156: i16 field156
157: string field157
158: binary field158
159: i64 field159
160: map<double, byte> field160
161: string field161
162: Struct2 field162
163: bool field163
164: i64 field164
165: bool field165
166: set<Struct6> field166
167: map<i16, set<float>> field167
168: list<string> field168
169: set<string> field169
170: set<byte> field170
171: list<bool> field171
172: Struct0 field172
173: list<binary> field173
174: map<i32, Struct8> field174
175: Struct3 field175
176: set<float> field176
177: i32 field177
178: byte field178
179: i16 field179
180: set<binary> field180
181: string field181
182: float field182
183: list<i64> field183
184: byte field184
185: set<string> field185
186: bool field186
187: set<binary> field187
188: Struct4 field188
189: bool field189
190: Struct7 field190
191: binary field191
192: float field192
193: i32 field193
194: float field194
195: set<i32> field195
196: double field196
197: Struct4 field197
198: i32 field198
199: Struct14 field199
200: list<float> field200
201: list<i64> field201
202: map<bool, i32> field202
203: string field203
204: map<i64, i32> field204
205: map<string, list<i32>> field205
206: byte field206
207: set<binary> field207
208: Struct8 field208
209: binary field209
210: map<binary, bool> field210
211: map<bool, i16> field211
212: binary field212
213: byte field213
214: Struct5 field214
215: i64 field215
216: i16 field216
217: string field217
218: float field218
219: list<float> field219
220: Struct13 field220
221: binary field221
222: Struct8 field222
223: set<i16> field223
224: i16 field224
225: list<float> field225
226: list<i16> field226
227: list<map<i64, i16>> field227
228: i64 field228
229: Struct2 field229
230: binary field230
}
struct Struct19 {
1: bool field1
2: map<binary, i16> field2
3: set<i64> field3
4: i64 field4
5: bool field5
6: map<double, bool> field6
7: map<string, set<i16>> field7
8: Struct0 field8
9: float field9
10: list<set<list<i32>>> field10
11: bool field11
12: map<i32, bool> field12
13: bool field13
14: byte field14
15: Struct7 field15
16: list<i16> field16
17: map<list<list<binary>>, byte> field17
18: set<binary> field18
19: set<double> field19
20: binary field20
21: list<i16> field21
22: set<set<double>> field22
23: string field23
24: string field24
25: double field25
26: bool field26
27: string field27
28: string field28
29: bool field29
30: binary field30
31: double field31
32: byte field32
33: list<bool> field33
34: set<list<string>> field34
35: i16 field35
36: map<float, byte> field36
37: map<string, i32> field37
38: i16 field38
39: set<i16> field39
40: string field40
41: list<list<i32>> field41
42: bool field42
43: set<i32> field43
44: string field44
45: set<float> field45
46: i32 field46
47: string field47
48: bool field48
49: bool field49
50: list<binary> field50
51: binary field51
52: i64 field52
53: bool field53
54: bool field54
55: byte field55
56: set<bool> field56
57: byte field57
58: set<list<bool>> field58
59: list<list<bool>> field59
60: set<i16> field60
61: set<binary> field61
62: bool field62
63: double field63
64: map<byte, string> field64
65: i64 field65
66: float field66
67: Struct3 field67
68: i64 field68
69: i16 field69
70: double field70
71: Struct8 field71
72: i32 field72
73: set<string> field73
74: set<binary> field74
75: set<float> field75
76: map<list<double>, Struct2> field76
77: string field77
78: byte field78
79: list<binary> field79
80: string field80
81: double field81
82: string field82
83: Struct8 field83
84: i16 field84
}
struct Struct20 {
1: Struct0 field1
2: set<Struct13> field2
3: float field3
4: byte field4
5: i32 field5
6: string field6
7: i32 field7
8: list<map<float, i16>> field8
9: Struct7 field9
10: bool field10
11: byte field11
12: set<Struct6> field12
13: map<list<bool>, list<bool>> field13
14: bool field14
15: bool field15
16: i16 field16
17: set<Struct3> field17
18: i64 field18
19: double field19
20: set<list<i32>> field20
21: map<byte, byte> field21
22: double field22
23: binary field23
24: Struct14 field24
25: string field25
26: set<byte> field26
27: Struct9 field27
28: byte field28
29: map<i16, i64> field29
30: set<set<list<byte>>> field30
31: Struct11 field31
32: list<string> field32
33: map<i16, double> field33
34: i32 field34
35: float field35
36: list<i64> field36
37: set<bool> field37
38: binary field38
39: list<double> field39
40: set<map<bool, set<string>>> field40
41: Struct13 field41
42: list<binary> field42
43: list<list<bool>> field43
44: i32 field44
45: i64 field45
46: double field46
47: i64 field47
48: i16 field48
49: Struct7 field49
50: double field50
51: Struct0 field51
52: set<binary> field52
53: string field53
54: float field54
55: float field55
56: i32 field56
57: set<i64> field57
58: byte field58
59: i32 field59
60: Struct5 field60
61: Struct3 field61
62: set<i32> field62
63: float field63
64: list<Struct8> field64
65: i32 field65
66: binary field66
67: double field67
68: map<float, binary> field68
69: list<list<i64>> field69
70: Struct3 field70
71: Struct12 field71
72: double field72
73: string field73
74: set<list<float>> field74
75: set<float> field75
76: list<bool> field76
77: set<string> field77
78: Struct8 field78
79: map<list<i16>, Struct6> field79
80: set<binary> field80
81: set<double> field81
82: i64 field82
}
struct Struct21 {
1: list<byte> field1
2: Struct1 field2
3: string field3
4: byte field4
5: float field5
6: double field6
7: map<i16, list<float>> field7
8: float field8
9: Struct12 field9
10: float field10
11: binary field11
12: byte field12
13: list<bool> field13
14: double field14
15: i32 field15
16: i16 field16
17: Struct2 field17
18: double field18
19: i16 field19
20: i16 field20
21: map<Struct10, list<double>> field21
22: set<i32> field22
23: list<bool> field23
24: set<float> field24
25: float field25
26: Struct1 field26
27: map<string, bool> field27
28: i64 field28
29: float field29
30: list<i16> field30
31: byte field31
32: list<i32> field32
33: set<list<i16>> field33
34: Struct16 field34
35: map<i16, binary> field35
36: map<bool, list<Struct5>> field36
37: i16 field37
38: map<float, i16> field38
39: set<i64> field39
40: bool field40
41: binary field41
42: i16 field42
43: Struct9 field43
44: set<binary> field44
45: map<i32, Struct3> field45
46: set<i64> field46
47: Struct2 field47
48: i32 field48
49: byte field49
50: bool field50
51: list<Struct10> field51
52: float field52
53: set<binary> field53
54: string field54
55: Struct11 field55
56: list<bool> field56
57: map<string, list<binary>> field57
58: i64 field58
59: byte field59
60: Struct11 field60
61: set<i64> field61
62: i16 field62
63: bool field63
64: bool field64
65: i32 field65
66: string field66
67: i32 field67
68: set<byte> field68
69: i32 field69
70: set<set<float>> field70
71: i16 field71
72: list<string> field72
73: map<Struct1, list<i16>> field73
74: Struct3 field74
75: string field75
76: list<list<double>> field76
77: list<bool> field77
78: set<Struct14> field78
79: binary field79
80: i32 field80
81: i16 field81
82: bool field82
83: map<Struct2, double> field83
84: list<map<Struct2, bool>> field84
85: map<bool, list<binary>> field85
86: Struct6 field86
87: string field87
88: float field88
89: list<bool> field89
90: i64 field90
91: bool field91
92: map<bool, list<double>> field92
93: float field93
94: byte field94
95: string field95
96: Struct4 field96
97: string field97
98: i16 field98
99: set<binary> field99
100: map<double, i64> field100
101: i16 field101
102: set<binary> field102
103: binary field103
104: i16 field104
105: map<byte, string> field105
106: binary field106
107: set<string> field107
108: Struct8 field108
109: i16 field109
110: binary field110
111: i32 field111
112: set<double> field112
113: list<i16> field113
114: i16 field114
115: byte field115
116: i64 field116
117: map<i32, i16> field117
118: i64 field118
119: list<double> field119
120: i64 field120
121: string field121
122: i64 field122
123: map<binary, map<byte, double>> field123
124: string field124
125: bool field125
126: byte field126
127: i16 field127
128: string field128
129: map<string, set<i32>> field129
130: map<i64, binary> field130
131: map<Struct18, set<byte>> field131
132: byte field132
133: double field133
134: map<i64, byte> field134
135: i32 field135
136: map<i32, binary> field136
137: list<string> field137
138: map<string, i16> field138
139: Struct5 field139
140: i32 field140
141: string field141
142: byte field142
143: i32 field143
144: set<double> field144
145: list<byte> field145
146: i64 field146
147: set<double> field147
148: string field148
149: i16 field149
150: set<map<i16, float>> field150
151: Struct14 field151
152: Struct3 field152
153: set<binary> field153
154: list<byte> field154
155: byte field155
156: byte field156
157: float field157
158: Struct2 field158
159: i32 field159
160: double field160
161: bool field161
162: list<binary> field162
163: map<Struct7, map<i64, Struct4>> field163
164: set<double> field164
165: list<i64> field165
166: set<byte> field166
167: Struct4 field167
168: binary field168
169: i16 field169
170: binary field170
171: map<i16, i16> field171
172: set<i32> field172
173: set<Struct5> field173
174: binary field174
}
struct Struct22 {
1: double field1
2: i32 field2
3: Struct9 field3
4: map<float, list<bool>> field4
5: map<binary, bool> field5
6: bool field6
7: float field7
8: set<byte> field8
9: string field9
10: map<Struct3, bool> field10
11: float field11
12: float field12
13: list<list<float>> field13
14: float field14
15: list<binary> field15
16: byte field16
17: Struct9 field17
18: map<i64, byte> field18
19: i32 field19
20: double field20
21: float field21
22: byte field22
23: byte field23
24: Struct12 field24
25: float field25
26: string field26
27: i16 field27
28: list<list<string>> field28
29: list<i16> field29
30: byte field30
31: set<double> field31
32: Struct0 field32
33: byte field33
34: map<string, string> field34
35: list<double> field35
36: list<i32> field36
37: list<Struct2> field37
38: binary field38
39: set<i32> field39
40: bool field40
41: map<i64, float> field41
42: string field42
43: i16 field43
44: map<i16, float> field44
45: bool field45
46: i16 field46
47: binary field47
48: Struct9 field48
49: map<double, list<string>> field49
50: float field50
51: set<bool> field51
52: map<float, float> field52
53: i16 field53
54: i64 field54
55: byte field55
56: Struct9 field56
57: double field57
58: list<string> field58
59: i32 field59
60: binary field60
61: binary field61
62: double field62
63: set<i16> field63
64: bool field64
65: float field65
66: map<byte, binary> field66
67: i64 field67
68: i16 field68
69: byte field69
70: map<i32, byte> field70
71: i64 field71
72: float field72
73: binary field73
74: byte field74
75: list<bool> field75
76: Struct15 field76
77: map<double, map<float, list<i32>>> field77
78: list<string> field78
79: Struct7 field79
80: i16 field80
81: i64 field81
82: double field82
83: list<double> field83
84: set<double> field84
85: i64 field85
86: Struct3 field86
87: Struct15 field87
88: byte field88
89: list<list<byte>> field89
90: binary field90
91: i16 field91
92: set<list<i16>> field92
93: i64 field93
94: binary field94
95: map<float, set<i64>> field95
}
struct Struct23 {
1: i16 field1
2: Struct15 field2
3: Struct15 field3
4: string field4
5: string field5
6: i64 field6
7: Struct6 field7
8: list<string> field8
9: map<set<i16>, string> field9
10: byte field10
11: i64 field11
12: i64 field12
13: string field13
14: Struct6 field14
15: list<set<string>> field15
16: Struct1 field16
17: string field17
18: map<byte, i64> field18
19: byte field19
20: list<map<byte, bool>> field20
21: set<string> field21
22: i64 field22
23: list<byte> field23
24: map<map<double, float>, float> field24
25: byte field25
26: set<string> field26
27: map<Struct1, i64> field27
28: list<string> field28
29: i64 field29
30: bool field30
31: bool field31
32: i32 field32
33: set<string> field33
34: Struct1 field34
35: map<i32, i16> field35
36: float field36
37: list<double> field37
38: list<i32> field38
39: Struct4 field39
40: Struct9 field40
41: i64 field41
}
struct Struct24 {
1: set<binary> field1
2: Struct4 field2
3: bool field3
4: i64 field4
5: i16 field5
6: list<string> field6
7: double field7
8: string field8
9: i16 field9
10: float field10
11: binary field11
12: set<byte> field12
13: set<i32> field13
14: map<i64, i64> field14
15: set<i32> field15
16: i16 field16
17: map<map<double, byte>, i16> field17
18: set<bool> field18
19: map<string, map<double, i16>> field19
20: map<float, double> field20
21: Struct7 field21
22: set<float> field22
23: bool field23
24: i16 field24
25: list<list<bool>> field25
26: string field26
27: i32 field27
28: map<set<bool>, bool> field28
29: i16 field29
30: byte field30
31: bool field31
32: list<i32> field32
33: set<i64> field33
34: Struct4 field34
35: Struct0 field35
36: Struct9 field36
37: Struct9 field37
38: Struct1 field38
39: bool field39
40: list<bool> field40
41: double field41
42: Struct3 field42
43: Struct8 field43
44: string field44
45: byte field45
46: i64 field46
47: i32 field47
48: set<Struct18> field48
49: float field49
50: byte field50
51: Struct5 field51
52: set<list<i64>> field52
53: string field53
54: byte field54
55: map<byte, bool> field55
56: list<list<double>> field56
}
struct Struct25 {
1: bool field1
2: map<byte, i64> field2
3: set<byte> field3
4: map<string, Struct6> field4
5: set<byte> field5
6: i32 field6
7: binary field7
8: string field8
9: i16 field9
10: double field10
11: map<string, Struct15> field11
12: map<binary, Struct20> field12
13: float field13
14: set<i16> field14
15: set<float> field15
16: binary field16
17: map<list<list<binary>>, i16> field17
18: bool field18
19: i64 field19
20: list<list<bool>> field20
21: i16 field21
22: set<list<i32>> field22
23: set<bool> field23
24: map<set<i64>, i16> field24
25: i64 field25
26: i16 field26
27: set<Struct12> field27
28: i64 field28
29: byte field29
30: set<binary> field30
31: Struct3 field31
32: Struct10 field32
33: byte field33
34: map<set<string>, byte> field34
35: Struct1 field35
36: binary field36
37: set<string> field37
38: list<Struct3> field38
39: set<string> field39
40: i32 field40
41: float field41
42: map<i16, map<list<double>, double>> field42
43: list<double> field43
44: string field44
45: set<Struct9> field45
46: i64 field46
47: Struct10 field47
48: double field48
49: bool field49
50: map<i32, binary> field50
51: Struct10 field51
52: byte field52
53: list<list<double>> field53
54: list<double> field54
55: map<double, float> field55
56: float field56
57: map<Struct4, byte> field57
58: double field58
59: list<map<list<bool>, i64>> field59
60: byte field60
61: bool field61
62: bool field62
63: bool field63
64: map<binary, list<double>> field64
65: list<double> field65
66: double field66
67: set<map<float, float>> field67
68: binary field68
69: list<string> field69
70: Struct15 field70
71: byte field71
72: set<i16> field72
73: list<float> field73
74: map<map<string, i16>, double> field74
75: i32 field75
76: double field76
77: i16 field77
78: string field78
79: set<byte> field79
}
struct Struct26 {
1: set<double> field1
2: double field2
3: map<byte, float> field3
4: byte field4
5: map<set<double>, i16> field5
6: set<i16> field6
7: i16 field7
8: string field8
9: i16 field9
10: map<double, map<map<double, i32>, bool>> field10
11: set<set<i32>> field11
12: list<binary> field12
13: i32 field13
14: Struct10 field14
15: bool field15
16: binary field16
17: set<byte> field17
18: i16 field18
19: set<double> field19
20: float field20
21: i16 field21
22: i16 field22
23: i16 field23
24: byte field24
25: i16 field25
26: double field26
27: set<binary> field27
28: list<double> field28
29: double field29
30: list<i16> field30
31: byte field31
32: Struct17 field32
33: list<i16> field33
34: i32 field34
35: bool field35
36: byte field36
37: set<byte> field37
38: bool field38
39: float field39
40: map<float, bool> field40
41: byte field41
42: Struct14 field42
43: map<i32, bool> field43
44: double field44
45: Struct7 field45
46: set<i16> field46
47: map<binary, map<string, bool>> field47
48: byte field48
49: i64 field49
50: binary field50
51: Struct10 field51
52: binary field52
53: Struct5 field53
54: double field54
55: Struct0 field55
56: double field56
57: set<double> field57
58: binary field58
59: Struct4 field59
60: double field60
61: list<set<float>> field61
62: i16 field62
63: set<map<byte, i32>> field63
64: list<i64> field64
65: set<list<double>> field65
66: float field66
67: set<binary> field67
68: binary field68
69: i32 field69
70: map<byte, map<float, string>> field70
71: i32 field71
72: set<byte> field72
73: string field73
74: i32 field74
75: map<bool, map<list<string>, i64>> field75
76: float field76
77: bool field77
78: Struct9 field78
79: i16 field79
80: set<i64> field80
81: double field81
82: byte field82
83: float field83
84: list<Struct15> field84
85: Struct2 field85
86: Struct9 field86
87: list<string> field87
88: string field88
89: map<byte, string> field89
90: Struct19 field90
91: double field91
92: byte field92
93: i64 field93
94: float field94
95: byte field95
96: Struct5 field96
97: i32 field97
98: Struct6 field98
99: set<bool> field99
100: byte field100
101: string field101
102: map<i64, i64> field102
103: binary field103
104: float field104
105: string field105
}
struct Struct27 {
1: Struct8 field1
2: float field2
3: set<double> field3
4: binary field4
5: map<byte, binary> field5
6: list<double> field6
7: i64 field7
8: set<double> field8
9: set<Struct1> field9
10: set<binary> field10
11: i64 field11
12: set<set<float>> field12
13: map<bool, binary> field13
14: bool field14
15: float field15
16: bool field16
17: Struct3 field17
18: Struct6 field18
19: set<bool> field19
20: i16 field20
21: set<i64> field21
22: string field22
23: byte field23
24: map<i16, float> field24
25: Struct0 field25
26: map<string, map<string, map<i32, float>>> field26
27: set<i64> field27
28: float field28
29: list<i32> field29
30: i32 field30
31: list<bool> field31
32: i64 field32
33: Struct9 field33
34: set<byte> field34
35: Struct15 field35
36: byte field36
37: i64 field37
38: bool field38
39: map<map<list<float>, byte>, i32> field39
40: list<string> field40
41: Struct4 field41
42: double field42
43: Struct7 field43
44: string field44
45: i16 field45
46: i32 field46
47: map<double, binary> field47
48: byte field48
49: Struct5 field49
50: Struct19 field50
51: binary field51
52: Struct16 field52
53: set<string> field53
54: set<list<string>> field54
55: double field55
56: bool field56
57: list<i32> field57
58: set<string> field58
59: map<map<map<i32, i64>, binary>, float> field59
60: Struct2 field60
61: float field61
62: Struct16 field62
63: set<i16> field63
64: i64 field64
65: i32 field65
66: list<bool> field66
67: bool field67
68: bool field68
69: Struct6 field69
70: byte field70
71: i32 field71
72: Struct6 field72
73: i16 field73
74: double field74
75: i64 field75
76: list<byte> field76
77: list<bool> field77
78: list<string> field78
79: byte field79
80: Struct4 field80
81: byte field81
82: string field82
83: list<map<map<float, bool>, byte>> field83
84: float field84
85: binary field85
86: i32 field86
87: i16 field87
88: set<i64> field88
89: bool field89
90: bool field90
91: list<list<list<i64>>> field91
92: binary field92
93: set<set<i64>> field93
94: double field94
95: string field95
96: bool field96
97: string field97
98: binary field98
99: binary field99
100: Struct13 field100
101: bool field101
102: float field102
103: i16 field103
104: i32 field104
105: i32 field105
106: set<double> field106
107: Struct9 field107
108: map<i64, list<bool>> field108
109: bool field109
110: i16 field110
111: list<byte> field111
112: float field112
113: i32 field113
114: Struct4 field114
115: Struct2 field115
116: i64 field116
117: set<binary> field117
118: byte field118
119: list<double> field119
120: Struct8 field120
121: Struct14 field121
122: i64 field122
123: map<i32, string> field123
124: i64 field124
125: binary field125
126: list<bool> field126
127: float field127
128: set<float> field128
129: i16 field129
130: set<bool> field130
131: list<i16> field131
132: map<set<binary>, float> field132
133: list<map<list<list<float>>, i32>> field133
134: list<i64> field134
135: map<Struct13, double> field135
136: float field136
137: map<byte, float> field137
138: map<double, Struct7> field138
139: list<set<binary>> field139
140: map<set<double>, string> field140
141: Struct12 field141
142: i16 field142
143: string field143
144: set<double> field144
145: double field145
146: Struct17 field146
147: binary field147
148: float field148
149: float field149
150: set<bool> field150
151: Struct18 field151
152: byte field152
153: binary field153
154: double field154
155: list<string> field155
156: Struct3 field156
157: i32 field157
158: map<i16, i16> field158
159: Struct8 field159
160: string field160
161: byte field161
162: i32 field162
163: set<double> field163
164: list<map<i64, i32>> field164
165: list<i64> field165
166: string field166
167: double field167
168: map<binary, string> field168
169: map<byte, byte> field169
170: double field170
171: map<binary, binary> field171
172: map<Struct3, float> field172
173: string field173
174: i16 field174
175: i64 field175
176: string field176
177: map<float, i16> field177
178: Struct0 field178
179: map<i64, set<i64>> field179
180: map<double, string> field180
181: i32 field181
182: Struct21 field182
183: binary field183
184: set<binary> field184
185: byte field185
186: float field186
187: i16 field187
188: set<set<double>> field188
189: string field189
190: set<double> field190
191: set<bool> field191
192: float field192
193: string field193
194: float field194
195: map<i64, byte> field195
196: Struct5 field196
197: bool field197
198: map<double, i32> field198
199: set<i16> field199
200: Struct18 field200
201: i32 field201
202: byte field202
203: Struct16 field203
204: map<list<bool>, string> field204
205: i32 field205
206: list<byte> field206
207: bool field207
208: map<byte, i32> field208
209: float field209
210: list<i32> field210
211: float field211
212: binary field212
213: set<float> field213
214: list<string> field214
215: map<binary, Struct5> field215
216: i64 field216
217: map<i64, double> field217
218: i64 field218
219: string field219
220: set<byte> field220
221: map<list<list<binary>>, list<float>> field221
222: double field222
223: list<byte> field223
224: set<string> field224
225: map<float, bool> field225
226: i64 field226
227: string field227
228: list<double> field228
229: i64 field229
230: byte field230
}
struct Struct28 {
1: set<string> field1
2: set<Struct7> field2
3: list<Struct11> field3
4: i64 field4
5: Struct3 field5
6: binary field6
7: list<set<binary>> field7
8: byte field8
9: binary field9
10: i64 field10
11: map<set<Struct14>, i16> field11
12: i64 field12
13: list<byte> field13
14: list<float> field14
15: list<i32> field15
16: bool field16
17: i32 field17
18: float field18
19: i16 field19
20: i16 field20
21: set<i16> field21
22: Struct21 field22
23: set<i32> field23
24: Struct3 field24
25: i64 field25
26: binary field26
27: list<i64> field27
28: Struct0 field28
29: Struct2 field29
30: list<i16> field30
31: byte field31
32: i64 field32
33: i32 field33
34: i64 field34
35: Struct1 field35
36: double field36
37: Struct11 field37
38: double field38
39: set<i16> field39
40: Struct6 field40
41: i32 field41
42: i64 field42
43: float field43
44: Struct10 field44
45: list<double> field45
46: double field46
47: Struct11 field47
48: float field48
49: map<i64, i32> field49
50: Struct6 field50
51: binary field51
52: bool field52
53: byte field53
54: i16 field54
55: list<double> field55
56: Struct23 field56
57: set<i64> field57
58: float field58
59: map<list<float>, i32> field59
60: bool field60
61: binary field61
62: list<i64> field62
63: byte field63
64: i32 field64
65: byte field65
66: float field66
67: byte field67
68: i64 field68
69: map<bool, byte> field69
70: set<i64> field70
71: double field71
72: set<double> field72
73: map<byte, map<list<double>, i16>> field73
74: byte field74
75: map<Struct13, bool> field75
76: list<list<i32>> field76
77: binary field77
78: map<bool, set<set<i16>>> field78
79: map<bool, binary> field79
80: set<i16> field80
81: binary field81
82: list<list<binary>> field82
83: binary field83
84: list<i64> field84
85: i16 field85
86: binary field86
87: i64 field87
88: set<map<binary, bool>> field88
89: string field89
90: float field90
91: byte field91
92: string field92
93: map<Struct20, i32> field93
94: float field94
95: string field95
96: byte field96
97: bool field97
98: double field98
99: set<Struct12> field99
100: map<set<set<binary>>, float> field100
101: binary field101
102: byte field102
103: string field103
104: Struct13 field104
105: string field105
106: Struct5 field106
107: map<i32, map<i16, double>> field107
108: string field108
109: i32 field109
110: Struct7 field110
111: Struct9 field111
112: Struct12 field112
113: set<i16> field113
114: float field114
115: float field115
116: Struct12 field116
117: set<set<byte>> field117
118: Struct1 field118
119: bool field119
120: binary field120
121: Struct12 field121
122: Struct3 field122
123: set<i32> field123
124: binary field124
125: double field125
126: double field126
127: map<list<i64>, bool> field127
128: Struct25 field128
129: Struct4 field129
130: string field130
131: bool field131
132: set<binary> field132
133: i32 field133
134: map<string, map<i64, i16>> field134
135: list<binary> field135
136: double field136
137: byte field137
138: byte field138
139: set<i16> field139
140: byte field140
141: map<byte, byte> field141
142: bool field142
143: bool field143
144: string field144
145: i32 field145
146: set<Struct18> field146
147: i16 field147
148: bool field148
149: i32 field149
150: map<byte, string> field150
151: map<binary, bool> field151
152: float field152
153: set<i64> field153
154: double field154
155: list<binary> field155
}
|
KERNAL_PRINTCHR EQU $e716
KERNAL_GETIN EQU $ffe4
INPUT_MAXCHARS EQU $06
RESERVED_STACK_POINTER DC.B 0
; setup default mem layout for xprom runtime environment
STDLIB_MEMSETUP SUBROUTINE
lda #$36
sta $01
rts
; print null-terminated petscii string
STDLIB_PRINT SUBROUTINE
sta $6f ; store string start low byte
sty $70 ; store string start high byte
ldy #$00 ; set length to 0
.1:
lda ($6f),y ; get byte from string
beq .2 ; exit loop if null byte [EOS]
jsr KERNAL_PRINTCHR
iny
bne .1
.2:
rts
; convert byte type decimal petscii
STDLIB_BYTE_TO_PETSCII SUBROUTINE
ldy #$2f
ldx #$3a
sec
.1: iny
sbc #100
bcs .1
.2: dex
adc #10
bmi .2
adc #$2f
rts
; print byte type as decimal
STDLIB_PRINT_BYTE SUBROUTINE
jsr STDLIB_BYTE_TO_PETSCII
pha
tya
cmp #$30
beq .skip
jsr KERNAL_PRINTCHR
.skip
txa
cmp #$30
beq .skip2
jsr KERNAL_PRINTCHR
.skip2
pla
jsr KERNAL_PRINTCHR
rts
; opcode for print byte as decimal
MAC stdlib_printb
pla
jsr STDLIB_PRINT_BYTE
ENDM
; print word as petscii decimal
STDLIB_PRINT_WORD SUBROUTINE
lda #<.tt
sta $6f ; store dividend_ptr_lb
lda #>.tt
sta $70 ; store dividend_ptr_hb
lda #$00
sta reserved6 ; has a non-zero char been printed?
lda reserved2+1
bpl .skip1
; negate number and print "-"
twoscomplement reserved2
lda #$2d
jsr KERNAL_PRINTCHR
.skip1
ldy #$00
.loop:
lda ($6f),y
sta reserved0
iny
lda ($6f),y
sta reserved0+1
tya
pha
jsr NUCL_DIVU16
lda reserved2
ora reserved6
beq .skip
inc reserved6
lda reserved2
jsr STDLIB_PRINT_BYTE
.skip:
pla
tay
iny
cpy #$08
beq .end
lda reserved4
sta reserved2
lda reserved4+1
sta reserved2+1
jmp .loop
.end:
lda reserved4
clc
adc #$30
jsr KERNAL_PRINTCHR
rts
.tt DC.W #10000
.ot DC.W #1000
.oh DC.W #100
.tn DC.W #10
; opcode for print word as decimal
MAC stdlib_printw
pla
sta reserved2+1
pla
sta reserved2
jsr STDLIB_PRINT_WORD
ENDM
MAC stdlib_putstr
pla
tay
pla
jsr STDLIB_PRINT
ENDM
MAC stdlib_putchar
pla
jsr KERNAL_PRINTCHR
ENDM
STDLIB_INPUT SUBROUTINE
.init:
ldx #INPUT_MAXCHARS
lda #$00
.loop:
sta input_str,x
dex
bpl .loop
lda #$00
sta input_counter
lda #62
jsr KERNAL_PRINTCHR
.again:
lda #228
jsr KERNAL_PRINTCHR
.input:
jsr KERNAL_GETIN
beq .input
cmp #$14
beq .input_delete
cmp #$0d
beq .input_done
ldx input_counter
cpx #INPUT_MAXCHARS
beq .input
jmp .input_filter
.reg:
inc input_counter
ldx input_counter
dex
sta input_str,x
.output:
pha
lda #20
jsr KERNAL_PRINTCHR
pla
jsr KERNAL_PRINTCHR
jmp .again
.input_delete:
pha
lda input_counter
bne .skip
pla
jmp .input
.skip:
pla
dec input_counter
jmp .output
.input_filter:
cmp #$2d
beq .minus
cmp #$3a
bcc .ok1
jmp .input
.ok1:
cmp #$30
bcs .ok2
jmp .input
.ok2:
jmp .reg
.minus:
ldx input_counter
bne *+5
jmp .reg
jmp .input
.input_done:
lda #20
jsr KERNAL_PRINTCHR
lda input_counter
jsr STDLIB_STRVAL
lda input_err
beq .input_success
jmp .init
.input_success:
rts
input_counter DC.B $00
input_str HEX 00 00 00 00 00 00 00
input_val HEX 00 00
input_err HEX 00
STDLIB_STRVAL SUBROUTINE
tax
beq .error
lda #$00
sta .digit_counter
sta input_err
lda input_str-1,x
cmp #$2d
beq .error
sec
sbc #$30
sta reserved0
lda #$00
sta reserved1
sta reserved2
sta reserved3
.loop:
inc .digit_counter
dex
beq .done
lda input_str-1,x
cmp #$2d
beq .minus
sec
sbc #$30
sta reserved2
lda #$00
sta reserved3
jsr .mult
clc
lda reserved2
adc reserved0
sta reserved0
lda reserved3
adc reserved1
sta reserved1
jmp .loop
.done:
rts
.minus
lda reserved0
pha
lda reserved1
pha
negw
pla
sta reserved1
pla
sta reserved0
rts
.error
lda #<.redo
ldy #>.redo
jsr STDLIB_PRINT
inc input_err
rts
.mult
ldy .digit_counter
.mult10
clc
rol reserved2 ; x2
rol reserved2+1
lda reserved2 ; save to temp
sta reserved4
lda reserved2+1
sta reserved4+1
clc
rol reserved2 ; x2
rol reserved2+1
clc
rol reserved2 ; x2
rol reserved2+1
clc
lda reserved4
adc reserved2
sta reserved2
lda reserved4+1
adc reserved2+1
sta reserved2+1
dey
bne .mult10
rts
.digit_counter HEX 00
.redo HEX 0d 52 45 44 4F 00
MAC input
jsr STDLIB_INPUT
lda reserved0
pha
lda reserved1
pha
lda #13
jsr KERNAL_PRINTCHR
ENDM |
if application "Sonos" is not running then
tell application "Sonos" to activate
tell application "System Events"
repeat until visible of process "Sonos" is true
delay 0.1
end repeat
delay 1 -- After app becomes visible, wait for it to render its buttons
end tell
end if
tell application "System Events"
tell process "Sonos"
set value of slider 1 of window 1 to get (value of slider 1 of window 1) + 2
end tell
end tell
|
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain`call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract eMax is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 2000000000 * 10**6 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'EthereumMax';
string private _symbol = 'eMax';
uint8 private _decimals = 18;
uint256 public _maxTxAmount = 20000000 * 10**6 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _tTotal.mul(maxTxPercent).div(
10**2
);
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
} |
::
:: Copyright (c) 2008-2017 the Urho3D project.
::
:: Permission is hereby granted, free of charge, to any person obtaining a copy
:: of this software and associated documentation files (the "Software"), to deal
:: in the Software without restriction, including without limitation the rights
:: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
:: copies of the Software, and to permit persons to whom the Software is
:: furnished to do so, subject to the following conditions:
::
:: The above copyright notice and this permission notice shall be included in
:: all copies or substantial portions of the Software.
::
:: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
:: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
:: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
:: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
:: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
:: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
:: THE SOFTWARE.
::
@"%~dp0cmake_generic.bat" %* -G "Ninja"
|
/-
Copyright (c) 2017 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
-/
prelude
import init.data.fin.basic init.data.fin.ops
|
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<head>
<title><xsl:value-of select="billStatus/bill/canonicalname"/></title>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"/>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
<style>
body {
background-color: rgba(201, 76, 76,.4);
}
</style>
</head>
<body>
<div class="container">
<div class="row">
<div class="col-xs-12">
<h1 id="title"><xsl:value-of select="billStatus/bill/canonicalname"/></h1>
</div>
</div>
<div class="row">
<div class="col-xs-6">
<p><h3>Bill Text</h3></p>
<p class="billtext"><xsl:value-of select="billStatus/bill/billText"/></p>
</div>
<div class="col-xs-6">
<h2 text-align="center">Bill History and Summary</h2>
<p><h3>History</h3></p><div><xsl:value-of select="billStatus/bill/summaries/history"/></div>
<p><h3>Summary</h3></p><div><xsl:value-of select="billStatus/bill/summaries/summary"/></div>
</div>
</div>
<hr/>
<div class="row">
<div class="col-xs-12">
<p><h2>Misc. Bill Info</h2></p>
<p> Introduced Date: <span text-align="right" class="introduceddate"> <xsl:value-of select="billStatus/bill/introducedDate"/></span></p>
<p>Legislation number: <xsl:value-of select="billStatus/bill/canonicalname"/></p>
<p><a>
<xsl:attribute name="href">
<xsl:value-of select="billStatus/bill/canonicalname"></xsl:value-of>
<xsl:text>.pdf</xsl:text>
</xsl:attribute>
PDF link
</a></p>
<br></br>
<h3>Sponsors and Authors</h3>
<div class="sponsors"></div>
<h3>Actions</h3>
<div class="actions"></div>
</div>
</div>
</div>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
|
-- This droplet processes folders dropped onto the applet
on open these_items
repeat with i from 1 to the count of these_items
set this_item to item i of these_items
set the item_info to info for this_item
if (alias of the item_info is false) and (folder of the item_info is true) then
process_item(this_item)
end if
end repeat
end open
-- this sub-routine processes folders
on process_item(this_item)
-- NOTE that the variable this_item is a folder reference in alias format
-- FOLDER PROCESSING STATEMENTS GOES HERE
end process_item |
#!/bin/csh
#
# DART software - Copyright UCAR. This open source software is provided
# by UCAR, "as is", without charge, subject to all terms of use at
# http://www.image.ucar.edu/DAReS/DART/DART_download
# diagnostics_obs.csh - shell script that computes observation
# specific diagnostics.
#
# $1 - analysis date
# $2 - parameter file
#
# created Aug. 2009 Ryan Torn, U. Albany
set datea = ${1}
set paramfile = ${2}
source $paramfile
cd $OBS_DIAG_DIR
${COPY} ${TEMPLATE_DIR}/input.nml.template input.nml
set gdate = (`echo $datea 0 -g | ${DART_DIR}/models/wrf/work/advance_time`)
set yyyy2 = `echo $datea | cut -b1-4`
set mm2 = `echo $datea | cut -b5-6`
set dd2 = `echo $datea | cut -b7-8`
set hh2 = `echo $datea | cut -b9-10`
# Determine appropriate dates for observation diagnostics
@ nhours = $OBS_VERIF_DAYS * 24
set datef = `echo $datea -${nhours} | ${DART_DIR}/models/wrf/work/advance_time`
set yyyy1 = `echo $datef | cut -b1-4`
set mm1 = `echo $datef | cut -b5-6`
set dd1 = `echo $datef | cut -b7-8`
set hh1 = `echo $datef | cut -b9-10`
@ half_bin = $ASSIM_INT_HOURS / 2
set datefbs = `echo $datef -${half_bin} | ${DART_DIR}/models/wrf/work/advance_time`
set fbs_yyyy1 = `echo $datefbs | cut -b1-4`
set fbs_mm1 = `echo $datefbs | cut -b5-6`
set fbs_dd1 = `echo $datefbs | cut -b7-8`
set fbs_hh1 = `echo $datefbs | cut -b9-10`
set datefbe = `echo $datef ${half_bin} | ${DART_DIR}/models/wrf/work/advance_time`
set fbe_yyyy1 = `echo $datefbe | cut -b1-4`
set fbe_mm1 = `echo $datefbe | cut -b5-6`
set fbe_dd1 = `echo $datefbe | cut -b7-8`
set fbe_hh1 = `echo $datefbe | cut -b9-10`
set datelbe = `echo $datea ${half_bin} | ${DART_DIR}/models/wrf/work/advance_time`
set lbe_yyyy1 = `echo $datelbe | cut -b1-4`
set lbe_mm1 = `echo $datelbe | cut -b5-6`
set lbe_dd1 = `echo $datelbe | cut -b7-8`
set lbe_hh1 = `echo $datelbe | cut -b9-10`
while ( $datef <= $datea )
if ( -e ${OUTPUT_DIR}/${datef}/obs_seq.final ) ${LINK} ${OUTPUT_DIR}/${datef}/obs_seq.final obs_seq.final_${datef}
set datef = `echo $datef $ASSIM_INT_HOURS | ${DART_DIR}/models/wrf/work/advance_time`
end
ls -1 obs_seq.final_* >! flist
cat >! script.sed << EOF
/obs_sequence_name/c\
obs_sequence_name = '',
/obs_sequence_list/c\
obs_sequence_list = 'flist',
/first_bin_center/c\
first_bin_center = ${yyyy1}, ${mm1}, ${dd1}, ${hh1}, 0, 0,
/last_bin_center/c\
last_bin_center = ${yyyy2}, ${mm2}, ${dd2}, ${hh2}, 0, 0,
/filename_seq /c\
filename_seq = 'obs_seq.final',
/filename_seq_list/c\
filename_seq_list = '',
/filename_out/c\
filename_out = 'obs_seq.final_reduced',
/first_obs_days/c\
first_obs_days = -1,
/first_obs_seconds/c\
first_obs_seconds = -1,
/last_obs_days/c\
last_obs_days = -1,
/last_obs_seconds/c\
last_obs_seconds = -1,
/edit_copies/c\
edit_copies = .true.,
/new_copy_index/c\
new_copy_index = 1, 2, 3, 4, 5,
/first_bin_start/c\
first_bin_start = ${fbs_yyyy1}, ${fbs_mm1}, ${fbs_dd1}, ${fbs_hh1}, 0, 0,
/first_bin_end/c\
first_bin_end = ${fbe_yyyy1}, ${fbe_mm1}, ${fbe_dd1}, ${fbe_hh1}, 0, 0,
/last_bin_end/c\
last_bin_end = ${lbe_yyyy1}, ${lbe_mm1}, ${lbe_dd1}, ${lbe_hh1}, 0, 0,
EOF
sed -f script.sed ${TEMPLATE_DIR}/input.nml.template >! input.nml
# create the state-space diagnostic summary
${DART_DIR}/models/wrf/work/obs_diag || exit 1
${MOVE} obs_diag_output.nc ${OUTPUT_DIR}/${datea}/.
${MOVE} `ls -1 observation_locations.*.dat | tail -1` ${OUTPUT_DIR}/${datea}/observation_locations.dat
# create a netCDF file with the original observation data (may not have some of the unusual metadata)
${DART_DIR}/models/wrf/work/obs_seq_to_netcdf
${MOVE} obs_epoch* ${OUTPUT_DIR}/${datea}/
${REMOVE} *.txt obs_seq.final_* flist observation_locations.*.dat
# prune the obs_seq.final and store result keeps first 5 copies? why not set num_output_obs = 0
# is it the time subsetting that is of interest?
${LINK} ${OUTPUT_DIR}/${datea}/obs_seq.final .
${DART_DIR}/models/wrf/work/obs_sequence_tool
${MOVE} obs_seq.final_reduced ${OUTPUT_DIR}/${datea}/.
${REMOVE} obs_seq.final
# process the mean analysis increment
cd ${OUTPUT_DIR}/${datea}
${COPY} ${SHELL_SCRIPTS_DIR}/mean_increment.ncl .
echo "ncl ${OUTPUT_DIR}/${datea}/mean_increment.ncl" >! nclrun.out
chmod +x nclrun.out
./nclrun.out
touch ${OUTPUT_DIR}/${datea}/obs_diags_done
exit 0
|
unit CustomAction.FileMaker.FM7DevPath;
interface
uses
SysUtils,
Classes,
routines_msi,
Msi,
MsiDefs, CustomAction.FileMaker ,
MsiQuery;
function FM7DevPath(hInstall: MSIHANDLE): UINT; stdcall;
function FM7DevBinPath(hInstall: MSIHANDLE): UINT; stdcall;
implementation
uses
Youseful.exceptions,CustomAction.Logging;
function FM7DevBinPath(hInstall: MSIHANDLE): UINT; stdcall;
var
Rtn :integer;
begin
msiLog(hInstall, 'FM7DevBinPath Entered');
result := GetFMBinPath(hInstall,'FMPRO70DEV','FM70DEVBIN');
msiLog(hInstall, 'FM7DevBinPath Entered');
end;
function FM7DevPath(hInstall: MSIHANDLE): UINT; stdcall;
var
Rtn :integer;
begin
msiLog(hInstall, 'FM7DevPath Entered');
result := GetFMPath(hInstall,'FMPRO70DEV','FM70DEVEXT');
msiLog(hInstall, 'FM7DevPath Entered');
end;
end.
|
open main
pred idk2ffMRLWGotQAmtZo_prop20 {
always all f : File | f in Trash since f not in Protected
}
pred __repair { idk2ffMRLWGotQAmtZo_prop20 }
check __repair { idk2ffMRLWGotQAmtZo_prop20 <=> prop20o } |
using MetacommunityDynamics
using DynamicGrids
using Plots
using Distributions
# Spatially explicit levins model
rs = SpatiallyExplicitLevinsColonization{:O}(probability=0.3) +
AbioticExtinction{:O}(:A, baseprobability=0.1);
pops = pointstogrid(generate(PoissonProcess, 20), gridsize=100)
areas = generate(StaticEnvironmentalLayer, similar(pops), Exponential(3), mask=pops)
areas = rand(5,5)
initocc = rand(Occupancy, 0.8, 5,5)
arrayout = ArrayOutput((O=initocc, A=areas ), tspan=1:3)
sim!(arrayout, rs)
|
%% @author Lee Barney
%% @copyright 2021 Lee Barney licensed under the <a>
%% rel="license"
%% href="http://creativecommons.org/licenses/by/4.0/"
%% target="_blank">
%% Creative Commons Attribution 4.0 International License</a>
%%
%%
%% These solutions are not intended to be ideal solutions. Instead,
%% they are solutions that you can compare against yours to see
%% other options and to come up with even better solutions.
%%
-module(exercise).
-export([run/0]).
run()->
Initial = trie:add("Dani",dict:new()),
io:format("found: ~p~n",[trie:lookup("Dani",Initial)]),
io:format("found: ~p~n",[trie:lookup("Daniel",Initial)]),
Three_names = trie:add("Daniel",trie:add("Daniella",Initial)),
io:format("found: ~p~n",[trie:lookup("Dani",Three_names)]),
io:format("found: ~p~n",[trie:lookup("Daniel",Three_names)]),
io:format("found: ~p~n",[trie:lookup("Daniella",Three_names)]),
Four_names = trie:add("Lee",Three_names),
io:format("found: ~p~n",[trie:lookup("Dani",Four_names)]),
io:format("found: ~p~n",[trie:lookup("Daniel",Four_names)]),
io:format("found: ~p~n",[trie:lookup("Daniella",Four_names)]),
io:format("found: ~p~n",[trie:lookup("Lee",Four_names)]),
io:format("found: ~p~n",[trie:lookup("Sue",Four_names)]).
|
\hypertarget{dir_04ed82fa347894d51633089936838d70}{}\doxysection{examples/003-\/json-\/call Directory Reference}
\label{dir_04ed82fa347894d51633089936838d70}\index{examples/003-\/json-\/call Directory Reference@{examples/003-\/json-\/call Directory Reference}}
\doxysubsection*{Files}
\begin{DoxyCompactItemize}
\item
file \mbox{\hyperlink{003-json-call_2main_8cpp}{main.\+cpp}}
\item
file \mbox{\hyperlink{003-json-call_2t1_8cpp}{t1.\+cpp}}
\item
file \mbox{\hyperlink{003-json-call_2t2_8cpp}{t2.\+cpp}}
\item
file \mbox{\hyperlink{003-json-call_2t3_8cpp}{t3.\+cpp}}
\item
file \mbox{\hyperlink{003-json-call_2t4_8cpp}{t4.\+cpp}}
\item
file \mbox{\hyperlink{t4_8h}{t4.\+h}}
\item
file \mbox{\hyperlink{003-json-call_2t5_8cpp}{t5.\+cpp}}
\item
file \mbox{\hyperlink{t5_8h}{t5.\+h}}
\item
file \mbox{\hyperlink{t6_8cpp}{t6.\+cpp}}
\item
file \mbox{\hyperlink{003-json-call_2test_8h}{test.\+h}}
\end{DoxyCompactItemize}
|
onerror {resume}
quietly WaveActivateNextPane {} 0
add wave -noupdate /prueba_snbits/A
add wave -noupdate /prueba_snbits/B
add wave -noupdate /prueba_snbits/cen
add wave -noupdate /prueba_snbits/SUM
add wave -noupdate /prueba_snbits/SUMref
add wave -noupdate /prueba_snbits/csal
add wave -noupdate /prueba_snbits/csalref
TreeUpdate [SetDefaultTree]
WaveRestoreCursors {{Cursor 1} {0 ps} 0}
quietly wave cursor active 0
configure wave -namecolwidth 184
configure wave -valuecolwidth 100
configure wave -justifyvalue left
configure wave -signalnamewidth 0
configure wave -snapdistance 10
configure wave -datasetprefix 0
configure wave -rowmargin 4
configure wave -childrowmargin 2
configure wave -gridoffset 40000
configure wave -gridperiod 80000
configure wave -griddelta 40
configure wave -timeline 0
configure wave -timelineunits ns
update
WaveRestoreZoom {0 ps} {1653758 ps}
|
<?php
include'config/connect.php';
if (isset($_POST['update'])) {
$nis = $_POST['nis'];
$nama = $_POST['nama'];
$kelas = $_POST['kelas'];
$tahun = $_POST['tahun'];
$que = mysqli_query($koneksi,"UPDATE imports SET nama='$nama',id_kelass='$kelas',tahun_ajaran='$tahun' WHERE nis='$nis'") or die(mysql_error());
if ($que) {
echo "<script>alert('Data Berhasil Di Update')</script>";
echo "<meta http-equiv='refresh' content='1 url=data_siswa.php'>";
} else {
echo "<script>alert('Gagal Di Update')</script>";
echo '<script>window.history.back()</script>';
# code...
}
# code...
}else{
echo '<script>window.history.back()</script>';
}
?> |
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
grammar OracleStatement;
import DMLStatement, TCLStatement, DCLStatement, StoreProcedure;
execute
: (select
| insert
| update
| delete
| createTable
| alterTable
| dropTable
| truncateTable
| createIndex
| dropIndex
| alterIndex
| commit
| rollback
| setTransaction
| savepoint
| grant
| revoke
| createUser
| dropUser
| alterUser
| createRole
| dropRole
| alterRole
| setRole
| call
| merge
| alterSynonym
| alterSession
| alterDatabase
| alterSystem
| setConstraints
| analyze
| associateStatistics
| disassociateStatistics
| audit
| noAudit
| comment
| flashbackDatabase
| flashbackTable
| purge
| rename
| createDatabase
| createDatabaseLink
| createDimension
| alterDimension
| dropDimension
| createFunction
) SEMI_?
;
|
%% coding: latin-1
%%------------------------------------------------------------
%%
%% Erlang header file
%%
%% Target: CosTransactions_Coordinator
%% Source: /net/isildur/ldisk/daily_build/19_prebuild_master-opu_o.2016-06-21_20/otp_src_19/lib/cosTransactions/src/CosTransactions.idl
%% IC vsn: 4.4.1
%%
%% This file is automatically generated. DO NOT EDIT IT.
%%
%%------------------------------------------------------------
-ifndef(COSTRANSACTIONS_COORDINATOR_HRL).
-define(COSTRANSACTIONS_COORDINATOR_HRL, true).
-endif.
|
' Visual Basic .NET Document
Option Strict On
' <Snippet1>
Imports System.Text.RegularExpressions
Module RegexSplit
Public Sub Main()
Dim regex As Regex = New Regex("-") ' Split on hyphens.
Dim substrings() As String = regex.Split("plum--pear")
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
End Sub
End Module
' The example displays the following output:
' 'plum'
' ''
' 'pear'
' </Snippet1>
|
> {-# OPTIONS_HADDOCK show-extensions #-}
> {-|
> Module : LTK.Learn.TSL
> Copyright : (c) 2020 Dakotah Lambert
> License : MIT
> A learner for tier-based strictly local stringsets.
> Different types are available via LTK.Learn.TSL.*,
> and this module selects a reasonable default.
>
> @since 0.3
> -}
> module LTK.Learn.TSL(module LTK.Learn.TSL.ViaSL) where
> import LTK.Learn.TSL.ViaSL
|
package Slim::Utils::Light;
# $Id: $
# Logitech Media Server Copyright 2001-2011 Logitech.
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License,
# version 2.
# This module provides some functions compatible with functions
# from the core Logitech Media Server code, without their overhead.
# These functions are called by helper applications like SqueezeTray
# or the control panel.
use Exporter::Lite;
@ISA = qw(Exporter);
use Config;
use FindBin qw($Bin);
use File::Spec::Functions qw(catfile catdir);
our @EXPORT = qw(string getPref);
my ($os, $language, %strings, $stringsLoaded);
BEGIN {
my @SlimINC = ();
# NB: The user may be on a platform who's perl reports a
# different x86 version than we've supplied - but it may work
# anyways.
my $arch = $Config::Config{'archname'};
$arch =~ s/^i[3456]86-/i386-/;
$arch =~ s/gnu-//;
my $perlmajorversion = $Config{'version'};
$perlmajorversion =~ s/\.\d+$//;
my $libPath = $Bin;
use Slim::Utils::OSDetect;
Slim::Utils::OSDetect::init();
if (my $libs = Slim::Utils::OSDetect::dirsFor('libpath')) {
# On Debian, RH and SUSE, our CPAN directory is located in the same dir as strings.txt
$libPath = $libs;
};
@SlimINC = (
catdir($libPath,'CPAN','arch',$perlmajorversion, $arch),
catdir($libPath,'CPAN','arch',$perlmajorversion, $arch, 'auto'),
catdir($libPath,'CPAN','arch',$Config{'version'}, $Config::Config{'archname'}),
catdir($libPath,'CPAN','arch',$Config{'version'}, $Config::Config{'archname'}, 'auto'),
catdir($libPath,'CPAN','arch',$perlmajorversion, $Config::Config{'archname'}),
catdir($libPath,'CPAN','arch',$perlmajorversion, $Config::Config{'archname'}, 'auto'),
catdir($libPath,'CPAN','arch',$Config::Config{'archname'}),
catdir($libPath,'lib'),
catdir($libPath,'CPAN'),
$libPath,
);
# This works like 'use lib'
# prepend our directories to @INC so we look there first.
unshift @INC, @SlimINC;
$os = Slim::Utils::OSDetect->getOS();
}
my ($serverPrefFile, $versionFile);
# return localised version of string token
sub string {
my $name = shift;
loadStrings() unless $stringsLoaded;
$language ||= getPref('language') || $os->getSystemLanguage();
my $lang = shift || $language;
my $string = $strings{ $name }->{ $lang } || $strings{ $name }->{ $language } || $strings{ $name }->{'EN'} || $name;
if ( @_ ) {
$string = sprintf( $string, @_ );
}
return $string;
}
sub loadStrings {
my $string = '';
my $language = '';
my $stringname = '';
# server string file
my $file;
# let's see whether this is a PerlApp/Tray compiled executable
if (defined $PerlApp::VERSION) {
$file = PerlApp::extract_bound_file('strings.txt');
}
elsif (defined $PerlTray::VERSION) {
$file = PerlTray::extract_bound_file('strings.txt');
}
# try to find the strings.txt file from our installation
unless ($file && -f $file) {
my $path = $os->dirsFor('strings');
$file = catdir($path, 'strings.txt');
}
open(STRINGS, "<:utf8", $file) || do {
warn "Couldn't open file [$file]!";
return;
};
foreach my $line (<STRINGS>) {
chomp($line);
next if $line =~ /^#/;
next if $line !~ /\S/;
if ($line =~ /^(\S+)$/) {
$stringname = $1;
$string = '';
next;
} elsif ($line =~ /^\t(\S*)\t(.+)$/) {
$language = uc($1);
$string = $2;
$strings{$stringname}->{$language} = $string;
}
}
close STRINGS;
$stringsLoaded = 1;
}
sub setString {
my ($stringname, $string) = @_;
loadStrings() unless $stringsLoaded;
$language ||= getPref('language') || $os->getSystemLanguage();
$strings{$stringname}->{$language} = $string;
}
# Read pref from the server preference file - lighter weight than loading YAML
# don't call this too often, it's in no way optimized for speed
sub getPref {
my $pref = shift;
my $prefFile = shift;
if ($prefFile) {
$prefFile = catdir($os->dirsFor('prefs'), 'plugin', $prefFile);
}
else {
$serverPrefFile ||= catfile( scalar($os->dirsFor('prefs')), 'server.prefs' );
$prefFile = $serverPrefFile;
}
require YAML::XS;
my $prefs = eval { YAML::XS::LoadFile($prefFile) };
my $ret;
if (!$@) {
$ret = $prefs->{$pref};
}
# if (-r $prefFile) {
#
# if (open(PREF, $prefFile)) {
#
# local $_;
# while (<PREF>) {
#
# # read YAML (server) and old style prefs (installer)
# if (/^$pref(:| \=)? (.+)$/) {
# $ret = $2;
# $ret =~ s/^['"]//;
# $ret =~ s/['"\s]*$//s;
# last;
# }
# }
#
# close(PREF);
# }
# }
return $ret;
}
sub checkForUpdate {
$versionFile ||= catfile( scalar($os->dirsFor('updates')), 'server.version' );
open(UPDATEFLAG, $versionFile) || return '';
my $installer = '';
local $_;
while ( <UPDATEFLAG> ) {
chomp;
if (/(?:LogitechMediaServer|Squeezebox|SqueezeCenter).*/i) {
$installer = $_;
last;
}
}
close UPDATEFLAG;
return $installer if ($installer && -r $installer);
}
sub resetUpdateCheck {
unlink $versionFile if $versionFile && -r $versionFile;
}
1;
|
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* 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.
*/
namespace cpp2 test_cpp2.cpp_reflection
struct dep_B_struct {
1: i32 i_b
}
|
/- Basic pi congruence -/
import logic.connectives logic.quantifiers
namespace pi_congr1
constants (p1 q1 p2 q2 p3 q3 : Prop) (H1 : p1 ↔ q1) (H2 : p2 ↔ q2) (H3 : p3 ↔ q3)
attribute forall_congr [congr]
attribute imp_congr [congr]
attribute H1 [simp]
attribute H2 [simp]
attribute H3 [simp]
#simplify iff env 1 p1 -- Broken?
#simplify iff env 1 p1 → p2
#simplify iff env 1 p1 → p2 → p3
end pi_congr1
namespace pi_congr2
universe l
constants (T : Type.{l}) (P Q : T → Prop) (H : ∀ (x : T), P x ↔ Q x)
attribute forall_congr [congr]
attribute H [simp]
constant (x : T)
#simplify iff env 1 (∀ (x : T), P x)
end pi_congr2
|
@article{ISI:000408747900002,
article-number = {384003},
author = {Giavazzi, Fabio and Malinverno, Chiara and Corallino, Salvatore and
Ginelli, Francesco and Scita, Giorgio and Cerbino, Roberto},
doi = {10.1088/1361-6463/aa7f8e},
eissn = {1361-6463},
issn = {0022-3727},
journal = {JOURNAL OF PHYSICS D-APPLIED PHYSICS},
month = {SEP 27},
number = {38},
orcid-numbers = {Cerbino, Roberto/0000-0003-0434-7741
Giavazzi, Fabio/0000-0003-4930-0592},
researcherid-numbers = {Cerbino, Roberto/A-2286-2008
Giavazzi, Fabio/C-3054-2017},
times-cited = {14},
title = {Giant fluctuations and structural effects in a flocking epithelium},
unique-id = {ISI:000408747900002},
volume = {50},
year = {2017}
}
|
PREFIX hpc: <https://github.com/HPC-FAIR/HPC-Ontology#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
CONSTRUCT {
?URI a hpc:DecisionTreeNode;
hpc:hasIDType ?IDTypestr;
hpc:name ?namestr;
hpc:alternateName ?alternateNamestr;
hpc:description ?descriptionstr;
hpc:url ?URLuri;
hpc:license ?Licensestr;
hpc:submitter ?submitteruri;
hpc:submitDate ?SubmitDatedatetime;
hpc:DecisionTree ?decisiontreestr;;
hpc:treeNodeLevel ?levelint;
hpc:decisionFeature ?featurestr;
hpc:relationOp ?relationOpstr;
hpc:relationValue ?relationValuefloat;
hpc:hasChildNode ?hasChildbool;
hpc:trueNode ?trueNodeurl;
hpc:falseNode ?falseNodeuri;
hpc:decisionLabel ?labelstr;
}
FROM <file:data.csv>
WHERE {
BIND (URI(CONCAT('http://example.org/decisiontreenode/', STR(CONCAT($DecisionTree,STR(?NodeID))))) AS ?URI)
BIND (xsd:string(?IDType) AS ?IDTypestr)
BIND (xsd:string(?name) AS ?namestr)
BIND (xsd:string(?alternateName) AS ?alternateNamestr)
BIND (xsd:string(?description) AS ?descriptionstr)
BIND (xsd:anyURI(?URL) AS ?URLuri)
BIND (xsd:string(?License) AS ?Licensestr)
BIND (URI(CONCAT('http://example.org/person/', STR(?submitter))) AS ?submitteruri)
BIND (xsd:dateTime(?SubmitDate) AS ?SubmitDatedatetime)
BIND (xsd:string(?DecisionTree) AS ?decisiontreestr)
BIND (xsd:integer(?level) AS ?levelint)
BIND (xsd:string(?feature) AS ?featurestr)
BIND (xsd:string(?relationOp) AS ?relationOpstr)
BIND (xsd:float(?relationValue) AS ?relationValuefloat)
BIND (xsd:integer(?hasChild) AS ?hasChildint)
BIND (xsd:boolean(IF(?hasChildint = 1, TRUE,FALSE)) AS ?hasChildbool)
BIND (URI(CONCAT('http://example.org/decisiontreenode/', STR(CONCAT($DecisionTree,?trueNode)))) AS ?trueNodeurl)
BIND (URI(CONCAT('http://example.org/decisiontreenode/', STR(CONCAT($DecisionTree,?falseNode)))) AS ?falseNodeuri)
BIND (xsd:string(?label) AS ?labelstr)
}
|
# Copyright (C) 2020 The Project U-Ray Authors.
#
# Use of this source code is governed by a ISC-style
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/ISC
#
# SPDX-License-Identifier: ISC
source "$::env(URAY_DIR)/utils/utils.tcl"
create_project -force -part $::env(URAY_PART) design design
read_verilog top.v
synth_design -top top
set_property BITSTREAM.GENERAL.PERFRAMECRC YES [current_design]
set_property IS_ENABLED 0 [get_drc_checks {REQP-79}]
set_property IS_ENABLED 0 [get_drc_checks {NSTD-1}]
set_property IS_ENABLED 0 [get_drc_checks {UCIO-1}]
place_design -directive Quick
route_design -directive Quick
write_checkpoint -force design.dcp
write_bitstream -force design.bit
|
package fi.riissanen.gwent.game;
import fi.riissanen.gwent.game.cards.UnitCard;
import fi.riissanen.gwent.game.combat.Unit;
import fi.riissanen.gwent.game.combat.UnitType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
/**
*
* @author Daniel
*/
public class TestGameSystem {
private final Gwent game = new Gwent();
@Rule
public final ExpectedException exception = ExpectedException.none();
@Before
public void before() {
game.initialize();
game.getGameSystem().initialize(new Player(game, true), new Player(game, false));
}
@Test
public void testPlayCardInvalidRow() {
Unit unit = new Unit("", "");
unit.setUnitType(UnitType.MELEE);
unit.setBaseStrength(1);
game.getGameSystem().stageCard(new UnitCard(unit));
game.getGameSystem().getStateSystem().update();
exception.expect(IllegalStateException.class);
game.getGameSystem().playCard(-1);
}
@Test
public void testPlayCardNotStaged() {
game.getGameSystem().unstageCard();
assertFalse(game.getGameSystem().playCard(0));
}
@Test
public void testPlayCardStaged() {
Unit unit = new Unit("", "");
unit.setUnitType(UnitType.MELEE);
unit.setBaseStrength(1);
game.getGameSystem().stageCard(new UnitCard(unit));
game.getGameSystem().getStateSystem().update();
assertTrue(game.getGameSystem().playCard(UnitType.MELEE.getIndex()));
}
}
|
//Address: 0x828539d6d54ac9b3d427113e878ae8357d1f928a
//Contract name: BAIRON
//Balance: 0 Ether
//Verification Date: 6/8/2018
//Transacion Count: 165
// CODE STARTS HERE
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract BAIRON {
// Public variables of the token
string public name = "Bairon";
string public symbol = "BARN";
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default
uint256 public totalSupply;
uint256 public BaironSupply = 3000000000;
uint256 public buyPrice = 300000;
address public creator;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function BAIRON() public {
totalSupply = BaironSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give BaironCoin Mint the total created tokens
creator = msg.sender;
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Buy tokens from contract by sending ether
function () payable internal {
uint amount = msg.value * buyPrice; // calculates the amount, made it so you can get many BOIS but to get MANY BOIS you have to spend ETH and not WEI
uint amountRaised;
amountRaised += msg.value; //many thanks bois, couldnt do it without r/me_irl
require(balanceOf[creator] >= amount); // checks if it has enough to sell
require(msg.value <= 10**17); // so any person who wants to put more then 0.1 ETH has time to think about what they are doing
balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
balanceOf[creator] -= amount; // sends ETH to BaironCoinMint
Transfer(creator, msg.sender, amount); // execute an event reflecting the change
creator.transfer(amountRaised);
}
}
|
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 0
Size of downloaded dataset files:
368 MB
Size of the auto-converted Parquet files:
368 MB
Number of rows:
205,173