					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:purple}Legendary {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:cry_exotic}Exotic {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:crp_mythic}Mythic {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:crp_exomythic}ExoMythic {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Better Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:crp_2exomythic4me}2ExoMythic4me {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_better_better_better_better_better_better_better_better_better_top-up_tag"] = {
				name = "Better Better Better Better Better Better Better Better Better Better Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:crp_22exomythic4mecipe}22ExoMythic4meCipe {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_best_top-up_tag"] = {
				name = "Best Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:crp_exomythicepicawesomeuncommon2mexotic22exomythic4mecipe}ExoMythicEpicAwesomeUncommon2MExotic22ExoMythic4meCipe {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_:3_top-up_tag"] = {
				name = ":3 Top-up Tag",
				text = {
					"Create up to {C:attention}#1#",
					"{C:HEX(ff00ff)}:3{} {C:attention}Joker#<s>1#",
					"{C:inactive}(Must have room)"
				}
			},
			["tag_crp_candy_top-up_tag"] = {


15
-- iCommandViewAWACSTargetZChanged	2129
-- iCommandViewAWACSChangeROE	2133
-- iCommandPlaneRightMFD_OSB12_Off	1018
-- iCommandPlaneADIAHRIllumination	813
-- iCommandPlaneLaunchPermissionOverride	349
-- iCommandPlane_VHF_AM_01MHz_Inc	1500
-- iCommandPlane_R_828_Channel_next	622
-- iCommandPlane_ILS_MHz_Increase	1440
-- iCommandPlaneCMSP_OSB_2	1325
-- iCommandPlayerCntrl	56
-- iCommandPlaneNav_Cancel	477
-- iCommandPlaneLeftMFD_OSB9	650
-- iCommandPlaneNavLights_CodeModeOff	520
-- iCommandPowerOnOff	315
-- iCommandElectricalPowerInverterOFF	1075
-- iCommandPlaneSelecterVerticalAbs	2034
-- iCommandPlaneRightMFD_OSB9_Off	1015
-- iCommandPlane_R_800_4th_wheel_up	613
-- iCommandViewMirage	11
-- iCommandPlaneDLK_SendMemory	454
-- iCommandPlane_VHF_FM_025MHz_Inc	1480
-- iCommandPlane_ADF_Homer_change	580
-- iCommandPlane_Peak_Vol_Decrease	1457
-- iCommandViewUpLeft	208
-- iCommandPlaneLeftMFD_OSB14	655
-- iCommandPlaneChangeLock	100
-- iCommandViewForwardStop	291
-- iCommandSelecterStop	230
-- iCommandPlaneCDU_Y	1278
-- iCommandActiveJamming	136
-- iCommandViewFastKeyboard	331
-- iCommandHelicopter_PPR_button_K	590
-- iCommandPlaneCDU_PNT	1252
-- iCommandPlaneCDU_3	1244
-- iCommandPlaneShipTakeOff	120
-- iCommandPlaneCDU_MINUS	1294
-- iCommandPlaneNavChangePanelModeLeft	456
-- iCommandPlaneNav_PB8	467
-- iCommand_VMS_ALMAZ_UP_Repeat	915
-- iCommandPlaneUHF10MhzSelectorDec	1206
-- iCommandPlaneIntercomILSDecrease	1179
-- iCommandViewDownRightSlow	211
-- iCommand_CPT_MECH_VMG_HYDRO_EKRAN_Cover	891
-- iCommandPlaneFeedbackTrimmer	2035
-- iCommandViewSnapView5	401
-- iCommandEjectingSystemPower1	730
-- iCommandPlane_HOTAS_MIC_SwitchRight	575
-- iCommandPlaneRightMFD_OSB6_Off	1012
-- iCommandPlaneCDU_FA	1286
-- iCommandPlane_I251_Brightness_Up	842
-- iCommandPlane_ABRIS_BT_1	496
-- iCommandPlaneFormationLightsDecrease	1359
-- iCommandHelicopter_CollectiveStopper_Up	856
-- iCommandCockpitTakeControl	248
-- iCommandADI_ZeroPitchTrimLeft	771
-- iCommandViewAWACSDistanceX1	2070
-- iCommandLandDetailsDecrease	138
-- iCommand_FireDetectorsTest1stGroup	954
-- iCommand_FireExting_ExtinguishersToDown	925
-- iCommandPlane_VHF_AM_Mode_EMERFM	1483
-- iCommandRecordCursorOnOff	307
-- iCommandLeftEngineFuelValveShutOff	722
-- iCommandPlaneCircuitBreaker_25	1139
-- defaultDeviceAssignmentFor	function: 000000002A965060
-- iCommandMainHydraulics	736
-- external_profile	function: 000000002B0FD1E0
-- iCommandKeyMaximum	2150
-- iCommandHelicopter_Rotor_Anti_Icing_System	818
-- filename	./Config/Input/Aircrafts/Default/keyboard/default.lua
-- iCommandHeadingMethodSwitch	745
-- folder


ngth
                //
                // move from [length..old_head] to [0..new_head]
                //
                // semantically equivalent to memmove()
                ptr::copy(buf_ptr.offset(length as isize), buf_ptr, self.head);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io;

    #[test]
    fn produce_consume_byte_buffer() {
        let raw = "hello, world!".as_bytes();
        let mut byte_buffer = ByteBuffer::new(64);

        let mut cursor = io::Cursor::new(raw);
        byte_buffer.read_from(&mut cursor).unwrap();
        assert_eq!("hello, world!".as_bytes(), byte_buffer.peek());

        byte_buffer.consume(7);
        assert_eq!("world!".as_bytes(), byte_buffer.peek());

        let mut cursor = io::Cursor::new(&raw[..5]);
        byte_buffer.read_from(&mut cursor).unwrap();
        assert_eq!("world!hello".as_bytes(), byte_buffer.peek());
    }
}
<filename>src/delegation_rules.rs
// use rify::Entity::{Bound, Unbound};

// After considering several options, I chose option 3.
// Option 1:
// if   a? rdf:type dock:SubjectUnbound
// and  b? rdf:type dock:Mentioned
// then a? dock:allowsSubject b?
//
// if   a? rdf:type dock:PredicateUnbound
// and  b? rdf:type dock:Mentioned
// then a? dock:allowsPredicate b?
//
// if   a? rdf:type dock:ObjectUnbound
// and  b? rdf:type dock:Mentioned
// then a? dock:allowsObject b?
//
// if   a? b? c?
// then a? rdf:type dock:Mentioned
// and  b? rdf:type dock:Mentioned
// and  c? rdf:type dock:Mentioned

// Option 2:
// if   a?   dock:claims           [s? p? o?]
// and  pol? { rdf:type dock:SubjectUnbound   } OR { dock:allowsSubject   s? }
// and  pol? { rdf:type dock:PredicateUnbound } OR { dock:allowsPredicate p? }
// and  pol? { rdf:type dock:ObjectUnbound    } OR { dock:allowsObject    o? }
// and  a?   dock:mayClaim         pol?
// then s? p? o?

// Option 3
// if   ?a dock:claims [rdf:subject ?s ; rdf:predicate ?p ; rdf:object ?o]
// and  ?a dock:mayClaim [
//     dock:allowSubjects   { [ rdfs:member ?s ] } OR { dock:Anything } ;
//     dock:allowPredicates { [ rdfs:member ?p ] } OR { dock:Anything } ;
//     dock:allowObjects    { [ rdfs:member ?o ] } OR { dock:Anything } ;
// ]
// then ?s ?p ?o

// Option 4:
// Maybe this is not the best course. Predicates with domain and range often entail the types of
// their subjects/objects. This may interact in unexpected ways with some policies.
// if   ?a dock:claims [rdf:subject ?s ; rdf:predicate ?p ; rdf:object ?o]
// and  ?a dock:mayClaim [
//     dock:allowSubjects   ?st ;
//     dock:allowPredicates ?pt ;
//     dock:allowObjects    ?ot ;
// ]
// and  ?s rdf:type ?st
// and  ?p rdf:type ?pt
// and  ?o rdf:type ?ot
// then ?s ?p ?o

// pub fn rules() -> Vec<[Vec<[rify::Entity<&'static str, RdfNode>; 3]>; 2]> {
//     vec![
//         [
//             vec![
//                 [
//                     Unbound("a"),
//                     Bound(Iri("https://dock.io/rdf/alpha/claims".to_string())),
//                     Unbound("c"),
//                 ],
//                 [
//                     Unbound("c"),
//                     Bound(Iri(
//                         "http://www.w3.org/1999/02/22-rdf-syntax


, -16]!
	mov	x3, x2
	mov	w2, w1
	mov	w1, w0
	add	x29, sp, 0
	mov	w0, 16
	bl	ftl_read
	ldp	x29, x30, [sp], 16
	ret
	.size	ftl_vendor_read, .-ftl_vendor_read
	.align	2
	.global	FlashBootVendorRead
	.type	FlashBootVendorRead, %function
FlashBootVendorRead:
	stp	x29, x30, [sp, -48]!
	add	x29, sp, 0
	stp	x19, x20, [sp, 16]
	mov	w19, w0
	str	x21, [sp, 32]
	mov	w20, w1
	mov	x21, x2
	bl	rknand_device_lock
	adrp	x0, .LANCHOR1+504
	ldr	w0, [x0, #:lo12:.LANCHOR1+504]
	cmp	w0, 1
	bne	.L3231
	mov	w0, w19
	mov	x2, x21
	mov	w1, w20
	bl	ftl_vendor_read
	mov	w19, w0
.L3230:
	bl	rknand_device_unlock
	ldr	x21, [sp, 32]
	mov	w0, w19
	ldp	x19, x20, [sp, 16]
	ldp	x29, x30, [sp], 48
	ret
.L3231:
	mov	w19, -1
	b	.L3230
	.size	FlashBootVendorRead, .-FlashBootVendorRead
	.align	2
	.global	ftl_sys_read
	.type	ftl_sys_read, %function
ftl_sys_read:
	stp	x29, x30, [sp, -16]!
	mov	x3, x2
	mov	w2, w1
	add	w1, w0, 256
	add	x29, sp, 0
	mov	w0, 16
	bl	ftl_read
	ldp	x29, x30, [sp], 16
	ret
	.size	ftl_sys_read, .-ftl_sys_read
	.align	2
	.global	StorageSysDataLoad
	.type	StorageSysDataLoad, %function
StorageSysDataLoad:
	stp	x29, x30, [sp, -32]!
	mov	w2, 512
	add	x29, sp, 0
	stp	x19, x20, [sp, 16]
	mov	x19, x1
	mov	w1, 0
	mov	w20, w0
	mov	x0, x19
	bl	ftl_memset
	bl	rknand_device_lock
	mov	x2, x19
	mov	w1, 1
	mov	w0, w20
	bl	ftl_sys_read
	mov	w19, w0
	bl	rknand_device_unlock
	mov	w0, w19
	ldp	x19, x20, [sp, 16]
	ldp	x29, x30, [sp], 32
	ret
	.size	StorageSysDataLoad, .-StorageSysDataLoad
	.align	2
	.global	FtlRead
	.type	FtlRead, %function
FtlRead:
	stp	x29, x30, [sp, -16]!
	and	w0, w0,


-shadow-colored:0 25px 50px -12px var(--tw-shadow-color)}.shadow-lg{--tw-shadow:0 10px 15px -3px #0000001a,0 4px 6px -4px #0000001a;--tw-shadow-colored:0 10px 15px -3px var(--tw-shadow-color),0 4px 6px -4px var(--tw-shadow-color)}.shadow-lg,.shadow-md{box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.shadow-md{--tw-shadow:0 4px 6px -1px #0000001a,0 2px 4px -2px #0000001a;--tw-shadow-colored:0 4px 6px -1px var(--tw-shadow-color),0 2px 4px -2px var(--tw-shadow-color)}.blur{--tw-blur:blur(8px)}.blur,.invert{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.invert{--tw-invert:invert(100%)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,-webkit-backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter,-webkit-backdrop-filter;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-1000{transition-duration:1s}.duration-300{transition-duration:.3s}.duration-500{transition-duration:.5s}.ease-in-out{transition-timing-function:cubic-bezier(.4,0,.2,1)}@media (min-width:640px){.sm\:btn-sm{height:2rem;min-height:2rem;padding-left:.75rem;padding-right:.75rem;font-size:.875rem}.btn-square:where(.sm\:btn-sm){height:2rem;width:2rem;padding:0}.btn-circle:where(.sm\:btn-sm){height:2rem;width:2rem;border-radius:9999px;padding:0}}.hover\:-translate-y-2:hover{--tw-translate-y:-0.5rem}.hover\:-translate-y-2:hover,.hover\:scale-105:hover{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-


PathElement_StringKey); ok {
			return x.StringKey
		}
	}
	return ""
}

type isFieldPathElement_Subscript interface {
	isFieldPathElement_Subscript()
}

type FieldPathElement_Index struct {
	// `index` specifies a 0-based index into a repeated field.
	Index uint64 `protobuf:"varint,6,opt,name=index,oneof"`
}

type FieldPathElement_BoolKey struct {
	// `bool_key` specifies a map key of type bool.
	BoolKey bool `protobuf:"varint,7,opt,name=bool_key,json=boolKey,oneof"`
}

