edClient(Ljava/lang/String;)Ljava/lang/String;
                        move-result-object v$register
                        """
                )
            }
        }

        // endregion

        // region Disable SABR playback.
        // If SABR is disabled, it seems 'MediaFetchHotConfig' may no longer need to be overridden, but I'm not sure.

        val (mediaFetchEnumClass, sabrFieldReference) =
            with(mediaFetchEnumConstructorFingerprint.methodOrThrow()) {
                val mediaFetchEnumClass = definingClass
                val stringIndex =
                    indexOfFirstStringInstructionOrThrow(DISABLED_BY_SABR_STREAMING_URI_STRING)
                val sabrFieldIndex = indexOfFirstInstructionOrThrow(stringIndex) {
                    opcode == Opcode.SPUT_OBJECT &&
                            getReference<FieldReference>()?.type == mediaFetchEnumClass
                }

                Pair(
                    mediaFetchEnumClass,
                    getInstruction<ReferenceInstruction>(sabrFieldIndex).reference
                )
            }

        // The method pattern is slightly different in YouTube Music 6.20.51.
        // TODO: If support for YouTube Music 6.20.51 is dropped, implement this as a generic fingerprint.
        val getMediaFetchEnumFingerprint = legacyFingerprint(
            name = "getMediaFetchEnumFingerprint",
            returnType = mediaFetchEnumClass,
            opcodes = listOf(
                Opcode.SGET_OBJECT,
                Opcode.RETURN_OBJECT,
            ),
            customFingerprint = { method, _ ->
                !method.parameterTypes.isEmpty()
            }
        )

        getMediaFetchEnumFingerprint
            .methodOrThrow()
            .addInstructionsWithLabels(
                0, """
                    invoke-static { }, $EXTENSION_CLASS_DESCRIPTOR->disableSABR()Z
                    move-result v0
                    if-eqz v0, :ignore
                    sget-object v0, $sabrFieldReference
                    return-object v0
                    :ignore
                    nop
                    """
            )

        // endregion

        // region Fix iOS livestream current time.

        hlsCurrentTimeFingerprint.injectLiteralInstructionBooleanCall(
            HLS_CURRENT_TIME_FEATURE_FLAG,
            "$EXTENSION_CLASS_DESCRIPTOR->fixHLSCurrentTime(Z)Z"
        )

        // endregion

        // region Skip response encryption in OnesiePlayerRequest

        if (fixMediaFetchHotConfigChanges()) {
            mediaFetchHotConfigFingerprint.injectLiteralInstructionBooleanCall(
                MEDIA_FETCH_HOT_CONFIG_FEATURE_FLAG,
                "$EXTENSION_CLASS_DESCRIPTOR->useMediaFetchHotConfigReplacement(Z)Z"
            )
        }

        // In 20.14 the flag was merged with 19.50 start playback flag.
        if (fixMediaFetchHotConfigAlternativeChanges()) {
            mediaFetchHotConfigAlternativeFingerprint.injectLiteralInstructionBooleanCall(
                MEDIA_FETCH_HOT_CONFIG_ALTERNATIVE_FEATURE_FLAG,
                "$EXTENSION_CLASS_DESCRIPTOR->useMediaFetchHotConfigReplacement(Z)Z"
            )
        }

        if (fixParsePlaybackResponseFeatureFlag()) {
            playbackStartDescriptorFeatureFlagFingerprint.injectLiteralInstructionBooleanCall(
                PLAYBACK_START_CHECK_ENDPOINT_USED_FEATURE_FLAG,
                "$EXTENSION_CLASS_DESCRIPTOR->usePlaybackStartFeatureFlag(Z)Z"
            )
        }

        // endregion

        var patchStatusArray = arrayOf(
            "SpoofStreamingData"
        )

        if (isYouTube()) {
            patchStatusArray += "SpoofStreamingDataYouTube"
        }

        patchStatusArray.forEach { methodName ->
            findMethodOrThrow("$PATCHES_PATH/


	#$000bffff,-(sp)	;demander l'tat shift,control
	trap	#13		;et altenrate
	addq.l	#4,sp		;
	and.w	#$f,d0		;Presse(s) ?
	beq.s	presskey		;non, attendre encore

exit	bsr	KillDMA		;couper la digit
	bsr	ExitLMC		;mettre le LMC aux valeur de dfaut
	bsr	Wait_Kbd		;attendre clavier
	move.b	#$8,KBD_data.w	;reprendre les transferts
				;souris
	move.b	save_conterm,conterm.w;et remettre bip clavier
	move.l	save_SSP,-(sp)	;repasse en utilisateur
	move.w	#$20,-(sp)		;
	trap	#1		;
	clr.w	(sp)		;et cassos
	trap	#1		;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
InitLMC	movem.l	d0-d1/a0-a1,-(sp)	;
	lea	PCM_base.w,a0	;adresse registres du PCM
	move.w	#_mcw_pmask,mcw_mask(a0);installe mask LMC
	lea	IL_data(pc),a1	;valeur de dbut
	moveq	#5,d1		;5 rglages  faire
IL_bcl	move.w	(a1)+,d0		;un de plus
	bsr	SendLMC		;on l'envoie
	dbf	d1,IL_bcl		;
	movem.l	(sp)+,d0-d1/a0-a1	;
	rts			;
IL_data	dc.w	_master_vol+40,_left_vol+20,_right_vol+20
	dc.w	_treble+6,_bass+6,_pcm_mix+2
;Volume  40 (maximum), voix gauches et droite  20 (maximum de ces
;"sous-volumes",aigus et graves  6 (normal),sample seul.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Passe D0 au LMC. Le masque du LMC doit avoir t mis auparavant
; $7FF une fois au moins. Et A0 doit tre gal  PCM_base
;On dbute par une attente avec dbf, car sinon le LMC n'a pas le temps
;de commencer  envoyer la donne prcdente, et on se mlange les
;pinceaux !!.
SendLMC	move.w	d0,-(sp)		;sauve D0 en attendant
	move.w	#99,d0		;petite boucle pour laisser
	dbf	d0,*		;le temps au LMC de commencer
	move.w	(sp)+,d0		;le transfert prcdent..
	cmpi.w	#_mcw_pmask,mcw_mask(a0);transfert achev ?
	bne.s	*-6		;non, attendre
	move.w	d0,mcw_data(a0)	;demande le transfert de D0
	rts			;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ExitLMC	movem.l	d0-d1/a0-a1,-(sp)	;mme chose, mais valeurs
	lea	PCM_base.w,a0	;un peu diffrentes.
	lea	EL_data(pc),a1	;pas besoin du mask, dj mis
	moveq	#5,d1
EL_bcl	move.w	(a1)+,d0
	bsr	SendLMC
	dbf	d1,EL_bcl
	movem.l	(sp)+,d0-d1/a0-a1
	rts

EL_data	dc.w	_master_vol+40,_left_vol+20,_right_vol+20


, r2, #2
	cmp r0, r2
	bgt _02269548
	ldr r0, _02269564 ; =0x00050600
	bx lr
_02269548:
	lsr r2, r1, #0x1f
	add r2, r1, r2
	asr r1, r2, #1
	cmp r0, r1
	bgt _02269558
	mov r0, #0xc1
	lsl r0, r0, #0xa
	bx lr
_02269558:
	ldr r0, _02269560 ; =0x00010200
	bx lr
	.balign 4, 0
_0226955C: .word 0x00070800
_02269560: .word 0x00010200
_02269564: .word 0x00050600
	thumb_func_end ov12_02269504

	thumb_func_start ov12_02269568
ov12_02269568: ; 0x02269568
	push {r4, r5, r6, lr}
	add r5, r1, #0
	add r6, r0, #0
	ldr r0, [r5]
	ldr r0, [r0]
	bl BattleSystem_GetBgConfig
	add r4, r0, #0
	ldrb r0, [r5, #0x13]
	cmp r0, #0
	beq _02269584
	cmp r0, #1
	beq _022695DA
	b _02269606
_02269584:
	mov r2, #8
	ldrsh r1, [r5, r2]
	ldr r0, _02269658 ; =0x000018E7
	add r1, r1, r0
	strh r1, [r5, #8]
	mov r1, #0xa
	ldrsh r3, [r5, r1]
	mov r1, #0xfa
	lsl r1, r1, #2
	sub r1, r3, r1
	strh r1, [r5, #0xa]
	ldrsh r1, [r5, r2]
	lsl r0, r0, #2
	sub r0, r0, r1
	mov r1, #0x64
	bl _s32_div_f
	strh r0, [r5, #0xc]
	mov r0, #0xa
	ldrsh r0, [r5, r0]
	mov r1, #0x64
	neg r0, r0
	bl _s32_div_f
	strh r0, [r5, #0xe]
	mov r0, #8
	ldrsh r0, [r5, r0]
	cmp r0, #0
	bge _022695C6
	mov r0, #0xa
	ldrsh r0, [r5, r0]
	cmp r0, #0
	bgt _02269656
_022695C6:
	mov r1, #0
	strh r1, [r5, #8]
	mov r0, #0x90
	strh r0, [r5, #0xa]
	strh r1, [r5, #0xc]
	strh r1, [r5, #0xe]
	ldrb r0, [r5, #0x13]
	add r0, r0, #1
	strb r0, [r5, #0x13]
	pop {r4, r5, r6, pc}
_022695DA:
	ldr r1, [r5]
	ldr r0, _0226965C ; =0x0000068E
	mov r2, #0
	strb r2, [r1, r0]
	ldr r0, [r5, #4]
	bl SysTask_Destroy
	bl HBlankInterruptDisable
	ldr r2, _02269660 ; =0x04001000
	ldr r0, _02269664 ; =0xFFFF1FF


()})

				out := helper.ExecuteAndCaptureOutput(t, root)

				apiClient := helper.TestClient()
				_, _, err := apiClient.VRFsApi.
					BgpDynamicNeighborsIdGet(context.Background(), bgpDynamicNeighbor.GetId()).
					Include([]string{"created_by"}).
					Execute()
				if err != nil && !strings.Contains(err.Error(), "Not Found") {
					t.Fatal(err)
				}

				strings.Contains(string(out), "BGP Dynamic Neighbor deletion initiated. Please check 'metal gateway get-bgp-dynamic-neighbor -i "+bgpDynamicNeighbor.GetId()+"' for status")
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			rootCmd := rootClient.NewCommand()
			rootCmd.AddCommand(tt.cmd)
			tt.cmdFunc(t, tt.cmd)
		})
	}
}
package devicestarttest

import (
	"strings"
	"testing"

	root "github.com/equinix/metal-cli/internal/cli"
	"github.com/equinix/metal-cli/internal/devices"
	outputPkg "github.com/equinix/metal-cli/internal/outputs"
	"github.com/equinix/metal-cli/test/helper"
	"github.com/spf13/cobra"
)

func TestCli_Devices_Update(t *testing.T) {
	subCommand := "device"
	rootClient := root.NewClient(helper.ConsumerToken, helper.URL, helper.Version)
	type fields struct {
		MainCmd  *cobra.Command
		Outputer outputPkg.Outputer
	}
	tests := []struct {
		name    string
		fields  fields
		want    *cobra.Command
		cmdFunc func(*testing.T, *cobra.Command)
	}{
		{
			name: "start_device",
			fields: fields{
				MainCmd:  devices.NewClient(rootClient, outputPkg.Outputer(&outputPkg.Standard{})).NewCommand(),
				Outputer: outputPkg.Outputer(&outputPkg.Standard{}),
			},
			want: &cobra.Command{},
			cmdFunc: func(t *testing.T, c *cobra.Command) {
				root := c.Root()
				projectName := "metal-cli-" + helper.GenerateRandomString(5) + "-device-start"
				project := helper.CreateTestProject(t, projectName)
				device := helper.CreateTestDevice(t, project.GetId(), "metal-cli-start-dev")
				status, err := helper.IsDeviceStateActive(t, device.GetId())

				if err != nil {
					_, err := helper.IsDeviceStateActive(t, device.GetId())
					if err != nil {
						t.Error(err)
					} else {
						err = helper.StopTestDevice(t, device.GetId())
						if err != nil {
							t.Error(err)
						}
						status, err = helper.IsDeviceStateActive(t, device.GetId())
						if err == nil {
							t.Error(err)
						}
					}
				}

				if !status {
					root.SetArgs([]string{subCommand, "start", "--id", device.GetId()})

					out := helper.ExecuteAndCaptureOutput(t, root)

					if !strings.Contains(string(out[:]), "Device "+device.GetId()+" successfully started.") {
						t.Fatal("expected output should include" + "Device " + device.GetId() + " successfully started." + "in the out string ")
					}

					status, err = helper.IsDeviceStateActive(t, device.GetId())
					if err != nil {
						t.Fatal(err)
					}
					if !status {
						t.Fatalf("Device not yet active, %s", device.Ge


#region License Information
/* HeuristicLab
 * Copyright (C) Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab 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 HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using HEAL.Attic;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Parameters;
using HeuristicLab.Problems.BinPacking;

namespace HeuristicLab.Problems.BinPacking2D {
  [Item("PackingItem (2d)", "Represents a rectangular packing-item for bin-packing problems.")]
  [StorableType("36B693B0-3CD9-4EE2-97EF-B8BEA8E4877A")]
  public class PackingItem : PackingShape, IPackingItem {

    public PackingShape TargetBin {
      get { return ((IValueParameter<PackingShape>)Parameters["TargetBin"]).Value; }
      set { ((IValueParameter<PackingShape>)Par


/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
/* Copyright (c) 2021 Mellanox Technologies. */

#ifndef __MLX5_EN_TC_TUN_ENCAP_H__
#define __MLX5_EN_TC_TUN_ENCAP_H__

#include "tc_priv.h"

void mlx5e_detach_encap(struct mlx5e_priv *priv,
			struct mlx5e_tc_flow *flow, int out_index);

int mlx5e_attach_encap(struct mlx5e_priv *priv,
		       struct mlx5e_tc_flow *flow,
		       struct net_device *mirred_dev,
		       int out_index,
		       struct netlink_ext_ack *extack,
		       struct net_device **encap_dev,
		       bool *encap_valid);
int mlx5e_attach_decap(struct mlx5e_priv *priv,
		       struct mlx5e_tc_flow *flow,
		       struct netlink_ext_ack *extack);
void mlx5e_detach_decap(struct mlx5e_priv *priv,
			struct mlx5e_tc_flow *flow);

int mlx5e_attach_decap_route(struct mlx5e_priv *priv,
			     struct mlx5e_tc_flow *flow);
void mlx5e_detach_decap_route(struct mlx5e_priv *priv,
			      struct mlx5e_tc_flow *flow);

struct ip_tunnel_info *mlx5e_dup_tun_info(const struct ip_tunnel_info *tun_info);

int mlx5e_tc_set_attr_rx_tun(struct mlx5e_tc_flow *flow,
			     struct mlx5_flow_spec *spec);

struct mlx5e_tc_tun_encap *mlx5e_tc_tun_init(struct mlx5e_priv *priv);
void mlx5e_tc_tun_cleanup(struct mlx5e_tc_tun_encap *encap);

#endif /* __MLX5_EN_TC_TUN_ENCAP_H__ */


 null);
  Expect.isTrue(iterator.moveNext());
  checkState(A, currentNode: D, stack: [C]);
  Expect.isTrue(iterator.moveNext());
  checkState(A, currentNode: C, stack: [G, F, E]);
  Expect.isTrue(iterator.moveNext());
  checkState(A, currentNode: E, stack: [G, F]);
  Expect.isTrue(iterator.moveNext());
  checkState(A, currentNode: F, stack: [G]);
  Expect.isTrue(iterator.moveNext());
  checkState(A, currentNode: G, stack: []);
  Expect.isFalse(iterator.moveNext());
  checkState(A, currentNode: null, stack: []);
}

testForEach() async {
  var env = await TypeEnvironment.create(r"""
      ///        A
      ///       / \
      ///      B   C
      ///     /   /|\
      ///    D   E F G
      ///         / \
      ///         H I
      ///
      class A implements X {}
      class B extends A {}
      class C extends A {}
      class D extends B {}
      class E extends C {}
      class F extends C implements B {}
      class G extends C implements D {}
      class H extends F {}
      class I extends F {}
      class X {}

      main() {
        A();
        C();
        D();
        E();
        F();
        G();
        H();
        I();
      }
      """);
  KClosedWorld world = env.kClosedWorld;

  ClassEntity A = env.getClass("A");
  ClassEntity B = env.getClass("B");
  ClassEntity C = env.getClass("C");
  ClassEntity D = env.getClass("D");
  ClassEntity E = env.getClass("E");
  ClassEntity F = env.getClass("F");
  ClassEntity G = env.getClass("G");
  ClassEntity H = env.getClass("H");
  ClassEntity I = env.getClass("I");
  ClassEntity X = env.getClass("X");

  void checkForEachSubclass(ClassEntity cls, List<ClassEntity> expected) {
    ClassSet classSet = world.classHierarchy.getClassSet(cls);
    List<ClassEntity> visited = <ClassEntity>[];
    classSet.forEachSubclass((cls) {
      visited.add(cls);
      return IterationStep.CONTINUE;
    }, ClassHierarchyNode.ALL);

    Expect.listEquals(
        expected,
        visited,
        "Unexpected classes on $cls.forEachSubclass:\n"
        "Actual: $visited, expected: $expected\n$classSet");

    visited = <ClassEntity>[];
    classSet.forEachSubclass((cls) {
      visited.add(cls);
      return IterationStep.CONTINUE;
    }, ClassHierarchyNode.ALL);

    Expect.listEquals(
        expected,
        visited,
        "Unexpected classes on $cls.forEachSubclass:\n"
        "Actual: $visited, expected: $expected\n$classSet");
  }

  checkForEachSubclass(A, [A, B, D, C, E, F, H, I, G]);
  checkForEachSubclass(B, [B, D]);
  checkForEachSubclass(C, [C, E, F, H, I, G]);
  checkForEachSubclass(D, [D]);
  checkForEachSubclass(E, [E]);
  checkForEachSubclass(F, [F, H, I]);
  checkForEachSubclass(G, [G]);
  checkForEachSubclass(H, [H]);
  checkForEachSubclass(I, [I]);
  checkForEachSubclass(X, [X]);

  void checkForEachSubtype(ClassEntity cls, List<ClassEntity> expected) {
    ClassSe


2_2 = nil
  L3_2 = cAA7097FF
  L3_2 = L3_2.fBD747484
  L4_2 = A0_2[3]
  L5_2 = L2_2
  L3_2 = L3_2(L4_2, L5_2)
  if L3_2 then
    L3_2 = A0_2[3]
    L4_2 = L3_2
    L3_2 = L3_2.fB0CA2B80
    L5_2 = A1_2
    L6_2 = 100
    L3_2(L4_2, L5_2, L6_2)
  end
end

L68_1 = _ENV["CA4DDEC3C8C5035C5"]["prototype"]
L69_1 = _ENV["CA4DDEC3C8C5035C5"]
L68_1.__class__ = L69_1
L68_1 = _ENV["CA4DDEC3C8C5035C5"]
L69_1 = "__super__"
L69_1 = _ENV["CA4DDEC3C8C5035C5"]["prototype"]
L70_1 = {}
L71_1 = "__index"


with_one_repeat(&self, input_path: Vec<String>) -> Vec<Vec<String>> {
        let current_node = &self.0[input_path.last().unwrap()];
        let path_repeats = self.path_has_small_cave_repeat(&input_path);

        match current_node {
            Node::Start { adjacents }
            | Node::BigCave { adjacents }
            | Node::SmallCave { adjacents } => adjacents
                .iter()
                .filter(|next_node| match &self.0[*next_node] {
                    Node::BigCave { .. } | Node::End => true,
                    Node::Start { .. } => false,
                    Node::SmallCave { .. } => !(input_path.contains(next_node) && path_repeats),
                })
                .flat_map(|a| {
                    let mut path = input_path.clone();
                    path.push(a.to_string());
                    self.extend_paths_with_one_repeat(path)
                })
                .collect(),
            Node::End => vec![input_path],
        }
    }

    fn get_path_with_one_repeat_count(&self) -> usize {
        self.extend_paths_with_one_repeat(vec!["start".to_string()])
            .len()
    }
}

impl From<&str> for CaveNetwork {
    fn from(input: &str) -> CaveNetwork {
        let mut cave_network = CaveNetwork::new();

        for connection in input.split('\n') {
            let mut nodes = connection.split('-');
            let node_a = nodes.next().unwrap();
            let node_b = nodes.next().unwrap();

            cave_network.add_node_pair(node_a, node_b);
        }

        cave_network
    }
}

#[derive(PartialEq, Debug)]
enum Node {
    Start { adjacents: HashSet<String> },
    End,
    BigCave { adjacents: HashSet<String> },
    SmallCave { adjacents: HashSet<String> },
}

impl Node {
    fn add_adjacent(&mut self, adjacent: &str) {
        match self {
            Node::Start { adjacents }
            | Node::BigCave { adjacents }
            | Node::SmallCave { adjacents } => {
                adjacents.insert(adjacent.to_string());
            }
            Node::End => {}
        }
    }
}

impl From<&str> for Node {
    fn from(input: &str) -> Node {
        match input {
            "start" => Node::Start {
                adjacents: HashSet::new(),
            },
            "end" => Node::End,
            s if s.chars().all(|c| c.is_ascii_uppercase()) => Node::BigCave {
                adjacents: HashSet::new(),
            },
            s if s.chars().all(|c| c.is_ascii_lowercase()) => Node::SmallCave {
                adjacents: HashSet::new(),
            },
            e => panic!("Invalid node: {}", e),
        }
    }
}

fn main() {
    let data = std::fs::read_to_string("data/day12.txt").unwrap();
    let cave_network = CaveNetwork::from(data.as_str());

    println!("{} possible paths", cave_network.get_path_count());
    println!(
        "{} possible paths with one repeated sm


		ImageVersionNumber: jsii.Number(123),
//   				},
//   			},
//   			DefaultResourceSpec: &ResourceSpecProperty{
//   				InstanceType: jsii.String("instanceType"),
//   				LifecycleConfigArn: jsii.String("lifecycleConfigArn"),
//   				SageMakerImageArn: jsii.String("sageMakerImageArn"),
//   				SageMakerImageVersionArn: jsii.String("sageMakerImageVersionArn"),
//   			},
//   			LifecycleConfigArns: []*string{
//   				jsii.String("lifecycleConfigArns"),
//   			},
//   		},
//   		RemoteAccess: jsii.String("remoteAccess"),
//   		SpaceManagedResources: jsii.String("spaceManagedResources"),
//   		SpaceStorageSettings: &SpaceStorageSettingsProperty{
//   			EbsStorageSettings: &EbsStorageSettingsProperty{
//   				EbsVolumeSizeInGb: jsii.Number(123),
//   			},
//   		},
//   	},
//   	SpaceSharingSettings: &SpaceSharingSettingsProperty{
//   		SharingType: jsii.String("sharingType"),
//   	},
//   	Tags: []cfnTag{
//   		&cfnTag{
//   			Key: jsii.String("key"),
//   			Value: jsii.String("value"),
//   		},
//   	},
//   }
//
// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html
//
type CfnSpaceProps struct {
	// The ID of the associated domain.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-domainid
	//
	DomainId *string `field:"required" json:"domainId" yaml:"domainId"`
	// The name of the space.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-spacename
	//
	SpaceName *string `field:"required" json:"spaceName" yaml:"spaceName"`
	// The collection of ownership settings for a space.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-ownershipsettings
	//
	OwnershipSettings interface{} `field:"optional" json:"ownershipSettings" yaml:"ownershipSettings"`
	// The name of the space that appears in the Studio UI.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-spacedisplayname
	//
	SpaceDisplayName *string `field:"optional" json:"spaceDisplayName" yaml:"spaceDisplayName"`
	// A collection of space settings.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-spacesettings
	//
	SpaceSettings interface{} `field:"optional" json:"spaceSettings" yaml:"spaceSettings"`
	// A collection of space sharing settings.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-space.html#cfn-sagemaker-space-spacesharingsettings
	//
	SpaceSharingSettings interface{} `field:"optional" json:"spaceSharingSettings" yaml:"spaceSharingSettings"`
	// An array of key-value pairs to apply to this resource.
	//
	// For more information, see [Tag](https://docs.aws.amazon.com/AWSCloudForm


<!DOCTYPE html>

<meta charset="utf-8">
<title>Basic table alignment</title>
<link rel="help" href="https://mathml-refresh.github.io/mathml-core/#table-or-matrix-mtable">
<meta name="assert" content="Verify alignment of cells in basic 2x2, 4x3 and 3x4 math tables.">

    <math>
      <mtable id="vertical">
        <mtr>
          <mtd>
            <mspace width="10px" height="40px" depth="0px" style="background: lightblue;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="0px" depth="40px" style="background: lightgreen;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="20px" depth="20px" style="background: cyan;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="30px" depth="10px" style="background: purple;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="10px" depth="30px" style="background: orange;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="80px" depth="0px" style="background: blue;"></mspace>
          </mtd>
          <mtd>
            <mspace width="10px" height="0px" depth="80px" st


es.status(405).json({
      success: false,
      message: "Method not allowed."
    });
  }

  if (!userAgent || !pageVisited) {
    return res.status(400).json({
      success: false,
      message: "Oops! It looks like the page URL you visited is missing."
    });
  }

  try {
    // Get user public ip
    // const response = await fetch("https://api.ipify.org");
    // const ipAddress = await response.json()

    // Get ip details
    // const ipDetailsResponse = await fetch(
    //   `https://ipinfo.io/${ipAddress}?token=${process.env.IP_INFO_TOKEN}`
    // );
    // const ipDetails = await ipDetailsResponse.json();

    // Let's count visitor
    const newVisitor = new Visitors({
      ipAddress: "unknown",
      ipDetails: "unknown",
      userAgent,
      pageVisited,
      source: source || "unknown"
    });

    await newVisitor.save();
    console.log(newVisitor)

    res.status(201).json({
      success: true,
      message: "Visitor counted",
      visitor: newVisitor
    });
  } catch (error) {
    console.log(`Error occured while saving visitor source. Cause: ${error.message}`);
    res.status(500).json({
      success: false,
      message: "Internal server error"
    });
  }
}
import { createStore, applyMiddleware, combineReducers } from 'redux';
import { createWrapper, HYDRATE } from 'next-redux-wrapper';
import thunkMiddleware from 'redux-thunk';
import counter from './counter/reducer';
import storage from './sync_storage';
// If you don't bother about the error redux-persist failed to create sync storage. falling back to noop storage...uncomment the next line and comment out the previous import. See more on - https://github.com/vercel/next.js/discussions/15687
// const storage = require('redux-persist/lib/storage').default;

//COMBINING ALL REDUCERS
const combinedReducer = combineReducers({
  counter,
  // OTHER REDUCERS WILL BE ADDED HERE
});

// BINDING MIDDLEWARE
const bindMiddleware = (middleware) => {
  if (process.env.NODE_ENV !== 'production') {
    const { composeWithDevTools } = require('redux-devtools-extension');
    return composeWithDevTools(applyMiddleware(...middleware));
  }
  return applyMiddleware(...middleware);
};

const makeStore = ({ isServer }) => {
  if (isServer) {
    //If it's on server side, create a store
    return createStore(combinedReducer, bindMiddleware([thunkMiddleware]));
  } else {
    //If it's on client side, create a store which will persist
    const { persistStore, persistReducer } = require('redux-persist');

    const persistConfig = {
      key: 'nextjs',
      whitelist: ['counter'], // only counter will be persisted, add other reducers if needed
      storage, // if needed, use a safer storage
    };

    const persistedReducer = persistReducer(persistConfig, combinedReducer); // Create a new reducer with our existing reducer

    const store = createStore(
      persistedReducer,
      bindMiddleware([thunkMiddleware])
    ); // Creating the store again

    store.__persistor = persistStore(store); // This creates a persistor object & push that persisted object to .__persistor, so that we can avail the persistability feature

    return store;
  }
};

// Export the wrapper & wrap the pages/_app.js with this wrapper only
export const wrapper = createWrapper(makeStore);
import React from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { incrementCounter, decrementCounter } from '../store/counter/action';
import Link from 'next/link';

function counter() {
  const globalState = useSelector((state) => state.counter.counter);


* 令牌无效
     */
    TOKEN_INVALID(5001, "令牌无效"),

    /**
     * 令牌过期
     */
    TOKEN_EXPIRED(5002, "令牌过期"),

    /**
     * 账户被锁定
     */
    ACCOUNT_LOCKED(5003, "账户被锁定");

    /**
     * 状态码
     */
    private final Integer code;

    /**
     * 消息
     */
    private final String message;
}class Solution {
    public int[] searchRange(int[] nums, int target) {
        int ans[] = new int[2];
        ans[0]=lower(nums,target);
        ans[1]=upper(nums,target);
        return ans;
    }
    public static int lower(int[] nums, int target){
        int low = 0;
        int high = nums.length-1;
        int ans = -1;
        int mid = (low + high)/2;
        while(low<=high){
            mid = (low + high)/2;
            if(nums[mid]==target){
                ans = mid;
                high = mid-1;
            }else if(nums[mid]<target){
                low = mid+1;
            }else{
                high = mid-1;
            }
        }
        return ans;
    }
    public static int upper(int[] nums, int target){
        int low = 0;
        int high = nums.length-1;
        int ans = -1;
        int mid = (low + high)/2;
        while(low <= high){
            mid = (low + high)/2;
            if(nums[mid]==target){
                ans = mid;
                low = mid+1;
            }else if(nums[mid]<target){
                low = mid+1;
            }else{
                high = mid-1;
            }
        }
        return ans;
    }
}class Solution {

    public int[] nodesBetweenCriticalPoints(ListNode head) {
        int[] result = { -1, -1 };

        // Initialize minimum distance to the maximum possible value
        int minDistance = Integer.MAX_VALUE;

        // Pointers to track the previous node, current node, and indices
        ListNode previousNode = head;
        ListNode currentNode = head.next;
        int currentIndex = 1;
        int previousCriticalIndex = 0;
        int firstCriticalIndex = 0;

        while (currentNode.next != null) {
            // Check if the current node is a local maxima or minima
            if (
                (currentNode.val < previousNode.val &&
                    currentNode.val < currentNode.next.val) ||
                (currentNode.val > previousNode.val &&
                    currentNode.val > currentNode.next.val)
            ) {
                // If this is the first critical point found
                if (previousCriticalIndex == 0) {
                    previousCriticalIndex = currentIndex;
                    firstCriticalIndex = currentIndex;
                } else {
                    // Calculate the minimum distance between critical points
                    minDistance = Math.min(
                        minDistance,
                        currentIndex - previousCriticalIndex
                    );
                    previousCriticalIndex = currentIndex;
                }
            }

            // Move to the next node and update indices
            currentIndex++;
            previousNode = currentNode;
            currentNode = currentNode.next;
        }

        // If at least two critical points were found
        if (minDistance != Integer.MAX_VALUE) {
            int maxDistance = previousCriticalIndex - firstCriticalIndex;
            result = new int[] { minDista


.4 638.2h-27.198c-2.2-.6-4.2-1.6-6.4-2-57.2-8.8-102.4-56.4-106.2-112.199-4.401-62.4 31.199-115.2 89.199-132.4 7.6-2.2 15.6-3.8 23.399-5.8h27.2c1.8.6 3.4 1.6 5.4 1.8 52.8 8.6 93 46.6 104.4 98.6.8 4 2 8 3 12v27.2c-.6 1.8-1.6 3.6-1.8 5.4-8.4 52-45.4 91.599-96.801 103.6-5 1.2-9.6 2.6-14.2 3.8zM130.603 385.8l27.202.001c2.2.6 4.2 1.6 6.4 1.8 57.6 9 102.6 56.8 106.2 113.2 4 62.2-32 114.8-90.2 131.8-7.401 2.2-15 3.8-22.401 5.6h-27.2c-1.8-.6-3.4-1.6-5.2-2-52-9.6-86-39.8-102.2-90.2-2.2-6.6-3.4-13.6-5.2-20.4v-27.2c.6-1.8 1.6-3.6 1.8-5.4 8.6-52.2 45.4-91.6 96.8-103.6 4.8-1.201 9.4-2.401 13.999-3.601zm370.801.001h27.2c2.2.6 4.2 1.6 6.4 2 57.4 9 103.6 58.6 106 114.6 2.8 63-35.2 116.4-93.8 131.4-6.2 1.6-12.4 3-18.6 4.4h-27.2c-2.2-.6-4.2-1.6-6.4-2-57.4-8.8-103.601-58.6-106.2-114.6-3-63 35.2-116.4 93.8-131.4 6.4-1.6 12.6-3 18.8-4.4z"/></svg>';
  static const String options_vertical =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1024" height="1024" preserveAspectRatio="xMidYMid meet" viewBox="0 0 1024 1024"><path fill="currentColor" d="M388.8 896.4v-27.198c.6-2.2 1.6-4.2 2-6.4 8.8-57.2 56.4-102.4 112.199-106.2 62.4-4.4 115.2 31.199 132.4 89.199 2.2 7.6 3.8 15.6 5.8 23.4v27.2c-.6 1.8-1.6 3.399-1.8 5.399-8.6 52.8-46.6 93-98.6 104.4-4 .8-8 2-12 3h-27.2c-1.8-.6-3.6-1.6-5.4-1.8-52-8.4-91.599-45.4-103.6-96.8-1.2-5-2.6-9.6-3.8-14.2zm252.4-768.797-.001 27.202c-.6 2.2-1.6 4.2-1.8 6.4-9 57.6-56.8 102.6-113.2 106.2-62.2 4-114.8-32-131.8-90.2-2.2-7.401-3.8-15-5.6-22.401v-27.2c.6-1.8 1.6-3.4 2-5.2 9.6-52 39.8-86 90.2-102.2 6.6-2.2 13.6-3.4 20.4-5.2h27.2c1.8.6 3.6 1.6 5.4 1.8 52.2 8.6 91.6 45.4 103.6 96.8 1.201 4.8 2.401 9.4 3.601 13.999zm-.001 370.801v27.2c-.6 2.2-1.6 4.2-2 6.4-9 57.4-


bits.  */
	tst	tmp1, #4
	pld	[src, #64]
	S2HI	tmp2, const_m1, tmp2
	orn	data1a, data1a, tmp2
	itt	ne
	ornne	data1b, data1b, tmp2
	movne	data1a, const_m1
	mov	const_0, #0
	b	.Lstart_realigned
	.size	strlen, . - strlen


 U+94D8, U+9513-9514, U+9529, U+963C,
    U+966C, U+9688, U+96B3, U+97B2, U+996B, U+9987, U+9998, U+9A75, U+9A7A, U+9A92, U+9ADF, U+9B08,
    U+9B43, U+9C94, U+9CB4, U+9CBD, U+9CD4, U+9E31, U+9E36, U+9E4E, U+9E71, U+9F0D, U+9F37;
}
@font-face {
  font-family: 'AaKaiSong';
  src:
    local('AaKaiSong'),
    url('./f13f0fe09831f38f6bf04a7666aeff50.woff2') format('woff2');
  font-style: normal;
  font-display: swap;
  font-weight: 400;
  unicode-range:
    U+4EF3, U+4F1B, U+4F7E, U+50EC, U+51AB, U+51B1, U+536E, U+54A9, U+54DA, U+55BE, U+564D, U+572C,
    U+576B, U+57CF, U+57F8, U+5844, U+5AE0, U+5B37, U+5B5B, U+5B80, U+5D1E, U+5D6B, U+5EFE, U+5F58,
    U+5F73, U+5F8C, U+602B, U+610D, U+641B, U+6634, U+66DB, U+676A, U+681D, U+698D, U+69B1, U+69E0,
    U+6A18, U+6B39, U+6B9B, U+6BB3, U+6D7C, U+6E16, U+6EBB, U+6ED7, U+6F36, U+7035, U+7173, U+7178,
    U+7228, U+728F, U+72B4, U+72EF, U+7331, U+7481, U+74E0, U+7540, U+755B, U+758B, U+7635, U+763C,
    U+76CD, U+7704, U+7780, U+7847, U+7962, U+7A02, U+7B6E, U+7B7B, U+7BFC, U+7C0F, U+7C16, U+7C9E,
    U+7CC7, U+7CF8, U+7E3B, U+7EA9, U+7EF2, U+7F02, U+7F23, U+7FBC, U+8016, U+8020, U+812C, U+8136,
    U+8182, U+825F, U+8268, U+8288, U+8291, U+829F, U+8308, U+8311, U+831A, U+836D, U+83B6, U+840F,
    U+845C, U+855E, U+85A4, U+863C, U+86C4, U+86DE, U+86F1, U+873E, U+87DB, U+880A, U+8864, U+887F,
    U+88F0, U+890A, U+892B, U+89CB, U+89EF, U+8A48, U+8C18, U+8C94, U+8DCF, U+8E6F, U+8E90, U+8F7E,
    U+8FB6, U+8FD3, U+902D, U+90BE, U+9161, U+91A3, U+936


_N***
- ***SSDT-RMCF-PS2Map-LenovoPRO13***
- ***SSDT-OCPublic-Merge*** – Patch for this chapter, see **Attachment** Description
- ***SSDT-BATS-PRO13***

> [!NOTE]
>
> The name changes required for the above patches are in the comments of the corresponding source code patch files (.dsl).

## Annex: Merging Shared Patches

- To simplify the operation as well as to reduce the number of patches, certain common patches are merged togother within: ***SSDT-OCPublic-Merge***.

### Merged Patches

- ***SSDT-EC-USBX*** - from the **USBX** section of the official OC patch example
- ***SSDT-ALS0*** - original patch located in Counterfeit Devices - Counterfeit Ambient Light Sensors
- ***SSDT-MCHC*** - the original patch is located in Adding Missing Parts

### Caution

- ***SSDT-OCPublic-Merge*** applies to all machines.
- After using ***SSDT-OCPublic-Merge***, the patches listed above **<u>Merged Patches</u>** no longer apply.
---
layout: base.njk
---

## Plugin Test Page

Cupcake ipsum dolor. Sit amet I love I love I love. I love pudding dragée. Halvah macaroon halvah I love jujubes bonbon I love pie. Bonbon gingerbread bonbon I love. Tootsie roll chocolate sweet jelly-o lemon drops cotton candy gummies.

Marshmallow macaroon cupcake I love I love jelly beans pudding pastry pie. Macaroon marzipan dragée cake marshmallow I love wafer oat cake. Cake marshmallow muffin cupcake danish. Chocolate cake croissant tiramisu lollipop jelly lollipop cookie caramels cookie. Fruitcake soufflé bonbon cupcake gingerbread I love jelly beans ice cream bonbon. Sugar plum marshmallow marshmallow cake apple pie marzipan sweet tootsie roll croissant.

```js
module.exports = function (eleventyConfig) {
  return {
    dir: {
      input: "src",
      output: "public",
    },
  };
};
```

Gummi bears chocolate bar gummi bears gummies. Soufflé soufflé dessert wafer carrot cake. Bonbon sesame snaps danish soufflé topping danish. Tart danish tootsie roll candy canes cotton candy lemon drops toffee fruitcake. Toffee gummies icing jelly beans toffee halvah. Caramels oat cake cookie topping caramels. Sesame snaps chocolate jujubes pie cake. Brownie chocolate sweet roll jelly-o. Apple pie I love jelly cake cake dragée danish candy. Tart caramels gummi bears bear claw sweet roll marzipan sweet marzipan pie.

Gummi bears candy cotton candy oat cake candy canes bonbon cake. Gummi bears jelly marzipan. Dessert topping biscuit jujubes jelly beans caramels cookie. Gingerbread candy gummi bears I love topping cookie halvah carrot cake topping. Sugar plum tart liquorice liquorice candy pudding powder. I love I love halvah chocolate cake I love cake apple pie wafer.

![test image](http://placecorgi.com/800/200)

I love lollipop chocolate cake marshmallow sesame snaps. Tart gingerbread fruitcake icing sesame snaps danish sesame snaps soufflé jujubes. Halvah I love I love lemon drops. Donut I love candy canes I love dragée sugar plum. I love tootsie roll I love cake. Cupcake danish danish macaroon lemon drops liquorice chocolate tart.

Sugar plum jelly sesame snaps I love powder. Chocolate sesame snaps cake. Pastry brownie donut I love liquorice tootsie roll. Gummi bears sesame snaps I love cookie tootsie roll. I love lemon drops topping toffee cake I love chocolate bar. Biscuit candy sweet candy canes danish danish cake. Marzipan tiramisu sweet roll fruitcake. Jujubes I love candy canes.

Chocolate bar pudding ice cream. Jelly-o tootsie roll pie gingerbread candy jelly beans cupcake donut lollipop. Croissant topping cake apple pie gummi bears gingerbread donut croissant tiramisu. Gummies chupa chups donut caramels gummies cotton candy cookie muffin pudding. Cho


using Android.Content.Res;
using Android.Views;
using Android.Views.InputMethods;
using AndroidX.AppCompat.Widget;
using AndroidX.Core.View;
using Maui.FreakyControls.Platforms.Android.NativeControls;

namespace Maui.FreakyControls
{
    public partial class FreakyEditorHandler
    {
        protected override AppCompatEditText CreatePlatformView()
        {
            var _nativeView = new AppCompatEditText(Context)
            {
                ImeOptions = ImeAction.Done,
                Gravity = GravityFlags.Top,
                TextAlignment = Android.Views.TextAlignment.ViewStart,
            };
            _nativeView.SetSingleLine(false);
            var colorStateList = ColorStateList.ValueOf(Android.Graphics.Color.Tran


} finally {
                SavedGameOptions.Available = true;
            }
        }

        /// <summary>
        /// Compiles mod options in to a byte array for storage in savegame.
        /// </summary>
        /// <param name="success">Current success state of SaveData operation.</param>
        /// <returns>Returns <c>true</c> if successful, otherwise <c>false</c>.</returns>
        public byte[] SaveData(ref bool success) {

            // Remember to update this when adding new options (lastIdx + 1)
            var save = new byte[61];

            try {
                save[0] = GeneralTab_SimulationGroup.SimulationAccuracy.Save();
                save[1] = 0; // SavedGameOptions.Instance.laneChangingRandomization
                save[2] = GameplayTab_VehicleBehaviourGroup.RecklessDrivers.Save();
                save[3] = (byte)(SavedGameOptions.Instance.relaxedBusses ? 1 : 0);
                save[4] = (byte)(SavedGameOptions.Instance.nodesOverlay ? 1 : 0);
                save[5] = (byte)(SavedGameOptions.Instance.allowEnterBlockedJunctions ? 1 : 0);
                save[6] = (byte)(SavedGameOptions.Instance.advancedAI ? 1 : 0);
                save[7] = (byte)(SavedGameOptions.Instance.highwayRules ? 1 : 0);
                save[8] = (byte)(SavedGameOptions.Instance.prioritySignsOverlay ? 1 : 0);
                save[9] = (byte)(SavedGameOptions.Instance.timedLightsOverlay ? 1 : 0);
                save[10] = (byte)(SavedGameOptions.Instance.speedLimitsOverlay ? 1 : 0);
                save[11] = (byte)(SavedGameOptions.Instance.vehicleRestrictionsOverlay ? 1 : 0);
                save[12] = GameplayTab_VehicleBehaviourGroup.StrongerRoadConditionEffects.Save();
                save[13] = (byte)(SavedGameOptions.Instance.allowUTurns ? 1 : 0);
                save[14] = (byte)(SavedGameOptions.Instance.allowLaneChangesWhileGoingStraight ? 1 : 0);
                save[15] = (byte)(SavedGameOptions.Instance.disableDespawning ? 1 : 0);
                save[16] = 0; // SavedGameOptions.Instance.IsDynamicPathRecalculationActive
                save[17] = (byte)(SavedGameOptions.Instance.connectedLanesOverlay ? 1 : 0);
                save[18] = (byte)(SavedGameOptions.Instance.prioritySignsEnabled ? 1 : 0);
                save[19] = (byte)(SavedGameOptions.Instance.timedLightsEnabled ? 1 : 0);
                save[20] = (byte)(SavedGameOptions.Instance.customSpeedLimitsEnabled ? 1 : 0);
                save[21] = (byte)(SavedGameOptions.Instance.vehicleRestrictionsEnabled ? 1 : 0);
                save[22] = (byte)(SavedGameOptions.Instance.laneConnectorEnabled ? 1 : 0);
                save[23] = (byte)(SavedGameOptions.Instance.junctionRestrictionsOverlay ? 1 : 0);
                save[24] = (byte)(SavedGameOptions.Instance.junctionRestrictionsEnabled ? 1 : 0);
                save[25] = (byte)(SavedGameOptions.Instance.parkingAI ? 1 : 0);
                save[26] = (byte)(SavedGameOptions.Instance.preferOuterLane ? 1 : 0);
                save[27] = GameplayTab_VehicleBehaviourGroup.IndividualDrivingStyle.Save();
                save[28] = (byte)(SavedGameOptions.Instance.evacBussesMayIgnoreRules ? 1 : 0);
                save[29] = 0; // (byte)(SavedGameOptions.Instance.instantEffects ? 1 : 0);
                save[30] = (byte)(SavedGameOptions.Instance.parkingRestrictionsEnabled ? 1 : 0);
                save[31] = (byte)(SavedGameOptions.Instance.parkingRestrictionsOverlay ? 1 : 0);
                save[32] = (byte)(SavedGameOptions.Instance.banRegularTrafficOn


.x ; encoding: [0x05,0x00,0x72,0xd2,0x00,0x02,0x00,0x00]

v_interp_mov_f32_e64 v5, p10, attr0.w
// NOSICI: error: instruction not supported on this GPU
// VI: v_interp_mov_f32_e64 v5, p10, attr0.w ; encoding: [0x05,0x00,0x72,0xd2,0xc0,0x00,0x00,0x00]

v_interp_mov_f32_e64 v5, p10, attr0.x clamp
// NOSICI: error: invalid operand for instruction
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x clamp ; encoding: [0x05,0x80,0x72,0xd2,0x00,0x00,0x00,0x00]

v_interp_mov_f32 v5, p10, attr0.x clamp
// NOSICI: error: invalid operand for instruction
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x clamp ; encoding: [0x05,0x80,0x72,0xd2,0x00,0x00,0x00,0x00]

v_interp_mov_f32_e64 v5, p10, attr0.x mul:2
// NOSICI: error: not a valid operand
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x mul:2 ; encoding: [0x05,0x00,0x72,0xd2,0x00,0x00,0x00,0x08]

v_interp_mov_f32_e64 v5, p10, attr0.x mul:4
// NOSICI: error: not a valid operand
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x mul:4 ; encoding: [0x05,0x00,0x72,0xd2,0x00,0x00,0x00,0x10]

v_interp_mov_f32_e64 v5, p10, attr0.x div:2
// NOSICI: error: not a valid operand
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x div:2 ; encoding: [0x05,0x00,0x72,0xd2,0x00,0x00,0x00,0x18]

v_interp_mov_f32 v5, p10, attr0.x div:2
// NOSICI: error: not a valid operand
// VI: v_interp_mov_f32_e64 v5, p10, attr0.x div:2 ; encoding: [0x05,0x00,0x72,0xd2,0x00,0x00,0x00,0x18]

v_interp_p1_f32_e64 v5, v2, attr0.x
// NOSICI: error: instruction not supported on this GPU
// VI: v_interp_p1_f32_e64 v5, v2, attr0.x ; encoding: [0x05,0x00,0x70,0xd2,0x00,0x04,0x02,0x00]

v_interp_p1_f32_e64 v5, v2, attr0.y
// NOSICI: error: instruction not supported on this GPU
// VI: v_interp_p1_f32_e64 v5, v2, attr0.y ; encoding: [0x05,0x00,0x70,0xd2,0x40,0x04,0x02,0x00]

v_interp_p1_f32_e64 v


3
	ldr r0, [r7, #0x0]
	add r1, r4, r6
	add r2, r2, r3
	bl AddWindow
	add r0, r4, r6
	mov r1, #0x0
	bl FillWindowPixelBuffer
	add r0, r5, #0x1
	lsl r0, r0, #0x10
	lsr r5, r0, #0x10
	cmp r5, #0x24
	blo _0207D5C4
	add r0, r7, #0x0
	bl sub_0207DB78
	add r0, r7, #0x0
	bl sub_0207D768
	add r0, r7, #0x0
	bl sub_0207D800
	add r0, r7, #0x0
	bl sub_0207D8A0
	pop {r3-r7, pc}
	.balign 4
_0207D600: .word UNK_020FB4AC

	thumb_func_start sub_0207D604
sub_0207D604: ; 0x0207D604
	push {r3-r7, lr}
	add r4, r0, #0x0
	ldr r0, _0207D6D8 ; =0x0000068C
	ldrsb r0, [r4, r0]
	cmp r0, #0x7
	bhi _0207D6D4
	add r0, r0, r0
	add r0, pc
	ldrh r0, [r0, #0x6]
	lsl r0, r0, #0x10
	asr r0, r0, #0x10
	add pc, r0
_0207D61C: ; jump table (using 16-bit offset)
	.short _0207D62C - _0207D61C - 2; case 0
	.short _0207D638 - _0207D61C - 2; case 1
	.short _0207D644 - _0207D61C - 2; case 2
	.short _0207D650 - _0207D61C - 2; case 3
	.short _0207D674 - _0207D61C - 2; case 4
	.short _0207D65C - _0207D61C - 2; case 5
	.short _0207D668 - _0207D61C - 2; case 6
	.short _0207D674 - _0207D61C - 2; case 7
_0207D62C:
	mov r0, #0x92
	mov r1, #0x6
	lsl r0, r0, #0x2
	ldr r5, _0207D6DC ; =UNK_020FB3FC
	str r1, [r4, r0]
	b _0207D692
_0207D638:
	mov r0, #0x92
	mov r1, #0x1
	lsl r0, r0, #0x2
	ldr r5, _0207D6E0 ; =UNK_020FB38C
	str r1, [r4, r0]
	b _0207D692
_0207D644:
	mov r0, #0x92
	mov r1, #0x8
	lsl r0, r0, #0x2
	ldr r5, _0207D6E4 ; =UNK_020FB42C
	str r1, [r4, r0]
	b _0207D692
_0207D650:
	mov r0, #0x92
	mov r1, #0x8
	lsl r0, r0, #0x2
	ldr r5, _0207D6E8 ; =UNK_020FB


mapOf(
                            FlickDirection.TAP to FlickAction.Input("0"),
                            FlickDirection.UP_LEFT_FAR to FlickAction.Input("〜"),
                            FlickDirection.UP to FlickAction.Input("…"),
                            FlickDirection.UP_RIGHT_FAR to FlickAction.Input("√"),
                        )
                    ),
                    "( ) [ ]" to listOf(
                        mapOf(
                            FlickDirection.TAP to FlickAction.Input("("),
                            FlickDirection.UP_LEFT_FAR to FlickAction.Input(")"),
                            FlickDirection.UP to FlickAction.Input("["),
                            FlickDirection.UP_RIGHT_FAR to FlickAction.Input("]"),
                        )
                    ),
                    "@\n/~;" to listOf(
                        mapOf(
                            FlickDirection.TAP to FlickAction.Input("@"),
                            FlickDirection.UP_LEFT_FAR to FlickAction.Input("/"),
                            FlickDirection.UP to FlickAction.Input("~"),
                            FlickDirection.UP_RIGHT_FAR to FlickAction.Input(";"),
                        )
                    ),
                    "#\n.^," to listOf(
                        mapOf(
                            FlickDirection.TAP to FlickAction.Input("#"),
                            FlickDirection.UP_LEFT_FAR to FlickAction.Input("."),
                            FlickDirection.UP to FlickAction.Input("^"),
                            FlickDirection.UP_RIGHT_FAR to FlickAction.Input(","),
                        )
                    ),
                    ":" to listOf(mapOf(FlickDirection.TAP to FlickAction.Input(":"))),
                    "-" to listOf(mapOf(FlickDirection.TAP to FlickAction.Input("-"))),
                )
            }

        dakutenToggleStates.getOrNull(0)?.label?.let { label ->
            flickMaps.put(label, listOf(emojiStateFlickMap))
        }
        dakutenToggleStates.getOrNull(1)?.label?.let { label ->
            flickMaps.put(label, listOf(dakutenStateFlickMap))
        }

        spaceConvertStates.getOrNull(0)?.label?.let { label ->
            flickMaps.put(label, listOf(spaceActionMap))
        }

        spaceConvertStates.getOrNull(1)?.label?.let { label ->
            flickMaps.put(label, listOf(conversionActionMap))
        }

        return KeyboardLayout(keys, flickMaps, 5, 4)
    }

}
import com.vanniktech.maven.publish.SonatypeHost

plugins {
    alias(libs.plugins.multiplatform)
    alias(libs.plugins.android.library)
    alias(libs.plugins.serialization)
    alias(libs.plugins.vannitktech.maven.publish)
}

val appVersion: String by rootProject.extra

group = "com.kdroid.kmplog"

kotlin {

    jvmToolchain(11)
    androidTarget {
        publishLibraryVariants("release")
    }

    jvm()

    js {
        browser {
            webpackTask {
                mainOutputFileName = "kmplog.js"
            }
        }
        binaries.executable()
    }

    wasmJs {
        browser()
        binaries.executable()
    }

    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        it.binaries.framework {
            baseName = "kmplog"
            isStatic = true
        }
    }

    listOf(
        macosX64(),
        macosArm64()
    ).forEach {
        it.binaries.framework {
            baseName = "kmplog"
            isStatic = true
        }
    }

    linuxX64 {
        binaries.staticLib {
            baseName = "kmplog"
        }
    }

    mingwX64 {
        binaries.staticLib {
            baseName =


s dl { display: block; width: 98%; height: 66px; clear: both; margin: 0 auto 0 2%; border-bottom: dotted 1px #DDD; position: relative; z-index: 1; }
.head-user-menu dl dd .incart-goods dt, .head-user-menu dl dd .incart-goods dd { background-color: transparent; border: 0; position: absolute; z-index: 1; }
.head-user-menu dl dd .incart-goods dt.goods-name { line-height: 16px; background-color: transparent; text-align: left; width: 180px; height: 32px; padding: 0; top: 8px; left: 64px; }
.head-user-menu dl dd .incart-goods dt.goods-name a { color: #333;}
.head-user-menu dl dd .incart-goods dd.goods-thumb { top: 8px; left: 8px;}
.head-user-menu dl dd .incart-goods dd.goods-price { text-align: right; width: 80px; height: 16px; top: 6px; right: 12px;}
.head-user-menu dl dd .incart-goods dd.goods-price em { font-size: 11px !important; font-weight: normal!important; line-height: 16px; color: #777 !important; word-break: break-all; word-wrap: break-word; text-overflow: ellipsis; white-space: nowrap; text-align: right; width: 50px; margin-right: 4px; overflow: hidden; -webkit-text-size-adjust:none;}
.head-user-menu dl dd .incart-goods dd.goods-sales { line-height: 16px; color: #999; background-color: transparent; width: 270px; height: 16px; top: 42px; left: 64px; }
.head-user-menu dl dd .incart-goods dd.handle {  width: 32px; top: 22px; right: 10px;}
.head-user-menu dl dd .checkout { background-color: #F0F0F0; text-align: right; padding: 8px; overflow: hidden;}
.head-user-menu dl dd .checkout .total-price { line-height: 20px; display: block;}
.head-user-menu dl dd .checkout .total-price i { font-weight: 600; color: #C00; margin: 0 4px;}
.head-user-menu dl dd .checkout .total-price em { font-family: Verdana, Geneva, sans-serif; font-size: 18px; font-weight: 600; color: #C00;}
.head-user-menu dl dd .checkout .btn-cart { float: right; clear: both; line-height: 20px; color: #FFF; background-color: #D93600; padding: 4px 8px; margin-top: 4px; border-radius: 4px;}
.head-user-menu dl div.addcart-goods-num { font: bold 11px/14px Verdana; color: #FFF; background: #F00; text-align: center; display: inline-block; height: 16px; min-width: 16px; max-width: auto!important; border: none 0; border-radius: 8px; position: absolute; z-index: 3; top: -4px; left: 20px;}

/* 公用导航区域
-------------------------------------- */
.public-nav-layout { background-color: #D93600; width: 100%; height: 40px; position: relative; z-index: 99;}
/*站点导航菜单*/
.public-nav-layout .site-menu { font-size: 0; *word-spacing:-1px/*IE6、7*/; float: left;}
.public-nav-layout .site-menu li { vertical-align: top; letter-spacing: normal; word-spacing: normal; display: inline-block; *display:inline/*IE6、7*/;}
.public-nav-layout .site-menu li a { font-size: 14px; font-weight: 600; line-height: 40px; color: #FFF; height: 4


dingBox();
    CPPUNIT_ASSERT_EQUAL(4, bbox.min().x());
    CPPUNIT_ASSERT_EQUAL(4, bbox.min().y());
    CPPUNIT_ASSERT_EQUAL(-6, bbox.min().z());
    CPPUNIT_ASSERT_EQUAL(4, bbox.max().x());
    CPPUNIT_ASSERT_EQUAL(4, bbox.max().y());
    CPPUNIT_ASSERT_EQUAL(6, bbox.max().z());
    CPPUNIT_ASSERT_EQUAL(6 + 6 + 1, int(clipped.activeVoxelCount()));
    CPPUNIT_ASSERT_EQUAL(2, int(clipped.constTree().leafCount()));

    typename GridT::ConstAccessor acc = clipped.getConstAccessor();
    const ValueT bg = clipped.background();
    Coord xyz;
    int &x = xyz[0], &y = xyz[1], &z = xyz[2];
    for (x = -10; x <= 10; ++x) {
        for (y = -10; y <= 10; ++y) {
            for (z = -10; z <= 10; ++z) {
                if (x == 4 && y == 4 && z >= -6 && z <= 6) {
                    CPPUNIT_ASSERT_EQUAL(fg, acc.getValue(Coord(4, 4, z)));
                } else {
                    CPPUNIT_ASSERT_EQUAL(bg, acc.getValue(Coord(x, y, z)));
                }
            }
        }
    }
}

// See also TestTools::testClipping()
void
TestGrid::testClipping()
{
    using namespace openvdb;

    const BBoxd clipBox(Vec3d(4.0, 4.0, -6.0), Vec3d(4.9, 4.9, 6.0));

    {
        const float fg = 5.f;
        FloatGrid cube(0.f);
        cube.fill(CoordBBox(Coord(-10), Coord(10)), /*value=*/fg, /*active=*/true);
        cube.clipGrid(clipBox);
        validateClippedGrid(cube, fg);
    }
    {
        const bool fg = true;
        BoolGrid cube(false);
        cube.fill(CoordBBox(Coord(-10), Coord(10)), /*value=*/fg, /*active=*/true);
        cube.clipGrid(clipBox);
        validateClippedGrid(cube, fg);
    }
    {
        const Vec3s fg(1.f, -2.f, 3.f);
        Vec3SGrid cube(Vec3s(0.f));
        cube.fill(CoordBBox(Coord(-10), Coord(10)), /*value=*/fg, /*active=*/true);
        cube.clipGrid(clipBox);
        validateClippedGrid(cube, fg);
    }
    /*
    {// Benchmark multi-threaded copy construction
        openvdb::util::CpuTimer timer;
        openvdb::initialize();
        openvdb::io::File file("/usr/pic1/Data/OpenVDB/LevelSetModels/crawler.vdb");
        file.open();
        openvdb::GridBase::Ptr baseGrid = file.readGrid("ls_crawler");
        file.close();
        openvdb::FloatGrid::Ptr grid = openvdb::gridPtrCast<openvdb::FloatGrid>(baseGrid);
        //grid->tree().print();
        timer.start("\nCopy construction");
        openvdb::FloatTree fTree(grid->tree());
        timer.stop();

        timer.start("\nBoolean topology copy construction");
        openvdb::BoolTree bTree(grid->tree(), false, openvdb::TopologyCopy());
        timer.stop();

        timer.start("\nBoolean topology union");
        bTree.topologyUnion(fTree);
        timer.stop();
        //bTree.print();
    }
    */
}

////////////////////////////////////////

namespace {

struct GridOp
{
    bool isConst = false;
    template<typename GridT> void


import io.reactivex.schedulers.Schedulers
import java.net.Inet6Address
import java.net.InetAddress

/**
 * [SmbDeviceScannerObservable.DiscoverDeviceStrategy] to just loop through other addresses within
 * same subnet (/24 netmask) and knock their SMB service ports for reachability.
 *
 * Will bypass [Inet6Address] device addresses. They may have much bigger neighourhood host count;
 * also for devices using IPv6, they shall be covered by [WsddDiscoverDeviceStrategy] anyway.
 *
 * TODO: if we can get the gateway using __legit__ API, may swarm the network in broader netmasks
 */
class SameSubnetDiscoverDeviceStrategy : SmbDeviceScannerObservable.DiscoverDeviceStrategy {
    private lateinit var worker: Disposable

    companion object {
        private const val HOST_UP_TIMEOUT = 1000
        private const val PARALLELISM = 10
        private val TCP_PORTS = arrayListOf(139, 445)
    }

    /**
     * No need to cleanup resources
     */
    override fun onCancel() {
        if (!worker.isDisposed) {
            worker.dispose()
        }
    }

    override fun discoverDevices(callback: (ComputerParcelable) -> Unit) {
        val neighbourhoods = getNeighbourhoodHosts()
        worker =
            Flowable.fromIterable(neighbourhoods)
                .parallel(PARALLELISM)
                .runOn(Schedulers.io())
                .map { addr ->
                    if (addr.isReachable(HOST_UP_TIMEOUT)) {
                        val portsReachable =
                            listOf(
                                PortScan.onAddress(addr).setPorts(TCP_PORTS).setMethodTCP().doScan(),
                            ).flatten()
                        if (portsReachable.isNotEmpty()) {
                            addr
                        } else {
                            false
                        }
                    } else {
                        false
                    }
                }.filter {
                    it is InetAddress
                }.doOnNext { addr ->
                    addr as InetAddress
                    callback.invoke(
                        ComputerParcelable(
                            addr.hostAddress,
                            if (addr.hostName == addr.hostAddress) {
                                addr.canonicalHostName
                            } else {
                                addr.hostName
                            },
                        ),
                    )
                }.sequential().subscribe()
    }

    private fun getNeighbourhoodHosts(): List<InetAddress> {
        val deviceAddress = NetworkUtil.getLocalInetAddress(AppConfig.getInstance(), requestMulticast = true)
        return deviceAddress?.let { addr ->
            if (addr is Inet6Address) {
                // IPv6 neigbourhood hosts can be very big - that should use wsdd instead; hence
                // empty list here
                emptyList()
            } else {
                val networkPrefix: String = addr.hostAddress.substringBeforeLast('.')
                (1..254).map {
                    InetAddress.getByName("$networkPrefix.$it")
                }
            }
        } ?: emptyList()
    }
}
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.compose.compiler)
}

android {
    namespace = "com.b1nd.dodam.designsystem.sample"
    compileSdk = libs.versions.compileSdk.get().toInt()

    defaultConfig {
        applicationId = "com.b1nd.dodam.designsystem.sample"
        minSdk = libs.versions.minSdk.get().toInt()
        targetSdk = libs.versions.targetSdk.get().toInt()
        versionCode = libs.versions.versionCode.get().toInt()
        versionName = libs.versions.appVersion.get()

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"


alt=":paw_prints:"],

/* unicode */

/* some emoji don't need to be inverted on Windows */

/* from https://github.com/Dunedan/mbp-2016-linux on Windows*/

/* <g-emoji alias="heavy_check_mark"
    fallback-src="https://assets-cdn.github.com/images/icons/emoji/unicode/2714.png"
    ios-version="6.0">✔</g-emoji> */

[alias="soon"],
[alias="on"],
[alias="end"],
[alias="heavy_dollar_sign"],
[alias="registered"],
[alias="tm"],
[alias="heavy_multiplication_x"],
[alias="heavy_plus_sign"],
[alias="heavy_minus_sign"],
[alias="heavy_division_sign"],
[alias="arrows_clockwise"],
[alias="wavy_dash"],
[alias="curly_loop"],
[alias="copyright"],
[alias="currency_exchange"],
[alias="top"],
[alias="back"],
[alias="zzz"],
[alias="notes"],
[alias="musical_score"],
[alias="black_large_square"],
[alias="black_medium_small_square"],
[alias="ant"],
[alias="musical_note"],
[alias="loop"],
[alias="feet"],
[alias="paw_prints"] {
    -webkit-filter: invert(100%) hue-rotate(180deg) brightness(80%) !important;
    filter: invert(100%) hue-rotate(180deg) brightness(80%) !important;
    background: transparent !important;
}

.emoji[alt=":heavy_check_mark:"] {
    filter: brightness(1.2) !important;
}

/* Invert problematic emoji fallback images used on Windows */

/* use tools/unicode-gen.js to generate */

g-emoji[fallback-src$="2795.png"],
g-emoji[fallback-src$="2796.png"],
g-emoji[fallback-src$="2797.png"],
g-emoji[fallback-src$="27b0.png"],
g-emoji[fallback-src$="2b1b.png"],
g-emoji[fallback-src$="25fe.png"],
g-emoji[fallback-src$="1f3b6.png"],
g-emoji[fallback-src$="1f3bc.png"],
g-emoji[fallback-src$="1f4b1.png"],
g-emoji[fallback-src$="1f4b2.png"],
g-emoji[fallback-src$="1f503.png"],
g-emoji[fallback-src$="1f519.png"],
g-emoji[fallback-src$="1f51a.png"],
g-emoji[fallback-src$="1f51b.png"],
g-emoji[fallback-src$="1f51c.png"],
g-emoji[fallback-src$="1f51d.png"],
g-emoji[fallback-src$="1f3b5.png"],
g-emoji[fallback-src$="27bf.png"],
g-emoji[fallback-src$="1f43e.png"],
g-emoji[fallback-src$="1f43e.png"] {
    -webkit-filter: invert(83%) !important;
    filter: invert(83%) !important;
}

.leaflet-tile-container img {
    -webkit-filter: invert(100%) hue-rotate(180deg) brightness(150%) !important;
    filter: invert(100%) hue-rotate(180deg) brightness(150%) !important;
}

.leaflet-marker-pane img,
.gundamcat {
    -webkit-filter: brightness(0.8) !important;
    filter: brightness(0.8) !important;
}

/* invert #fff to #25272a */

/* https://github.com/sujitpal/statlearning-notebooks/blob/master/src/chapter2.ipynb */

.output_area img,
table.pricing-table,
div[id^="contribution-first"] img,
div[id^=


',
    14: 'وَمَا هُوَ بِالْهَزْلِ',
    15: 'إِنَّهُمْ يَكِيدُونَ كَيْدًا',
    16: 'وَأَكِيدُ كَيْدًا',
    17: 'فَمَهِّلِ الْكَافِرِينَ أَمْهِلْهُمْ رُوَيْدًا',
  },
  87: {
    1: 'بِسْمِ اللَّهِ الرَّحْمَـٰنِ الرَّحِيمِ سَبِّحِ اسْمَ رَبِّكَ الْأَعْلَى',
    2: 'الَّذِي خَلَقَ فَسَوَّىٰ',
    3: 'وَالَّذِي قَدَّرَ فَهَدَىٰ',
    4: 'وَالَّذِي أَخْرَجَ الْمَرْعَىٰ',
    5: 'فَجَعَلَهُ غُثَاءً أَحْوَىٰ',
    6: 'سَنُقْرِئُكَ فَلَا تَنْسَىٰ',
    7: 'إِلَّا مَا شَاءَ اللَّهُ ۚ إِنَّهُ يَعْلَمُ الْجَهْرَ وَمَا يَخْفَىٰ',
    8: 'وَنُيَسِّرُكَ لِلْيُسْرَىٰ',
    9: 'فَذَكِّرْ إِنْ نَفَعَتِ الذِّكْرَىٰ',
    10: 'سَيَذَّكَّرُ مَنْ يَخْشَىٰ',
    11: 'وَيَتَجَنَّبُهَا الْأَشْقَى',
    12: 'الَّذِي يَصْلَى النَّارَ الْكُبْرَىٰ',
    13: 'ثُمَّ لَا يَمُوتُ فِيهَا وَلَا يَحْيَىٰ',
    14: 'قَدْ أَفْلَحَ مَنْ تَزَكَّىٰ',
    15: 'وَذَكَرَ اسْمَ رَبِّهِ فَصَلَّىٰ',
    16: 'بَلْ تُؤْثِرُونَ الْحَيَاةَ الدُّنْيَا',
    17: 'وَالْآخِرَةُ خَيْرٌ وَأَبْقَىٰ',
    18: 'إِنَّ هَـٰذَا لَفِي الصُّحُفِ الْأُولَىٰ',
    19: 'صُحُفِ إِبْرَاهِ


ples_used[iext])
						{
							unused_samples--;
							samples_used[iext] = TRUE;
							DestroySample(iext);
							n = iext;
							for (UINT mapchk=0; mapchk<nmap; mapchk++)
							{
								if (samplemap[mapchk] == n) samplemap[mapchk] = 0;
							}
							for (UINT clrs=1; clrs<iIns; clrs++) if (Headers[clrs])
							{
								INSTRUMENTHEADER *pks = Headers[clrs];
								for (UINT ks=0; ks<128; ks++)
								{
									if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0;
								}
							}
							memset(&Ins[n], 0, sizeof(Ins[0]));
							break;
						}
					}
				}
#endif // MODPLUG_FASTSOUNDLIB
			}
			if (newsamples < n) newsamples = n;
			samplemap[nmap] = n;
		}
		m_nSamples = newsamples;
		// Reading Volume Envelope
		INSTRUMENTHEADER *penv = Headers[iIns];
		penv->nMidiProgram = pih->type;
		penv->nFadeOut = xmsh.volfade;
		penv->nPan = 128;
		penv->nPPC = 5*12;
		if (xmsh.vtype & 1) penv->dwFlags |= ENV_VOLUME;
		if (xmsh.vtype & 2) penv->dwFlags |= ENV_VOLSUSTAIN;
		if (xmsh.vtype & 4) penv->dwFlags |= ENV_VOLLOOP;
		if (xmsh.ptype & 1) penv->dwFlags |= ENV_PANNING;
		if (xmsh.ptype & 2) penv->dwFlags |= ENV_PANSUSTAIN;
		if (xmsh.ptype & 4) penv->dwFlags |= ENV_PANLOOP;
		if (xmsh.vnum > 12) xmsh.vnum = 12;
		if (xmsh.pnum > 12) xmsh.pnum = 12;
		penv->nVolEnv = xmsh.vnum;
		if (!xmsh.vnum) penv->dwFlags &= ~ENV_VOLUME;
		if (!xmsh.pnum) penv->dwFlags &= ~ENV_PANNING;
		penv->nPanEnv = xmsh.pnum;
		penv->nVolSustainBegin = penv->nVolSustainEnd = xmsh.vsustain;
		if (xmsh.vsustain >= 12) penv->dwFlags &= ~ENV_VOLSUSTAIN;
		penv->nVolLoopStart = xmsh.vloops;
		penv->nVolLoopEnd = xmsh.vloope;
		if (penv->nVolLoopEnd >= 12) penv->nVolLoopEnd = 0;
		if (penv->nVolLoopStart >= penv->nVolLoopEnd) penv->dwFlags &= ~ENV_VOLLOOP;
		penv->nPanSustainBegin = penv->nPanSustainEnd = xmsh.psustain;
		if (xmsh.psustain >= 12) penv->dwFlags &= ~ENV_PANSUSTAIN;
		penv->nPanLoopStart = xmsh.ploops;
		penv->nPanLoopEnd = xmsh.ploope;
		if (penv->nPanLoopEnd >= 12) penv->nPanLoopEnd = 0;
		if (penv->nPanLoopStart >= penv->nPanLoopEnd) penv->dwFlags &= ~ENV_PANLOOP;
		penv->nGlobalVol = 64;
		for (UINT ienv=0; ienv<12; ienv++)
		{
			penv->VolPoints[ienv] = (WORD)xmsh.venv[ienv*2];
			penv->VolEnv[ienv] = (BYTE)xmsh.venv[ienv*2+1];
			penv->PanPoints[ienv] = (WORD)xmsh.penv[ienv*2];
			penv->PanEnv[ienv] =


res
                <%
					SWAP 'name' STORE
					FLATTEN UNIQUE
					<%
							NEWGTS SWAP RENAME { '.name' $name } RELABEL NOW NaN NaN NaN 1 ADDVALUE
							1 ->LIST +
					%> FOREACH
                %>
                FOREACH
		` + fmt.Sprintf("[ %d %d ] SUBLIST", offset, limit)

	return mc2
}

func getShowTagValuesCardinalityWarpScript(token string, selectors []string, labelsFilter string, offset, limit int, separator string) string {
	// TODO: controle FIND Limits here
	mc2 := "[\n"
	for _, selector := range selectors {
		mc2 += fmt.Sprintf("'%s' 'selector' STORE\n", selector)
		mc2 += fmt.Sprintf("[ '%s' '~%s.*' %s ", token, selector, labelsFilter) +
			` ] FINDSTATS
		'per.label.value.estimate' GET
		<%
			$regExp SIZE 0 >
		%>
		<%
			{} 'regExpLabels' STORE
			<%
					'valueRegExp' STORE
				DUP 'keyRegExp' STORE
				$regExp 0 GET
				MATCH
				<%
					SIZE 0 >
				%>
				<%
					$regExpLabels
					$valueRegExp
					$keyRegExp
					PUT
					'regExpLabels' STORE
				%>
				IFT
			%>
			FOREACH
			$regExpLabels
		%>
		<%
			$labelsKeys SUBMAP
		%>
		IFTE
		[]
		SWAP
		<%
			SWAP DROP
			'value' STORE
			NEWGTS { '.name' $selector } RELABEL NOW NaN NaN NaN $value ADDVALUE
			+
		%>
		FOREACH
		[ SWAP bucketizer.last NOW 0 1 ] BUCKETIZE
		[ SWAP [ '.name' ] reducer.sum ] REDUCE
		NONEMPTY
		`
	}
	mc2 += "]"
	return mc2
}

// getShowTagValuesWarpScript specific SHOW TAG VALUES STATEMENT to extract tag values from WarpScript FIND
func getShowTagValuesWarpScript(token, findString, labelsFilter string, offset, limit int, selector string) string {
	// FIXME: controle FIND Limits here
	mc2 := fmt.Sprintf("[ '%s' '%s' %s ", token, findString, labelsFilter) +
		` ] FIND
		{} 'res' STORE
                <%
		`

	mc2 += fmt.Sprintf("DUP NAME '%s' ", selector)
	mc2 += "<% DUP '' == %> <% DROP 1 ->LIST %> <% SPLIT %> IFTE\n"
	mc2 += `0 GET 'key' STORE
                                LABELS
                                <%
                                    $regExp SIZE 0 >
                                %>
                                <%
                                    {} 'regExpLabels' STORE
                                    <%
                                        'valueRegExp' STORE
                                        DUP 'keyRegExp' STORE
                                        $regExp 0 GET
                                        MATCH
                                        <%
                                           SIZE 0 >
                                        %>
                                        <%
                                            $regExpLabels
                                            $valueRegExp
                                            $keyRegExp
                                            PUT
                                            'regExpLabels' STORE
                                        %>
                                        IFT
                                    %>
                                    FOREACH
                                    $regExpLabels
                                %>
                                <%
                                    $labelsKeys SUBMAP
                                %>
                                IFTE
                                1 ->LIST
                                $res
                                <%
                                        $key CONTAINSKEY
                                %>
                                <%
                                        $key GET SWAP  +
                                %>


ensity.ONE)
            ), code = "17", maxi = SeismicIntensity.TREE
        )

        val prefectureIntensityArray2 = PrefectureIntensityArray(
            city = arrayOf(
                CityMaxIntensity("1620900", SeismicIntensity.ONE),
                CityMaxIntensity("1621100", SeismicIntensity.ONE)
            ), code = "16", maxi = SeismicIntensity.ONE
        )

        val jmaQuakeData = JmaQuakeData(
            acd = "390",
            anm = "石川県能登地方",
            at = "2024-01-03T16:08:00+09:00",
            cod = "+37.4+136.9-10000/",
            ctt = "20240103161126",
            eid = "20240103160815",
            enAnm = "Noto, Ishikawa Prefecture",
            enTtl = "Earthquake and Seismic Intensity Information",
            ift = "発表",
            int = arrayOf(prefectureIntensityArray1, prefectureIntensityArray2),
            json = "20240103161126_20240103160815_VXSE5k_1.json",
            mag = "4.2",
            maxi = SeismicIntensity.TREE,
            rdt = "2024-01-03T16:11:00+09:00",
            ser = "1",
            ttl = "震源・震度情報"
        )
        val json = format.encodeToString(jmaQuakeData)
        assertEquals(expected, json)
    }

    @Test
    fun encodeJmaQuakeDataSerIntZeroTest() {

        val serIntZero = """
    {
        "acd": "390",
        "anm": "石川県能登地方",
        "at": "2024-01-03T16:08:00+09:00",
        "cod": "+37.4+136.9-10000/",
        "ctt": "20240103161126",
        "eid": "20240103160815",
        "en_anm": "Noto, Ishikawa Prefecture",
        "en_ttl": "Earthquake and Seismic Intensity Information",
        "ift": "発表",
        "int": [
            {
                "city": [
                    {
                        "code": "1720300",
                        "maxi": "1"
                    },
                    {
                        "code": "1721100",
                        "maxi": "1"
                    }
                ],
                "code": "17",
                "maxi": "3"
            },
            {
                "city": [
                    {
                        "code": "1620900",
                        "maxi": "1"
                    },
                    {
                        "code": "1621100",
                        "maxi": "1"
                    }
                ],
                "code": "16",
                "maxi": "1"
            }
        ],
        "json": "20240103161126_20240103160815_VXSE5k_1.json",
        "mag": "4.2",
        "maxi": "3",
        "rdt": "2024-01-03T16:11:00+09:00",
        "ser": 0,
        "ttl": "震源・震度情報"
    }
        """.trimIndent()

        val prefectureIntensityArray1 = PrefectureIntensityArray(
            city = arrayOf(
                CityMaxIntensity("1720300", SeismicIntensity.ONE),
                CityMaxIntensity("1721100", SeismicIntensity.ONE)
            ), code = "17", maxi = SeismicIntensity.TREE
        )

        val prefectureIntensityArray2 = PrefectureIntensityArray(
            city = arrayOf(
                CityMaxIntensity


.equals("Economic"))
		{
			try{
				while(i<20)
				{
					if(type1.row2[i][1].equals(sTo))
					{
						iPrice = Integer.parseInt((String)type1.row2[i][2]);
						sTime = (String)type1.row2[i][3];
						break;
					}
					i++;
				}
			}catch(Exception e1)
			{
				JOptionPane.showMessageDialog(null, "You have no rights to access");
				System.exit(0);
			}
		}
		else
		{
			try
			{
				while(i<20)
				{
					if(type1.row2[i][1].equals(sTo))
					{
						iPrice = Integer.parseInt((String)type1.row4[i][2]);
						sTime = (String)type1.row4[i][3];
						break;
					}
					i++;
				}
			}catch(Exception e1)
			{
				JOptionPane.showMessageDialog(null, "You have no rights to access it");
				System.exit(0);
			}
		}
		type.setTitle(iPrice + " " + sTime);

		iPrice = (iPrice*iAdult)+(iPrice*(iChildren/2));

		int iCount=0;
		int iSeatCount=0;

		String[] sTempFrom=new String[1250];
		String[] sTempTo=new String[1250];
		String[] sTempClass=new String[1250];
		String[] sTempBookingDate=new String[1250];
		String[] sTempTime=new String[1250];
		Integer[] iTempAdult=new Integer[1250];
		Integer[] iTempChildren=new Integer[1250];
		Integer[] iTempInfant=new Integer[1250];
		Integer[] iTempPrice=new Integer[1250];

		try
		{
//read from data
			Save1 save1;
			ObjectInputStream OIS1 = new ObjectInputStream(new FileInputStream("save1"));
			do
			{
				save1 = (Save1)OIS1.readObject();
				sTempFrom[iCount] = save1.sFrom;
				sTempTo[iCount] = save1.sTo;
				sTempClass[iCount] = save1.sClass;
				sTempBookingDate[iCount] = save1.sBookingDate;
				sTempTime[iCount] = save1.sTime;
				iTempAdult[iCount] = save1.iAdult;
				iTempChildren[iCount] = save1.iChildren;
				iTempInfant[iCount] = save1.iInfant;
				iTempPrice[iCount] = save1.iPrice;

				iCount++;
				if(save1.sBookingDate.equals(sBookingDate))
					if(save1.sTo.equals(sTo))
						iSeatCount=iSeatCount + save1.iAdult + save1.iChildren + save1.iInfant;
			}while(save1!=null);
			OIS1.close();

		}
		catch(Exception e1)
		{
		}

		iSeatCount = iSeatCount + iAdult + iChildren + iInfant;

		if(iSeatCount > 60)
		{
			JOptionPane.showMessageDialog(null,"Seats are full. Sorry!");
		}
		else
		{
			int iChoice = JOptionPane.showConfirmDialog(null,"Seats available. Do you want to Book now?");
			if(iChoice == JOptionPane.YES_OPTION)
			{
				new PrintTicket1(sFrom, sTo, sClass, iAdult, iChildren, iInfant, sBookingDate, iPrice, sTime);
			try
			{
//write into data
				Save1 save2=new Save1(sFrom, sTo, sClass, iAdult, iChildren, iInfant, sBookingDate, iPrice, sTime);
				ObjectOutputStream OOS1 = new ObjectOutputStream(new FileOutputStream("save1"));
				fo


",
			script = "Actor/Npc/YJTSneakAI",
			id = 10067,
			pos = "Q1000Guard07",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI8",
			script = "Actor/Npc/YJTSneakAI",
			id = 10068,
			pos = "Q1000Guard08",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI10",
			script = "Actor/Npc/YJTSneakAI",
			id = 10070,
			pos = "Q1000Guard10",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI11",
			script = "Actor/Npc/YJTSneakAI",
			id = 10071,
			pos = "Q1000Guard11",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI12",
			script = "Actor/Npc/YJTSneakAI",
			id = 10072,
			pos = "Q1000Guard12",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI13",
			script = "Actor/Npc/YJTSneakAI",
			id = 10073,
			pos = "Q1000Guard13",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI14",
			script = "Actor/Npc/YJTSneakAI",
			id = 10074,
			pos = "Q1000Guard14",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI15",
			script = "Actor/Npc/YJTSneakAI",
			id = 10075,
			pos = "Q1000Guard15",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI16",
			script = "Actor/Npc/YJTSneakAI",
			id = 10076,
			pos = "Q1000Guard16",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI17",
			script = "Actor/Npc/YJTSneakAI",
			id = 10077,
			pos = "Q1000Guard17",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI31",
			script = "Actor/Npc/YJTSneakAI",
			id = 10078,
			pos = "Q1000Guard31",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,
		},
		{
            -- 真实守卫
			alias = "SneakAI32",
			script = "Actor/Npc/YJTSneakAI",
			id = 10079,
			pos = "Q1000Guard32",
			scene_id = 3,
			room_ID = 0,
			data_index = 0,


,plive,ptvar);
  //    return sb;
  //  } else { // Neither combo head nor tail, just print
  //    return dump(d,sb,typebs,dups,hmt_bs,hmt_dups,plive,ptvar).nl();
  //  }
  //}
  //private boolean is_multi_tail() { return _op==OP_PARM || _op==OP_PHI || _op==OP_PROJ || _op==OP_CPROJ; }
  //boolean is_CFG() { return false; }
  //
  //public String dumprpo( boolean prims, boolean plive, boolean ptvar ) {
  //  Ary<Node> nodes = new Ary<>(new Node[1],0);
  //  postorder(nodes,new VBitSet());
  //  // Walk the node list and count Type duplicates.  This means the same types
  //  // use the same Dup name on every node in the entire print.
  //  NonBlockingHashMapLong<String> dups = new NonBlockingHashMapLong<>();
  //  VBitSet typebs = new VBitSet();
  //  Type.UCnt ucnt = new Type.UCnt();
  //  VBitSet hmt_bs   = new VBitSet();
  //  VBitSet hmt_dups = new VBitSet();
  //  for( Node n : nodes ) {
  //    n._val ._str_dups(typebs, dups, ucnt, false);
  //    n._live._str_dups(typebs, dups, ucnt, false);
  //    if( n._tvar!=null ) n._tvar._get_dups(hmt_bs,hmt_dups,true,prims);
  //  }
  //  typebs.clr();
  //  hmt_bs.clr();
  //
  //  // Dump in reverse post order
  //  SB sb = new SB();
  //  Node prior = null;
  //  for( int i=nodes._len-1; i>=0; i-- ) {
  //    Node n = nodes.at(i);
  //    if( n.is_prim() && !prims )
  //      continue;               // Visited, but do not print
  //    // Add a nl after the last of a multi-tail sequence.
  //    if( (prior != null && prior.is_multi_tail() && !n.is_multi_tail()) ||
  //        // Add a nl before the start of a multi-head sequence.
  //        n.isMultiHead() )
  //      sb.nl();
  //    if( n._op==OP_FUN ) _header((FunNode)n,sb);
  //    n.dump(0,sb,typebs,dups,hmt_bs,hmt_dups,plive,ptvar).nl();
  //    if( n._op==OP_RET && n.in(4) instanceof FunNode ) _header((FunNode)n.in(4),sb);
  //    prior = n;
  //  }
  //  return sb.toString();
  //}
  //private static void _header(FunNode fun, SB sb) {
  //  sb.p("============ ").p(fun==null?"null":fun.name()).p(" ============").nl();
  //}
  //private void postorder( Ary<Node> nodes, VBitSet bs ) {
  //  if( bs.tset(_uid) ) return;
  //  // If CFG, walk the CFG first.  Do not walk thru Returns (into Calls) as
  //  // this breaks up the whole- functions-at-once.
  //  if( is_CFG() && _op!=OP_RET && is_copy(0)==null ) {
  //    // Walk any CProj first.
  //    for( Node use : _uses )
  //      if( use._op == OP_CPROJ )
  //        use.postorder(nodes,bs);
  //    // Walk the CFG, walking CallEpis last
  //    for( Node use : _uses )
  //      if( !(use instanceof CallEpiNode) && use.is_CFG() )
  //        use.postorder(nodes,bs);
  //    for( Node use : _uses )
  //      if(  (use instanceof CallEpiNode) && use.


.ceil(windData.length / numChunks));
  return rawChunks.map((timeBucket, i) => {
    const windReductions = timeBucket.reduce(
      (acc, cur) => {
        if (cur.y < acc.min) {
          acc.min = cur.y;
        }
        if (cur.y > acc.max) {
          acc.max = cur.y;
        }
        acc.directions.push(cur.directionDegrees);

        if (cur.temperature) {
          acc.temperatures.push(cur.temperature);
        }

        if (cur.rain) {
          acc.rainTotal += cur.rain;
        }

        return acc;
      },
      {
        min: Infinity,
        max: -Infinity,
        directions: [] as number[],
        temperatures: [] as number[],
        // in millimeters
        rainTotal: 0,
      }
    );

    return {
      ...windReductions,
      label: getChunkLabel(i),
      averageDirection: averageAngle(windReductions.directions),
      averageTemperature:
        windReductions.temperatures.length > 0 &&
        windReductions.temperatures.reduce((a, b) => a + b, 0) /
          windReductions.temperatures.length,
    };
  });
};

export const prepareForecastData = (
  data: CombinedForecastV2DetailFragment,
  date: Date
) => {
  const chartData: WindData[] = data.wind.map((datum) => {
    return {
      x: new Date(datum.timestamp),
      y: datum.base,
      gustY: datum.gusts - datum.base,
      ySum: datum.gusts,
      directionDegrees: datum.direction.degrees,
      temperature: data.temperature.find((x) => x.timestamp === datum.timestamp)
        ?.temperature.degrees,
      rain: data.rain.find((x) => x.timestamp === datum.timestamp)?.mmPerHour,
    };
  });

  // make sure we have an entry for each hour
  let oldestData = chartData[0];
  for (let h = 0; h < 24; h++) {
    const targetTime = addHours(date, h);
    const match = chartData.find((x) => isEqual(x.x, targetTime));
    if (!match) {
      const toAdd = { ...oldestData, x: targetTime, fake: true };
      chartData.push(toAdd);
    } else {
      oldestData = match;
    }
  }

  // sort by date
  chartData.sort((a, b) => (isBefore(a.x, b.x) ? -1 : 1));

  // split into 4 time buckets
  const timeChunks = createTimeChunks(chartData);

  return { chartData, timeChunks };
};

function sum(a: number[]) {
  return a.reduce((acc, cur) => {
    acc += cur;
    return acc;
  }, 0);
}

function degreeToRadians(degrees: number) {
  return (Math.PI / 180) * degrees;
}

function averageAngle(degrees: number[]) {
  const base = Math.floor(
    (180 / Math.PI) *
      Math.atan2(
        sum(degrees.map(degreeToRadians).map(Math.sin)) / degrees.length,
        sum(degrees.map(degreeToRadians).map(Math.cos)) / degrees.length
      )
  );

  return base < 0 ? base + 360 : base;
}

export function degreesToCompass(degrees: number): string {
  var val = Math.floor(degrees / 22.5 + 0.5);
  var arr = [
    "N",
    "NNE",
    "NE",
    "ENE",
    "E",
    "ESE",
    "SE",
    "SSE",
    "S",
    "SSW",


    map.put('\u2479', "PARENTHESIZED DIGIT SIX");
    map.put('\u247A', "PARENTHESIZED DIGIT SEVEN");
    map.put('\u247B', "PARENTHESIZED DIGIT EIGHT");
    map.put('\u247C', "PARENTHESIZED DIGIT NINE");
    map.put('\u247D', "PARENTHESIZED NUMBER TEN");
    map.put('\u247E', "PARENTHESIZED NUMBER ELEVEN");
    map.put('\u247F', "PARENTHESIZED NUMBER TWELVE");
    map.put('\u2480', "PARENTHESIZED NUMBER THIRTEEN");
    map.put('\u2481', "PARENTHESIZED NUMBER FOURTEEN");
    map.put('\u2482', "PARENTHESIZED NUMBER FIFTEEN");
    map.put('\u2483', "PARENTHESIZED NUMBER SIXTEEN");
    map.put('\u2484', "PARENTHESIZED NUMBER SEVENTEEN");
    map.put('\u2485', "PARENTHESIZED NUMBER EIGHTEEN");
    map.put('\u2486', "PARENTHESIZED NUMBER NINETEEN");
    map.put('\u2487', "PARENTHESIZED NUMBER TWENTY");
    map.put('\u2488', "DIGIT ONE FULL STOP");
    map.put('\u2489', "DIGIT TWO FULL STOP");
    map.put('\u248A', "DIGIT THREE FULL STOP");
    map.put('\u248B', "DIGIT FOUR FULL STOP");
    map.put('\u248C', "DIGIT FIVE FULL STOP");
    map.put('\u248D', "DIGIT SIX FULL STOP");
    map.put('\u248E', "DIGIT SEVEN FULL STOP");
    map.put('\u248F', "DIGIT EIGHT FULL STOP");
    map.put('\u2490', "DIGIT NINE FULL STOP");
    map.put('\u2491', "NUMBER TEN FULL STOP");
    map.put('\u2492', "NUMBER ELEVEN FULL STOP");
    map.put('\u2493', "NUMBER TWELVE FULL STOP");
    map.put('\u2494', "NUMBER THIRTEEN FULL STOP");
    map.put('\u2495', "NUMBER FOURTEEN FULL STOP");
    map.put('\u2496', "NUMBER FIFTEEN FULL STOP");
    map.put('\u2497', "NUMBER SIXTEEN FULL STOP");
    map.put('\u2498', "NUMBER SEVENTEEN FULL STOP");
    map.put('\u2499', "NUMBER EIGHTEEN FULL STOP");
    map.put('\u249A', "NUMBER NINETEEN FULL STOP");
    map.put('\u249B', "NUMBER TWENTY FULL STOP");
    map.put('\u249C', "PARENTHESIZED LATIN SMALL LETTER A");
    map.put('\u249D', "PARENTHESIZED LATIN SMALL LETTER B");
    map.put('\u249E', "PARENTHESIZED LATIN SMALL LETTER C");
    map.put('\u249F', "PARENTHESIZED LATIN SMALL LETTER D");
    map.put('\u24A0', "PARENTHESIZED LATIN SMALL LETTER E");
    map.put('\u24A1', "PARENTHESIZED LATIN SMALL LETTER F");
    map.put('\u24A2', "PARENTHESIZED LATIN SMALL LETTER G");
    map.put('\u24A3', "PARENTHESIZED LATIN SMALL LETTER H");
    map.


igned int cpu = sys_dev->id;
	unsigned long i;

	for (i = 0; i < num_cache_leaves; i++) {
		cache_remove_shared_cpu_map(cpu, i);
		kobject_unregister(&(INDEX_KOBJECT_PTR(cpu,i)->kobj));
	}
	kobject_unregister(cache_kobject[cpu]);
	cpuid4_cache_sysfs_exit(cpu);
	return;
}

static int cacheinfo_cpu_callback(struct notifier_block *nfb,
					unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	struct sys_device *sys_dev;

	sys_dev = get_cpu_sysdev(cpu);
	switch (action) {
	case CPU_ONLINE:
		cache_add_dev(sys_dev);
		break;
	case CPU_DEAD:
		cache_remove_dev(sys_dev);
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block cacheinfo_cpu_notifier =
{
    .notifier_call = cacheinfo_cpu_callback,
};

static int __cpuinit cache_sysfs_init(void)
{
	int i;

	if (num_cache_leaves == 0)
		return 0;

	register_cpu_notifier(&cacheinfo_cpu_notifier);

	for_each_online_cpu(i) {
		cacheinfo_cpu_callback(&cacheinfo_cpu_notifier, CPU_ONLINE,
			(void *)(long)i);
	}

	return 0;
}

device_initcall(cache_sysfs_init);

#endif


'div context - between blocks' );
		assert.areSame( output,			parseHtml( source, 'figcaption' ),	'figcaption context - between blocks' );
	},

	// Test whitespaces handling in different context. (https://dev.ckeditor.com/ticket/3715)
	'parse pre-formatted contents': function() {
		var pre = '
\t\tfoo\nbar quz  \n
',
			textarea = '
<textarea>\t\tfoo\nbar quz  \n</textarea>
';

		assert.areSame( pre, parseHtml( pre ) );
		assert.areSame( textarea, parseHtml( textarea ) );
		assert.areSame( '
foo bar
', parseHtml( '
foo   bar
' ) );
	},

	'parse list and table contents (with context)': function() {
		// Given the list/table as the parent element, parser should not attempt
		// to fix partial content.
		var source = '
foo

bar
';
		assert.areSame( source, parseHtml( source, 'ul' ) );

		source = '
foo

bar
';
		assert.areSame( source, parseHtml( '
foo

bar
', 'ol' ) );

		source = '
foo

bar
';
		assert.areSame( source, parseHtml( '
foo

bar
', 'dl' ) );

		source = '
foo	bar
';
		assert.areSame( source, parseHtml( '
foo	bar
', 'table' ) );

		source = '

foo	bar

';
		assert.areSame( source, parseHtml( '

foo	bar

', 'table' ) );

		source = '
foo
';
		assert.areSame( source, parseHtml( '
foo
', 'table' ) );
	},

	'parse pre and textarea contents (with context)': function() {
		// Given the pre/textarea as context, parser should preserve all white spaces.
		var source = '\t\tfoo\nbar quz  \n';

		assert.areSame( source, parseHtml( source, 'pre' ) );
		assert.areSame( source, parseHtml( source, 'textarea' ) );
	},

	'parser orphan text in list/table.': function() {
		assert.areSame( '

foobar

',
						parseHtml( '
foobar
' ) );
		assert.areSame( '

foo

bar

',
						parseHtml( '
foo
bar

' ) );
		assert.areSame( '

foobar

',
						parseHtml( '
foobar
' ) );
		assert.areSame( '

foo	bar

',
						parseHtml( '
foobar
' ) );
		assert.areSame( '

foo

bar

',
						parseHtml( '
<


 +
    \sum_{i=1}^n \left(
            L_{i+1}(X) \prod_{j=1}^i
    \frac{  (\omega_j +\beta\omega^{j-1}+\gamma)
            (\omega_{n+j} + \beta k_1 \omega^{j-1} +\gamma)
            (\omega_{2n+j}+ \beta k_2 \omega^{j-1} +\gamma)}
         {  (\omega_j +\beta \sigma(j) +\gamma)
            (\omega_{n+j} + \beta \sigma(n+j) +\gamma)
            (\omega_{2n+j}+ \beta \sigma(2n+j) +\gamma)}
            \right)
$$

Compute $[z]_1 := [z(x)]_1$

Output $[z]_1$

**Round 3**

Compute quotient challenge $\alpha \in \mathbb{F}_p$
$$
    \alpha = hash(Transcript)
$$

Compute quotient polynomial $t(X)$:
$$
    t(X) :=\\
    \frac{1}{Z_H(X)} (a(X)b(X)q_M(X) +
                      a(X)q_L(X) +
                      b(X)q_R(X) +
                      c(X)q_O(X) +
                      PI(X) +
                      q_C(X)) +\\
    \frac{\alpha}{Z_H(X)} ((a(X) + \beta X + \gamma)
                           (b(X) + \beta k_1 X + \gamma)
                           (c(X) + \beta k_2 X + \gamma)
                           z(X)) -\\
    \frac{\alpha}{Z_H(X)} ((a(X) + \beta S_{\sigma_1}(X) + \gamma)
                           (b(X) + \beta S_{\sigma_2}(X) + \gamma)
                           (c(X) + \beta S_{\sigma_3}(X) + \gamma)
                           z(X \omega)) +\\
    (z(X) - 1)L_1(X)\frac{\alpha^2}{z_H(X)}
$$

Note that all terms of the polynomial are divided by $Z_H(X)$. This can be done because if all the constraints hold the then the polynomials are 0 in all elements of H, and therefore, divisible by $Z_H(X)$

Split $t(X)$ into $<n$ degree polynomials
$t_{lo}(X), t_{mid}(X), t_{hi}(X)$ so that:

$$
t(X) = t_{lo}(X) + X^n t_{mid}(X) + X^{2n} t_{hi}(X) +
$$

Compute $[t_{lo}]_1 := [t_{lo}(x)]_1$,
        $[t_{mid}]_1 := [t_{mid}(x)]_1$,
        $[t_{hi}]_1 = [t_{hi}(x)]_1$

Output $([t_{lo}]_1, [t_{mid}]_1, [t_{hi}]_1)$

**Round 4**

Compute evaluation challenge $\zeta \in \mathbb{F}_p$:
$$
    \zeta = hash(Transcript)
$$

Compute opening evaluations at $\zeta$:
$$
    \bar{a}:= a(\zeta),
    \bar{b}:= b(\zeta),
    \bar{c}:= c(\zeta),\\
    \bar{s}_{\sigma_1} := S_{\sigma_1}(\zeta),
    \bar{s}_{\sigma_2} := S_{\sigma_2}(\zeta),\\
    \bar{t} := t(\zeta),
    \bar{z}_{\omega} := z(\omega\zeta),
$$

Compute


0  3B C0 00 00 */	li r30, 0
/* 80178394 00173FF4  3B A0 00 00 */	li r29, 0
/* 80178398 00173FF8  3B 00 00 00 */	li r24, 0
/* 8017839C 00173FFC  80 63 00 08 */	lwz r3, 8(r3)
/* 801783A0 00174000  38 03 00 01 */	addi r0, r3, 1
/* 801783A4 00174004  54 03 10 3A */	slwi r3, r0, 2
/* 801783A8 00174008  48 06 26 CD */	bl __nwa__FUl
/* 801783AC 0017400C  1C 1B 00 98 */	mulli r0, r27, 0x98
/* 801783B0 00174010  80 99 00 AC */	lwz r4, 0xac(r25)
/* 801783B4 00174014  7C 84 02 14 */	add r4, r4, r0
/* 801783B8 00174018  38 A4 00 10 */	addi r5, r4, 0x10
/* 801783BC 0017401C  48 00 00 74 */	b lbl_80178430
lbl_801783C0:
/* 801783C0 00174020  38 C0 00 00 */	li r6, 0
/* 801783C4 00174024  38 E0 00 00 */	li r7, 0
/* 801783C8 00174028  7F E9 03 A6 */	mtctr r31
/* 801783CC 0017402C  2C 1F 00 00 */	cmpwi r31, 0
/* 801783D0 00174030  40 81 00 30 */	ble lbl_80178400
lbl_801783D4:
/* 801783D4 00174034  88 19 00 00 */	lbz r0, 0(r25)
/* 801783D8 00174038  2C 00 00 00 */	cmpwi r0, 0
/* 801783DC 0017403C  40 82 00 1C */	bne lbl_801783F8
/* 801783E0 00174040  80 99 00 78 */	lwz r4, 0x78(r25)
/* 801783E4 00174044  7C 04 38 AE */	lbzx r0, r4, r7
/* 801783E8 00174048  7C 1B 00 00 */	cmpw r27, r0
/* 801783EC 0017404C  40 82 00 0C */	bne lbl_801783F8
/* 801783F0 00174050  38 C0 00 01 */	li r6, 1
/* 801783F4 00174054  48 00 00 0C */	b lbl_80178400
lbl_801783F8:
/* 801783F8 00174058  38 E7 00 01 */	addi r7, r7, 1
/* 801783FC 0017405C  42 00 FF D8 */	bdnz lbl_801783D4
lbl_80178400:
/* 80178400 00174060  2C 06 00 00 */	cmpwi r6, 0
/* 80178404 00174064  40 82 00 24 */	bne lbl_80178428
/* 80178408 00174068  88 85 00 5D */	lbz r4, 0x5d(r5)
/* 8017840C 0017406C  80 1C 00 10 */	lwz r0, 0x10(r28)
/* 80178410 00174070  7C 04 00 00 */	cmpw r4, r0
/* 80178414 00174074  41 81 00 14 */	bgt lbl_80178428
/* 80178418 00174078  7F 63 C1 2E */	stwx r27, r3, r24
/* 8017841C 0017407C  3B DE 00 01 */	addi r30, r30, 1
/* 80178420 00174080  3B BD 00 01 */	addi r29,


                pos += attr.Write(buffer, offset + pos);
            }

            Utilities.WriteBytesLittleEndian(uint.MaxValue, buffer, offset + pos);

            return headerEnd;
        }

        protected override int CalcSize()
        {
            int firstAttrPos = (ushort)Utilities.RoundUp((_haveIndex ? 0x30 : 0x2A) + UpdateSequenceSize, 8);

            int size = firstAttrPos;
            foreach (var attr in _attributes)
            {
                size += attr.Size;
            }

            return Utilities.RoundUp(size + 4, 8); // 0xFFFFFFFF terminator on attributes
        }
    }
}


void) dup2(ProcOutput, 2);
		pclose(toproc);
		execv(Portsrv, argv);
		printf("execl failed\n");
		_exit(1);
	}

	newp = (Process *) malloc(sizeof *newp);
	newp->p_next = procs;
	newp->p_state = NEW;
	newp->p_cmd = 0;

	cmdbuf[0] = '\0';
	va_start(ap);
	while (cp = va_arg(ap, char *))
		sprintf(&cmdbuf[strlen(cmdbuf)], "%s ", cp);
	va_end(ap);
	newp->p_name = copystr(cmdbuf);
	procs = newp;
	newp->p_portpid = pid;
	newp->p_pid = -1;

	newbuf = do_select((Window *) 0, bufname);
	newbuf->b_type = B_PROCESS;
	newp->p_buffer = newbuf;
	newbuf->b_process = newp;	/* sorta circular, eh? */
	pop_wind(bufname, clobber, B_PROCESS);
	ToLast();
	if (!bolp())
		LineInsert(1);
	/* Pop_wind() after everything is set up; important!
	   Bindings won't work right unless newbuf->b_process is already
	   set up BEFORE NEWBUF is first SetBuf()'d. */
	newp->p_mark = MakeMark(curline, curchar, M_FLOATER);

	newp->p_toproc = toproc[1];
	newp->p_reason = 0;
	NumProcs += 1;
	(void) close(toproc[0]);
	SetWind(owind);
	sigrelse(SIGCHLD);
#ifdef SIGWINCH
	sigrelse(SIGWINCH);
#endif
}

pinit()
{
	int	p[2];

	(void) signal(SIGCHLD, proc_child);
	(void) pipe(p);
	ProcInput = p[0];
	ProcOutput = p[1];
	(void) signal(INPUT_SIG, procs_read);
	sighold(INPUT_SIG);	/* Released during terminal read */
}

doread(fd, buf, n)
char	*buf;
{
	int	nread;

	if ((nread = read(fd, buf, n)) != n)
		complain("Cannot read %d (got %d) bytes.", n, nread);
}


          "', port=" .. UPSTREAM_PORT ..
                                                ", protocol='http';\" | " ..
      ssh_execute_wrap(self, self.kong_ip,
      "sudo docker exec -i kong-database psql -Ukong kong_tests"),
      { logger = self.ssh_log.log_exec })
end

function _M:get_based_version()
  return self.daily_image_desc or perf.get_kong_version()
end

return _M


---@type LazySpec
return {
  "nosduco/remote-sshfs.nvim",
  cmd = {
    "RemoteSSHFSConnect",
    "RemoteSSHFSDisconnect",
    "RemoteSSHFSEdit",
    "RemoteSSHFSFindFiles",
    "RemoteSSHFSLiveGrep",
  },
  opts = {},
  dependencies = {
    "nvim-lua/plenary.nvim",
    { "nvim-telescope/telescope.nvim", opts = function() require("telescope").load_extension "remote-sshfs" end },
  },
  specs = {
    {
      "AstroNvim/astrocore",
      optional = true,
      opts = function(_, opts)
        local map = opts.mappings
        map.n["<Leader>R"] = { desc = "Remote" }
        map.n["<Leader>Rc"] = { function() require("remote-sshfs.api").connect() end, desc = "Connect" }
        map.n["<Leader>Rd"] = { function() require("remote-sshfs.api").disconnect() end, desc = "Disconnect" }
        map.n["<Leader>Re"] = { function() require("remote-sshfs.api").edit() end, desc = "Edit" }
        -- Override telescope find_files and live_grep to make dynamic based on if connected to host
        local find_files = map.n["<Leader>ff"]


 await_suspend(coroutine_handle<>);
  void await_resume();
};
} // namespace experimental
} // namespace std
template <typename ag>
auto ah(ag) { return ag().ah(0); }
template <typename>
struct f;
struct g {
  struct h {
    int await_ready() noexcept;
    template <typename al>
    void await_suspend(std::experimental::coroutine_handle<al>) noexcept;
    void await_resume() noexcept;
  };
  std::experimental::e initial_suspend();
  h final_suspend() noexcept;
  template <typename ag>
  auto await_transform(ag) { return ah(ag()); }
};
struct j : g {
  f<std::b<std::c<int, int>>> get_return_object();
  void return_value(std::b<std::c<int, int>>);
  void unhandled_exception();
};
struct k {
  k(std::experimental::coroutine_handle<>);
  int await_ready();
};
template <typename am>
struct f {
  using promise_type = j;
  std::experimental::coroutine_handle<> ar;
  struct l : k {
    using at = k;
    l(std::experimental::coroutine_handle<> m) : at(m) {}
    void await_suspend(std::experimental::coroutine_handle<>);
  };
  struct n : l {
    n(std::experimental::coroutine_handle<> m) : l(m) {}
    am await_resume();
  };
  auto ah(int) { return n(ar); }
};
template <typename am, typename av, typename aw>
auto ax(std::c<am, av>, aw) -> f<std::c<int, aw>>;
template <typename>
struct J { static f<std::b<std::c<int, int>>> bo(); };
// CHECK-LABEL: _ZN1JIiE2boEv(
template <typename bc>
f<std::b<std::c<int, int>>> J<bc>::bo() {
  std::c<int> bu;
  int bw(0);
  // CHECK: void @_ZN1j12return_valueESt1bISt1cIiiEE(%struct.j* {{[^,]*}} %__promise)
  co_return{0, co_await ax(bu, bw)};
}
void bh() {
  auto cn = [] { J<int>::bo; };
  cn();
}
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -O1 -emit-llvm %s -o - -disable-llvm-passes | FileCheck %s

#include "Inputs/coroutine.h"

namespace coro = std::experimental::coroutines_v1;

struct detached_task {
  struct promise_type {
    detached_task get_return_object() noexcept {
      return detached_task{coro::coroutine_handle<promise_type>::from_promise(*this)};
    }

    void return_void() noexcept {}

    struct final_awaiter {
      bool await_ready() noexcept { return false; }
      coro::coroutine_handle<> await_suspend(coro::coroutine_handle<promise_type> h) noexcept {
        h.destroy();
        return {};
      }
      void await_resume() noexcept {}
    };

    void unhandled_exception() noexcept {}

    final_awaiter final_suspend() noexcept { return {}; }

    coro::suspend_always initial_suspend() noexcept { return {}; }
  };

  ~detached_task() {
    if (coro_) {
      coro_.destroy();
      coro_ = {};
    }
  }

  void start() && {
    auto tmp = coro_;
    coro_ = {};
    tmp.resume();
  }

  coro::coroutine_handle<promise_type>