.open("GET", testURI("resource", "xhr", key));
      req.send();
      await loadPromise;
      return key;
    }

read: async (key) => {
      const req = new XMLHttpRequest();
      const loadPromise = new Promise(resolve => req.addEventListener("load", resolve));
      req.open("GET", testURI("resource", "xhr", key));
      req.send();
      await loadPromise;
      let countResponse = await fetch(testURI("ctr", "xhr", key),
                                      {cache: "reload"});
      return (await countResponse.text()).trim();
    }

result, same first party: 2, 2, 2, 2

result, different first party: 3, 3, 3, 3

unsupported: false, false, false, false

passed: true, true, true, true

test failed: false, false, false, false

            Navigation tests
            Which browsers prevent websites from sharing tracking data when you click on a link?

          When you click a hyperlink to navigate your browser from one site to another, certain browser APIs allow the first site to communicate to the second site. These privacy vulnerabilities can be fixed by introducing new limits on how much data is transfered between sites.',

document.referrerThe Referer [sic] request header is a mechanism used by browsers to let a website know where the user is visiting from. This header is inherently tracking users across websites. In recent times, browsers have switched to a policy of trimming a referrer to convey less tracking information, but Referer continues to convey cross-site tracking data by default.

write: (secret) => { /* do nothing */ }

read: () => document.referrer

result, same first party: https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/

result, different first party: https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/, https://test-pages.privacytests2.org/

unsupported: false, false, false, false

passed: false, false, false, false

test failed: false, false, false, false

sessionStorageThe sessionStorage API is similar to the localStorage API, but it does not persist across tabs or across browser sessions. Nonetheless, it can be used to track users if they navigate from one website to another. This tracking can be thwarted by partitioning sessionStorage between websites.

write: (secret) => sessionStorage.setItem("secret", secret)

read: () => sessionStorage.getItem("secret")

result, same first party: 0a821a51-b157-4afa-bce1-a101e6db7918, 1f1f85d0-6d3d-4cda-8b3d-078038507e27, 50242799-278b-4e02-ad6b-fd6864092a86, 0519900a-4505-46bb-9239-b3ae0469a74d

result, different first party: , , ,

unsupported: false, false, false, false

passe


CONDARY_TAB = 'mui-bar-footer-secondary-tab';
		// var content = document.querySelector('.' + CLASS_CONTENT);
		// if (content) {
		// 	document.body.insertBefore(content, document.body.firstElementChild);
		// }
		document.addEventListener('focusin', function(e) {
			if ($.os.plus) { //在父webview里边不fix
				if (window.plus) {
					if (plus.webview.currentWebview().children().length > 0) {
						return;
					}
				}
			}
			var target = e.target;
			//TODO 需考虑所有键盘弹起的情况
			if (target.tagName && (target.tagName === 'TEXTAREA' || (target.tagName === 'INPUT' && (target.type === 'text' || target.type === 'search' || target.type === 'number')))) {
				if (target.disabled || target.readOnly) {
					return;
				}
				document.body.classList.add(CLASS_FOCUSIN);
				var isFooter = false;
				for (; target && target !== document; target = target.parentNode) {
					var classList = target.classList;
					if (classList && classList.contains(CLASS_BAR_TAB) || classList.contains(CLASS_BAR_FOOTER) || classList.contains(CLASS_BAR_FOOTER_SECONDARY) || classList.contains(CLASS_BAR_FOOTER_SECONDARY_TAB)) {
						isFooter = true;
						break;
					}
				}
				if (isFooter) {
					var scrollTop = document.body.scrollHeight;
					var scrollLeft = document.body.scrollLeft;
					setTimeout(function() {
						window.scrollTo(scrollLeft, scrollTop);
					}, 20);
				}
			}
		});
		document.addEventListener('focusout', function(e) {
			var classList = document.body.classList;
			if (classList.contains(CLASS_FOCUSIN)) {
				classList.remove(CLASS_FOCUSIN);
				setTimeout(function() {
					window.scrollTo(document.body.scrollLeft, document.body.scrollTop);
				}, 20);
			}
		});
	});
})(mui, document);
/**
 * mui namespace(optimization)
 * @param {type} $
 * @returns {undefined}
 */
(function($) {
	$.namespace = 'mui';
	$.classNamePrefix = $.namespace + '-';
	$.classSelectorPrefix = '.' + $.classNamePrefix;
	/**
	 * 返回正确的className
	 * @param {type} className
	 * @returns {String}
	 */
	$.className = function(className) {
		return $.classNamePrefix + className;
	};
	/**
	 * 返回正确的classSelector
	 * @param {type} classSelector
	 * @returns {String}
	 */
	$.classSelector = function(classSelector) {
		return classSelector.replace(/\./g, $.classSelectorPrefix);
	};
	/**
         * 返回正确的eventName
         * @param {type} event
         * @param {type} module
         * @returns {String}
         */
	$.eventName = function(event, module) {
		return event + ($.namespace ? ('.' + $.namespace) : '') + ( module ? ('.' + module) : '');
	};
})(mui);

/**
 * mui gestures
 * @param {type} $
 * @param {type} window
 * @returns {undefined}
 */