type FieldPathElement_IntKey struct {
	// `int_key` specifies a map key of type int32, int64, sint32, sint64, sfixed32 or sfixed64.
	IntKey int64 `protobuf:"varint,8,opt,name=int_key,json=intKey,oneof"`
}

type FieldPathElement_UintKey struct {
	// `uint_key` specifies a map key of type uint32, uint64, fixed32 or fixed64.
	UintKey uint64 `protobuf:"varint,9,opt,name=uint_key,json=uintKey,oneof"`
}

type FieldPathElement_StringKey struct {
	// `string_key` specifies a map key of type string.
	StringKey string `protobuf:"bytes,10,opt,name=string_key,json=stringKey,oneof"`
}

func (*FieldPathElement_Index) isFieldPathElement_Subscript() {}

func (*FieldPathElement_BoolKey) isFieldPathElement_Subscript() {}

func (*FieldPathElement_IntKey) isFieldPathElement_Subscript() {}

func (*FieldPathElement_UintKey) isFieldPathElement_Subscript() {}

func (*FieldPathElement_StringKey) isFieldPathElement_Subscript() {}

var file_buf_validate_validate_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
		ExtensionType: (*MessageRules)(nil),
		Field:         1159,
		Name:          "buf.validate.message",
		Tag:           "bytes,1159,opt,name=message",
		Filename:      "buf/validate/validate.proto",
	},
	{
		ExtendedType:  (*descriptorpb.OneofOptions)(nil),
		ExtensionType: (*OneofRules)(nil),
		Field:         1159,
		Name:          "buf.validate.oneof",
		Tag:           "bytes,1159,opt,name=oneof",
		Filename:      "buf/validate/validate.proto",
	},
	{
		ExtendedType:  (*descriptorpb.FieldOptions)(nil),
		ExtensionType: (*FieldRules)(nil),
		Field:         1159,
		Name:          "buf.validate.field",
		Tag:           "bytes,1159,opt,name=field",
		Filename:      "buf/validate/validate.proto",
	},
	{
		ExtendedType:  (*descriptorpb.FieldOptions)(nil),
		ExtensionType: (*PredefinedRules)(nil),
		Field:         1160,
		Name:          "buf.validate.predefined",
		Tag:           "bytes,1160,opt,name=predefined",
		Filename:      "buf/validate/validate.proto",
	},
}

// Extension fields to descriptorpb.MessageOptions.
var (
	// Rules specify the validations to be performed on this message. By default,
	// no validation is perfo


rs are produced!
        }

        // Tell runtime system how many input items we consumed on each input stream.
        consume_each (consumed_items);
        // Tell runtime system how many output items we produced.
        return nout;
    }

    // method contains steps to produce output with all necessary steps! Does not create any new variables etc.
    void
    pss_symbol_selector_cvc_impl::produce_output(gr_complex *&out, const gr_complex *in, long abs_pos, int &nout)
    {
        memcpy(out,in+d_cpl,sizeof(gr_complex)*d_fftl); //copy samples to output buffer!

        // pss_calc needs the exact position of first sample in stream
        add_item_tag(0,nitems_written(0)+nout,d_key, pmt::from_long( abs_pos ),d_tag_id);
        nout++; // 1 output vector produced
        out+=d_fftl; //move pointer to output buffer by the size of one vector
    }

  } /* namespace lte */
} /* namespace gr */

/* -*- c++ -*- */
/*
 * Copyright 2010,2013 Communications Engineering Lab, KIT
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pad_vector_impl.h"
#include <gnuradio/io_signature.h>
#include <cstring>

namespace gr {
namespace specest {

pad_vector::sptr pad_vector::make(size_t item_size, unsigned vlen_in, unsigned vlen_out)
{
    return gnuradio::get_initial_sptr(new pad_vector_impl(item_size, vlen_in, vlen_out));
}

pad_vector_impl::pad_vector_impl(size_t item_size, unsigned vlen_in, unsigned vlen_out)
    : gr::sync_block("pad_vector",
                     gr::io_signature::make(1, 1, vlen_in * item_size),
                     gr::io_signature::make(1, 1, vlen_out * item_size))
{
    if (item_size, vlen_in < vlen_out) {
        d_copylen = vlen_in * item_size;
        d_padlen = (vlen_out - vlen_in) * item_size;
    } else {
        d_copylen = vlen_out * item_size;
        d_padlen = 0;
    }
}

pad_vector_impl::~pad_vector_impl() {}

int pad_vector_impl::work(int noutput_items,
                          gr_vector_const_void_star& input_items,
                          gr_vector_void_star& output_items)
{
    const char* in = (const char*)input_items[0];
    char* out = (char*)output_items[0];

    for (int i = 0; i < noutput_items; i++) {
        memcpy(out, in, d_copylen);
        memset(out + d_copylen, 0, d_padlen);
        in += d_copylen;
        out += d_copylen + d


words = [
    'python', 'programming', 'computer', 'algorithm', 'database',
    'network', 'software', 'hardware', 'internet', 'developer',
    'coding', 'debugging', 'testing', 'deployment', 'version',
    'control', 'repository', 'function', 'variable', 'class'
]


, v\nhash = Secp256k1::Util.sha256 \"Henlo, Wordl\"\npubl = Secp256k1::Point.new \"0416008a369439f1a8a75cf974860bed5b10180518d6b1dd3ac847f423fd375d6aa29474394f0cd79d2ea543507d069e97339284f01bdbfd27392daec0ec553816\"\nctx.verify sig, hash, publ\n# => true\n```\n\nThere are example scripts for generating `Bitcoin` and `Ethereum` accounts in `src/bitcoin.cr` and `src/ethereum.cr`.\n\n# Documentation\n\nThe full library documentation can be found here: [q9f.github.io/secp256k1.cr](https://q9f.github.io/secp256k1.cr/)\n\nGenerate a local copy with:\n\n```shell\ncrystal docs\n```\n\n# Testing\n\nThe library is entirely specified through tests in `./spec`; run:\n\n```shell\ncrystal spec --verbose\n```\n\n# Understand\n\nPrivate keys are just scalars (`Secp256k1::Num`) and public keys are points (`Secp256k1::Point`) with `x` and `y` coordinates.\n\nBitcoin public keys can be uncompressed `p|x|y` or compressed `p|x`. both come with a prefix `p` which is useless for uncompressed keys but necessary for compressed keys to recover the `y` coordinate on the `Secp256k1` elliptic curve field.\n\nEthereum public keys are uncompressed `x|y` without any prefix. The last 20 bytes slice of the `y` coordinate is actually used as address without any checksum. A checksum was later added in EIP-55 using a `keccak256` hash and indicating character capitalization.\n\nNeither Bitcoin nor Ethereum allow for recovering public keys from an address unless there exists a transaction with a valid signature on the blockchain.\n\n# Known issues\n\n_Note: this library should not be used in production without proper auditing. It should be considered slow and insecure._\n\n* This library is not constant time and might be subject to side-channel attacks. ([#4](https://github.com/q9f/secp256k1.cr/issues/4))\n* This library does unnecessary big-integer math and should someday rather correctly implement the `Secp256k1` prime field ([#5](https://github.com/q9f/secp256k1.cr/issues/5))\n* This library is slow in recovering signatures. Future versions should respect the recovery ID to quickly identify the correct public key from a signature.\n\nFound any other issue? Report it: [github.com/q9f/secp256k1.cr/issues](https://github.com/q9f/secp256k1.cr/issues)\n\n# Contribute\n\nCreate a pull request, and make sure tests and linter pass.\n\nThis pure crystal implementation is based on the python implementation [wobine/blackboard101](https://github.com/wobine/blackboard101) which is also used as reference to write tests against. It's a complete rewrite of the abandoned [packetzero/bitcoinutils](https://github.com/packetzero/bitcoinutils) for educational purposes.\n\nHonerable mention for the [bitcoin wiki](https://en.bitcoin.it/wiki/Main_Page) and the [ethereum stackexchange](https://ethereum.stackexchange.com/) for providing so many in-depth resources that supported this project in reimplementing everything.\n\nLicense: Apache License v2.0\n\nContributors: [**@q9f**](https://github.com/q9f/), [@cserb](https://github.com/cserb), [MrSorcus](https://github.com/MrSorcus)\n","program":{"html_id":"secp256k1/toplevel","path":"toplevel.html","kind":"module","full_name":"Top Lev


LEFTTRIM, "left-trim", NodeTypesOption.KEYWORD),
  LENGTH(Proparse.LENGTH, "length", NodeTypesOption.KEYWORD),
  LIBRARY(Proparse.LIBRARY, "library", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LIKE(Proparse.LIKE, "like", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LIKESEQUENTIAL(Proparse.LIKESEQUENTIAL, "like-sequential", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LINECOUNTER(Proparse.LINECOUNTER, "line-counter", 10, NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LISTEVENTS(Proparse.LISTEVENTS, "list-events", NodeTypesOption.KEYWORD),
  LISTING(Proparse.LISTING, "listing", 5, NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LISTITEMPAIRS(Proparse.LISTITEMPAIRS, "list-item-pairs", NodeTypesOption.KEYWORD),
  LISTITEMS(Proparse.LISTITEMS, "list-items", NodeTypesOption.KEYWORD),
  LISTQUERYATTRS(Proparse.LISTQUERYATTRS, "list-query-attrs", NodeTypesOption.KEYWORD),
  LISTSETATTRS(Proparse.LISTSETATTRS, "list-set-attrs", NodeTypesOption.KEYWORD),
  LISTWIDGETS(Proparse.LISTWIDGETS, "list-widgets", NodeTypesOption.KEYWORD),
  LITTLEENDIAN(Proparse.LITTLEENDIAN, "little-endian", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LOAD(Proparse.LOAD, "load", NodeTypesOption.KEYWORD),
  LOADMOUSEPOINTER(Proparse.LOADMOUSEPOINTER, "load-mouse-pointer", 12, NodeTypesOption.KEYWORD),
  LOADPICTURE(Proparse.LOADPICTURE, "load-picture", NodeTypesOption.KEYWORD),
  LOBDIR(Proparse.LOBDIR, "lob-dir", NodeTypesOption.KEYWORD),
  LOCKED(Proparse.LOCKED, "locked", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LOG(Proparse.LOG, "log", NodeTypesOption.KEYWORD),
  LOGICAL(Proparse.LOGICAL, "logical", NodeTypesOption.KEYWORD),
  LOGMANAGER(Proparse.LOGMANAGER, "log-manager", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LONG(Proparse.LONG, "long", NodeTypesOption.KEYWORD),
  LONGCHAR(Proparse.LONGCHAR, "longchar", 6, NodeTypesOption.KEYWORD),
  LOOKAHEAD(Proparse.LOOKAHEAD, "lookahead", NodeTypesOption.KEYWORD),
  LOOKUP(Proparse.LOOKUP, "lookup", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  LTHAN(Proparse.LTHAN, "lt", NodeTypesOption.KEYWORD),

  // M
  MACHINECLASS(Proparse.MACHINECLASS, "machine-class", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  MAP(Proparse.MAP, "map", NodeTypesOption.KEYWORD, NodeTypesOption.RESERVED),
  MARGINEXTRA(Proparse.MARGINEXTRA, "margin-extra", NodeTypesOption.KEYWORD),
  MARGINHEIGHTCHARS(Proparse.MARGINHEIGHTCHARS, "margin-height-chars", 15, NodeTypesOption.KEYWORD),
  MARGINHEIGHTPIXELS(Proparse.MARGINHEIGHTPIXELS, "margin-height-pixels", 15, NodeTypesOption.KEYWORD),
  MARGINWIDTHCHARS(Proparse.MARGINWIDTHCHARS, "margin-width-chars", 14, NodeTypesOption.KEYWORD),
  MARGINWIDTHPIXELS(Proparse.MARGINWIDTHPIXELS, "margin-width-pixels", 14, NodeTypesOption.KEYWORD),


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*                  This file is part of the class library                   */
/*       SoPlex --- the Sequential object-oriented simPlex.                  */
/*                                                                           */
/*    Copyright (C) 1996-2018 Konrad-Zuse-Zentrum                            */
/*                            fuer Informationstechnik Berlin                */
/*                                                                           */
/*  SoPlex is distributed under the terms of the ZIB Academic Licence.       */
/*                                                                           */
/*  You should have received a copy of the ZIB Academic License              */
/*  along with SoPlex; see the file COPYING. If not email to soplex@zib.de.  */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/**@file  wallclocktimer.h
 * @brief WallclockTimer class.
 */

#ifndef _WALLCLOCK_TIMER_H_
#define _WALLCLOCK_TIMER_H_

#include "spxdefines.h"
#include "timer.h"

namespace soplex
{

class WallclockTimer : public Timer
{
private:

   //------------------------------------
   /**@name Data */
   //@{
   mutable long sec;           ///< seconds
   mutable long usec;          ///< microseconds

   mutable Real lasttime;
   //@}

   //------------------------------------
   /**@name Internal helpers */
   //@{
   /// convert wallclock time to secounds.
   Real wall2sec(long s, long us) const
   {
      return (Real)s+ 0.000001 * (Real)us;
   }

   //@}

public:

   //------------------------------------
   /**@name Construction / destruction */
   //@{
   /// default constructor
   WallclockTimer()
      : Timer(), sec(0), usec(0), lasttime(0.0)
   {}
   /// copy constructor
   WallclockTimer(const WallclockTimer& old)
      : Timer(), sec(old.sec), usec(old.usec), lasttime(old.lasttime)
   {}
   /// assignment operator
   WallclockTimer& operator=(const WallclockTimer& old)
   {
      sec = old.sec;
      usec = old.usec;
      lasttime = old.lasttime;
      return *this;
   }

   virtual ~WallclockTimer()
   {}
   //@}

   //------------------------------------
   /**@name Control */
   //@{
   /// initialize timer, set timing accounts to zero.
   virtual void reset()
   {
      status   = RESET;
      sec = usec = 0;
      lasttime = 0.0;
   }

   /// start timer, resume accounting user, system and real time.
   virtual void start();

   /// stop timer, return accounted user time.
   virtual Real stop();

   /// return type of timer
   virtual TYPE type()
   {
      return WALLCLOCK_TIME;
   }
   //@}

   //------------------------------------
   /**@name Access */
   //@{
   virtual Real time() const;

   virtual Real lastTime() const;

   //@}
};
} // namespace soplex
#endif // _WALLCLOCK_TIMER_H_


& React.RefAttributes<T>
  > {}
// Create Sharpie class
// We should know about each sharpie their color (which should be a string),
// width (which will be a floating point number), inkAmount (another floating point number)
// When creating one, we need to specify the color and the width
// Every sharpie is created with a default 100 as inkAmount
// We can use() the sharpie objects
// which decreases inkAmount

'use strict'

class Sharpie {
  color: string;
  witdh: number;
  inkAmount: number;

  constructor(color: string, width: number) {
    this.color = color;
    this.witdh = width;
    this.inkAmount = 100;
  }

  // use method - depends on how much hours are the sharpies used
  use(hoursOfUse: number) {
    this.inkAmount -= (1 * hoursOfUse);
  }
}

let sharpieBig = new Sharpie('purple', 2.5);

console.log(sharpieBig);
sharpieBig.use(10);
console.log(sharpieBig);
export { };
let price: number;
let price2 = 9.95;
let name = 'John';

let counter: number = 0;
let x: number = 100,
    y: number = 200;
let bin = 0b100;
console.log(bin);
let anotherBin: number = 0B010;
console.log(anotherBin);
let octal: number = 0o10;
console.log(octal);
let hexadecimal: number = 0XA;
console.log(hexadecimal);
let big: bigint = 9007199254740991n;
console.log(big);declare namespace org {
    namespace bukkit {
        namespace event {
            namespace player {
                // @ts-ignore
                 class PlayerEditBookEvent extends org.bukkit.event.player.PlayerEvent implements org.bukkit.event.Cancellable {
                    constructor(who: org.bukkit.entity.Player, slot: number, previousBookMeta: org.bukkit.inventory.meta.BookMeta, newBookMeta: org.bukkit.inventory.meta.BookMeta, isSigning: boolean)
                    /**
                     * Gets the book meta currently on the book.
                     *

                     * Note: this is a copy of the book meta. You cannot use this object to
                     * change the existing book meta.
                     */
                    public getPreviousBookMeta(): org.bukkit.inventory.meta.BookMeta;
                    /**
                     * Gets the book meta that the player is attempting to add to the book.
                     *

                     * Note: this is a copy of the proposed new book meta. Use {@link
                     * #setNewBookMeta(BookMeta)} to change what will actually be added to the
                     * book.
                     */
                    public getNewBookMeta(): org.bukkit.inventory.meta.BookMeta;
                    /**
                     * Gets the inventory slot number for the book item that triggered this
                     * event.
                     *

                     * This is a slot number on the player's hotbar in the range 0-8, or -1 for
                     * off hand.
                     */
                    public getSlot(): number;
                    /**
                     * Sets the book meta that will actually be added to the book.
                     */
                    public setNewBookMeta(newBookMeta: org.bukkit.inventory.meta.BookMeta): void;
                    /**
                     * Gets whether or not the book is being signed. If a book is signed the
                     * Material changes from BOOK_AND_QUILL to WRITT


1be7 293a66dd0dc8d145 0dc7ff7337bfe115 bf058ef2eb9bed09 cee85c26963a5bcc 0905dc2df7cc6a76 "))
        sha384_tests.append(TestCase("00"*112,112,"3e0cbf3aee0e3aa7 0415beae1bd12dd7 db821efa446440f1 2132edffce76f635 e53526a111491e75 ee8e27b9700eec20 "))
        sha384_tests.append(TestCase("55"*1005,1005,"1bb8e256da4a0d1e 87453528254f223b 4cb7e49c4420dbfa 766bba4adba44eec a392ff6a9f565bc3 47158cc970ce44ec "))

        for test in sha384_tests:
            test.runTest(self, sha384, 384)

    def test_sha512(self):
        '''
        This method tests the implementation of sha 512 against known hash values
        '''

        print("Testing SHA 512 Against Known Input \nFrom https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA2_Additional.pdf")
        sha512_tests = []
        sha512_tests.append(TestCase("",0,"cf83e1357eefb8bd f1542850d66d8007 d620e4050b5715dc 83f4a921d36ce9ce 47d0d13c5d85f2b0 ff8318d2877eec2f 63b931bd47417a81 a538327af927da3e"))
        sha512_tests.append(TestCase("00"*111,111,"77ddd3a542e530fd 047b8977c657ba6c e72f1492e360b2b2 212cd264e75ec038 82e4ff0525517ab4 207d14c70c2259ba 88d4d335ee0e7e20 543d22102ab1788c"))
        sha512_tests.append(TestCase("00"*112,112,"2be2e788c8a8adea a9c89a7f78904cac ea6e39297d75e057 3a73c756234534d6 627ab4156b48a665 7b29ab8beb733340 40ad39ead81446bb 09c70704ec707952"))
        sha512_tests.append(TestCase("55"*1005,1005,"59f5e54fe299c6a8 764c6b199e44924a 37f59e2b56c3ebad 939b7289210dc8e4 c21b9720165b0f4d 4374c90f1bf4fb4a 5ace17a116179801 5052893a48c3d161"))

        for test in sha512_tests:
            test.runTest(self, sha512, 512)

if __name__ == '__main__':
    unittest.main()


[10769] = {"散播敌意......",nil, {"伪装成伊利达雷血精灵，杀死5个疯狂的巨人，然后向影月谷内影月村的奥巴洛恩大王复命，并将库卡隆信号枪一并交还给他。"}},
[10770] = {"灰烬中的小鬼",nil, {"古树莫斯伍德要求你杀死8只灼烧小鬼，然后回去向他复命。"}},
[10771] = {"灰烬中的新生",nil, {"古树莫斯伍德要求你前往焦火荒野，将铁根种子植入那里三堆不同的肥沃的火山灰中，然后回到卢安荒野向他复命。"}},
[10772] = {"征服之路",nil, {"前往影月谷的征服之路。在你对那里的局势做出初步判断后，使用蛮锤信号枪召唤来一名蛮锤狮鹫骑士。nn如果你不慎丢失了蛮锤信号枪，可以问影月谷内蛮锤要塞的大领主尤雷加尔另要一支。"}},
[10773] = {"扫清道路",nil, {"杀死20名日蚀士兵、10名日蚀骑兵和5个考罗克之子，然后使用蛮锤信号枪召唤一名蛮锤狮鹫，告诉他你已经完成了任务。nn如果你不慎丢失了蛮锤信号枪，可以向影月谷内蛮锤要塞的大领主尤雷加尔另要一支。"}},
[10774] = {"血精灵 + 巨人 = ？？",nil, {"杀死特派使者莉芙·血叶和强大的考罗克，夺得伊利丹的命令。完成任务后使用蛮锤信号枪召唤来一名蛮锤狮鹫骑士。nn如果你不慎丢失了蛮锤信号枪，可以问影月谷内蛮锤要塞的大领主尤雷加尔再要一支。"}},
[10775] = {"伊利达雷徽章",nil, {"收集10件伊利达雷徽章。"}},
[10776] = {"散播敌意……",nil, {"伪装成伊利丹的手下，杀死5个疯狂的巨人，然后向影月谷内蛮锤要塞的大领主尤雷加尔复命，并将蛮锤信号枪一并交还给他。"}},
[10777] = {"阿斯迦的图腾",nil, {"将斯克瑟隆作战图腾交给熔岩平原的帕沙恩。"}},
[10778] = {"莉安丝魔棒",nil, {"从日蚀岗哨的血精灵身上夺得莉安丝的钥匙，用它打开莉安丝的保


ctx context.Context, name string, opts metav1.DeleteOptions) error {
	_, err := c.Fake.
		Invokes(testing.NewDeleteActionWithOptions(alertmanagersResource, c.ns, name, opts), &v1.Alertmanager{})

	return err
}

// DeleteCollection deletes a collection of objects.
func (c *FakeAlertmanagers) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error {
	action := testing.NewDeleteCollectionActionWithOptions(alertmanagersResource, c.ns, opts, listOpts)

	_, err := c.Fake.Invokes(action, &v1.AlertmanagerList{})
	return err
}

// Patch applies the patch and returns the patched alertmanager.
func (c *FakeAlertmanagers) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.Alertmanager, err error) {
	emptyResult := &v1.Alertmanager{}
	obj, err := c.Fake.
		Invokes(testing.NewPatchSubresourceActionWithOptions(alertmanagersResource, c.ns, name, pt, data, opts, subresources...), emptyResult)

	if obj == nil {
		return emptyResult, err
	}
	return obj.(*v1.Alertmanager), err
}

// GetScale takes name of the alertmanager, and returns the corresponding scale object, and an error if there is any.
func (c *FakeAlertmanagers) GetScale(ctx context.Context, alertmanagerName string, options metav1.GetOptions) (result *autoscalingv1.Scale, err error) {
	emptyResult := &autoscalingv1.Scale{}
	obj, err := c.Fake.
		Invokes(testing.NewGetSubresourceActionWithOptions(alertmanagersResource, c.ns, "scale", alertmanagerName, options), emptyResult)

	if obj == nil {
		return emptyResult, err
	}
	return obj.(*autoscalingv1.Scale), err
}

// UpdateScale takes the representation of a scale and updates it. Returns the server's representation of the scale, and an error, if there is any.
func (c *FakeAlertmanagers) UpdateScale(ctx context.Context, alertmanagerName string, scale *autoscalingv1.Scale, opts metav1.UpdateOptions) (result *autoscalingv1.Scale, err error) {
	emptyResult := &autoscalingv1.Scale{}
	obj, err := c.Fake.
		Invokes(testing.NewUpdateSubresourceActionWithOptions(alertmanagersResource, "scale", c.ns, scale, opts), &autoscalingv1.Scale{})

	if obj == nil {
		return emptyResult, err
	}
	return obj.(*autoscalingv1.Scale), err
}
/*
This file is part of the KubeVirt project

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.

Copyright The KubeVirt Authors.
*/

// Code generated by client-gen. DO NOT EDIT.

package v1beta1

import (
	"context"

	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	gentype "k8s.io/client-go/gentype"
	scheme "kubevirt.io/client-go/containerizeddataimporter/scheme"
	v1beta1 "kubevirt.io/containerized-data-importer-api/pkg/apis/core/v1beta1


>>> {
        return json.decodeFromString(s) ?: emptyMap()
    }

    @TypeConverter
    fun fromMapList(tags: Map<String, List<Map<String, String>>>): String {
        return json.encodeToString(tags) ?: ""
    }
}package com.github.jing332.database.dao

import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Transaction
import androidx.room.Update
import com.github.jing332.database.entities.AbstractListGroup.Companion.DEFAULT_GROUP_ID
import com.github.jing332.database.entities.replace.GroupWithReplaceRule
import com.github.jing332.database.entities.replace.ReplaceRule
import com.github.jing332.database.entities.replace.ReplaceRuleGroup
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.conflate
import kotlinx.coroutines.flow.map
import kotlin.math.min

@Dao
interface ReplaceRuleDao {
    @get:Query("SELECT * FROM ReplaceRule ORDER BY `order` ASC")
    val all: List<ReplaceRule>

    @get:Query("SELECT * FROM ReplaceRule WHERE isEnabled = '1' ORDER BY `order` ASC")
    val allEnabled: List<ReplaceRule>

    @Query("SELECT * FROM ReplaceRule ORDER BY `order` ASC")
    fun flowAll(): Flow<List<ReplaceRule>>

    @get:Query("SELECT count(*) FROM ReplaceRule")
    val count: Int

    @Query("SELECT * FROM ReplaceRule WHERE id = :id")
    fun get(id: Long): ReplaceRule?

    @get:Query("SELECT * FROM replaceRuleGroup ORDER by `order` ASC")
    val allGroup: List<ReplaceRuleGroup>

    @Transaction
//    @Query("SELECT * FROM replaceRuleGroup ORDER BY `order` ASC")
    fun allGroupWithReplaceRules(): List<GroupWithReplaceRule> {
        val list = mutableListOf<GroupWithReplaceRule>()
        allGroup.forEach {
            list.add(GroupWithReplaceRule(it, getListInGroup(it.id)))
        }

        return list
    }

    @Transaction
    @Query("SELECT * FROM replaceRuleGroup ORDER BY `order` ASC")
    fun internalFlowAllGroupWithReplaceRules(): Flow<List<GroupWithReplaceRule>>

    fun flowAllGroupWithReplaceRules(): Flow<List<GroupWithReplaceRule>> =
        internalFlowAllGroupWithReplaceRules().conflate().map { list ->
            list.map { groupWithRules ->
                GroupWithReplaceRule(
                    groupWithRules.group,
                    groupWithRules.list.sortedBy { it.order })
            }
        }

    @Query("SELECT * FROM replaceRuleGroup WHERE id = :id")
    fun getGroup(id: Long = DEFAULT_GROUP_ID): ReplaceRuleGroup?

    @Query("SELECT * FROM ReplaceRule WHERE groupId = :groupId ORDER BY `order` ASC")
    fun getListInGroup(groupId: Long = DEFAULT_GROUP_ID): List<ReplaceRule>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertGroup(vararg data: ReplaceRuleGroup)

    @Update
    fun updateGroup(vararg data: ReplaceRuleGroup)

    @Delete
    fun deleteGroup(vararg data: ReplaceRuleGroup)

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(vararg data: ReplaceRule)

    @Delete
    fun delete(vararg data: ReplaceRule)

    @Query("DELETE from ReplaceRule WHERE groupId = :groupId")
    fun deleteAllByGroup(groupId: Long)

    @Update
    fun update(vararg data: ReplaceRule)

    /**
     * 更新数据并刷新排序索引
     */
    fun updateDataAndRefreshOrder(data: ReplaceRule) {
        val list = getListInGroup(data.groupId).toMutableList()
        list.removeIf { it.id == data.id }
        list.add(min(data.order, list.size), data)
        list.forEachIndexed { index, value -> value.apply { order = index } }

        update(*list.toTypedArray())
    }

    fun updateAllOrder() {
        allGroupWithReplaceRules().forEach


--micosft-e1a5506d", "xn--mirsft-41a156cba", "xn--microof-kqf6736g",
		"xn--mcrsoft-ueb2739d", "xn--micosft-pld8436d", "xn--microft-x2c06e",
		"xn--micrsf-n1e93uba", "xn--mcrosft-2gd933b", "xn--mcrosft-3gc617c",
		"m1cros0ft", "xn--rncrosoft-18d", "xn--micr0sft-4dg",
		"xn--icrosft-wz1cm5n", "xn--microst-i5b262c", "xn--micsoft-hld5536d",
		"xn--nicosoft-v7g", "xn--mcrosft-7ya207h", "xn--icrosft-wz1c45n",
		"xn--mcrsft-p9a617eba", "xn--micosof-drb83w", "xn--micsoft-f5b39q",
		"xn--icosoft-vid4i", "xn--mirsoft-cjgz", "xn--mirsft-c1a150fba",
		"xn--micsoft-emd7336d", "xn--mirosft-6pf54x", "xn--mirooft-6pf0936g",
		"xn--mcrsoft-7ya007h", "xn--mirsft-5wbb420c", "xn--nnicrooft-q9h",
		"xn--mcosoft-3gc27m", "xn--mcrosft-7ya616d", "xn--mcrsoft-7ya63n",
		"xn--microsf-dkg910a", "xn--micrst-07f48db", "n1crosoft",
		"xn--microft-nog6112d", "xn--mcrosft-p0a13c", "xn--micsoft-bpf0469c",
		"xn--mcrosft-ueb621h", "xn--mlcrsft-g5bb", "xn--icrsoft-bpf2022d",
		"xn--microft-qm6ao06i", "xn--micrsf-n1e78gba", "xn--icrooft-vid4349g",
		"xn--microst-y2c489a", "xn--icrsft-k0eb0149c", "xn--rricrsoft-47a",
		"xn--mlcrsoft-7fd", "xn--nnicrsft-l90db", "xn--micrsof-g5b040c",
		"xn--mcrsft-3va298cba", "xn--mlcrsft-djgb", "xn--mirsoft-f5b620c",
		"xn--ricrosoft-qfe", "xn--ncrosoft-u2a", "xn--mcr0s0ft-1ud",
		"xn--mirsoft-64a564h", "xn--icosoft-wz1c1i", "xn--micr0sof-vxb",
		"xn--mcrosft-rfb090h", "xn--crosoft-2gc0666d", "xn--micooft-vmd900b",
		"xn--mcrosft-e1a40c", "xn--micsft-rof2gb", "xn--micosft-0mh4796c",
		"xn--nicosoft-s7gd", "xn--micrsft-x2c558b", "xn--mcrsft-iwa67wba",
		"xn--mirsoft-bpf8a", "xn--micsoft-v2c757b", "xn--micrft-6wba143d",
		"xn--ricosoft-xzdc", "xn--micrsft-z


e [Keccak.digest] method against the NIST test vectors.
 * The original test vectors can be found here: https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/sha3/sha-3bittestvectors.zip
 */
class KeccakTests {

    private val allNistTestVectors = listOf(
        testVectors224 to KeccakParameter.SHA3_224,
        testVectors256 to KeccakParameter.SHA3_256,
        testVectors384 to KeccakParameter.SHA3_384,
        testVectors512 to KeccakParameter.SHA3_512
    )

    @Test
    fun testNistVectors() {
        allNistTestVectors.forEach { (vectorList, params) ->
            vectorList.forEach { (input, expected) ->
                assertEquals(Keccak.digest(HexString(input).hexToByteArray(), params).toNoPrefixHexString(), expected)
            }
        }
    }

    @Test
    fun keccak256hashesAreCorrect() {

        assertTrue(
            "".digestKeccak(KeccakParameter.KECCAK_256)
                .contentEquals(HexString("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").hexToByteArray())
        )

        assertTrue(
            "The quick brown fox jumps over the lazy dog".digestKeccak(KeccakParameter.KECCAK_256)
                .contentEquals(HexString("4d741b6f1eb29cb2a9b9911c82f56fa8d73b04959d3d9d222895df6c0b28aa15").hexToByteArray())
        )

        assertTrue(
            "The quick brown fox jumps over the lazy dog.".digestKeccak(KeccakParameter.KECCAK_256)
                .contentEquals(HexString("578951e24efd62a3d63a86f7cd19aaa53c898fe287d2552133220370240b572d").hexToByteArray())
        )

        assertTrue(
            "The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog.The quick brown fox jumps over the lazy dog."
                .digestKeccak(KeccakParameter.KECCAK_256)
                .contentEquals(HexString("e35949d2ca446ea2fd99f49bed23c60e0b9849f5384661bc574a5c55fcaeb4bd").hexToByteArray())
        )

        assertEquals(
            Keccak.digest(
                HexString("a1b31be4d58a7ddd24b135db0da56a90fb5382077ae26b250e1dc9cd6232ce2270f4c995428bc76aa78e522316e95d7834d725efc9ca754d043233af6ca90113").hexToByteArray(),
                KeccakParameter.KECCAK_256
            ).toHexString(""),
            "e1674295e8fc8ffdfb46cadb01c52b08330e05d731e38c856c1043288f7d9744"
        )
    }


ify-content: center;
        margin: 0 auto;
      }

      .card--title {
        margin-right: 40px;
        line-height: 1.2;
        flex: 0 1 auto;
        text-align: center;
      }

      .sumo-button {
        flex: 0 1 auto;
      }

      .card--desc {
        min-width: 25ch;
        max-width: 45ch;
        flex: 1 1 0;
        @include p.bidi(((margin, 0 40px 0 0, 0 0 0 40px),
          ));
      }
    }
  }
}

.elevation-00 {
  @include c.elevation-00;
}

.elevation-01 {
  @include c.elevation-01;
}

.elevation-02 {
  @include c.elevation-02;
}

.elevation-03 {
  @include c.elevation-03;
}@use 'protocol/css/includes/lib' as p;
@use '../config' as c;
@use 'sass:math';

// Containers
//
// This container provides default horizontal margins for the page and a max-width of 1400px.
//
// Markup: ../../../../../../styleguide/styleguide-examples/containers.njk
//
// Weight: 20
//
// Style guide: containers

.mzp-l-content {
  @include c.container;

  &.narrow {
    max-width: 1000px;
  }

  & & {
    padding-right: math.div(c.$gutter-width, 2);
    padding-left: math.div(c.$gutter-width, 2);
  }
}

.sumo-page-section {
  padding-top: p.$spacing-xl;
  padding-bottom: p.$spacing-xl;

  &--lg {
    padding-top: 40px;
    padding-bottom: p.$spacing-xl;

    &.extra-pad-bottom {
      padding-bottom: 40px;
    }

    @media #{p.$mq-md} {
      padding-top: p.$spacing-2xl;

      &.extra-pad-bottom {
        padding-bottom: p.$spacing-2xl;
      }
    }

    @media #{p.$mq-lg} {
      padding-top: 72px;

      &.extra-pad-bottom {
        padding-bottom: 72px;
      }
    }
  }

  &--md {
    padding-top: p.$spacing-xl;
    padding-bottom: p.$spacing-xl;

    @media #{p.$mq-md} {
      padding-top: 40px;
      padding-bottom: 40px;
    }

    @media #{p.$mq-lg} {
      padding-top: p.$spacing-2xl;
      padding-bottom: p.$spacing-2xl;
    }
  }

  &--sm {
    padding-top: p.$spacing-sm;
    padding-bottom: p.$spacing-sm;

    @media #{p.$mq-md} {
      padding-top: p.$spacing-md;
      padding-bottom: p.$spacing-md;
    }
  }

  &.extra-pad-bottom {
    @media #{p.$mq-lg} {
      padding-bottom: p.$spacing-2xl;
    }
  }

  &--inner {
    padding-top: p.$spacing-lg;
    padding-bottom: p.$spacing-lg;

    &:first-child {
      padding-top: p.$spacing-xl;
    }

    &:last-child {
      padding-bottom: 72px;
    }

    @media #{p.$mq-md} {
      padding-top: 28px;
      padding-bottom: 28px;

      &:first-child {
        padding-top: 40px;
      }
    }

    @media #{p.$mq-lg} {
      padding-top: 36px;
      padding-bottom: 36px;

      &:first-child {
        padding-top: p.$spacing-2xl;
      }

      &:last-child {
        padding-bottom: 96px;
      }
    }


.next();
            if (value.done) {
                for (var k = 0; k < count; k++) {
                    yield result[(j + k) % count];
                }
                return;
            }
            result[j++] = value.value;
            if (j === count) {
                j = 0;
            }
        }
    });
}

export function takelast<T>(source: Iterable<T>, count: number): Iterable<T>;
export function takelast<T>(count: number): Operator<T, T>;
export function takelast() {
    return wrapInThunk(arguments, _takelast);
}

declare module '../enumerable_' {
    interface Enumerable<T> {
        takelast(count: number): Enumerable<T>;
    }
}
Enumerable.prototype.takelast = function <T>(this: Enumerable<T>, count: number) {
    return new Enumerable<T>(_takelast<T>(this, count));
};/**
 * Split NAL units from an H.264/H.265 Annex B stream.
 *
 * The input is not modified.
 * The returned NAL units are views of the input (no memory allocation nor copy),
 * and still contains emulation prevention bytes.
 *
 * This methods returns a generator, so it can be stopped immediately
 * after the interested NAL unit is found.
 */
export function* annexBSplitNalu(buffer: Uint8Array): Generator<Uint8Array> {
    // -1 means we haven't found the first start code
    let start = -1;
    // How many `0x00`s in a row we have counted
    let zeroCount = 0;
    let inEmulation = false;

    for (let i = 0; i < buffer.length; i += 1) {
        const byte = buffer[i]!;

        if (inEmulation) {
            if (byte > 0x03) {
                // `0x00000304` or larger are invalid
                throw new Error("Invalid data");
            }

            inEmulation = false;
            continue;
        }

        if (byte === 0x00) {
            zeroCount += 1;
            continue;
        }

        const prevZeroCount = zeroCount;
        zeroCount = 0;

        if (start === -1) {
            // 0x000001 is the start code
            // But it can be preceded by any number of zeros
            // So 2 is the minimal
            if (prevZeroCount >= 2 && byte === 0x01) {
                // Found start of first NAL unit
                start = i + 1;
                continue;
            }

            // Not begin with start code
            throw new Error("Invalid data");
        }

        if (prevZeroCount < 2) {
            // zero or one `0x00`s are acceptable
            continue;
        }

        if (byte === 0x01) {
            // Found another NAL unit
            yield buffer.subarray(start, i - prevZeroCount);

            start = i + 1;
            continue;
        }

        if (prevZeroCount > 2) {
            // Too much `0x00`s
            throw new Error("Invalid data");
        }

        switch (byte) {
            case 0x02:
                // Didn't find why, but 7.4.1 NAL unit semantics forbids `0x000002` appearing in NAL units
                throw new Error("Invalid data");
            case 0x03:
                // `0x000003` is the "emulation_prevention_three_byte"
                // `0x00000300`, `0x00000301`, `0x00000302` and `0x00000303` represent
                // `0x000000`, `0x000001`, `0x000002` and `0x000003` respectively
                inEmulation = true;
                break;
            default:
                // `0x000004` or larger are as-is
                break;
        }
    }

    if (inEmulation) {
        throw new Error("Invalid data");
    }

    yield buffer.subarray(start, buffer.length);
}