(function($, window) {
	$.gestures = {
		session: {}
	};
	/**
	 * Gesture preventDefault
	 * @param {type} e
	 * @retu


                 {
                        hasObtained = true;
                        break;
                    }
                }
                else
                {
                    if (!junkMateriales.ContainsKey(currentMaterial))
                    {
                        junkMateriales.Add(currentMaterial, 0);
                    }

                    junkMateriales[currentMaterial] += quantity[i];
                }
            }

            if (hasObtained)
            {
                break;
            }

            lineArgs = Console.ReadLine().ToLower().Split().ToArray();
        }

        var obtainedElementName = keyMateriales
            .Where(x => x.Value >= 250)
            .First()
            .Key;

        keyMateriales[obtainedElementName] -= 250;

        keyMateriales = keyMateriales
            .OrderByDescending(x => x.Value)
            .ThenBy(x => x.Key)
            .ToDictionary(x => x.Key, x => x.Value);

        Console.WriteLine($"{keyMaterialesNames[obtainedElementName]} obtained!");

        var result = keyMateriales.Concat(junkMateriales).ToDictionary(x => x.Key, x => x.Value);

        foreach (var material in result)
        {
            Console.WriteLine($"{material.Key}: {material.Value}");
        }
    }
}


using System;
using System.Collections;
using Server.Items;
using Server.Targeting;
using Server.Misc;

namespace Server.Mobiles
{
	[CorpseName( "an orcish corpse" )]
	public class OrcBomber : BaseCreature
	{
		public override InhumanSpeech SpeechType{ get{ return InhumanSpeech.Orc; } }

		[Constructable]
		public OrcBomber() : base( AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4 )
		{
			Body = 182;

			Name = "an orc bomber";
			BaseSoundID = 0x45A;

			SetStr( 147, 215 );
			SetDex( 91, 115 );
			SetInt( 61, 85 );

			SetHits( 95, 123 );

			SetDamage( 1, 8 );

			SetDamageType( ResistanceType.Physical, 75 );
			SetDamageType( ResistanceType.Fire, 25 );

			SetResistance( ResistanceType.Physical, 25, 35 );
			SetResistance( ResistanceType.Fire, 30, 40 );
			SetResistance( ResistanceType.Cold, 15, 25 );
			SetResistance( ResistanceType.Poison, 15, 20 );
			SetResistance( ResistanceType.Energy, 25, 30 );

			SetSkill( SkillName.MagicResist, 70.1, 85.0 );
			SetSkill( SkillName.Swords, 60.1, 85.0 );
			SetSkill( SkillName.Tactics, 75.1, 90.0 );
			SetSkill( SkillName.Wrestling, 60.1, 85.0 );

			Fame = 2500;
			Karma = -2500;

			VirtualArmor = 30;

			PackItem( new SulfurousAsh( Utility.RandomMinMax( 6, 10 ) ) );
			PackItem( new MandrakeRoot( Utility.RandomMinMax( 6, 10 ) ) );
			PackItem( new BlackPearl( Utility.RandomMinMax( 6, 10 ) ) );
			PackItem( new MortarPestle() );
			PackItem( new LesserExplosionPotion() );

			if ( 0.2 > Utility.RandomDouble() )
				PackItem( new BolaBall() );
		}

		public override void GenerateLoot()
		{
			AddLoot( LootPack.Average );
			AddLoot( LootPack.Meager );
		}

		public override bool CanRummageCorpses{ get{ return true; } }

		public override OppositionGroup OppositionGroup
		{
			get{ return OppositionGroup.SavagesAndOrcs; }
		}

		public override bool IsEnemy( Mobile m )
		{
			if ( m.Player && m.FindItemOnLayer( Layer.Helm ) is OrcishKinMask )
				return false;

			return base.IsEnemy( m );
		}

		public override void AggressiveAction( Mo


	it = hostMap.find(conn.dstIP);
		if (it == hostMap.end()) {
			Host* h = hostManager.getNewInstance();
			h->setIP(conn.dstIP);
			it = hostMap.insert(pair<uint32_t, Host*>(conn.dstIP, h)).first;
		}
		it->second->addConnection(&conn);
	}
}

void HostStatistics::onReconfiguration1()
{
	dumpStatistics();
}

void HostStatistics::dumpStatistics()
{
	HostMap::iterator it;
	std::fstream outfile(logPath.c_str(), fstream::out);
	outfile << "# ip answeredFlows unansweredFlows sentBytes sentPackets recBytes recPackets recHighPorts sentHighports recLowPorts sentLowPorts" << std::endl;

	// for each element in ipList, write an entry like: IP:Bytesum
	for (it = hostMap.begin(); it != hostMap.end(); it++) {
		Host* h = it->second;
		outfile << IPToString(it->first).c_str() << " "
			<< h->answeredFlows << " "
			<< h->unansweredFlows << " "
			<< h->sentBytes << " "
			<< h->sentPackets << " "
			<< h->recBytes << " "
			<< h->recPackets << " "
			<< h->recHighPorts << " "
			<< h->sentHighPorts << " "
			<< h->recLowPorts << " "
			<< h->sentLowPorts << std::endl;
	}
}
/*
 * Vermont PCAP Exporter
 * Copyright (C) 2010 Vermont Project
 * Copyright (C) 2010 Thomas Hauenstein <sithhaue@users.berlios.de>
 *
 * This program 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 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */

#include "PCAPExporterPipe.h"

#include "modules/packet/Packet.h"
#include "common/Time.h"

#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <cstdlib>
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream>
#include <vector>
#include <cstring>
#include <boost/filesystem/operations.hpp>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <sys/wait.h>
#include <common/SignalHandler.h>

namespace bfs = boost::filesystem;

PCAPExporterPipe::PCAPExporterPipe(const std::string& logfile)
	: logFileName(logfile),
	  fifoReaderCmd(""),
	  workingPath(""),
	  onRestart(false),
	  appenddate(false),
	  restartOnSignal(false),
	  fifoReaderPid(0),
	  dummy(NULL),
	  sigKillTimeout(1),
	  counter(0),
	  last_check(0),
	  statPktsForwarded(0),
	  statBytesForwarded(0),
	  restartInterval(0)
{
	bzero(&nextRestart, sizeof(nextRestart));
}

PCAPExporte


/*-
 * Copyright (c) 2010 The FreeBSD Foundation
 * All rights reserved.
 *
 * This software was developed by Semihalf under sponsorship from
 * the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: release/9.1.0/sys/arm/mv/kirkwood/sheevaplug.c 209131 2010-06-13 13:28:53Z raj $");

#include <dev/fdt/fdt_common.h>
#include <dev/ofw/openfirm.h>

#include <machine/fdt.h>

int
fdt_pci_devmap(phandle_t node, struct pmap_devmap *devmap, vm_offset_t io_va,
    vm_offset_t mem_va)
{

	return (0);
}


�是因为 *callback* 返回 false 而中止，则返回 false，否则返回 true。
     */
    each(callback: EachCallback, scope?: any) {
        return callback.call(scope, this.body, "body", this) !== false;
    }

    /**
     * 使用指定的节点访问器处理当前节点。
     * @param vistior 要使用的节点访问器。
     * @returns 返回访问器的处理结果。
     */
    accept(vistior: NodeVisitor) {
        return vistior.visitComputedPropertyName(this);
    }

}

// #endregion

// #region 注释

/**
 * 表示一个 JS 注释。
 */
export interface Comment {

}

/**
 * 表示一个包含 \<reference /> 的注释。
 */
export interface ReferenceComment extends Comment {

}

/**
 * 表示一个 JS 文档注释。
 */
export interface JsDocComment extends Comment {

}

// #endregion
import { Unit } from "~/entity";

// List of preferred semester/teaching period names to be displayed on the front and stored in the database
// Currently set to be `Moodle Semester` terminology
let preferredSemesterName = {
  FULLYEAR: "FY",
  "SEMESTER 1": "S1",
  "MONASH ONLINE 2": "MO-TP2",
  "MONASH ONLINE 3": "MO-TP3",
  "TERM 3": "T3",
  "WINTER SEMESTER": "WS",
  "MONASH ONLINE 4": "MO-TP4",
  "SEMESTER 2 SEMESTER 1": "S2-S1",
  "SEMESTER 2 SUMMER A": "S2-SS",
  "SEMESTER 2": "S2",
  "MONASH ONLINE 5": "MO-TP5",
  "OCTOBER INTAKE MALAYSIA": "OCT-MY",
  "MONASH ONLINE 6": "MO-TP6",
  "NOVEMBER 12WEEK TEACHING PERIOD": "Nov",
  "SUMMER SEMESTER A": "SSA",
  "SUMMER SEMESTER B": "SSB",
  "MONASH ONLINE 1": "MO-TP1",
};

// Dictionary to map various semester/teaching periods string to their preferred versions (Moodle form)
let semesterNamesDict: { [key: string]: string } = {
  // Full Year
  FULLYEAR: preferredSemesterName[`FULLYEAR`],
  FY01: preferredSemesterName[`FULLYEAR`],
  FY: preferredSemesterName[`FULLYEAR`],
  "FULL YEAR OFFICIAL CALENDAR": preferredSemesterName[`FULLYEAR`],

  // SEMESTER 1
  "SEMESTER 1": preferredSemesterName[`SEMESTER 1`],
  S101: preferredSemesterName[`SEMESTER 1`],
  S1: preferredSemesterName[`SEMESTER 1`],
  "SEM 1 OFFICIAL CALENDAR": preferredSemesterName[`SEMESTER 1`],

  // Monash online 2
  "MONASH ONLINE 2": preferredSemesterName[`MONASH ONLINE 2`],
  MOTP201: preferredSemesterName[`MONASH ONLINE 2`],
  MOTP2: preferredSemesterName[`MONASH ONLINE 2`],
  TP2: preferredSemesterName[`MONASH ONLINE 2`],
  "MONASH ONLINE TEACHING PERIOD 2": preferredSemesterName[`MONASH ONLINE 2`],

  // Monash online 3
  "MONASH ONLINE 3": preferredSemesterName[`MONASH ONLINE 3`],
  MOTP301: preferredSemesterName[`MONASH ONLINE 3`],
  MOTP3: preferredSemesterName[`MONASH ONLINE 3`],
  TP3: preferredSemesterName[`MONASH ONLINE 3`],
  "MONASH ONLINE TEACHING PERIOD 3": pr


(1, big.NewInt(0), deployer, secondSCAddress, gasPrice, 1000, txData)
	returnCode, err := testContextSecondContract.TxProcessor.ProcessTransaction(tx)
	require.Nil(t, err)
	require.Equal(t, vmcommon.Ok, returnCode)
	_, err = testContextSecondContract.Accounts.Commit()
	require.Nil(t, err)
	utils.CheckOwnerAddr(t, testContextSecondContract, secondSCAddress, firstContract)

	// STEP 3
	// call `change_owner` function from the first contract
	gasLimit := uint64(5000000)
	dataField := append([]byte("change_owner"), []byte("@"+hex.EncodeToString(secondSCAddress))...)
	dataField = append(dataField, []byte("@"+hex.EncodeToString(firstOwner))...)
	tx = vm.CreateTransaction(1, big.NewInt(0), firstOwner, firstContract, gasPrice, gasLimit, dataField)

	retCode, err := testContextSource.TxProcessor.ProcessTransaction(tx)
	require.Equal(t, vmcommon.Ok, retCode)
	require.Nil(t, err)

	intermediateTxs := testContextSource.GetIntermediateTransactions(t)
	require.Equal(t, 1, len(intermediateTxs))

	expectedDataField := core.BuiltInFunctionChangeOwnerAddress + "@" + hex.EncodeToString(firstOwner)
	require.True(t, strings.HasPrefix(string(intermediateTxs[0].GetData()), expectedDataField))

	logs := testContextSource.TxsLogsProcessor.GetAllCurrentLogs()
	require.NotNil(t, logs)

	// STEP 4
	// executed results smart contract results of the shard1 where the second contract was deployed
	testContextSecondContract.TxsLogsProcessor.Clean()
	utils.ProcessSCRResult(t, testContextSecondContract, intermediateTxs[0], vmcommon.Ok, nil)
	utils.CheckOwnerAddr(t, testContextSecondContract, secondSCAddress, firstOwner)

	logs = testContextSecondContract.TxsLogsProcessor.GetAllCurrentLogs()
	require.NotNil(t, logs)
	require.Equal(t, core.BuiltInFunctionChangeOwnerAddress, string(logs[0].GetLogEvents()[0].GetIdentifier()))
}
package multiShard

import (
	"encoding/hex"
	"math/big"
	"testing"

	"github.com/multiversx/mx-chain-go/config"
	"github.com/multiversx/mx-chain-go/integrationTests"
	"github.com/multiversx/mx-chain-go/integrationTests/vm"
	"github.com/multiversx/mx-chain-go/integrationTests/vm/txsFee/utils"
	"github.com/multiversx/mx-chain-go/testscommon"
	vmcommon "github.com/multiversx/mx-chain-vm-common-go"
	"github.com/stretchr/testify/require"
)

func TestAsyncCallShouldWork(t *testing.T) {
	if testing.Short() {
		t.Skip("this is not a short test")
	}

	enableEpochs := config.EnableEpochs{
		DynamicGasCostForDataTrieStorageLoadEnableEpoch: integrationTests.UnreachableEpoch,
	}

	testContextFirstContract, err := vm.CreatePreparedTxProcessorWithVMsMultiShard(0, enableEpochs, 1)
	require.Nil(t, err)
	defer testContextFirstContract.Close()

	testContextSecondContract, err := vm.CreatePreparedTxProcessorWithVMsMultiShard(1, enableEpochs, 1)
	require.Nil(t, err)
	defer testContextSecondContract.Close()

	testContextSender, err := vm.CreatePreparedTxProcessorWithVMsMultiShard(2, enableEpochs, 1)
	require.Nil(t, err)
	defer testContextSender.Close()

	firstContractOwner := []byte("12345678901234567890123456789


ut<string>? SecurityGroupId { get; set; }

        /// <summary>
        /// VPC ID
        /// </summary>
        [Input("vpcId", required: true)]
        public Input<string> VpcId { get; set; } = null!;

        /// <summary>
        /// Virtual Switch ID
        /// </summary>
        [Input("vswitcheList", required: true)]
        public Input<string> VswitcheList { get; set; } = null!;

        public ServiceMeshNetworkGetArgs()
        {
        }
        public static new ServiceMeshNetworkGetArgs Empty => new ServiceMeshNetworkGetArgs();
    }
}


var lineStart = textModel.getLineStart(line);
			var lineEnd = textModel.getLineEnd(line);
			var add = AT.createAnnotation(type, lineStart, lineEnd);
			// Replace to or add the new annotation
			if (remove) {
				annotationModel.replaceAnnotations([remove], [add]);
			} else {
				annotationModel.addAnnotation(add);
			}
		},

		/**
		 * Unhightlight the highlighted line
		 */
		unhighlightLine: function() {
			var annotationModel = this.getAnnotationModel();
			var textModel = this.getModel();
			if (textModel.getBaseModel) {
				textModel = textModel.getBaseModel();
			}
			var type = AT.ANNOTATION_HIGHLIGHTED_LINE;
			var annotations = annotationModel.getAnnotations(0, textModel.getCharCount());
			var remove = null;
			while (annotations.hasNext()) {
				var annotation = annotations.next();
				if (annotation.type === type) {
					remove = annotation;
					break;
				}
			}
			if (remove) {
				annotationModel.removeAnnotation(remove);
			}
		},

		install : function() {
			if (this._textView) { return; }

			// Create textView and install optional features
			this._textView = this._textViewFactory(this);
			if (this._undoStackFactory) {
				this._undoStack = this._undoStackFactory.createUndoStack(this);
				this._textView.setOptions({undoStack: this._undoStack});
				this.checkDirty();
			}
			if (this._textDNDFactory) {
				this._textDND = this._textDNDFactory.createTextDND(this, this._undoStack);
			}
			if (this._contentAssistFactory) {
				var contentAssistMode = this._contentAssistFactory.createContentAssistMode(this);
				this._contentAssist = contentAssistMode.getContentAssist();
			}

			var tooltip = mTooltip.Tooltip.getTooltip(this._textView, this);
			if (this._hoverFactory) {
				this._hover = this._hoverFactory.createHover(this);
				tooltip.hover = this._hover;
			}

			var editor = this, textView = this._textView;

			var that = this;
			this._listener = {
				onModelChanged: /* @callback */ function(e) {
					that.checkDirty();
				},
				onMouseOver: function(e) {
					that._listener.onMouseMove(e);
				},
				onMouseDown: /* @callback */ function(e) {
					that._listener.mouseDown = true;
				},
				onMouseUp: /* @callback */ function(e) {
					that._listener.mouseDown = false;
				},
				onMouseMove: function(e) {
					if (!tooltip || that._listener.mouseDown) { return; }

					// Prevent spurious mouse event (e.g. on a scroll)
					if (e.event.clientX === that._listener.lastMouseX
						&& e.event.clientY === that._listener.lastMouseY) {
						return;
					}

					that._listener.lastMouseX = e.event.clientX;
					that._listener.lastMouseY = e.event.clientY;

					if (that._hoverTimeout) {
						window.clearTimeout(that._hoverTimeout);
						that._hoverTimeout = null;
					}
					that._hoverTimeout = window.setTimeout(function() {
						that._hoverTimeout = null;

						// Re-check incase editor closed...
						if (!that._listener){
							return;
						}

						tooltip.onHover({
							y: e.y,
							x: e.x,
							getTooltipInfo: function() {
								return that._getTooltipInfo(this.x, this.y);
							}
						}, e.x, e.y);
					}, 175);
				},
				onMouseOut: /* @callback */ function(e) {
					// When mouse leaves the editor, ignore any pending


if Pads.check(PAD, PAD_CIRCLE) or Pads.check(PAD, PAD_TRIANGLE) and CONTROL.JOYSTICK_ON == false then
			local nueva_conf = {lista_config[1]; lista_config[2]; lista_config[3]; color1; color2; color3;
			estilo_lista; lista_config[8]; lista_config[9]; lista_config[10]; lista_config[11];
			lista_config[12]; lista_config[13]; lista_config[14]; lista_config[15]; lista_config[16]; lista_config[17];
			lista_config[18]; lista_config[19]; lista_config[20]; lista_config[21]; selec_fuente; selec_fondo;
			lista_config[24]; lista_config[25]; selec_dir; lista_texto_config[27]; lista_config[28]; lista_config[29];
			volume; lista_config[31]; lista_config[33]; lista_config[34]; tras_demo; OPCIONES.LIBERAR_LISTAS; font_x;
			font_Y; font_shadow; font_scroll;};
			cambio_realizado = false
			for chequeo = 1, #nueva_conf do
				if nueva_conf[chequeo] ~= anterior_conf[chequeo] then cambio_realizado = true end
			end
			if cambio_realizado == true then
				local pregunta = true
				local message_exit = {"UNSAVED CHANGES DO YOU WANT TO EXIT?", "EXIT", "CANCEL"}
				Graphics.drawRect(0, 160+CONTROL.Y_FIX_PAL, CONTROL.ANCHO, 114, Color.new(128, 128, 128))
				Graphics.drawRect(0, 162+CONTROL.Y_FIX_PAL, CONTROL.ANCHO, 110, Color.new(0, 0, 0))
				Font.ftPrint(CONTROL.fontARCA, (CONTROL.ANCHO//2), (162+8)+CONTROL.Y_FIX_PAL, 8, CONTROL.ANCHO, 88, message_exit[1], COLOR.BLANCO)
				Graphics.drawScaleImage(PAD_IMG.CROSS, 300-35, 195+CONTROL.Y_FIX_PAL, 20, 20)
				Font.ftPrint(CONTROL.fontARCA, 300, 195+CONTROL.Y_FIX_PAL, 0, 160, 24, message_exit[2], COLOR.BLANCO)
				Graphics.drawScaleImage(PAD_IMG.SQUARE, 300-35, 219+CONTROL.Y_FIX_PAL, 20, 20)
				Font.ftPrint(CONTROL.fontARCA, 300, 219+CONTROL.Y_FIX_PAL, 0, 160, 24, message_exit[3], COLOR.BLANCO)
				Font.ftPrint(CONTROL.fontARCA, (CONTROL.ANCHO//2), 246+CONTROL.Y_FIX_PAL, 8, CONTROL.ANCHO, 50, "All changes made will be lost upon reboot.", COLOR.BLANCO)
				refrescar(false)
				while pregunta do
					capturar(JOYSTICK_LIMITE)
					if Pads.check(PAD, PAD_CROSS) then
						if doesFileExist(OPCIONES.SALIDA_RETROLANCHER) == false
							or string.lower(string.sub(OPCIONES.SALIDA_RETROLANCHER, -4)) ~= ".elf" then
							OPCIONES.SALIDA_RETROLANCHER_ON = anterior_conf[26]
							OPCIONES.SALIDA_RETROLANCHER = anterior_conf[27]
						end
						noob = false
						pregunta = false
					elseif Pads.check(PAD, PAD_SQUARE) then
						pregunta = false
					end
					refrescar(true)
				end
			else
				noob = false
			end
			if OPCIONES.SOUND_ON == 1 and S_CANCELAR ~= nil then
				Sound.playADPCM(1, S_CANCELAR)
			end
			CONTROL.JOYSTIC


    ) -> Result<(), CyclesAccountError> {
        self.withdraw_with_threshold(cycles, threshold).map(|()| {
            self.consumed_cycles_since_replica_started += NominalCycles::from_cycles(cycles)
        })
    }

    /// Adds `cycles` to the canister's balance.
    pub fn add_cycles(&mut self, cycles_to_add: Cycles) {
        self.cycles_balance += cycles_to_add;
    }

    pub fn refund_cycles(&mut self, cycles_to_refund: Cycles) {
        self.cycles_balance += cycles_to_refund;
        self.consumed_cycles_since_replica_started -= NominalCycles::from_cycles(cycles_to_refund);
    }

    /// Note that this function is made public to facilitate some logistic in
    /// tests.
    #[doc(hidden)]
    pub fn set_balance(&mut self, cycles: Cycles) {
        self.cycles_balance = cycles;
    }
}

impl From<&CyclesAccount> for pb::CyclesAccount {
    fn from(item: &CyclesAccount) -> Self {
        Self {
            cycles_balance: item.cycles_balance.into(),
        }
    }
}

impl From<pb::CyclesAccount> for CyclesAccount {
    fn from(value: pb::CyclesAccount) -> Self {
        Self {
            cycles_balance: Cycles::from(&value.cycles_balance),
            // TODO(EXC-173): Refactoring the cycles account.
            // Clearing up the tech debt mentioned above, will remove this field and
            // directly update the one from CanisterMetrics.
            // After loading CyclesAccount from checkpoint, we set this field
            // to the proper value which is held by `CanisterStateBits`
            consumed_cycles_since_replica_started: Default::default(),
        }
    }
}
use gtk_sys;

use libc::c_char;

use glib::subclass::prelude::*;
use glib::translate::*;
use glib::GString;

use super::cell_renderer::CellRendererImpl;
use CellRenderer;
use CellRendererToggle;

pub trait CellRendererToggleImpl: CellRendererToggleImplExt + CellRendererImpl {
    fn toggled(&self, renderer: &CellRendererToggle, path: &str) {
        self.parent_toggled(renderer, path);
    }
}

pub trait CellRendererToggleImplExt {
    fn parent_toggled(&self, renderer: &CellRendererToggle, path: &str);
}

impl<T: CellRendererToggleImpl> CellRendererToggleImplExt for T {
    fn parent_toggled(&self, renderer: &CellRendererToggle, path: &str) {
        unsafe {
            let data = T::type_data();
            let parent_class =
                data.as_ref().get_parent_class() as *mut gtk_sys::GtkCellRendererToggleClass;
            if let Some(f) = (*parent_class).toggled {
                f(renderer.to_glib_none().0, path.to_glib_none().0)
            }
        }
    }
}

unsafe impl<T: CellRendererToggleImpl> IsSubclassable<T> for CellRendererToggle {
    fn override_vfuncs(class: &mut ::glib::Class<Self>) {
        <CellRenderer as IsSubclassable<T>>::override_vfuncs(class);

        let klass = class.as_mut();
        klass.toggled = Some(cell_renderer_toggle_toggled::<T>);
    }
}

unsafe extern "C" fn


local tint = require("techbase.utils").tint

return function(c, hl)
  hl["GitSignsAdd"] = { fg = c.git_add_col }
  hl["GitSignsChange"] = { fg = c.git_change_col }
  hl["GitSignsDelete"] = { fg = c.git_delete_col }
  hl["GitSignsChangedelete"] = { link = "GitSignsChange" }
  hl["GitSignsTopdelete"] = { link = "GitSignsDelete" }
  hl["GitSignsUntracked"] = { link = "NonText" }
  hl["GitSignsStagedAdd"] = { fg = tint(c.git_add_col, -50) }
  hl["GitSignsStagedChange"] = { fg = tint(c.git_change_col, -50) }
  hl["GitSignsStagedDelete"] = { fg = tint(c.git_delete_col, -50) }
  hl["GitSignsStagedChangedelete"] = { link = "GitSignsStagedChange" }
  hl["GitSignsStagedTopdelete


(func() {
			reloader = &spiffefakes.FakeReloader{}
			writer = &spiffefakes.FakeSVIDWriter{}
			certFetcher = &spiffefakes.FakeCertFetcher{}
			// create channels for certFetcher
			certCh = make(chan *workloadapi.X509Context, 10)
			errCh = make(chan error)
			// set response from fake cert fetcher
			certFetcher.StartReturns(certCh, errCh, nil)
		})
		JustBeforeEach(func() {
			certManager = sc.NewCertManagerWithReloader(reloader, writer, certFetcher, certWaitTimeout)
		})
		It("fetches certs, writes, and reloads until stop signal is received", func() {
			ctx, cancel := context.WithCancel(context.Background())
			var err error
			certCh <- &workloadapi.X509Context{} // initial trust bundle
			err = certManager.Run(ctx)
			Expect(err).ToNot(HaveOccurred())

			// write certs to channel
			for i := 0; i < 10; i++ {
				certCh <- &workloadapi.X509Context{}
			}
			fetchDone := make(chan struct{})
			// wait for all the certs to be read off the channel
			go func() {
				for {
					if len(certCh) == 0 {
						close(fetchDone)

						return
					}
				}
			}()
			<-fetchDone
			cancel()
			err = <-certManager.ErrCh
			Expect(err).Should(MatchError(context.Canceled))
			Expect(writer.WriteCallCount()).Should(BeNumerically(">=", 9))
			Expect(reloader.ReloadCallCount()).Should(BeNumerically(">=", 9))
		})
		It("exits on write error", func() {
			ctx, cancel := context.WithCancel(context.Background())
			var err error
			// stub writer error
			writer.WriteReturns(errFakeWriteFail)

			go func() {
				err = certManager.Run(ctx)
				cancel()
			}()
			// put a cert on the cert channel
			certCh <- &workloadapi.X509Context{}
			<-ctx.Done()
			Expect(err.Error()).To(ContainSubstring("fake write error"))
		})
		It("quits and logs error on certFetcher start error", func() {
			ctx, cancel := context.WithCancel(context.Background())
			defer cancel()
			// stub error response from cert fetcher
			certFetcher.StartReturns(nil, nil, errFakeFetchFail)
			err := certManager.Run(ctx)
			Expect(err).To(HaveOccurred())
			Expect(err.Error()).To(ContainSubstring("fake fetch error"))
		})
		It("quits when context is canceled", func() {
			ctx, cancel := context.WithCancel(context.Background())
			var err error
			certCh <- &workloadapi.X509Context{} // initial trust bundle
			err = certManager.Run(ctx)
			Expect(err).ToNot(HaveOccurred())
			cancel()
			err = <-certManager.ErrCh
			// check that certManager exits after context is canceled
			Expect(err).Should(MatchError(context.Canceled))
		})
	})

	Describe("Disk SVID Writer", func() {
		config := sc.DiskSVIDConfig{
			KeyFilename:      "tls.key",
			CertFilename:     "tls.crt",
			CABundleFilename: "ca.crt",
		}
		It("creates correct file paths from config", func() {
			// create directory
			dir, err := os.MkdirTemp("", "ssl")
			Expect(err).ToNot(HaveOccurred())
			defer func() {
				Expect(os.RemoveAll(dir)).To(Succeed())
			}()
			config.CertDir = dir
			writer, err := sc.NewDiskSVIDWriter(config)
			Expect(err).ToNot(HaveOccu


class Contestant():

    # , points_f, place_sf1, points_sf1, place_sf2, points_sf2, broadcaster, composer, writer):
    def __init__(self, year, country, performer, song, page_url,
                 running_final=None, running_sf=None,
                 sf_num=None,
                 place_contest=None,
                 place_final=None, points_final=None,
                 place_sf=None, points_sf=None,
                 points_tele_final=None, points_jury_final=None,
                 points_tele_sf=None, points_jury_sf=None):

        self.year = year
        self.country = country
        self.performer = performer
        self.song = song
        self.page_url = page_url
        self.composers = []
        self.lyricists = []
        self.lyrics = None
        self.youtube_url = None

        self.sf_num = sf_num
        self.running_final = running_final
        self.running_sf = running_sf

        # All possible places and points
        self.place_contest = place_contest
        self.place_final = place_final
        self.points_final = points_final
        self.place_sf = place_sf
        self.points_sf = points_sf
        self.points_tele_final = points_tele_final
        self.points_jury_final = points_jury_final
        self.points_tele_sf = points_tele_sf
        self.points_jury_sf = points_jury_sf

        self.betting_offices = []

        # self.broadcaster = broadcaster
        # self.composer = composer
        # self.writer = writer

    def __str__(self):
        return '{} ({}) - {} - {}'.format(self.country, self.year, self.performer, self.song)


-----------------------------------------------------#
        #   给图像增加灰条，实现不失真的resize
        #---------------------------------------------------------#
        image_data, nw, nh  = resize_image(image, (self.input_shape[1], self.input_shape[0]))
        #---------------------------------------------------------#
        #   归一化+添加上batch_size维度
        #---------------------------------------------------------#
        image_data  = np.expand_dims(preprocess_input(np.array(image_data, np.float32)), 0)

        #---------------------------------------------------#
        #   图片传入网络进行预测
        #---------------------------------------------------#
        pr = self.model.predict(image_data)[0]
        #--------------------------------------#
        #   将灰条部分截取掉
        #--------------------------------------#
        pr = pr[int((self.input_shape[0] - nh) // 2) : int((self.input_shape[0] - nh) // 2 + nh), \
                int((self.input_shape[1] - nw) // 2) : int((self.input_shape[1] - nw) // 2 + nw)]
        #---------------------------------------------------#
        #   取出每一个像素点的种类
        #---------------------------------------------------#
        pr = pr.argmax(axis=-1).reshape([self.input_shape[0],self.input_shape[1]])

        t1 = time.time()
        for _ in range(test_interval):
            #---------------------------------------------------#
            #   图片传入网络进行预测
            #---------------------------------------------------#
            pr = self.model.predict(image_data)[0]
            #--------------------------------------#
            #   将灰条部分截取掉
            #--------------------------------------#
            pr = pr[int((self.input_shape[0] - nh) // 2) : int((self.input_shape[0] - nh) // 2 + nh), \
                    int((self.input_shape[1] - nw) // 2) : int((self.input_shape[1] - nw) // 2 + nw)]
            #---------------------------------------------------#
            #   取出每一个像素点的种类
            #---------------------------------------------------#
            pr = pr.argmax(axis=-1).reshape([self.input_shape[0],self.input_shape[1]])

        t2 = time.time()
        tact_time = (t2 - t1) / test_interval
        return tact_time

    def get_miou_png(self, image):
        #---------------------------------------------------------#
        #   在这里将图像转换成RGB图像，防止灰度图在预测时报错。
        #   代码仅仅支持RGB图像的预测，所有其它类型的图像都会转化成RGB
        #---------------------------------------------------------#
        image       = cvtColor(image)
        orininal_h  = np.array(image).shape[0]
        orininal_w  = np.array(image).shape[1]
        #---------------------------------------------------------#
        #   给图像增加灰条，实现不失真的resize
        #---------------------------------------------------------#
        image_data, nw, nh  = resize_image(image, (self.input_shape[1], self.input_shape[0]))
        #---------------------------------------------------------#
        #   归一化+添加上batch_size维度
        #---------------------------------------------------------#
        image_data  = np.expand_dims(preprocess_input(np.array(image_data, np.float32)), 0)

        #--------------------------------------#
        #   图片传入网络进行预测
        #--------------------------------------#
        pr = self.model.predict(image_data)[0]
        #--------------------------------------#
        #   将灰条部分截取掉
        #--------------------------------------#
        pr = pr[int((self.input_shape[0] - nh) // 2) : int((self.input_shape[0] - nh) // 2 + nh), \
                int((self.input_shape[1] - nw) // 2) : int((self.input_shape[1] - nw) // 2 + nw)]
        #--------------------------------------#
        #   进行图片的resize
        #--------------------------------------#
        pr = cv2.resize(pr, (orininal_w, orininal_h), interpolation = cv2.INTER_LINEAR)
        #---------------------------------------------------#
        #   取出每一个像素点的种类
        #---------------------------------------------------#
        pr = pr.argmax(axis=-1)

        image = Image.fromarray(np.uint8(pr))
        return image


        return null
    }

    fun mk_chnk_vect(): ByteArray? {
        // chnk_is_valid = false // not implemented yet
        // if (chnk_is_valid) return null

        val lst = ArrayList<Any>()
        var v = ""
        var encoding_len = 0

        var i = 0
        var new_chnk_offs = chnk_offs + 1
        while (i < context.tinyGoset.keys.size) {
            val ndx = (chnk_offs + i) % context.tinyGoset.keys.size
            val fid = context.tinyGoset.keys[ndx]
            val r = fid2replica(fid)
            val pending = r?.get_open_chains()
            if (pending == null || pending.isEmpty()) {
                i++
                continue
            }
            new_chnk_offs++
            var lim = 3 // limit # of chunks per feed that we ask for
            for ((seq, p) in pending) {
                val c = arrayListOf(ndx, seq, p.cnr)
                lst.add(c)
                // val cl = Bipf.encodingLength(c)
                // Log.d("repo", "mk_chunk_vect - enc_len ${cl}")
                encoding_len += Bipf.encodingLength(c)
                v += (if (v.length == 0) "[" else " ") + "$ndx.$seq.${p.cnr}"
                if (encoding_len > 100)
                    break
                lim--
                if (lim <= 0)
                    break
            }
            if (encoding_len > 100)
                break
            i++
        }
        chnk_offs = new_chnk_offs % context.tinyGoset.keys.size
        // chnk_is_valid = true

        if (lst.size > 0) {
            Log.d("repo", "mk_chnk offs=${chnk_offs}, vector=${v}]")
            val lst_e = Bipf.encode(Bipf.mkList(lst))
            return lst_e
        }
        return null
    }

    fun listFeeds(): List<ByteArray> {
        return replicas.map { it -> it.fid }
    }

    fun feed_read_content(fid: ByteArray, seq: Int): ByteArray? {
        return fid2replica(fid)?.read_content(seq)
    }

    /**
     * Converts the old repo filesystem (used in version v0.1.5-alpha) to the current filesystem.
     * This method is crash resistant, e.g it only overwrites/deletes old files, if the upgrade was successful.
     *
     * It is assumed that the previous filesystem was correctly stored.
     *
     */
    fun upgrade_repo() {
        val dir = File(context.getDir(TINYSSB_DIR, MODE_PRIVATE), FEED_DIR)
        feediterate@ for (f in dir.listFiles()) {
            if (!f.isDirectory || f.name.length != 2* FID_LEN)
                continue
            val feed_dir = File(dir, f.name)
            val feed_files = feed_dir.listFiles()
            if(feed_files == null) { // no upgrade needed or unknown file system
                continue
            }
            // crashed after writing log file to disk, which can lead to missing mid.bin file
            if(feed_files.any { it.name == "log.bin" }) {
                if(!feed_files.any { it.name == "mid.bin" }) {
                    Files.move(File(feed_dir, "mid").toPath(), File(feed_dir, "mid.bin").toPath(), StandardCopyOption.ATOMIC_MOVE)
                    val sidechains = feed_files.filter { it.name.startsWith("!") || it.name.startsWith("-") }
                    sidechains.forEach { it.delete() }
                }
                continue // frontier, mid and log file are already successfully upgraded
            }
            val old_log = RandomAccessFile(File(feed_dir, "log"), "r")
            val buffer = ByteArray(TINYSSB_PKT_L


radius: 4px;
}
.cxd-FormulaPicker-ResultBox span.c-func {
  color: #ae4597;
  font-weight: bold;
  line-height: 14px;
  padding: 0 2px;
}
.cxd-FormulaPicker.is-input-group {
  border: var(--Form-input-borderWidth) solid var(--Form-input-borderColor);
  padding: 0 var(--Form-input-paddingX) 0 0;
  border-radius: var(--borderRadius);
  background-color: var(--colors-neutral-fill-11);
  height: var(--Form-input-height);
}
.cxd-FormulaPicker.is-input-group.cxd-FormulaPicker--text {
  padding: var(--Form-input-paddingY) var(--Form-input-paddingX) var(--Form-input-paddingY) 0.3125rem;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input {
  display: flex;
  align-items: center;
  background: none;
  padding: 0;
  border: 0;
  margin: 0;
  margin-right: 0.625rem;
  max-width: unset;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input:focus {
  border: none;
  outline: none;
  box-sizing: none;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-select, .cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-number, .cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-boolean, .cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-date, .cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-time, .cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-datetime {
  height: var(--InputFormula-input-schema-height);
  padding-left: var(--Form-input-paddingX);
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-number {
  padding-left: 0;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-number .cxd-Number-handler-wrap {
  height: unset; /* 避免调节器超出Input框 */
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-custom {
  border: 0;
  flex: 1;
  min-width: 0;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-custom > div {
  border: 0;
  padding: 0 0 0 var(--Form-input-paddingX);
  align-items: center;
  height: var(--InputFormula-input-schema-height);
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-input-variable {
  border: none;
  min-height: unset;
  line-height: 1.125rem;
  padding-top: 0;
  padding-bottom: 0;
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-toggler {
  color: var(--colors-neutral-text-2);
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-toggler .icon-function {
  transform: scale(1.3);
}
.cxd-FormulaPicker.is-input-group .cxd-FormulaPicker-toggler .icon-ellipsis-v {
  transform: rotate(90deg);
}
.cxd-FormulaPicker


rokAttributesRemoval() {
        assertFieldNames("""
            from message_types
            | eval type = 1
            | lookup join message_types_lookup on message
            | drop  message
            | grok type "%{WORD:b}"
            | stats x = max(b)
            | keep x""", Set.of("_index", "x", "b", "type", "message", "x.*", "message.*", "type.*", "b.*"));
    }

    public void testAvoidGrokAttributesRemoval2() {
        assertFieldNames("""
            from sample_data
            | dissect message "%{type}"
            | drop type
            | lookup join message_types_lookup on message
            | stats count = count(*) by type
            | keep count
            | sort count""", Set.of("_index", "type", "message", "count", "message.*", "type.*", "count.*"));
    }

    public void testAvoidGrokAttributesRemoval3() {
        assertFieldNames(
            """
                from sample_data
                | grok message "%{WORD:type}"
                | drop type
                | lookup join message_types_lookup on message
                | stats max = max(event_duration) by type
                | keep max
                | sort max""",
            Set.of("_index", "type", "event_duration", "message", "max", "event_duration.*", "message.*", "type.*", "max.*")
        );
    }

    /**
     * @see ES|QL: Grok only supports KEYWORD or TEXT values, found expression [type] type [INTEGER]
     */
    public void testAvoidGrokAttributesRemoval4() {
        assertFieldNames("""
            from message_types
            | eval type = 1
            | lookup join message_types_lookup on message
            | drop  message
            | grok type "%{WORD:b}"
            | stats x = max(b)
            | keep x""", Set.of("_index", "x", "b", "type", "message", "x.*", "message.*", "type.*", "b.*"));
    }

    /**
     * @see ES|QL: Grok only supports KEYWORD or TEXT values, found expression [type] type [INTEGER]
     */
    public void testAvoidGrokAttributesRemoval5() {
        assertFieldNames(
            """
                FROM sample_data, employees
                | EVAL client_ip = client_ip::keyword
                | RENAME languages AS language_code
                | LOOKUP JOIN clientips_lookup ON client_ip
                | EVAL type = 1::keyword
                | EVAL type = 2
                | LOOKUP JOIN message_types_lookup ON message
                | LOOKUP JOIN languages_lookup ON language_code
                | DISSECT type "%{type_as_text}"
                | KEEP message
                | WHERE message IS NOT NULL
                | SORT message DESC
                | LIMIT 1""",
            Set.of(
                "_index",
                "message",
                "type",
                "languages",
                "client_ip",
                "language_code",
                "language_code.*",
                "client_ip.*",
                "message.*",
                "type.*",
                "languages.*"
            )

        );
    }

    public void testEnrichOnDefaultField() {
        assertFieldNames("""
            from employees
            | enrich languages_policy""", true, ALL_FIELDS, Set.of());
    }

    public void testMetrics() {
        var query = "TS k8s | STATS bytes=sum(rate(network.total_bytes_in)), sum(rate(network.total_cost)) BY cluster";
        assertFieldNames(
            query,
            Set.of(
                "_index",
                "@timestamp",
                "@timestamp.*",


().map(|&x| x as i64).collect();
        longs
    }

    pub fn csv_string_to_ints(contents: &str) -> Vec<i32> {
        let mut ints = Vec::new();
        for s in contents.split(",") {
            ints.push(s.trim().parse::<i32>().unwrap());
        }
        ints
    }
}

pub mod int_code_computer {
    use std::collections::VecDeque;
    use derive_more::From;

    #[derive(Debug)]
    enum InstrResult {
        Halt,
        AdvanceIP(i64),
    }

    #[derive(PartialEq, Debug)]
    enum ParamMode {
        Position,
        Immediate,
    }

    #[derive(PartialEq, Debug)]
    enum ParamType {
        Read(ParamMode),
        Write(ParamMode),
    }

    #[derive(PartialEq, Debug)]
    struct Nullary;
    #[derive(PartialEq, Debug)]
    struct Unary(ParamType);
    #[derive(PartialEq, Debug)]
    struct Binary(ParamType, ParamType);
    #[derive(PartialEq, Debug)]
    struct Ternary(ParamType, ParamType, ParamType);

    #[derive(PartialEq, Debug, From)]
    enum InstrArity<'a> {
        Unary(&'a Unary),
        Binary(&'a Binary),
        Ternary(&'a Ternary),
    }

    type ParamValue = i64;

    enum InstrParams {
        Unary(ParamValue),
        Binary(ParamValue, ParamValue),
        Ternary(ParamValue, ParamValue, ParamValue),
    }

    #[derive(PartialEq, Debug)]
    enum Instr {
        Add(Ternary),
        Multiply(Ternary),
        Input(Unary),
        Output(Unary),
        JumpIfTrue(Binary),
        JumpIfFalse(Binary),
        LessThan(Ternary),
        Equals(Ternary),
        Halt(Nullary),
    }

    #[derive(Debug)]
    pub struct Computer {
        memory: Vec<i64>,
        input_values: VecDeque<i64>,
        output_values: Vec<i64>,
        ip: i64,
        debug: bool,
    }

    impl Computer {
        pub fn new(m: &[i64]) -> Computer {
            Computer {
                memory: m.to_vec(),
                input_values: VecDeque::new(),
                output_values: Vec::new(),
                ip: 0,
                debug: false,
            }
        }

        pub fn add_input_values(&mut self, input: &[i64]) {
            self.input_values.extend(input);
        }

        pub fn get_output_values(&self) -> &[i64] {
            &self.output_values
        }

        pub fn run(&mut self) {
            loop {
                debug_assert_ge!(self.ip, 0);
                debug_assert_lt!(self.ip as usize, self.memory.len());

                let op_code = self.get_next_instr();
                let result = self.run_instruction(op_code);
                if self.debug {
                    println!("Op result is: {:?}", result);
                }
                match result {
                    InstrResult::AdvanceIP(delta) => self.ip += delta,
                    InstrResult::Halt => break,
                }
            }
        }

        fn get_next_instr(&self) -> Instr {
            Instr::from(self.memory[self.ip as usize]).unwrap()
        }

        pub fn get_value_at_address(&self, address: i64) -> i64 {
            self.memory[address as usize]
        }

        pub fn set_value_at_address(&mut self, address: i64, value: i64) {
            self.memory[address as usize] = value
        }

        fn get_value_for_operand(&self, addr: i64, mode: &ParamMode) -> i64 {
            match mode {
                ParamMode::Position => {
                    let address_to_read = self.get_value_at_address(addr);


/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   ft_strcat.c                                        :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*                                                  +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*                                                     #+#    #+#             */
/*                                                    ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

char	*ft_strcat(char *dest, char *src)
{
	int		c;
	int		d;

	c = 0;
	d = 0;
	while (dest[c] != '\0')
		c++;
	while (src[d] != '\0')
	{
		dest[c] = src[d];
		c++;
		d++;
	}
	dest[c] = '\0';
	return (dest);
}


 = 0;
         if (var11 < var5) {
            int[] var23 = this.Method104(a, 0, var11, var4, 1, (int[])var9);
            int[] var24 = this.Method104(this.Field690, 0, var11, var4, 1, (int[])var10);
            int var12 = 0;
            if (var12 < var4) {
               int var13 = var23[var12];
               int var14 = var24[var12];
               int var15 = var13 >> 24 & 255;
               int var16 = var13 >> 16 & 255;
               int var17 = var13 >> 8 & 255;
               int var18 = var13 & 255;
               int var19 = var14 >> 24 & 255;
               int var20 = var14 >> 16 & 255;
               int var21 = var14 >> 8 & 255;
               int var22 = var14 & 255;
               var16 = Class767.Method1687(Class776.Method1718(this.Field691, var16, var20));
               var17 = Class767.Method1687(Class776.Method1718(this.Field691, var17, var21));
               var18 = Class767.Method1687(Class776.Method1718(this.Field691, var18, var22));
               var23[var12] = var15 << 24 | var16 << 16 | var17 << 8 | var18;
               ++var12;
            }

            this.Method1267(a, 0, var11, var4, 1, var23);
            ++var11;
         }
      }

      return a;
   }

   public String toString() {
      return "Effects/Interpolate...";
   }
}
package awsl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import obfuscate.b;

public class Class11 extends Class267 {
   public List Field181;
   public List Field182;
   private List Field183;
   public Map Field184;
   private int Field185;
   private int Field186;
   private String Field187;

   public Class11(String a, int a, String a, String a, Class267 a) {
      this(327680, a, a, a, a, a);
      if (this.getClass() != Class11.class) {
         throw new IllegalStateException();
      }
   }

   protected Class11(int a, String a, int a, String a, String a, Class267 a) {
      super(a, a);
      this.Field187 = a;
      this.Field181 = new ArrayList();
      this.Field182 = new ArrayList();
      this.Field184 = new HashMap();
      if ((a & 8) == 0) {
         if ("<init>".equals(a)) {
            this.Field181.Method2530(Class45.Field402);
         } else {
            this.Field181.Method2530(a);
         }
      }

      b[] var7 = b.Method3211(a);

      for(int var8 = 0; var8 < var7.length; ++var8) {
         b var9 = var7[var8];
         switch (var9.Method3217()) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
               this.Field181.Method2530(Class45.Field397);
               break;
            case 6:
               this.Field181.Method2530(Class45.Field398);
               break;
            case 7:
               this.Field181.Method2530(Class45.Field400);
               this.Field181.Method2530(Class45.Field396);
               break;
            case 8:
               this.Field181.Method2530(Class45.Field399);
               this.Field181.Method2530(Class45.


 variant,returned only by new library functions.
///
/// ```
/// use abi_stable::{
///     nonexhaustive_enum::{NonExhaustive, NonExhaustiveFor},
///     sabi_trait,
///     std_types::RString,
///     StableAbi,
/// };
///
/// #[repr(u8)]
/// #[derive(StableAbi, Debug, Clone, PartialEq)]
/// #[sabi(kind(WithNonExhaustive(
///     size = "[usize;8]",
///     traits(Debug, Clone, PartialEq),
/// )))]
/// pub enum Error {
///     #[doc(hidden)]
///     __NonExhaustive,
///     CouldNotFindItem {
///         name: RString,
///     },
///     OutOfStock {
///         id: usize,
///         name: RString,
///     },
///     InvalidItemId {
///         id: usize,
///     },
/// }
///
/// fn returns_invalid_item_id() -> NonExhaustiveFor<Error> {
///     NonExhaustive::new(Error::InvalidItemId { id: 100 })
/// }
///
/// ```
///
/// If a library user attempted to unwrap `Error::InvalidItemId`
/// (using NonExhaustive::as_enum/as_enum_mut/into_enum)
/// with the 1.0 version of `Error` they would get an `Err(..)` back.
///
#[repr(C)]
#[derive(StableAbi)]
#[sabi(
    //debug_print,
    not_stableabi(E,S,I),
    bound="NonExhaustiveVtable_Ref<E,S,I>:StableAbi",
    bound="E: GetNonExhaustive<S>",
    bound="I: InterfaceBound",
    extra_checks="<I as InterfaceBound>::EXTRA_CHECKS",
    phantom_type_param="<E as GetNonExhaustive<S>>::NonExhaustive",
)]
pub struct NonExhaustive<E, S, I> {
    // This is an opaque field since we only care about its size and alignment
    #[sabi(unsafe_opaque_field)]
    fill: ScratchSpace<S>,
    vtable: NonExhaustiveVtable_Ref<E, S, I>,
    _marker: PhantomData<()>,
}

/// The type of a `NonExhaustive<>` wrapping the enum E,
/// using the `E`'s  default storage and interface.
pub type NonExhaustiveFor<E> =
    NonExhaustive<E, <E as GetEnumInfo>::DefaultStorage, <E as GetEnumInfo>::DefaultInterface>;

/// The type of a `NonExhaustive<>` wrapping the enum E,
/// using the `E`'s  default storage and a custom interface.
pub type NonExhaustiveWI<E, I> = NonExhaustive<E, <E as GetEnumInfo>::DefaultStorage, I>;

/// The type of a `NonExhaustive<>` wrapping the enum E,
/// using a custom storage and the `E`'s default interface.
pub type NonExhaustiveWS<E, S> = NonExhaustive<E, S, <E as GetEnumInfo>::DefaultInterface>;

impl<E, S, I> NonExhaustive<E, S, I> {
    /// Constructs a `NonExhaustive<>` from `value` using its default interface and storage.
    ///
    /// # Panic
    ///
    /// This panics if the storage has an alignment or size smaller than that of `E`.
    #[inline]
    pub fn new(value: E) -> Self
    where
        E: GetVTable<S, I, DefaultStorage = S, DefaultInterface = I>,
    {
        NonExhaustive::with_storage_and_interface(value)
    }

    /// Constructs a `NonExhaustive<>` from `value` using its default storage
    /// and a custom interface.
    ///
    /// # Panic
    ///
    /// This panics if the storage has an alignment or size smaller than that of `E`.
    #[inline]
    pub fn with


la Ave", "", "", "BIGGERA WATERS", "QLD", 4216, "State School", "2 Morala Ave", "BIGGERA WATERS", "", "Coombabah Rd", "Gate from Coombabah Rd", -27.9274694, 153.3969927, 3161402, "Assisted", 1797, 236, 4, 3},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Brisbane City (Fadden)", 14205, "Current", "Primary Industries Building", "80 Ann Street", "", "", "BRISBANE", "QLD", 4000, "Primary Industries Building", "80 Ann St", "BRISBANE CITY", "", "", "Venue in Brisbane CBD. Details to be con firmed.", -27.4688591, 153.0225778, 3191901, "Assisted", 34, 0, 0, 0},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Canowindra (Fadden)", 6281, "Current", "Ormeau State School", "29 Mirambeena Dr", "", "", "PIMPAMA", "QLD", 4209, "Ormeau State School", "29 Mirambeena Dr", "PIMPAMA", "", "", "Gate to Hall in Mirambeena Dr", -27.8005, 153.276, 3160211, "Assisted", 1475, 106, 3, 1},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Coombabah", 6264, "Current", "Coombabah State School", "164-172 Oxley Dr", "", "", "COOMBABAH", "QLD", 4216, "State School", "164-172 Oxley Dr", "COOMBABAH", "", "", "Gate in Oxley Drive or Gate in Bundarra St", -27.8942, 153.388, 3160902, "Assisted", 1729, 248, 4, 3},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Coombabah South", 32519, "Current", "Coombabah High School", "550 Pine Ridge Rd", "", "", "COOMBABAH", "QLD", 4216, "High School", "550 Pine Ridge Rd", "COOMBABAH", "", "", "Gate in Pine Ridge Rd", -27.92431, 153.37785, 3160919, "Assisted", 1207, 175, 3, 2},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Coomera", 6265, "Appointment", "Coomera State School", "Dreamworld Pkwy", "", "", "COOMERA", "QLD", 4209, "Coomera State School", "Beattie Rd", "COOMERA", "", "", "Gate in Beattie Rd", -27.8675337, 153.3168697, 3160323, "Assisted", 1248, 242, 3, 3},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Coomera North", 58876, "Current", "Coomera Rivers State School", "81-87 Finnegan Way", "", "", "COOMERA", "QLD", 4209, "Coomera Rivers State School", "81-87 Finnegan Way", "COOMERA", "", "", "Main gate Finegan Way", -27.845603, 153.3275557, 3160313, "Assisted", 2095, 231, 5, 4},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Harley Park", 6268, "Current", "Labrador Memorial Senior Citizens Centre", "370 Marine Pde", "", "", "LABRADOR", "QLD", 4215, "Labrador Memorial Senior Citizens Assoc", "370 Marine Pde", "LABRADOR", "", "", "Broad St carpark entry, Marine Pde pedestrian access", -27.9407, 153.407, 3161503, "Assisted", 1636, 311, 4, 3},
		PollingPlace{4, "QLD", "Fadden", 159, 8, "Helensvale", 6269, "Current", "Helensvale State School", "8 Lindfield Rd", "", "", "HELENSVALE",


/unpack routines
------------------------------------------------------------------------- */

void CommTiled::forward_comm(int /*dummy*/)
{
  int i,irecv,n,nsend,nrecv;
  AtomVec *avec = atom->avec;
  double **x = atom->x;

  // exchange data with another set of procs in each swap
  // post recvs from all procs except self
  // send data to all procs except self
  // copy data to self if sendself is set
  // wait on all procs except self and unpack received data
  // if comm_x_only set, exchange or copy directly to x, don't unpack

  for (int iswap = 0; iswap < nswap; iswap++) {
    nsend = nsendproc[iswap] - sendself[iswap];
    nrecv = nrecvproc[iswap] - sendself[iswap];

    if (comm_x_only) {
      if (recvother[iswap]) {
        for (i = 0; i < nrecv; i++)
          MPI_Irecv(x[firstrecv[iswap][i]],size_forward_recv[iswap][i],
                    MPI_DOUBLE,recvproc[iswap][i],0,world,&requests[i]);
      }
      if (sendother[iswap]) {
        for (i = 0; i < nsend; i++) {
          n = avec->pack_comm(sendnum[iswap][i],sendlist[iswap][i],
                              buf_send,pbc_flag[iswap][i],pbc[iswap][i]);
          MPI_Send(buf_send,n,MPI_DOUBLE,sendproc[iswap][i],0,world);
        }
      }
      if (sendself[iswap]) {
        avec->pack_comm(sendnum[iswap][nsend],sendlist[iswap][nsend],
                        x[firstrecv[iswap][nrecv]],pbc_flag[iswap][nsend],pbc[iswap][nsend]);
      }
      if (recvother[iswap]) MPI_Waitall(nrecv,requests,MPI_STATUS_IGNORE);

    } else if (ghost_velocity) {
      if (recvother[iswap]) {
        for (i = 0; i < nrecv; i++)
          MPI_Irecv(&buf_recv[size_forward*forward_recv_offset[iswap][i]],
                    size_forward_recv[iswap][i],MPI_DOUBLE,recvproc[iswap][i],0,world,&requests[i]);
      }
      if (sendother[iswap]) {
        for (i = 0; i < nsend; i++) {
          n = avec->pack_comm_vel(sendnum[iswap][i],sendlist[iswap][i],
                                  buf_send,pbc_flag[iswap][i],pbc[iswap][i]);
          MPI_Send(buf_send,n,MPI_DOUBLE,sendproc[iswap][i],0,world);
        }
      }
      if (sendself[iswap]) {
        avec->pack_comm_vel(sendnum[iswap][nsend],sendlist[iswap][nsend],
                            buf_send,pbc_flag[iswap][nsend],pbc[iswap][nsend]);
        avec->unpack_comm_vel(recvnum[iswap][nrecv],firstrecv[iswap][nrecv],buf_send);
      }
      if (recvother[iswap]) {
        for (i = 0; i < nrecv; i++) {
          MPI_Waitany(nrecv,requests,&irecv,MPI_STATUS_IGNORE);
          avec->unpack_comm_vel(recvnum[iswap][irecv],firstrecv[iswap][irecv],
                                &buf_recv[size_forward*forward_recv_offset[iswap][irecv]]);
        }
      }

    } else {
      if (recvother[iswap]) {
        for (i = 0; i < nrecv; i++)
          MPI


   {
            return new Vector2D(v.X * c, v.Y * c);
        }

        public static Vector2D operator *(double c, Vector2D v)
        {
            return v * c;
        }

        public static Vector2D operator -(Vector2D v)
        {
            return new Vector2D(-v.X, -v.Y);
        }

        /// <summary>
        /// Returns the scaled vector with length 1.
        /// </summary>
        /// <exception cref="InvalidOperationException"></exception>
        public Vector2D Normalize()
        {
            var r = R;
            if (r == 0.0) throw new InvalidOperationException();
            return new Vector2D(this) * (1.0 / r);
        }

        /// <summary>
        /// Inner product.
        /// </summary>
        public double Dot(Vector2D v)
        {
            return v.X * X + v.Y * Y;
        }

        public bool Equals(Vector2D v)
        {
            return v != null && v.X == X && v.Y == Y;
        }

        public bool Equals(Vector2D v, double delta)
        {
            return v != null && (this - v).R <= delta;
        }
    }
}


; --bg-option-bar-11: 60; --bg-option-bar-12: 30;
  }

  100% {
    --bg-option-bar-1: 40; --bg-option-bar-2: 70; --bg-option-bar-3: 50; --bg-option-bar-4: 90;
    --bg-option-bar-5: 30; --bg-option-bar-6: 80; --bg-option-bar-7: 60; --bg-option-bar-8: 50;
    --bg-option-bar-9: 70; --bg-option-bar-10: 30; --bg-option-bar-11: 90; --bg-option-bar-12: 40;
  }
}

[data-element="rymstats-track-panel"] {
  container-type: size;
}

[data-element="rymstats-track-panel"] {
  &.bg-option-18:after {
    --gap: 0px;
    --n: 12;
    --bar-width: calc((100% / var(--n)) - var(--gap));

    --clr-1: var(--clr-palette-lightvibrant);
    --clr-3: var(--clr-palette-vibrant);
    --clr-5: var(--clr-palette-darkvibrant);
    --clr-7: var(--clr-palette-lightmuted);
    --clr-9: var(--clr-palette-muted);
    --clr-11: var(--clr-palette-darkmuted);
    --clr-2: color-mix(in lch, var(--clr-1) 50%, var(--clr-3));
    --clr-4: color-mix(in lch, var(--clr-3) 50%, var(--clr-5));
    --clr-6: color-mix(in lch, var(--clr-5) 50%, var(--clr-7));
    --clr-8: color-mix(in lch, var(--clr-7) 50%, var(--clr-9));
    --clr-10: color-mix(in lch, var(--clr-9) 50%, var(--clr-11));
    --clr-12: color-mix(in lch, var(--clr-11) 20%, var(--clr-1));

    --bar-1-x: calc((0 * 100%) / (var(--n) - 1));
    --bar-2-x: calc((1 * 100%) / (var(--n) - 1));
    --bar-3-x: calc((2 * 100%) / (var(--n) - 1));
    --bar-4-x: calc((3 * 100%) / (var(--n) - 1));
    --bar-5-x: calc((4 * 100%) / (var(--n) - 1));
    --bar-6-x: calc((5 * 100%) / (var(--n) - 1));
    --bar-7-x: calc((6 * 100%) / (var(--n) - 1));
    --bar-8-x: calc((7 * 100%) / (var(--n) - 1));
    --bar-9-x: calc((8 * 100%) / (var(--n) - 1));
    --bar-10-x: calc((9 * 100%) / (var(--n) - 1));
    --bar-11-x: calc((10 * 100%) / (var(--n) - 1));
    --bar-12-x: calc((11 * 100%) / (var(--n) - 1));

    background:
      linear-gradient(to top, var(--clr-1) calc(var(--bg-option-bar-1) * 1%), transparent calc(var(--bg-option-bar-1) * 1%))
        var(--bar-1-x) 0 / var(--bar-width) 100% no-repeat,

      linear-gradient(to top, var(--clr-2) calc(var(--bg-option-bar-2) * 1%), transparent calc(var(--bg-option-bar-2) * 1%))
        var(--bar-2-x) 0 / var(--bar-width) 100% no-repeat,

      l


payload = new ArrayList<>();
        payload.add(new Message.Body("en", "The cake is a lie."));
        Set<Jid> to = new HashSet<>();
        to.add(JidCreate.bareFrom("alice@wonderland.lit"));
        CryptElement element = new CryptElement(to,
                "f0rm1l4n4-mT8y33j!Y%fRSrcd^ZE4Q7VDt1L%WEgR!kv",
                testDate,
                payload);

        assertXmlSimilar(expected, element.toXML().toString());

        XmlPullParser parser = TestUtils.getParser(expected);
        CryptElement parsed = (CryptElement) OpenPgpContentElementProvider.parseOpenPgpContentElement(parser);

        assertEquals(element.getTimestamp(), parsed.getTimestamp());
        assertEquals(element.getTo(), parsed.getTo());
        assertEquals(element.getExtensions(), parsed.getExtensions());
    }

    @SuppressWarnings("UndefinedEquals")
    @Test
    public void signcryptElementProviderTest() throws Exception {
        String expected =
                "<signcrypt xmlns='urn:xmpp:openpgp:0'>" +
                        "<to jid='juliet@example.org'/>" +
                        "<time stamp='2014-07-10T15:06:00.000+00:00'/>" +
                        "<payload>" +
                        "This is a secret message." +
                        "</payload>" +
                        "<rpad>f0rm1l4n4-mT8y33j!Y%fRSrcd^ZE4Q7VDt1L%WEgR!kv</rpad>" +
                        "</signcrypt>";

        List<ExtensionElement> payload = new ArrayList<>();
        payload.add(new Message.Body("en", "This is a secret message."));
        Set<Jid> jids = new HashSet<>();
        jids.add(JidCreate.bareFrom("juliet@example.org"));
        SigncryptElement element = new SigncryptElement(jids,
                "f0rm1l4n4-mT8y33j!Y%fRSrcd^ZE4Q7VDt1L%WEgR!kv",
                testDate, payload);

        assertXmlSimilar(expected, element.toXML().toString());

        XmlPullParser parser = TestUtils.getParser(expected);
        SigncryptElement parsed = (SigncryptElement) OpenPgpContentElementProvider.parseOpenPgpContentElement(parser);

        assertEquals(element.getTimestamp(), parsed.getTimestamp());
        assertEquals(element.getTo(), parsed.getTo());
        assertEquals(element.getExtensions(), parsed.getExtensions());
        assertEquals(payload.get(0), element.getExtension(Message.Body.NAMESPACE));
        assertEquals(payload.get(0), element.getExtension(Message.Body.ELEMENT, Message.Body.NAMESPACE));
    }

    @Test
    public void openPgpContentElementProvider_invalidElementTest() {
        String invalidElementXML = "<payload>" +
                "This is a secret message." +
                "</payload>";
        assertThrows(XmlPullParserException.class, () ->
        OpenPgpContentElementProvider.parseOpenPgpContentElement(invalidElementXML));
    }

}
/*
 *
 * Copyright 2018 Paul Schaub.
 *
 * 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 org.jivesoftware.smackx.ox.crypto;

import java.io.ByteArrayOutputStream;
import java


 if (!matchesSchemaExpression(path, schemaExpression, schema)) return@f2
                        nextContextConfigs += config
                    }
                    is CwtValueConfig -> {
                        if (path != "-") return@f2
                        nextContextConfigs += config
                    }
                }
            }
            contextConfigs = nextContextConfigs
            if (flatten) contextConfigs = contextConfigs.flatMapTo(mutableListOf()) { it.configs.orEmpty() }
        }
        return contextConfigs
    }

    fun matchesSchemaExpression(value: String, schemaExpression: CwtSchemaExpression, schema: CwtSchemaConfig): Boolean {
        return when (schemaExpression) {
            is CwtSchemaExpression.Constant -> {
                schemaExpression.expressionString == value
            }
            is CwtSchemaExpression.Enum -> {
                schema.enums[schemaExpression.name]?.values?.any { it.stringValue == value } ?: false
            }
            is CwtSchemaExpression.Template -> {
                value.matchesPattern(schemaExpression.pattern)
            }
            else -> true //fast check
        }
    }
}
package icu.windea.pls.config.config.delegated

import icu.windea.pls.config.config.CwtDelegatedConfig
import icu.windea.pls.config.config.CwtPropertyConfig
import icu.windea.pls.config.config.delegated.impl.CwtDeclarationConfigResolverImpl
import icu.windea.pls.cwt.psi.CwtProperty

import icu.windea.pls.lang.expression.ParadoxDefinitionSubtypeExpression

/**
 * 声明规则。
 *
 * 用于描述定义声明的结构，从而在定义声明中提供代码补全、代码检查等功能。
 *
 * 说明：
 * - 可在其中通过子类型表达式（[ParadoxDefinitionSubtypeExpression]）限定定义声明的结构。
 * - 可在其中引用别名规则（[CwtAliasConfig]）与单别名规则（[CwtSingleAliasConfig]），从而简化声明规则的编写。
 * - 切换类型（swapped type）的声明规则可以直接嵌套在对应的基础类型（base type）的声明规则中。
 *
 * 路径定位：`{name}`，`{name}` 匹配规则名称（定义类型）。
 * - 任何无法在解析其他规则的过程中被匹配到的顶级属性，如果键是一个合法的标识符，最终都会在回退时尝试解析为声明规则。
 *
 * CWTools 兼容性：兼容。
 *
 * 示例：
 * ```cwt
 * event = {
 *     id = scalar
 *     subtype[triggered] = { # 通过子类型表达式限定定义声明的结构
 *         ## cardinality = 0..1
 *         weight_multiplier = {
 *             factor = float
 *             alias_name[modifier_rule] = alias_match_left[modifier_rule] # 引用别名规则
 *         }
 *     }
 *     ## cardinality = 0..1
 *     trigger = single_alias_right[trigger_clause] # 引用单别名规则
 *     # ...
 * }
 * ```
 *
 * @property name 名称。
 * @property configForDeclaration 可直接用于检查定义声明的结构，经过处理后的属性规则。
 * @property subtypesUsedInDeclaration 其中的子类型表达式（[ParadoxDefinitionSubtypeExpression]）中使用到的子类型的集合。
 *
 * @see CwtTypeConfig
 * @see CwtSubtypeConfig
 */
interface CwtDeclarationConfig : CwtDelegatedConfig<CwtProperty, CwtPropertyConfig> {
    @FromKey
    val name: String

    val configForDeclaration: CwtPropertyConfig
    val subtypesUsedInDeclaration: Set<String>

    interface Resolver {
        /** 由属性规则解析为声明规则，可指定 [name] 以覆盖规则名称。*/
        fun resolve(config: CwtPropertyConfig, name: String? = null): CwtDeclarationConfig?
    }

    companion object : Resolver by CwtDeclarationConfigResolverImpl()
}


  63dbb:	00          	halt
   63dbc:	70 00 00    	movd $0x0 [d-float],$0x0 [d-float]
   63dbf:	00          	halt
   63dc0:	73 00       	tstd $0x0 [d-float]
   63dc2:	00          	halt
   63dc3:	00          	halt
   63dc4:	00          	halt
   63dc5:	00          	halt
   63dc6:	00          	halt
   63dc7:	00          	halt
   63dc8:	fc          	xfc
   63dc9:	ff ff       	.word 0xffff
   63dcb:	ff 73       	.word 0xff73
   63dcd:	00          	halt
   63dce:	00          	halt
   63dcf:	00          	halt
   63dd0:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63dd3:	00          	halt
   63dd4:	00          	halt
   63dd5:	00          	halt
   63dd6:	00          	halt
   63dd7:	00          	halt
   63dd8:	f8 ff ff ff 	ashp *743ddd <_end+0x6d43b5>,$0x0,$0x0,(fp),$0x0,$0x0
   63ddc:	6d 00 00 00
   63de0:	6d 00 00
   63de3:	00          	halt
   63de4:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63de7:	00          	halt
   63de8:	08 00 00 00 	cvtps $0x0,$0x0,$0x0,-(r3)
   63dec:	73
   63ded:	00          	halt
   63dee:	00          	halt
   63def:	00          	halt
   63df0:	70 00 00    	movd $0x0 [d-float],$0x0 [d-float]
	...
   63dfb:	00          	halt
   63dfc:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63dff:	00          	halt
   63e00:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63e03:	00          	halt
   63e04:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63e07:	00          	halt
   63e08:	04          	ret
   63e09:	00          	halt
   63e0a:	00          	halt
   63e0b:	00          	halt
   63e0c:	73 00       	tstd $0x0 [d-float]
   63e0e:	00          	halt
   63e0f:	00          	halt
   63e10:	6d 00 00    	cvtwd $0x0,$0x0 [d-float]
   63e13:	00          	halt
   63e14:	1c 00       	bvc 63e16 <op+0x4fba>
   63e16:	00          	halt
   63e17:	00          	halt
   63e18:	10 00       	bsbb 63e1a <op+0x4fbe>
   63e1a:	00          	halt
   63e1b:	00          	halt
   63e1c:	70 00 00    	movd $0x0 [d-float],$0x0 [d-float]
   63e1f:	00          	halt
   63e20:	73 00       	tstd $0x0 [d-float]
   63e22:	00          	halt
   63e23:


# Generated by Django 5.1.1 on 2024-10-11 12:24

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [
        ('auth', '0012_alter_user_first_name_max_length'),
        ('squadzone', '0008_usuario_veremail'),
    ]

    operations = [
        migrations.RemoveField(
            model_name='usuario',
            name='senha',
        ),
        migrations.RemoveField(
            model_name='usuario',
            name='verEmail',
        ),
        migrations.RemoveField(
            model_name='usuario',
            name='verSenha',
        ),
        migrations.AddField(
            model_name='usuario',
            name='groups',
            field=models.ManyToManyField(blank=True, help_text='Grupos a que este usuário pertence.', related_name='custom_usuario_set', to='auth.group', verbose_name='Grupos'),
        ),
        migrations.AddField(
            model_name='usuario',
            name='is_superuser',
            field=models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status'),
        ),
        migrations.AddField(
            model_name='usuario',
            name='last_login',
            field=models.DateTimeField(blank=True, null=True, verbose_name='last login'),
        ),
        migrations.AddField(
            model_name='usuario',
            name='password',
            field=models.CharField(default=124, max_length=128, verbose_name='password'),
            preserve_default=False,
        ),
        migrations.AddField(
            model_name='usuario',
            name='user_permissions',
            field=models.ManyToManyField(blank=True, help_text='Permissões específicas deste usuário.', related_name='custom_usuario_set', to='auth.permission', verbose_name='Permissões'),
        ),
    ]


, which is attributed to a combination of factors, although specific reasons are not detailed. The context highlights that the revenue for the first quarter was $2.24 billion, down from the previous year, while it did show an increase of 22% from the previous quarter. This suggests that while there may have been a seasonal or cyclical recovery, the overall year-over-year decline reflects challenges in the gaming segment during that period.

### Evaluation results:
trustworthiness: 0.8018049078305449
context_sufficiency: 0.26134514055082803
response_groundedness: 0.8147481620994604
response_helpfulness: 0.28647897539109127
query_ease: 0.952132218665045

```

**Analysis:** The generator LLM avoids conjecture by providing a reliable response, as seen in the high `trustworthiness_score`. The low `context_sufficiency` score reflects that the retrieved context was lacking, and the response doesn’t actually answer the user’s query, as indicated by the low `response_helpfulness`.
Let’s see how our RAG system responds to another _challenging_ question.
In [ ]:
Copied!
```
get_answer(
    "How much did Nvidia's revenue decrease this quarter vs last quarter, in dollars?"
)

```

get_answer( "How much did Nvidia's revenue decrease this quarter vs last quarter, in dollars?" )
```
### Query:
How much did Nvidia's revenue decrease this quarter vs last quarter, in dollars?

### Trimmed Context:
# NVIDIA Announces Financial Results for First Quarter Fiscal 2024

NVIDIA (NASDAQ: NVDA) today reported revenue for the first quarter ended April 30, 2023, of $7.19 billion, down 13% from a year ago and up 19% from the previous quarter.

- **Quarterly revenue** of $7.19 billion, up 19% from the pre...

### Generated response:
NVIDIA's revenue decreased by $1.10 billion this quarter compared to the last quarter.

### Evaluation results:
trustworthiness: 0.572441384819641
context_sufficiency: 0.9974990573223977
response_groundedness: 0.006136548076912901
response_helpfulness: 0.997512230771839
query_ease: 0.8018484929561781

```

**Analysis** : The generated response incorrectly states that NVIDIA's revenue decreased this quarter, when in fact the referenced report notes a 19% increase quarter-over-quarter.
Cleanlab's low trustworthiness score helps us automatically catch this incorrect RAG response in real-time! To root-cause why this response was untrustworthy, we see the `response_groundedness` score is low, which indicates our LLM model is to blame for fabricating this false information.
Let's try another one:
In [ ]:
Copied!
```
get_answer(
    "If NVIDIA's Data Center segment maintains its Q1 FY2024 quarter-over-quarter growth rate for the next four quarters, what would be its projected annual revenue?"
)

```

get_answer( "If NVIDIA's Data Center segment maintains its Q1 FY2024 quarter-over-quarter growth rate for the next four quarters, what would be its projected annual revenue?" )
```
### Query:
If NVIDIA's Data Center segment maintains its Q1 FY2024 quarter-over-quarter growth rate for the next four quarters, what would be its projected annual revenue?

### Trimmed Context:
# NVIDIA Announces Financial Results for First Quarter Fiscal 2024

NVIDIA (NASDAQ: NVDA) today reported revenue for the first quarter ended April 30, 2023, of $7.19 billion, down 13% from a year ago and up 19% from the previous quarter.

- **Quarterly revenue** of $7.19 billion, up 19% from the pre...

### Generated response:
If NVIDIA's Data Center segment maintains its quarter-over-quarter growth rate of 18% from Q1 FY2024 for the next four quarters, the projected revenue for the next four


	vbroadcasti32x4	80(%rcx),%zmm0
	vaesdec	%zmm0,%zmm1,%zmm1
	vaesdec	%zmm0,%zmm2,%zmm2

	vbroadcasti32x4	96(%rcx),%zmm0
	vaesdec	%zmm0,%zmm1,%zmm1
	vaesdec	%zmm0,%zmm2,%zmm2

	vbroadcasti32x4	112(%rcx),%zmm0
	vaesdec	%zmm0,%zmm1,%zmm1
	vaesdec	%zmm0,%zmm2,%zmm2

	vbroadcasti32x4	128(%rcx),%zmm0
	vaesdec	%zmm0,%zmm1,%zmm1
	vaesdec	%zmm0,%zmm2,%zmm2

	vbroadcasti32x4	144(%rcx),%zmm0
	vaesdec	%zmm0,%zmm1,%zmm1
	vaesdec	%zmm0,%zmm2,%zmm2

	vbroadcasti32x4	160(%rcx),%zmm0
	vaesdeclast	%zmm0,%zmm1,%zmm1
	vaesdeclast	%zmm0,%zmm2,%zmm2

	vpxorq	%zmm9,%zmm1,%zmm1
	vpxorq	%zmm10,%zmm2,%zmm2

	vmovdqa32	%zmm15,%zmm9
	vmovdqa32	%zmm16,%zmm10
	vmovdqu8	%zmm1,(%rsi)
	vmovdqu8	%zmm2,64(%rsi)
	addq	$0x80,%rsi
	subq	$0x80,%rdx
	cmpq	$0x80,%rdx
	jge	.L_main_loop_run_8_amivrujEyduiFoi
	jmp	.L_do_n_blocks_amivrujEyduiFoi

.L_steal_cipher_amivrujEyduiFoi:

	vmovdqa	%xmm8,%xmm2

	leaq	vpshufb_shf_table(%rip),%rax
	vmovdqu	(%rax,%rdx,1),%xmm10
	vpshufb	%xmm10,%xmm8,%xmm8

	vmovdqu	-16(%rdi,%rdx,1),%xmm3
	vmovdqu	%xmm8,-16(%rsi,%rdx,1)

	leaq	vpshufb_shf_table(%rip),%rax
	addq	$16,%rax
	subq	%rdx,%rax
	vmovdqu	(%rax),%xmm10
	vpxor	mask1(%rip),%xmm10,%xmm10
	vpshufb	%xmm10,%xmm3,%xmm3

	vpblendvb	%xmm10,%xmm2,%xmm3,%xmm3

	vpxor	%xmm0,%xmm3,%xmm8

	vpxor	(%rcx),%xmm8,%xmm8
	vaesdec	16(%rcx),%xmm8,%xmm8
	vaesdec	32(%rcx),%xmm8,%xmm8
	vaesdec	48(%rcx),%xmm8,%xmm8
	vaesdec	64(%rcx),%xmm8,%xmm8
	vaesdec	80(%rcx),%xmm8,%xmm8
	vaesdec	96(%rcx),%xmm8,%xmm8
	vaesdec	112(%rcx),%xmm8,%xmm8
	vaesdec	128(%rcx),%xmm8,%xmm8
	vaesdec	144(%rcx),%xmm8,%xmm8
	vaesdeclast	160(%rcx),%xmm8,%xmm8


 op === '<=' && outputLength > 1 ) {

				return builder.format( `${ builder.getMethod( 'lessThanEqual' ) }( ${a}, ${b} )`, type, output );

			} else if ( op === '>' && outputLength > 1 ) {

				return builder.format( `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`, type, output );

			} else if ( op === '>=' && outputLength > 1 ) {

				return builder.format( `${ builder.getMethod( 'greaterThanEqual' ) }( ${a}, ${b} )`, type, output );

			} else {

				return builder.format( `( ${a} ${this.op} ${b} )`, type, output );

			}

		} else if ( typeA !== 'void' ) {

			return builder.format( `${a} ${this.op} ${b}`, type, output );

		}

	}

	serialize( data ) {

		super.serialize( data );

		data.op = this.op;

	}

	deserialize( data ) {

		super.deserialize( data );

		this.op = data.op;

	}

}

export default OperatorNode;

export const add = nodeProxy( OperatorNode, '+' );
export const sub = nodeProxy( OperatorNode, '-' );
export const mul = nodeProxy( OperatorNode, '*' );
export const div = nodeProxy( OperatorNode, '/' );
export const remainder = nodeProxy( OperatorNode, '%' );
export const equal = nodeProxy( OperatorNode, '==' );
export const assign = nodeProxy( OperatorNode, '=' );
export const lessThan = nodeProxy( OperatorNode, '<' );
export const greaterThan = nodeProxy( OperatorNode, '>' );
export const lessThanEqual = nodeProxy( OperatorNode, '<=' );
export const greaterThanEqual = nodeProxy( OperatorNode, '>=' );
export const and = nodeProxy( OperatorNode, '&&' );
export const or = nodeProxy( OperatorNode, '||' );
export const xor = nodeProxy( OperatorNode, '^^' );
export const bitAnd = nodeProxy( OperatorNode, '&' );
export const bitOr = nodeProxy( OperatorNode, '|' );
export const bitXor = nodeProxy( OperatorNode, '^' );
export const shiftLeft = nodeProxy( OperatorNode, '<<' );
export const shiftRight = nodeProxy( OperatorNode, '>>' );

addNodeElement( 'add', add );
addNodeElement( 'sub', sub );
addNodeElement( 'mul', mul );
addNodeElement( 'div', div );
addNodeElement( 'remainder', remainder );
addNodeElement( 'equal', equal );
addNodeElement( 'assign', assign );
addNodeElement( 'lessThan', lessThan );
addNodeElement( 'greaterThan', greaterThan );
addNodeElement( 'lessThanEqual', lessThanEqual );
addNodeElement( 'greaterThanEqual', greaterThanEqual );
addNodeElement( 'and', and );
addNodeElement( 'or', or );
addNodeElement( 'xor', xor );
addNodeElement( 'bitAnd', bitAnd );
addNodeElement( 'bitOr', bitOr );
addNodeElement( 'bitXor', bitXor );
addNodeElement( 'shiftLeft', shiftLeft );
addNodeElement( 'shiftRight', shiftRight );

addNodeClass( OperatorNode );
import BRDF_Lambert from './BSDF/BRDF_Lambert.js';
import BRDF_GGX from './BSDF/BRDF_GGX.js';
import DFGApprox from './BSDF/DFGApprox.js';
import { lightingModel } from '../core/LightingModel.js';
import { temp } from '../core/VarNode.js';
import { diffuseColor, specularColor, roughness } from '../core/PropertyNode.js';
import { transformedNormalView } from '../accessors/NormalNode.js';
import { positionViewDirection } from '../accessors/PositionNode.js';
import { ShaderNode, float, vec3 } from '../shadernode/ShaderNode.js';

// Fdez-Ag


�   政治处 陈克荣 副主任 男 56 原区供销社副处长   政治处 丛慧滋 副主任 女 51 区商业厅副处长   计划处 唐锡章 副处长 男 51 原区供销社副科长   物价处 林耀 副处长 男 55 区商业厅副处长   基层处 苏巨铰 副处长 男 50 区商业厅副处长   基建处 王连登 副处长 男 53 区商业厅副处长   区土产公司 左凤财 经理 男 48 原区供销社副处长   区土产公司 唐杰 副经理 男 53 梧州市副市长   区土产公司 覃继禧 副经理 男 43 原区供销社副科长   区日杂公司 边景春 副经理 男 53 区供销社驻天津办事处负责人   区日杂公司 郑玉德 副经理 男 51 南宁军分区副参谋长   区日杂公司 田思誉 副经理 男 52 区农资公司副经理   区农资公司 王福奎 经理 男 56 原区供销社副处长   区农资公司 李若奇 副经理 男 51 一六四师政治部副主任   区农资公司 莫畏 副经理 男 35 原区供销社政治处副主任

   来源：《广西“文革”档案资料》（第十六册），中共广西壮族自治区委员会整党领导小组办公室编，1988年3月。

    [返回索引页面]

   Copyright (C)  2024  Marxist-Leninist-Maoist.

   Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".

  <title>
   广西平南县“文革”大事记 - 中共平南县委整党领导... - 1986-11-0 - CCRD 中国当代政治运动史数据库
  </title>
  <link href="../../../../Emblem_of_the_PCP-Shining_Path.svg.ico" rel="icon" type="image/x-icon"/>

  <meta content="广西平南县“文革”大事记" property="title"/>
  <meta content="1986-11-0" property="dat


}
}
// Copyright 2017 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package cmdtest

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"regexp"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
	"text/template"
	"time"

	"github.com/docker/docker/pkg/reexec"
)

func NewTestCmd(t *testing.T, data interface{}) *TestCmd {
	return &TestCmd{T: t, Data: data}
}

type TestCmd struct {
	// For total convenience, all testing methods are available.
	*testing.T

	Func    template.FuncMap
	Data    interface{}
	Cleanup func()

	cmd    *exec.Cmd
	stdout *bufio.Reader
	stdin  io.WriteCloser
	stderr *testlogger
	// Err will contain the process exit error or interrupt signal error
	Err error
}

var id int32

// Run exec's the current binary using name as argv[0] which will trigger the
// reexec init function for that name (e.g. "geth-test" in cmd/geth/run_test.go)
func (tt *TestCmd) Run(name string, args ...string) {
	id := atomic.AddInt32(&id, 1)
	tt.stderr = &testlogger{t: tt.T, name: fmt.Sprintf("%d", id)}
	tt.cmd = &exec.Cmd{
		Path:   reexec.Self(),
		Args:   append([]string{name}, args...),
		Stderr: tt.stderr,
	}
	stdout, err := tt.cmd.StdoutPipe()
	if err != nil {
		tt.Fatal(err)
	}
	tt.stdout = bufio.NewReader(stdout)
	if tt.stdin, err = tt.cmd.StdinPipe(); err != nil {
		tt.Fatal(err)
	}
	if err := tt.cmd.Start(); err != nil {
		tt.Fatal(err)
	}
}

// InputLine writes the given text to the child's stdin.
// This method can also be called from an expect template, e.g.:
//
//	geth.expect(`Passphrase: {{.InputLine "password"}}`)
func (tt *TestCmd) InputLine(s string) string {
	io.WriteString(tt.stdin, s+"\n")
	return ""
}

func (tt *TestCmd) SetTemplateFunc(name string, fn interface{}) {
	if tt.Func == nil {
		tt.Func = make(map[string]interface{})
	}
	tt.Func[name] = fn
}

// Expect runs its argument as a template, then expects the
// child process to output the result of the template within 5s.
//
// If the template starts with a newline, the newline is removed
// before matching.
func (tt *TestCmd) Expect(tplsource string) {
	// Generate the expected output by running the template.
	tpl := template.Must(template.New("").Funcs(tt.Func).Parse(tplsour


hattanDistance);
      }

    }
    return result;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getPhysicalUnits()
   */
  public final String getPhysicalUnits() {
    String result;
    if (StringUtil.isEmpty(this.m_physicalUnitsX) && StringUtil.isEmpty(this.m_physicalUnitsY)) {
      result = "";
    } else {
      result = new StringBuffer("[x: ").append(this.getPhysicalUnitsX()).append(", y: ").append(
          this.getPhysicalUnitsY()).append("]").toString();

    }
    return result;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getPhysicalUnitsX()
   */
  public final String getPhysicalUnitsX() {
    return this.m_physicalUnitsX;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getPhysicalUnitsY()
   */
  public final String getPhysicalUnitsY() {
    return this.m_physicalUnitsY;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getPointHighlighters()
   */
  public final Set<IPointPainter< ? >> getPointHighlighters() {

    return this.m_pointHighlighters;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getPropertyChangeListeners(String)
   */
  public PropertyChangeListener[] getPropertyChangeListeners(final String property) {
    return this.m_propertyChangeSupport.getPropertyChangeListeners(property);
  }

  /**
   * Returns the chart that renders this instance or null, if this trace is not
   * added to a chart.
   *

   * The chart that renders this trace registers itself with this trace in
   * {@link Chart2D#addTrace(ITrace2D)}.
   *

   *
   * @return Returns the renderer.
   * @see Chart2D#addTrace(ITrace2D)
   */
  public final Chart2D getRenderer() {
    Chart2D result = null;
    if (this.m_renderer instanceof Chart2D) {
      result = (Chart2D) this.m_renderer;
    }
    return result;
  }

  /**
   * Get the Stroke object this instance will be painted with.
   *

   *
   * @return the Stroke object this ITrace2D will be
   *         painted with.
   * @see info.monitorenter.gui.chart.ITrace2D#getStroke()
   */
  public final Stroke getStroke() {
    return this.m_stroke;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getTracePainters()
   */
  public final Set<ITracePainter< ? >> getTracePainters() {

    return this.m_tracePainters;
  }

  /**
   * @see info.monitorenter.gui.chart.ITrace2D#getZIndex()
   */
  public final Integer getZIndex() {
    // More expensive but the contract of the order of values described in the
    // interface is inverted to the contract of TreeSetGreedy.
    // This is done here instead of get/set ComparableProperty
    // as those are invoked several times for each iteration
    // (and paint contains several iterations).
    if (Chart2D.DEBUG_THREADING) {
      System.out.println(Thread.currentThread().getName() + ", " + this.getClass().getName()
          + ".getZindex, 0 locks");
    }
    synchronized (this.m_renderer) {
      if (Chart2D.DEBUG_THREADING) {
        System.out.println(Thread.currentThread().getName() + ", " + this.getClass().getName()
            + ".getZindex, 1 locks"


level2_itch_v2_0.level_2.dissect(buffer, index, packet, parent)

  -- Level 3: 8 Byte Unsigned Fixed Width Integer
  index, level_3 = nasdaq_nsmequities_level2_itch_v2_0.level_3.dissect(buffer, index, packet, parent)

  return index
end

-- Dissect: Mwcb Decline Level Message
nasdaq_nsmequities_level2_itch_v2_0.mwcb_decline_level_message.dissect = function(buffer, offset, packet, parent)
  if show.mwcb_decline_level_message then
    -- Optionally add element to protocol tree
    parent = parent:add(omi_nasdaq_nsmequities_level2_itch_v2_0.fields.mwcb_decline_level_message, buffer(offset, 0))
    local index = nasdaq_nsmequities_level2_itch_v2_0.mwcb_decline_level_message.fields(buffer, offset, packet, parent)
    local length = index - offset
    parent:set_len(length)
    local display = nasdaq_nsmequities_level2_itch_v2_0.mwcb_decline_level_message.display(packet, parent, length)
    parent:append_text(display)

    return index, parent
  else
    -- Skip element, add fields directly
    return nasdaq_nsmequities_level2_itch_v2_0.mwcb_decline_level_message.fields(buffer, offset, packet, parent)
  end
end

-- Interest Flag
nasdaq_nsmequities_level2_itch_v2_0.interest_flag = {}

-- Size: Interest Flag
nasdaq_nsmequities_level2_itch_v2_0.interest_flag.size = 1

-- Display: Interest Flag
nasdaq_nsmequities_level2_itch_v2_0.interest_flag.display = function(value)
  if value == "B" then
    return "Interest Flag: Buy Side Rpi Orders Available (B)"
  end
  if value == "S" then
    return "Interest Flag: Sell Side Rpi Orders Available (S)"
  end
  if value == "A" then
    return "Interest Flag: Both Sides Rpi Orders Available (A)"
  end
  if value == "N" then
    return "Interest Flag: No Rpi Orders Available (N)"
  end

  return "Interest Flag: Unknown("..value..")"
end

-- Dissect: Interest Flag
nasdaq_nsmequities_level2_itch_v2_0.interest_flag.dissect = function(buffer, offset, packet, parent)
  local length = nasdaq_nsmequities_level2_itch_v2_0.interest_flag.size
  local range = buffer(offset, length)
  local value = range:string()
  local display = nasdaq_nsmequities_level2_itch_v2_0.interest_flag.display(value, buffer, offset, packet, parent)

  parent:add(omi_nasdaq_nsmequities_level2_itch_v2_0.fields.interest_flag, range, value, display)

  return offset + length, value
end

-- Retail Price Interest Indicator Message
nasdaq_nsmequities_level2_itch_v2_0.retail_price_interest_indicator_message = {}

-- Size: Retail Price Interest Indicator Message
nasdaq_nsmequities_level2_itch_v2_0.retail_price_interest_indicator_message.size =
  nasdaq_nsmequities_level2_itch_v2_0.tracking_number.size +
  nasdaq_nsmequities_level2_itch_v2_0.timestamp.size +
  nasdaq_nsmequities_level2_itch_v2_0.stock.size +
  nasdaq_nsmequities_level2_itch_v2_0.interest_flag.size

-- Display: Retail Price Interest


IC", "text=y=x")
  @Iteration("matheq_hi", "type=MATH_EQUATION", "lang=HINDI", "text=y=x")
  @Iteration("matheq_hi-EN", "type=MATH_EQUATION", "lang=HINGLISH", "text=y=x")
  @Iteration("matheq_pt", "type=MATH_EQUATION", "lang=PORTUGUESE", "text=y=x")
  @Iteration("matheq_pt-BR", "type=MATH_EQUATION", "lang=BRAZILIAN_PORTUGUESE", "text=y=x")
  fun testView_allInteractions_unsupportedLang_producesAnswerOriginalExpAsDescription() {
    val interactionType = MathInteractionType.valueOf(type)
    val interaction = createInteraction()
    val language = OppiaLanguage.valueOf(lang)
    val translationContext = createTranslationContext(language)
    launch(interactionType, interaction, translationContext).use { scenario ->
      testCoroutineDispatchers.runCurrent()

      typeExpressionInput(text)

      // Unsupported languages should produce content descriptions that are the original expression
      // (since no readable expression can be generated).
      scenario.onActivity { activity ->
        val pendingAnswer = activity.mathExpressionViewModel.getPendingAnswer()
        assertThat(pendingAnswer.contentDescription).isEqualTo(text)
      }
    }
  }

  // This test covers all errors which are not customized based on the specific input provided (i.e.
  // they're the same for all possible expressions/equations that can produce that error), and
  // aren't tied to specific interaction types.
  @Test
  @Iteration(
    "numexp_exp_too_large",
    "type=NUMERIC_EXPRESSION",
    "text=2^10",
    "expErr=Sorry, powers higher than 5 are not supported by the app. Please revise your answer."
  )
  @Iteration(
    "numexp_exp_incomplete_func_name",
    "type=NUMERIC_EXPRESSION",
    "text=sqr(2)",
    "expErr=Did you mean sqrt? If not, please separate the variables with multiplication symbols."
  )
  @Iteration(
    "numexp_exp_hanging_square_root",
    "type=NUMERIC_EXPRESSION",
    "text=√",
    "expErr=Missing input for square root."
  )
  @Iteration(
    "numexp_exp_nested_exponent",
    "type=NUMERIC_EXPRESSION",
    "text=2^3^4",
    "expErr=Sorry, repeated powers/exponents are not supported by the app. Please limit your" +
      " answer to one power."
  )
  @Iteration(
    "numexp_exp_spaces_in_number_input",
    "type=NUMERIC_EXPRESSION",
    "text=3.14 1",
    "expErr=Please remove the spaces between numbers in your answer."
  )
  @Iteration(
    "numexp_exp_consecutive_unary",
    "type=NUMERIC_EXPRESSION",
    "text=--2",
    "expErr=Please remove the extra symbols in your answer."
  )
  @Iteration(
    "numexp_exp_divide_by_zero",
    "type=NUMERIC_EXPRESSION",
    "text=2/0",
    "expErr=Dividing by zero is invalid. Please revise your answer."
  )
  @Iteration(
    "numexp_exp_hanging_parenthesis",
    "type=NUMERIC_EXPRESSION",
    "text=2+(3-1",
    "expErr=Please close or remove parentheses."
  )
  @Iteration(
    "numexp_exp