/**
 * Remove emulation prevention bytes from a H.264/H.265 NAL Unit.
 *
 * The input is not modified.
 *


是否有该技能的标记 */
        hasMark(skill:string):boolean;
        /** 有多少该技能的标记（若标记为数组，返回数组长度） */
        countMark(skill:string):number;
        /** 添加标记（只适用于标记是数字） */
        addMark(skill:string,num:number,log?:boolean);
        /** 移除标记（只适用于标记是数字） */
        removeMark(skill:string,num?:number,log?:boolean);

        //【1.9.98.7】扩展mark的一些简化操作，主要规范保存的数据是数组（一般特指卡牌数组）：
        /**
         * 快速向storage中添加卡牌并标记(即使storage是undefined)
		 *
         * @param name 标记的名字
         * @param info 添加进标记的数据，以数组形式添加，如果info不是数组（或默认不填时），则默认设置空数组
         */
        markAuto(name:string,info:any[]): void;
        /**
         * 获取标记保存的数据
         *
         * 若player.storage.xxx不为undefined则返回player.storage.xxx,
		 *
         * 为undefined则返回空数组;
		 *
         * (注：当然，若是非数组类型的就不要使用这一系列的方法)
		 *
         * @param name 标记的名字
         */
        getStorage(name:string):any[];
        getStorage<T>(name:string):T[];
        /**
         * 快速从storage中移出卡牌并判断数组剩余长度，若为0则移除标记
		 *
         * @param name 标记的名字
         * @param info 删除出标记的数据
         */
        unmarkAuto(name:string,info:any[]): void;

        /** 添加“连环”UI */
        addLink(): void;
        /** 删除“连环”UI */
        removeLink(): void;
        /**
         * 检测card是否可以使用
         *
         * 最终，都通过，默认最后lib.filter.filterTarget
		 *
         * @param card 卡牌名
         * @param target 目标
         * @param distance 是否检测距离,取值false时，则只执行lib.filter.targetEnabled不进行距离判定，默认执行lib.filter.filterTarget有对距离的判定；
         * @param includecard 进行卡牌检测（优先与上面distance），默认lib.filter.cardEnabled，若为true，则追加执行lib.filter.cardUsable相关检测；取值false是都不执行；
         */
        canUse(card: string|{name:string}, target: Player, distance?: boolean, includecard?: boolean): boolean;
        /**
         * 检测是否有该card的使用目标
		 *
         * @param card 卡牌名（也是用于canUse）
         * @param distance 用于canUse，参考canUse的distance参数
         * @param includecard 用于canUse，参考canUse的includecard参数
         */
        hasUseTarget(card: string|{name:string}, distance?: boolean, includecard?: boolean): boolean;
        /**
         * 获取该卡牌可对至少x目标使用的数量
		 *
         * @param card
         * @param distance 用于canUse，参考canUse的d


lt)."])
    var optimise: String = "0"

    @CommandLine.Option(names = ["-g", "--debug"], description = ["Generate debug information."])
    var debug: Boolean = false

    @CommandLine.Option(names = ["-t", "--target"], description = ["Target, Vulkan (default) or OpenGL."])
    var target: String = "Vulkan"

    @CommandLine.Option(names = ["-e", "--entryPoint"], description = ["Entry point for the shader. Default is main."])
    var entryPoint: String = "main"

    @CommandLine.Option(names = ["-s", "--strict"], description = ["Strict compilation, treats warnings as errors."])
    var strict: Boolean = false

    @CommandLine.Option(names = ["-v", "--verbose"], description = ["Activate verbose logging."])
    var verbose: Boolean = false

    /**
     * Optimisation level for shader compilation.
     */
    enum class OptimisationLevel {
        NoOptimisation,
        Performance,
        Size
    }

    private fun Lazy<Logger>?.debug(format: String, vararg args: Any) {
        if(this == null) {
            // debug logging, don't do anything if verbose is not set
            if(verbose) {
                println(format)
            }
        } else {
            this.value.debug(format, args)
        }
    }

    private fun Lazy<Logger>?.error(format: String, vararg args: Any) {
        if(this == null) {
            System.err.println(format)
        } else {
            this.value.error(format, args)
        }
    }

    /**
     * Compiles the [code] given to SPIRV bytecode.
     */
    fun compile(
        code: String,
        type: ShaderType,
        target: Shaders.ShaderTarget,
        entryPoint: String = "main",
        debug: Boolean = false,
        warningsAsErrors: Boolean = false,
        optimisationLevel: OptimisationLevel = OptimisationLevel.NoOptimisation,
        path: String? = null,
        baseClass: String? = null
    ): ByteArray {
        val options = Shaderc.shaderc_compile_options_initialize()
        logger.debug("Compiling code from $path of $baseClass, debug=$debug, optimisation=$optimisationLevel")
        val shaderType = when (type) {
            ShaderType.VertexShader -> Shaderc.shaderc_glsl_vertex_shader
            ShaderType.FragmentShader -> Shaderc.shaderc_glsl_fragment_shader
            ShaderType.GeometryShader -> Shaderc.shaderc_glsl_geometry_shader
            ShaderType.TessellationControlShader -> Shaderc.shaderc_glsl_tess_control_shader
            ShaderType.TessellationEvaluationShader -> Shaderc.shaderc_glsl_tess_evaluation_shader
            ShaderType.ComputeShader -> Shaderc.shaderc_glsl_compute_shader
        }

        Shaderc.shaderc_compile_options_set_source_language(options, Shaderc.shaderc_source_language_glsl)

        var shaderCode = if(target == Shaders.ShaderTarget.Vulkan) {
            Shaderc.shaderc_compile_options_set_target_env(options, Shaderc.shaderc_target_env_vulkan, Shaderc.shaderc_env_version_vulkan_1_2)
            Shaderc.shaderc_compile_options_set_target_spirv(options, Shaderc.shaderc_spirv_version_1_2)
            code
        } else {
            Shaderc.shaderc_compile_options_set_target_env(options, Shaderc.shaderc_target_env_opengl, Shaderc.shaderc_env_version_opengl_4_5)
            val extensionEnd = code.indexOf("\n", code.findLastAnyOf(listOf("#extension", "#version"))?.first ?: 0)
            code.substring(0, extensionEnd) + "\n#define OPENGL\n" + code.substring(extensionEnd)
        }

        val optimisation = when(optimisationLevel


A5138 002C0821 */  addu  $at, $at, $t4
/* 14B1AC 801A513C E42E6850 */  swc1  $f14, 0x6850($at)
/* 14B1B0 801A5140 8C4D0000 */  lw    $t5, ($v0)
/* 14B1B4 801A5144 3C01800E */  lui   $at, 0x800e
/* 14B1B8 801A5148 24E73E50 */  addiu $a3, %lo(D_800E3E50) # addiu $a3, $a3, 0x3e50
/* 14B1BC 801A514C 000D7880 */  sll   $t7, $t5, 2
/* 14B1C0 801A5150 00CF7021 */  addu  $t6, $a2, $t7
/* 14B1C4 801A5154 E5CC0000 */  swc1  $f12, ($t6)
/* 14B1C8 801A5158 8C430000 */  lw    $v1, ($v0)
/* 14B1CC 801A515C 00031880 */  sll   $v1, $v1, 2
/* 14B1D0 801A5160 00C3C021 */  addu  $t8, $a2, $v1
/* 14B1D4 801A5164 C7000000 */  lwc1  $f0, ($t8)
/* 14B1D8 801A5168 00230821 */  addu  $at, $at, $v1
/* 14B1DC 801A516C E4203750 */  swc1  $f0, 0x3750($at)
/* 14B1E0 801A5170 8C590000 */  lw    $t9, ($v0)
/* 14B1E4 801A5174 3C01800E */  lui   $at, 0x800e
/* 14B1E8 801A5178 00194080 */  sll   $t0, $t9, 2
/* 14B1EC 801A517C 00280821 */  addu  $at, $at, $t0
/* 14B1F0 801A5180 E4203590 */  swc1  $f0, 0x3590($at)
/* 14B1F4 801A5184 8C490000 */  lw    $t1, ($v0)
/* 14B1F8 801A5188 3C01800E */  lui   $at, 0x800e
/* 14B1FC 801A518C 00095080 */  sll   $t2, $t1, 2
/* 14B200 801A5190 002A0821 */  addu  $at, $at, $t2
/* 14B204 801A5194 E42033D0 */  swc1  $f0, 0x33d0($at)
/* 14B208 801A5198 8C4B0000 */  lw    $t3, ($v0)
/* 14B20C 801A519C 3C01800E */  lui   $at, 0x800e
/* 14B210 801A51A0 000B6080 */  sll   $t4, $t3, 2
/* 14B214 801A51A4 002C0821 */  addu  $at, $at, $t4
/* 14B218 801A51A8 E4203210 */  swc1  $f0, 0x3210($at)
/* 14B21C 801A51AC 8C4D0000 */  lw    $t5, ($v0)
/* 14B220 801A51B0 3C01800E */  lui   $at, 0x800e
/* 14B224 801A51B4 000D7880 */  sll   $t7, $t5, 2
/* 14B228 801A51B8 002F0821 */  addu  $at, $at, $t7
/* 14B22C 801A51BC E4203050 */  swc1  $f0, 0x3050($at)
/* 14B230 801A51


Resources[n]

		if !ok {
			return fmt.Errorf("Not found: %s", n)
		}

		if rs.Primary.ID == "" {
			return errors.New("No Record ID is set")
		}

		sess, err := acc.TestAccProvider.Meta().(conns.ClientSession).IBMPISession()
		if err != nil {
			return err
		}

		ids, err := flex.IdParts(rs.Primary.ID)
		if err != nil {
			return err
		}
		cloudInstanceID, vgID := ids[0], ids[1]
		client := instance.NewIBMPIVolumeGroupClient(context.Background(), sess, cloudInstanceID)

		_, err = client.Get(vgID)
		if err != nil {
			return err
		}
		return nil
	}
}

func testAccCheckIBMPIVolumeGroupStopActionConfig(name string) string {
	return testAccCheckIBMPIVolumeGroupConfig(name) + fmt.Sprintf(`
	  resource "ibm_pi_volume_group_action" "power_volume_group_action" {
		pi_cloud_instance_id   = "%[1]s"
		pi_volume_group_id     = ibm_pi_volume_group.power_volume_group.volume_group_id
		pi_volume_group_action {
			stop {
				access = true
			}
		}
	  }
	`, acc.Pi_cloud_instance_id)
}

func testAccCheckIBMPIVolumeGroupStartActionConfig(name string) string {
	return testAccCheckIBMPIVolumeGroupConfig(name) + fmt.Sprintf(`
	  resource "ibm_pi_volume_group_action" "power_volume_group_action" {
		pi_cloud_instance_id   = "%[1]s"
		pi_volume_group_id     = ibm_pi_volume_group.power_volume_group.volume_group_id
		pi_volume_group_action {
			start {
				source = "master"
			}
		}
	  }
	`, acc.Pi_cloud_instance_id)
}
// Copyright IBM Corp. 2024 All Rights Reserved.
// Licensed under the Mozilla Public License v2.0

package power_test

import (
	"context"
	"errors"
	"fmt"
	"testing"

	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"

	"github.com/IBM-Cloud/power-go-client/clients/instance"
	acc "github.com/IBM-Cloud/terraform-provider-ibm/ibm/acctest"
	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/conns"
)

func TestAccIBMPIHostGroupBasic(t *testing.T) {
	name := fmt.Sprintf("tf_name_%d", acctest.RandIntRange(10, 100))
	displayName := fmt.Sprintf("tf_display_name_%d", acctest.RandIntRange(10, 100))

	resource.Test(t, resource.TestCase{
		PreCheck:     func() { acc.TestAccPreCheck(t) },
		Providers:    acc.TestAccProviders,
		CheckDestroy: testAccCheckIBMPIHostGroupDestroy,
		Steps: []resource.TestStep{
			{
				Config: testAccCheckIBMPIHostGroupConfigBasic(name, displayName),
				Check: resource.ComposeAggregateTestCheckFunc(
					testAccCheckIBMPIHostGroupExists("ibm_pi_host_group.hostGroup"),
					resource.TestCheckResourceAttr("ibm_pi_host_group.hostGroup", "pi_name", name),
				),
			},
		},
	})
}

func testAccCheckIBMPIHostGroupConfigBasic(name, displayName string) string {
	return fmt.Sprintf(`
		resource "ibm_pi_


rld.getMoonPhase();
        ++frameCounter;

        if (frameCounter >= 720720)
        {
            frameCounter = 0;
        }

        systemTime = System.currentTimeMillis();

        if (lastSystemTime == 0L)
        {
            lastSystemTime = systemTime;
        }

        diffSystemTime = systemTime - lastSystemTime;
        lastSystemTime = systemTime;
        frameTime = (float)diffSystemTime / 1000.0F;
        frameTimeCounter += frameTime;
        frameTimeCounter %= 3600.0F;
        rainStrength = minecraft.theWorld.getRainStrength(partialTicks);
        float f = (float)diffSystemTime * 0.01F;
        float f1 = (float)Math.exp(Math.log(0.5D) * (double)f / (double)(wetness < rainStrength ? drynessHalfLife : wetnessHalfLife));
        wetness = wetness * f1 + rainStrength * (1.0F - f1);
        Entity entity = mc.getRenderViewEntity();

        if (entity != null)
        {
            isSleeping = entity instanceof EntityLivingBase && ((EntityLivingBase)entity).isPlayerSleeping();
            eyePosY = (float)entity.posY * partialTicks + (float)entity.lastTickPosY * (1.0F - partialTicks);
            eyeBrightness = entity.getBrightnessForRender(partialTicks);
            f1 = (float)diffSystemTime * 0.01F;
            float f2 = (float)Math.exp(Math.log(0.5D) * (double)f1 / (double)eyeBrightnessHalflife);
            eyeBrightnessFadeX = eyeBrightnessFadeX * f2 + (float)(eyeBrightness & 65535) * (1.0F - f2);
            eyeBrightnessFadeY = eyeBrightnessFadeY * f2 + (float)(eyeBrightness >> 16) * (1.0F - f2);
            Block block = ActiveRenderInfo.getBlockAtEntityViewpoint(mc.theWorld, entity, partialTicks);
            Material material = block.getMaterial();

            if (material == Material.water)
            {
                isEyeInWater = 1;
            }
            else if (material == Material.lava)
            {
                isEyeInWater = 2;
            }
            else
            {
                isEyeInWater = 0;
            }

            if (mc.thePlayer != null)
            {
                nightVision = 0.0F;

                if (mc.thePlayer.isPotionActive(Potion.nightVision))
                {
                    nightVision = Config.getMinecraft().entityRenderer.getNightVisionBrightness(mc.thePlayer, partialTicks);
                }

                blindness = 0.0F;

                if (mc.thePlayer.isPotionActive(Potion.blindness))
                {
                    int i = mc.thePlayer.getActivePotionEffect(Potion.blindness).getDuration();
                    blindness = Config.limit((float)i / 20.0F, 0.0F, 1.0F);
                }
            }

            Vec3 vec3 = mc.theWorld.getSkyColor(entity, partialTicks);
            vec3 = CustomColors.getWorldSkyColor(vec3, currentWorld, entity, partialTicks);
            skyColorR = (float)vec3.xCoord;
            skyColorG = (float)vec3.yCoord;
            skyColorB = (float)vec3.zCoord;
        }

        isRenderingWorld = true;
        isCompositeRendered = false;
        isShadowPass = false;
        isHandRenderedMain = false;
        isHandRenderedOff = false;
        skipRenderHandMain = false;
        skipRenderHandOff = false;
        bindGbuffersTextures();
        previousCameraPositionX = cameraPositionX;
        previousCameraPositionY = cameraPositionY;
        previousCameraPositionZ = cameraPositionZ;
        previousProjection.position(0);


	 * 相関係数監視情報を設定
	 * @see com.clustercontrol.monitor.run.factory.OperationNumericValueInfo#setMonitorAdditionInfo()
	 */
	@Override
	protected void setCheckInfo() throws MonitorNotFound {

		// 相関係数監視情報を取得
		if (!m_isMonitorJob) {
			// 監視ジョブ以外の場合
			m_correlation = QueryUtil.getMonitorCorrelationInfoPK(m_monitorId);
		} else {
			// 監視ジョブの場合
			m_correlation = QueryUtil.getMonitorCorrelationInfoPK(m_monitor.getMonitorId());
		}
		try {
			m_referFacilityIdList = new RepositoryControllerBean().getExecTargetFacilityIdList(
					m_correlation.getReferFacilityId(), m_monitor.getOwnerRoleId());
		} catch (HinemosUnknown e) {
			// 何もしない
		}
	}

	/* (非 Javadoc)
	 * ノード用メッセージを取得
	 * @see com.clustercontrol.monitor.run.factory.RunMonitor#getMessage(int)
	 */
	@Override
	public String getMessage(int id) {
		if(m_message == null || "".equals(m_message)){
			return m_unKnownMessage;
		}
		return m_message;
	}

	/* (非 Javadoc)
	 * ノード用オリジナルメッセージを取得
	 * @see com.clustercontrol.monitor.run.factory.RunMonitor#getMessageOrg(int)
	 */
	@Override
	public String getMessageOrg(int id) {
		if (m_monitor == null || m_monitor.getCorrelationCheckInfo() == null) {
			return "";
		}
		String msgTargetItemName = AnalyticsUtil.getMsgItemName(
				m_monitor.getCorrelationCheckInfo().getTargetItemName(),
				m_monitor.getCorrelationCheckInfo().getTargetDisplayName(),
				m_monitor.getCorrelationCheckInfo().getTargetMonitorId());
		String msgReferItemName = AnalyticsUtil.getMsgItemName(
				m_monitor.getCorrelationCheckInfo().getReferItemName(),
				m_monitor.getCorrelationCheckInfo().getReferDisplayName(),
				m_monitor.getCorrelationCheckInfo().getReferMonitorId());
		String[] args = {
				msgTargetItemName,
				m_monitor.getCorrelationCheckInfo().getAnalysysRange().toString(),
				m_monitor.getCorrelationCheckInfo().getReferFacilityId(),
				msgReferItemName};
		/** メッセージ出力 */
		return m_message + "\n" + MessageConstant.MESSAGE_MONITOR_ORGMSG_CORRELATION.getMessage(args) + "\n" + m_collectDataListMessage;
	}

	/* (非 Javadoc)
	 * ノード用オリジナルメッセージを取得(監視ジョブ)
	 * @see com.clustercontrol.monitor.run.factory.RunMonitor#makeJobOrgMessage(java.lang.String, java.lang.String)
	 */
	@Override
	protected String makeJobOrgMessage(String orgMsg, String msg) {
		String rtn = "";
		if (m_monitor == null || m_monitor.getCorrelationCheckInfo() == null) {
			return rtn;
		}
		String msgTargetItemName = AnalyticsUtil.getMsgItemName(
				m_monitor.getCorrelationCheckInfo().getTargetItemName(),
				m_monitor.getCorrelationCheckInfo().getTargetDisplayName(),
				m_monitor.getCorrelationCheckInfo().getTargetMonitorId());
		String msgReferItemName = AnalyticsUtil.getMsgItemName(
				m_monitor.getCorrelationCheckInfo().getReferItemName(),
				m_monitor.getCorrelationCheckInfo().getReferDisplayName(),
				m_monitor.getCorrelationCheckInfo().getReferMonitorId());
		String[] args = {
				msgTargetItemName,
				m_monitor.getCorrelationCheckInfo().getAnalysysRange().toString(),
				m_monitor.getCorrelationCheckInfo().getReferFacilityId(),
				msgReferItemName};
		/** メッセージ出力 */
		if (msg != null) {
			rtn = msg + "\n";
		}
		rtn += MessageConstant.MESSAGE_JOB_MONITOR_ORGMSG_CORRELATION.getMessage(args);
		return rtn;
	}
}
/*
 * Copyright (c) 2022 NTT DATA INTELLILINK Corporation.
 *
 * Hinemos (http://www.hinemos.info/)
 *
 * See the LICENSE file for lic


cftf161(a, offa + 256, w, nw - 8);
            cftf162(a, offa + 288, w, nw - 32);
            cftf161(a, offa + 320, w, nw - 8);
            cftf161(a, offa + 352, w, nw - 8);
            if (isplt != 0) {
                cftmdl1(128, a, offa + 384, w, nw - 64);
                cftf161(a, offa + 480, w, nw - 8);
            } else {
                cftmdl2(128, a, offa + 384, w, nw - 128);
                cftf162(a, offa + 480, w, nw - 32);
            }
            cftf161(a, offa + 384, w, nw - 8);
            cftf162(a, offa + 416, w, nw - 32);
            cftf161(a, offa + 448, w, nw - 8);
        } else {
            cftmdl1(64, a, offa, w, nw - 32);
            cftf081(a, offa, w, nw - 8);
            cftf082(a, offa + 16, w, nw - 8);
            cftf081(a, offa + 32, w, nw - 8);
            cftf081(a, offa + 48, w, nw - 8);
            cftmdl2(64, a, offa + 64, w, nw - 64);
            cftf081(a, offa + 64, w, nw - 8);
            cftf082(a, offa + 80, w, nw - 8);
            cftf081(a, offa + 96, w, nw - 8);
            cftf082(a, offa + 112, w, nw - 8);
            cftmdl1(64, a, offa + 128, w, nw - 32);
            cftf081(a, offa + 128, w, nw - 8);
            cftf082(a, offa + 144, w, nw - 8);
            cftf081(a, offa + 160, w, nw - 8);
            cftf081(a, offa + 176, w, nw - 8);
            if (isplt != 0) {
                cftmdl1(64, a, offa + 192, w, nw - 32);
                cftf081(a, offa + 240, w, nw - 8);
            } else {
                cftmdl2(64, a, offa + 192, w, nw - 64);
                cftf082(a, offa + 240, w, nw - 8);
            }
            cftf081(a, offa + 192, w, nw - 8);
            cftf082(a, offa + 208, w, nw - 8);
            cftf081(a, offa + 224, w, nw - 8);
        }
    }

    private void cftmdl1(int n, double[] a, int offa, double[] w, int startw) {
        int j0, j1, j2, j3, k, m, mh;
        double wn4r, wk1r, wk1i, wk3r, wk3i;
        double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
        int idx0, idx1, idx2, idx3, idx4, idx5;

        mh = n >> 3;
        m = 2 * mh;
        j1 = m;
        j2 = j1 + m;
        j3 = j2 + m;
        idx1 = offa + j1;
        idx2 = offa + j2;
        idx3 = offa + j3;
        x0r = a[offa


.tab-content > .tab-pane {
  display: none; }

.tab-content > .active {
  display: block; }

/* ###### 5.7 Nav   ###### */
@media (min-width: 768px) {
  .main-nav {
    align-items: center; } }

.main-nav .nav-link {
  display: block;
  color: #4d5875;
  padding: 0;
  position: relative;
  line-height: normal; }
  .main-nav .nav-link:hover, .main-nav .nav-link:focus {
    color: #242f48; }
  .main-nav .nav-link + .nav-link {
    padding-top: 12px;
    margin-top: 12px;
    border-top: 1px solid #949eb7; }
  .main-nav .nav-link.active {
    color: #0162e8 !important; }

@media (min-width: 768px) {
  .main-nav .nav-link + .nav-link {
    padding-top: 0;
    margin-top: 0;
    border-top: 0;
    padding-right: 15px;
    margin-right: 15px;
    border-right: 1px solid #949eb7; } }

.main-nav-column {
  flex-direction: column; }
  .main-nav-column .nav-link {
    padding: 0;
    height: 38px;
    color: #242f48;
    display: flex;
    align-items: center;
    justify-content: flex-start; }
    .main-nav-column .nav-link i {
      font-size: 24px;
      line-height: 0;
      width: 24px;
      margin-right: 12px;
      text-align: center;
      transition: all 0.2s ease-in-out; }
      .main-nav-column .nav-link i:not([class*=' tx-']) {
        color: #737f9e; }
      .main-nav-column .nav-link i.typcn {
        line-height: .9; }
    .main-nav-column .nav-link span {
      font-weight: 400;
      font-size: 11px;
      color: #949eb7;
      margin-right: auto; }
    .main-nav-column .nav-link:hover, .main-nav-column .nav-link:focus, .main-nav-column .nav-link:hover i:not([class*=' tx-']), .main-nav-column .nav-link:focus i:not([class*=' tx-']) {
      color: #242f48; }
    .main-nav-column .nav-link.active {
      position: relative;
      color: #0162e8; }
      .main-nav-column .nav-link.active::before {
        content: '';
        position: absolute;
        top: 6px;
        bottom: 6px;
        left: -28px;
        width: 3px;
        background-color: #0162e8;
        border-radius: 3px;
        display: none; }
      .main-nav-column .nav-link.active:hover, .main-nav-column .nav-link.active:focus, .main-nav-column .nav-link.active i, .main-nav-column .nav-link.active:hover i, .main-nav-column .nav-link.active:focus i {
        color: #0162e8; }
    .main-nav-column .nav-link + .nav-link {
      border-top: 1px dotted #b9c2d8; }
  .main-nav-column.sm .nav-link {
    font-size: 0.875rem;
    font-weight: 400;
    padding: 10px 0; }
    .main-nav-column.sm .nav-link i {
      font-size: 21px; }

@media (prefers-reduced-mot


d		l, a
	call	WAIT_RESP_NO_FF
	ld		d, a
	call	WAIT_RESP_NO_FF
	ld		e, a
	ld		b, h
	ld		c, l
	pop		af
	ret

; ------------------------------------------------
; Enviar comando em A com 4 bytes de parametros
; em BC DE e enviar CRC correto se for CMD0 ou
; CMD8 e aguardar processamento do cartao
; Destroi AF, BC
; ------------------------------------------------
SD_SEND_CMD:
	out		(PORTSPI), a
	push	af
	ld		a, b
	nop
	out		(PORTSPI), a
	ld		a, c
	nop
	out		(PORTSPI), a
	ld		a, d
	nop
	out		(PORTSPI), a
	ld		a, e
	nop
	out		(PORTSPI), a
	pop		af
	cp		#CMD0
	ld		b, #0x95						; CRC para CMD0
	jr		z, enviaCRC
	cp		#CMD8
	ld		b, #0x87						; CRC para CMD8
	jr		z, enviaCRC
	ld		b, #0xFF						; CRC dummy
enviaCRC:
	ld		a, b
	out		(PORTSPI), a
	jr		WAIT_RESP_NO_FF

; ------------------------------------------------
; Esperar que resposta do cartao seja $FE
; Destroi AF, B
; ------------------------------------------------
WAIT_RESP_FE:
	ld		b, #10						; 10 tentativas
.loop1:
	push	bc
	call	WAIT_RESP_NO_FF				; esperar resposta diferente de $FF
	pop		bc
	cp		#0xFE						; resposta  $FE ?
	ret	z								; sim, retornamos com carry=0
	djnz	.loop1
	scf									; erro, carry=1
	ret

; ------------------------------------------------
; Esperar que resposta do cartao seja diferente
; de $FF
; Destroi AF, BC
; ------------------------------------------------
WAIT_RESP_NO_FF:
	ld		bc, #100					; 100 tentativas
.loop2:
	in		a, (PORTSPI)
	cp		#0xFF						; testa $FF
	ret	nz								; sai se nao for $FF
	djnz	.loop2
	dec		c
	jr		nz, .loop2
	ret


e_all_regions = value;
        }
        public bool ShouldSerializeenable_all_regions() => __pbn__enable_all_regions != null;
        public void Resetenable_all_regions() => __pbn__enable_all_regions = null;
        private bool? __pbn__enable_all_regions;

        [global::ProtoBuf.ProtoMember(2)]
        public global::System.Collections.Generic.List<Region> enabled_regions { get; } = new global::System.Collections.Generic.List<Region>();

        [global::ProtoBuf.ProtoContract()]
        public partial class Region : global::ProtoBuf.IExtensible
        {
            private global::ProtoBuf.IExtension __pbn__extensionData;
            global::ProtoBuf.IExtension global::ProtoBuf.IExtensible.GetExtensionObject(bool createIfMissing)
                => global::ProtoBuf.Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);

            [global::ProtoBuf.ProtoMember(1)]
            public float min_latitude
            {
                get => __pbn__min_latitude.GetValueOrDefault();
                set => __pbn__min_latitude = value;
            }
            public bool ShouldSerializemin_latitude() => __pbn__min_latitude != null;
            public void Resetmin_latitude() => __pbn__min_latitude = null;
            private float? __pbn__min_latitude;

            [global::ProtoBuf.ProtoMember(2)]
            public float max_latitude
            {
                get => __pbn__max_latitude.GetValueOrDefault();
                set => __pbn__max_latitude = value;
            }
            public bool ShouldSerializemax_latitude() => __pbn__max_latitude != null;
            public void Resetmax_latitude() => __pbn__max_latitude = null;
            private float? __pbn__max_latitude;

            [global::ProtoBuf.ProtoMember(3)]
            public float min_longitude
            {
                get => __pbn__min_longitude.GetValueOrDefault();
                set => __pbn__min_longitude = value;
            }
            public bool ShouldSerializemin_longitude() => __pbn__min_longitude != null;
            public void Resetmin_longitude() => __pbn__min_longitude = null;
            private float? __pbn__min_longitude;

            [global::ProtoBuf.ProtoMember(4)]
            public float max_longitude
            {
                get => __pbn__max_longitude.GetValueOrDefault();
                set => __pbn__max_longitude = value;
            }
            public bool ShouldSerializemax_longitude() => __pbn__max_longitude != null;
            public void Resetmax_longitude() => __pbn__max_longitude = null;
            private float? __pbn__max_longitude;

        }

    }

}

#pragma warning restore CS0612, CS0618, CS1591, CS3021, CS8981, IDE0079, IDE1006, RCS1036, RCS1057, RCS1085, RCS1192
#endregion


NISH))
      val primaryColor =
        if (!tlvReader.isNull()) {
          tlvReader.getUByte(ContextSpecificTag(TAG_PRIMARY_COLOR))
        } else {
          tlvReader.getNull(ContextSpecificTag(TAG_PRIMARY_COLOR))
          null
        }

      tlvReader.exitContainer()

      return BasicInformationClusterProductAppearanceStruct(finish, primaryColor)
    }
  }
}
/*
 *
 *    Copyright (c) 2023 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package matter.controller.cluster.structs

import java.util.Optional
import matter.controller.cluster.*
import matter.tlv.ContextSpecificTag
import matter.tlv.Tag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter

class OvenModeClusterModeTagStruct(val mfgCode: Optional<UShort>, val value: UShort) {
  override fun toString(): String = buildString {
    append("OvenModeClusterModeTagStruct {\n")
    append("\tmfgCode : $mfgCode\n")
    append("\tvalue : $value\n")
    append("}\n")
  }

  fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
    tlvWriter.apply {
      startStructure(tlvTag)
      if (mfgCode.isPresent) {
        val optmfgCode = mfgCode.get()
        put(ContextSpecificTag(TAG_MFG_CODE), optmfgCode)
      }
      put(ContextSpecificTag(TAG_VALUE), value)
      endStructure()
    }
  }

  companion object {
    private const val TAG_MFG_CODE = 0
    private const val TAG_VALUE = 1

    fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): OvenModeClusterModeTagStruct {
      tlvReader.enterStructure(tlvTag)
      val mfgCode =
        if (tlvReader.isNextTag(ContextSpecificTag(TAG_MFG_CODE))) {
          Optional.of(tlvReader.getUShort(ContextSpecificTag(TAG_MFG_CODE)))
        } else {
          Optional.empty()
        }
      val value = tlvReader.getUShort(ContextSpecificTag(TAG_VALUE))

      tlvReader.exitContainer()

      return OvenModeClusterModeTagStruct(mfgCode, value)
    }
  }
}
/*
 *
 *    Copyright (c) 2023 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package matter.controller.cluster.structs

import java.util.Optional
import matter.controller.cluster.*
import matter.tlv.ContextSpecificTag
import matter.tlv.Tag
import matter.tlv.TlvReader
import matter.tlv.TlvWriter

class ElectricalPowerMeasurementClusterMeasurementRangeStruct(
  val measurementType: UShort,
  val min: Long,
  val max: Long,
  val startTimestamp: Optional<UInt>,


 "0") val specialSeasonsEnabled: Boolean,
  @ColumnInfo(name = "show_anticipated_movies", defaultValue = "0") val showAnticipatedMovies: Boolean,
  @ColumnInfo(name = "discover_movies_filter_genres", defaultValue = "") val discoverMoviesFilterGenres: String,
  @ColumnInfo(name = "discover_movies_filter_feed", defaultValue = "HOT") val discoverMoviesFilterFeed: String,
  @ColumnInfo(name = "my_movies_all_sort_by", defaultValue = "NAME") val myMoviesAllSortBy: String,
  @ColumnInfo(name = "see_later_movies_sort_by", defaultValue = "NAME") val seeLaterMoviesSortBy: String,
  @ColumnInfo(name = "progress_movies_sort_by", defaultValue = "NAME") val progressMoviesSortBy: String,
  @ColumnInfo(name = "show_collection_shows", defaultValue = "1") val showCollectionShows: Boolean,
  @ColumnInfo(name = "show_collection_movies", defaultValue = "1") val showCollectionMovies: Boolean,
  @ColumnInfo(name = "widgets_show_label", defaultValue = "1") val widgetsShowLabel: Boolean,
  @ColumnInfo(name = "my_movies_recent_is_enabled", defaultValue = "1") val myMoviesRecentIsEnabled: Boolean,
  @ColumnInfo(name = "quick_rate_enabled", defaultValue = "0") val quickRateEnabled: Boolean,
  @ColumnInfo(name = "lists_sort_by", defaultValue = "DATE_UPDATED") val listsSortBy: String,
  @ColumnInfo(name = "progress_upcoming_enabled", defaultValue = "1") val progressUpcomingEnabled: Boolean,
)
@file:Suppress("ktlint")

package com.michaldrabik.data_local.database.dao

import androidx.room.Dao
import androidx.room.Query
import androidx.room.Transaction
import com.michaldrabik.data_local.database.model.Person
import com.michaldrabik.data_local.sources.PeopleLocalDataSource

@Dao
interface PeopleDao : BaseDao<Person>, PeopleLocalDataSource {

  @Transaction
  override suspend fun upsert(people: List<Person>) {
    val result = insert(people)
    val updateList = mutableListOf<Person>()
    result.forEachIndexed { index, id ->
      if (id == -1L) {
        updateList.add(people[index])
      }
    }
    if (updateList.isNotEmpty()) update(updateList)
  }

  @Query("SELECT * FROM people WHERE id_tmdb = :tmdbId")
  override suspend fun getById(tmdbId: Long): Person?

  @Query(
    """
    SELECT
    people.id_tmdb,
    people.id_trakt,
    people.id_imdb,
    people.name,
    people.biography,
    people.biography_translation,
    people.birthday,
    people.birthplace,
    people.deathday,
    people.image_path,
    people.homepage,
    people.created_at,
    people.updated_at,
    people.details_updated_at,
    people_shows_movies.department AS department,
    people_shows_movies.character AS character,
    people_shows_movies.job AS job,
    people_shows_movies.episodes_count AS episodes_count
    FROM people
    INNER JOIN people_shows_movies ON people_shows_movies.id_tmdb_person = people.id_tmdb
    WHERE people_shows_movies.id_trakt_show = :showTraktId
    """
  )
  override suspend fun getAllForShow(showTraktId: Long): List<Person>

  @Query(
    """
    SELECT
    people.id_tmdb,
    people.id_trakt,
    people.id_imdb,
    people.name,
    people


/*
 * Copyright 1989 Chris Torek
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and that
 * both that copyright notice and this permission notice appear in
 * supporting documentation, and that the name of Chris Torek or M.I.T.
 * not be used in advertising or publicity pertaining to distribution of
 * the software without specific, written prior permission.  Chris
 * Torek and M.I.T. make no representations about the suitability of
 * this software for any purpose.  It is provided "as is" without express
 * or implied warranty.
 *
 * CHRIS TOREK AND M.I.T. DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS.  IN NO EVENT SHALL CHRIS TOREK OR M.I.T. BE LIABLE FOR ANY
 * SPECIAL, 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.
 *
 * Original Author:
 * 	Chris Torek
 * 	Dept. of Computer Science
 * 	Univ. of Maryland
 * 	chris@cs.umd.edu
 */

/* Definitions for ScanPostAmble */

/*
 * ScanPostAmble reads the postamble of a DVI file from the (stdio)
 * file specified in its first argument.  It is handed two pointers to
 * functions.  The first (ScanPostAmble's second argument) is called
 * after the header information has been read, and given a pointer to a
 * PostAmbleInfo structure.  It is the job of this function to extract the
 * required information from this structure (which is deallocated when
 * ScanPostAmble returns).
 *
 * The second function is called once for each font definition occurring in
 * the postamble, and is given a pointer to a PostAmbleFont structure.  This
 * function should do whatever the device needs to read the actual font.
 *
 * If the DVI file appears malformed, ScanPostAmble will print an error
 * message and exit.  (Drastic, perhaps, but effective.)
 */

struct PostAmbleInfo {
	i32	pai_PrevPagePointer;	/* previous page pointer */
	i32	pai_Numerator;		/* numerator from dvi file */
	i32	pai_Denominator;	/* denominator from dvi file*/
	i32	pai_DVIMag;		/* \magnification */
	i32	pai_TallestPageHeight;	/* height of tallest page */
	i32	pai_WidestPageWidth;	/* width of widest page */
	int	pai_DVIStackSize;	/* DVI stack size required */
	int	pai_NumberOfPages;	/* total number of pages in DVI file */
};

struct PostAmbleFont {
	char	*paf_name;		/* name of font (null terminated) */
	int 	paf_n1;			/* length of first part of name */
	int 	paf_n2;			/* length of second part of name */
	i32 	paf_DVIFontIndex;	/* font index number */
	i32 	paf_DVIChecksum;	/* checksum from DVI file */
	i32 	paf_DVIMag;		/* "at size" */
	i32 	paf_DVIDesignSize;	/* design size of font */
};


r0
	beq 2f
	movs tos, #0
	push {r0}
	bl _comma_1
	pop {r0}
	b 1b
2:	pull_tos
	pop {pc}
	end_inlined

	@@ Compile a c-string
	define_word "cstring,", visible_flag
_current_comma_cstring:
	push {lr}
	ldr r0, =255
	cmp tos, r0
	ble 1f
	movs tos, r0
1:	push_tos
	bl _current_comma_1
	movs r0, tos
	pull_tos
	movs r1, tos
	pull_tos
2:	cmp r0, #0
	beq 1f
	push_tos
	ldrb tos, [r1]
	push {r0, r1}
	bl _current_comma_1
	pop {r0, r1}
	subs r0, #1
	adds r1, #1
	b 2b
1:	pop {pc}
	end_inlined

	@@ Push a value onto the return stack
	define_word ">r", visible_flag | inlined_flag
_push_r:
	push {tos}
	pull_tos
	bx lr
	end_inlined

	@@ Pop a value off the return stack
	define_word "r>", visible_flag | inlined_flag
_pop_r:	push_tos
	pop {tos}
	bx lr
	end_inlined

	@@ Get a value off the return stack without popping it
	define_word "r@", visible_flag | inlined_flag
_get_r:	push_tos
	ldr tos, [sp]
	bx lr
	end_inlined

	@@ Drop a value from the return stack
	define_word "rdrop", visible_flag | inlined_flag
_rdrop:	adds sp, #4
	bx lr
	end_inlined

	@@ Push two values onto the return stack
	define_word "2>r", visible_flag | inlined_flag
_push_2r:
	ldr r0, [dp], #4
        ldr r1, [dp], #4
	push {tos}
	push {r0}
	movs tos, r1
	bx lr
	end_inlined

	@@ Pop two values off the return stack
	define_word "2r>", visible_flag | inlined_flag
_pop_2r:
	push_tos
	pop {r0, tos}
	stmdb dp!, {r0}
	bx lr
	end_inlined

	@@ Get two values off the return stack without popping it
	define_word "2r@", visible_flag | inlined_flag
_get_2r:
	push_tos
	ldr tos, [sp, #4]
	ldr r0, [sp, #0]
	stmdb dp!, {r0}
	bx lr
	end_inlined

	@@ Drop two values from the return stack
	define_word "2rdrop", visible_flag | inlined_flag
_2rdrop:
	adds sp, #8
	bx lr
	end_inlined

	@@ Get the return stack pointer
	define_word "rp@", visible_flag | inlined_flag
_get_rp:
	push_tos
	mov tos, sp
	bx lr
	end_inlined

	@@ Set the return stack pointer
	define_word "rp!", visible_flag | inlined_flag
_store_rp:
	mov sp, tos
	pull_tos
	bx lr
	end_inlined

	@@ Get the data stack pointer
	define_word "sp@", visible_flag | inlined_flag
_get_sp:
	push_tos
	movs tos, dp
	bx lr
	end_inlined

	@@ Set the data stack pointer
	def


px;
  color: black;
}
ul li.input {
  padding: 2px;
}
/*ul li:last-child {*/
  /*border-bottom: 1px solid #cccccc;*/
/*}*/
ul li small {
  font-size: 60%;
  display: block;
  position: static;
  text-align: left;
  overflow: hidden;
  padding-left: 25px;
  text-overflow: ellipsis;
}
ul li a {
  position: relative;
  text-overflow: ellipsis;
  white-space: nowrap;
  overflow: hidden;
  text-decoration: none;
  display: block;
  padding: 20px;
  margin: -15px;
  color: #5a5a5a;
}
ul li a.active,
ul li a:active {
  background-image: none;
  background-color: #00bdeb;
  color: white;
}
.less ul li a.active,
.less ul li a:active {
  background-color: #ffffff;
  color: #5a5a5a;
}
ul li a.wrap,
ul li a.textarea {
  text-overflow: initial;
  white-space: pre-wrap;
  overflow: auto;
}
ul li a.eye {
  padding: 0 10px;
  display: block;
  width: 24px;
  height: 100%;
  position: absolute;
  right: 15px;
  top: 15px;
  font-size: 120%;
  line-height: 60px;
  background: url('../img/RevealPassword.svg') center center no-repeat;
  background-size: 24px 24px;
}
ul li a.eye.revealed {
  background: url('../img/MaskPassword.svg') center center no-repeat;
  background-size: 24px 24px;
}
ul li a.eye.active,
ul li a.eye:active {
  background-size: 28px 28px;
}
ul li a[data-type=Password] {
  transition: text-shadow .2s ease-in-out;
  color: #5a5a5a;
}
ul li a.obscure,
ul li a.password {
  text-shadow: 0 0 20px #000000;
  color: transparent;
}
ul li pre {
  margin: 0;
  padding: 0;
  font-family: -apple-system-font, Roboto, sans-serif;
  letter-spacing: -0.02em;
}
ul li.sep {
  font-size: 80%;
  /*letter-spacing: -0.03em;*/
  padding: 24px 24px 8px 24px;
  background-color: #f8f8f8;
  border: none;
  color: #C1235B;
  font-weight: normal;
  font-family: UniSans, -apple-system-headline1, Roboto, Helvetica, sans-serif;
  text-transform: uppercase;
}
ul li.entry {
  font-size: 100%;
  line-height: 100%;
}
ul li.entry .entry-label {
  margin-left: 24px;
  margin-top: 4px;
}
ul li.entry .small {
  font-family: UniSans, -apple-system-headline1, Roboto, Helvetica, sans-serif;
  font-size: 76%;
  text-transform: uppercase;
}
ul li.entry .entry-icon {
  width: 16px;
  height: 16px;
  text-align: center;
  margin-right: 8px;
  margin-bottom: -2px;
}
.about-encryptr {
  position: relative;
  top: 24px;
  color: #ccc;
  font-size: 90%;
  width: 100%;
  text-align: center;
  margin: 10px 0 164px 0;
}
ul .entriesViewLoading {
  text-align: center;
  height: 0;
  padding: 0;
  display: none;
}

ul .entriesViewLoading.s


hread = this->bytes_per_chain * this->chains_per_thread;
	this->bytes_per_test = this->bytes_per_thread * this->num_threads;
}

void Experiment::print() {
	printf("strict            = %s\n", strict?"yes":"no");
	printf("pointer_size      = %d\n", pointer_size);
	printf("sizeof(Chain)     = %d\n", sizeof(Chain));
	printf("sizeof(Chain *)   = %d\n", sizeof(Chain *));
	printf("bytes_per_line    = %d\n", bytes_per_line);
	printf("links_per_line    = %d\n", links_per_line);
	printf("bytes_per_page    = %d\n", bytes_per_page);
	printf("lines_per_page    = %d\n", lines_per_page);
	printf("links_per_page    = %d\n", links_per_page);
	printf("bytes_per_chain   = %d\n", bytes_per_chain);
	printf("lines_per_chain   = %d\n", lines_per_chain);
	printf("links_per_chain   = %d\n", links_per_chain);
	printf("pages_per_chain   = %d\n", pages_per_chain);
	printf("chains_per_thread = %d\n", chains_per_thread);
	printf("bytes_per_thread  = %d\n", bytes_per_thread);
	printf("num_threads       = %d\n", num_threads);
	printf("bytes_per_test    = %d\n", bytes_per_test);
	printf("loop length       = %d\n", loop_length);
	printf("prefetch hint     = %s\n", prefetch_hint_string(prefetch_hint));
	printf("iterations        = %d\n", iterations);
	printf("experiments       = %d\n", experiments);
	printf("access_pattern    = %d\n", access_pattern);
	printf("stride            = %d\n", stride);
	printf("output_mode       = %d\n", output_mode);
	printf("numa_placement    = %d\n", numa_placement);
	printf("offset_or_mask    = %d\n", offset_or_mask);
	printf("numa_max_domain   = %d\n", numa_max_domain);
	printf("num_numa_domains  = %d\n", num_numa_domains);

	for (int i = 0; i < this->num_threads; i++) {
		printf("%d: ", this->thread_domain[i]);
		for (int j = 0; j < this->chains_per_thread; j++) {
			printf("%d,", this->chain_domain[i][j]);
		}
		printf("\n");
	}

	fflush(stdout);
}

const char* Experiment::access() {
	const char* result = NULL;

	if (this->access_pattern == RANDOM) {
		result = "random";
	} else if (this->access_pattern == STRIDED && 0 < this->stride) {
		result = "forward";
	} else if (this->access_pattern == STRIDED && this->stride < 0) {
		result = "reverse";
	}

	return result;
}

const char* Experiment::placement() {
	const char* result = NULL;

	if (this->numa_placement == LOCAL) {
		result = "local";
	} else if (this->numa_placement == XOR) {
		result = "xor";
	} else if (this->numa_placement == ADD) {
		result = "add";
	} else if (this->numa_placement == MAP) {
		result = "map";
	}

	return result;
}
// Copyright (c) 2015, Matthew Malensek.
// Distributed under the BSD 2-Clause License (see


;
  -o-transform: scaleX(-1);
  transform: scaleX(-1);
  filter: FlipH;
  -ms-filter: 'FlipH'; }

#mainNav.static-top .sidenav-toggler {
  display: none; }

@media (min-width: 992px) {
  #mainNav.static-top .sidenav-toggler {
    display: flex; } }

body.sidenav-toggled #mainNav.static-top #sidenavToggler i {
  -webkit-transform: scaleX(-1);
  -moz-transform: scaleX(-1);
  -o-transform: scaleX(-1);
  transform: scaleX(-1);
  filter: FlipH;
  -ms-filter: 'FlipH'; }

.content-wrapper {
  overflow-x: hidden;
  background: white; }
  @media (min-width: 992px) {
    .content-wrapper {
      margin-left: 250px; } }

#sidenavToggler i {
  font-weight: 800; }

.navbar-sidenav-tooltip.show {
  display: none; }

@media (min-width: 992px) {
  body.sidenav-toggled .content-wrapper {
    margin-left: 55px; } }

body.sidenav-toggled .navbar-sidenav {
  overflow-x: hidden;
  width: 55px; }
  body.sidenav-toggled .navbar-sidenav .nav-link-text {
    display: none; }
  body.sidenav-toggled .navbar-sidenav .nav-item,
  body.sidenav-toggled .navbar-sidenav .nav-link {
    width: 55px !important; }
    body.sidenav-toggled .navbar-sidenav .nav-item:after,
    body.sidenav-toggled .navbar-sidenav .nav-link:after {
      display: none; }

body.sidenav-toggled .navbar-sidenav-tooltip.show {
  display: flex; }

#mainNav.navbar-dark .navbar-collapse .navbar-sidenav .nav-link-collapse:after {
  color: #868e96; }

#mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item > .nav-link {
  color: #868e96; }
  #mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item > .nav-link:hover {
    color: #adb5bd; }

#mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-second-level > li > a,
#mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-third-level > li > a {
  color: #868e96; }
  #mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-second-level > li > a:focus, #mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-second-level > li > a:hover,
  #mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-third-level > li > a:focus,
  #mainNav.navbar-dark .navbar-collapse .navbar-sidenav > .nav-item .sidenav-third-level > li > a:hover {
    color: #adb5bd; }

#mainNav.navbar-dark .navbar-collapse .navbar-nav > .nav-item.dropdown > .nav-link:after {
  color: #adb5bd; }

@media (min-width: 992px) {
  #mainNav.navbar-dark .navbar-collapse .navbar-sidenav {
    background: #343a40; }
    #mainNav.navbar-dark .navbar-collapse .navbar-sidenav li.active a {
      color: white !important


{
            thread.join().expect("Failed to join child thread");
        }

        assert_eq!(bucket.count(), 2_000_000);
    }
}
#[cfg(test)]
mod multiply {
    use crate::rational::Rational;
    use crate::expr::Expr;
    use crate::var::Var;
    #[test]
    fn test_01() {
        let x = Var::new(&"x", 0.0_f64..);

        let expected = {
            let mut linear = std::collections::HashMap::new();
            linear.insert(&x, 3.2_f64.into());

            Expr {
                linear, constant: Rational::default()
            }
        };

        let expr = 3.2_f64 * &x;

        // println!("{expr:?}");

        assert_eq!(expr, expected);
    }
}
<gh_stars>1-10
use std::env;

fn help() {
    println!("usage: up-all [options]

Options:

  --cache        Force cache file use
  --no-cache     Disable cache file use
  --config=FILE  If specified, use the given file as the up-all configuration

Fly, you fools!
")
}

fn main() {
    // Take a look at this: https://github.com/BurntSushi/xsv/blob/master/src/main.rs
    // parse args / flags

    // open cache & config

    // run package managers

    // store results to cache
}
<reponame>al-jshen/compute
use crate::distributions::*;

const EULER_MASCHERONI: f64 = 0.577215664901532860606512090082402431042159335939923598805767234884867726777664670936947063291746749;
const PISQ6: f64 = std::f64::consts::PI;

/// Implements the [Gumbel](https://en.wikipedia.org/wiki/Gumbel_distribution) distribution.
#[derive(Debug, Clone, Copy)]
pub struct Gumbel {
    /// Shape parameter μ.
    mu: f64,
    /// Rate parameter β.
    beta: f64,
    uniform_gen: Uniform,
}

impl Gumbel {
    /// Create a new Gumbel distribution with location `mu` and scale `beta`.
    ///
    /// # Errors
    /// Panics if `beta <= 0`.
    pub fn new(mu: f64, beta: f64) -> Self {
        if beta <= 0. {
            panic!("Beta must be positive.");
        }
        Gumbel {
            mu,
            beta,
            uniform_gen: Uniform::new(0., 1.),
        }
    }
    pub fn set_mu(&mut self, mu: f64) -> &mut Self {
        self.mu = mu;
        self
    }
    pub fn set_beta(&mut self, beta: f64) -> &mut Self {
        if beta <= 0. {
            panic!("Beta must be positive.");
        }
        self.beta = beta;
        self
    }
}

impl Default for Gumbel {
    fn default() -> Self {
        Self::new(0., 1.)
    }
}

impl Distribution for Gumbel {
    type Output = f64;
    /// Samples from the given Gumbel distribution.
    fn sample(&self) -> Self::Output {
        self.mu - self.beta * (-self.uniform_gen.sample().ln()).ln()
    }
}

impl Distribution1D for Gumbel {
    fn update(&mut self, params: &[f64]) {
        self.set_mu(params[0]).set_beta(params[1]);
    }
}

impl Continuous for Gumbel {
    type PDFType = f64;
    /// Calculates the probability density function for the given Gumbel function at `x`.
    fn pdf(&self, x: f64) -> Self::PDFType {
        let z = (x - self.mu) / self.beta