.append(w)
                attempts += 1

            # warning if the number of peaks is lower than expected
            if len(p) < n_peaks:
                warnings.warn(f"Signal {i+1}: only placed {len(p)} of {n_peaks} peaks due to overlap constraints.")

            # Generate signal
            generator_map = {k: generator(k) for k in kinds}
            s = signal.from_peaks(p, x=x, generator_map=generator_map, name=f"{name_prefix}_{i+1}")
            s.y_label = "intensity"
            s.y_unit = "a.u."

            # Normalize
            if normalize:
                ymax = np.max(np.abs(s.y))
                if ymax > 0:
                    s.y /= ymax

            # Add noise or bias
            if noise:
                s = s.add_noise(**noise, bias=bias)
            elif bias is not None:
                s = s.add_noise(kind="gaussian", scale=0.0, bias=bias)  # bias only

            s._source_peaks = p
            signals.append(s)

        return cls(*signals, n=n_points, mode='union', force=True), [s._source_peaks for s in signals]

    @classmethod
    def generate_mixtures(cls,
                          n_mixtures=10,             # int
                          max_peaks = 16,            # int,
                          peaks_per_mixture = (3,8), # tuple[int, int],
                          amplitude_range = (0.5,2), # tuple[float, float],
                          flatten = 'mean',          # literal['sum', 'mean']
                          # parameters
                          n_signals=1,
                          n_peaks=1,
                          kinds=("gauss",),
                          width_range=(0.5, 3),
                          height_range=(1.0, 5.0),
                          x_range=(0, 500),
                          n_points=1024,
                          normalize=False,
                          seed=None,
                          **kwargs):
        """
        Generate synthetic mixtures of signals by combining a subset of base peaks.

        Parameters
        ----------
        n_mixtures : int
            Number of synthetic mixtures to generate.

        max_peaks : int
            Maximum number of base signals (from which peaks are taken).

        peaks_per_mixture : tuple of (int, int)
            Range (min, max) for the number of peaks to combine in each mixture.
            Cannot exceed `max_peaks`.

        amplitude_range : tuple of (float, float)
            Random scaling range applied to peak amplitudes in each mixture.

        flatten : {'sum', 'mean'}, default='mean'
            How to combine the signals for each mixture.

        **kwargs : dict
            All other keyword arguments passed to `generate_synthetic`.

        Returns
        -------
        result_collection : signal_collection
            A collection of synthetic mixed signals.

        all_peaks : list of dict
            All individual peaks originally generated.

        used_peak_ids : list of list of str
            For each mixture, the list of peak names used.

        Examples
        --------
        S, pS = signal_collection.generate_mixtures(
        ...     n_mixtures=30,
        ...     max_peaks=12,


160; * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR

   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

   17  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE

   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

   19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

   20  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

   21  * STRICT LIABILITY, OR TOR (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

   22  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   23  *

   24  **************************************************************************************************/

   29 #pragma once

   30

   31

   32 #include "cutlass/cutlass.h"

   33 #include "cutlass/arch/wmma.h"

   34

   35 #if defined(CUTLASS_ARCH_WMMA_ENABLED)

   36

   37 #include "cutlass/wmma_array.h"

   38 #include &


).latest('pk')
        train_job = Job.objects.get(
            job_name='train_classifier', source_id=source_2.pk)
        extract_jobs = list(Job.objects.filter(
            job_name='extract_features', source_id=source_3.pk))
        self.assertEqual(len(extract_jobs), 2)
        for job in [deploy_job, train_job] + extract_jobs:
            self.assertEqual(job.status, Job.Status.IN_PROGRESS)

        # Now collect.
        self.do_collect_spacer_jobs()
        # 1 deploy, 1 train, 2 extract
        self.assert_job_result_message(
            'collect_spacer_jobs', "Jobs checked/collected: 4 SUCCEEDED")
        # Should all be done.
        for job in [deploy_job, train_job] + extract_jobs:
            job.refresh_from_db()
            self.assertEqual(job.status, Job.Status.SUCCESS)


/****************************************************************************
 * include/nuttx/sensors/amg88xx.h
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

#ifndef __INCLUDE_NUTTX_SENSORS_AMG88XX_H
#define __INCLUDE_NUTTX_SENSORS_AMG88XX_H

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>
#include <nuttx/i2c/i2c_master.h>
#include <stdint.h>
#include <stdbool.h>

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define AMG88XX_PIXELS                           (64)      /* hex 0x40     */
#define AMG88XX_PIXELS_ARRAY_LENGTH              (127)

#define AMG88XX_THERMISTOR_RESOLUTION            (0.0625)
#define AMG88XX_THERMISTOR_MAX_VALUE             (0x7FF)   /* +127.9375 *c */
#define AMG88XX_THERMISTOR_MIN_VALUE             (0xBBB)   /*  -59.6875 *c */

#define AMG88XX_PIXEL_RESOLUTION                 (0.25)
#define AMG88XX_PIXEL_MAX_VALUE                  (0x1F4)   /*  +125     *c */
#define AMG88XX_PIXEL_MIN_VALUE                  (0xF24)   /*  -55      *c */

/****************************************************************************
 * Public Types
 ****************************************************************************/

/* Data returned by sensor read typedef  */

typedef uint8_t amg88xx_pixels_temp_t[AMG88XX_PIXELS_ARRAY_LENGTH];

/* Typedef used to interact with ioctl syscall to set sensor operation mode */

typedef enum
{
  op_mode_normal = 0,
  op_mode_sleep = 1
} amg88xx_operation_mode_e;

/* Typedef used to interact with ioctl syscall to set sensor fps */

typedef enum
{
  fps_one = 0,
  fps_ten = 1
} amg88xx_fps_e;

/* Runtime configuration struct sent to the sensor driver */

struct amg88xx_config_s
{
  uint8_t addr;
  uint32_t speed;
};

/****************************************************************************
 * Public Function Prototypes
 ****************************************************************************/

/****************************************************************************
 * Name: amg88xx_register
 *
 * Description:
 *   Register the amg88xx character device as 'devpath'
 *
 * Input Parameters:
 *   devpath - The full path to the driver to register. E.g., "/dev/irm0"
 *   i2c     - An instance of the I2C interface to use to communicate with
 *             AMG88xx
 *   config  - Initial configuration of the sensor
 *
 * Returned Value:
 *   Zero (OK) on success; a negated errno value on failure.
 *
 ****************************************************************************/

int amg88xx_register(FAR const char *devpath,
                     FAR struct i2c_master_s *i2c,
                     FAR struct amg88xx_config_s *config);

#endif /* __INCLUDE_NUTTX_SENSORS_AMG88XX_H */


 = {
				template = "nrf_input",
				Anchor = { "TOPRIGHT", "$parentslider2", "BOTTOMRIGHT", 0, -20 },
				vars = {
					text = NRF_TIMESTAMP,
					option = "timestampsformat",
				},
			},
			input2 = {
				template = "nrf_input",
				Anchor = { "TOPRIGHT", "$parentinput1", "BOTTOMRIGHT", 0, -15 },
				vars = {
					text = NRF_KEYWORD,
					option = "keyword",
				},
			},
		},
	},

	["Hud"] = {
		template = "nrf_options",
		children = {
			check1 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parent", "TOPLEFT", 3, -3 },
				vars = { text = NRF_NOCOMBAT, option = "nocombat" },
			},

			slider1 = {
				template = "nrf_slider",
				Anchor = { "TOPRIGHT", "$parent", "TOPRIGHT", -5, -15 },
				vars = {
					text = NRF_NOCOMBATALPHA,
					option = "nocombatalpha",
					low = "0%",
					high = "100%",
					min = 0,
					max = 1,
					format = "%.2f",
					step = 0.01,
				},
			},
			slider2 = {
				template = "nrf_slider",
				Anchor = { "TOPRIGHT", "$parentslider1", "BOTTOMRIGHT", 0, -25 },
				vars = {
					text = NRF_COMBATALPHA,
					option = "combatalpha",
					low = "0%",
					high = "100%",
					min = 0,
					max = 1,
					format = "%.2f",
					step = 0.01,
				},
			},
		},
	},

	["UnitFrames"] = {
		template = "nrf_options",
		children = {
			check1 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parent", "TOPLEFT", 3, -3 },
				vars = { text = "Hide Party in Raid", option = "hideparty", func = function() Nurfed_UnitFrames_ToggleParty() end },
			},
			check2 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parentcheck1", "BOTTOMLEFT", 0, -3 },
				vars = { text = "Use Layout (|cffff0000ReloadUI|r)", option = "uselayout", func = function() StaticPopup_Show("NRF_RELOADUI") end },
			},
			check3 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parentcheck2", "BOTTOMLEFT", 0, -3 },
				vars = { text = SHOW_DISPELLABLE_DEBUFFS_TEXT, option = "dispellable", func = function() Nurfed_UnitFrames_UpdateAuras() end },
			},
			check4 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parentcheck3", "BOTTOMLEFT", 0, -3 },
				vars = { text = SHOW_CASTABLE_BUFFS_TEXT, option = "castable", func = function() Nurfed_UnitFrames_UpdateAuras() end },
			},
			check5 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parentcheck4", "BOTTOMLEFT", 0, -3 },
				vars = { text = "Ignore Target Debuff Filter", option = "targetdebuffs", func = function() Nurfed_UnitFrames_UpdateAuras() end },
			},
			check6 = {
				template = "nrf_check",
				Anchor = { "TOPLEFT", "$parentcheck5", "BOTTOMLEFT", 0, -3 },
				vars = { text = "Ignore Target Buff Filter", option = "targetbuffs", func = function() N


         row.important = False

        if self.highlight:
            row.highlight = True
        else:
            row.highlight = False

        row.update(clear=clear)

    def calculate_area_needed(self):
        return 1,0

class CheckBox(Checkbox):
    pass

class RoundCheckBox(Checkbox):
    False_box = '( )'
    True_box  = '(X)'

class CheckBoxMultiline(Checkbox):
    def _create_label_area(self, screen):
        self.label_area = []
        for y in range(self.height):
            self.label_area.append(
               Textfield(screen, rely=self.rely+y,
                           relx=self.relx+5,
                           width=self.width-5,
                           value=None)
            )

    def _update_label_area(self, clear=True):
        for x in range(len(self.label_area)):
            if x >= len(self.name):
                self.label_area[x].value = ''
                self.label_area[x].hidden = True
            else:
                self.label_area[x].value = self.name[x]
                self.label_area[x].hidden = False
                self._update_label_row_attributes(self.label_area[x], clear=clear)

    def calculate_area_needed(self):
        return 0,0

class RoundCheckBoxMultiline(CheckBoxMultiline):
    False_box = '( )'
    True_box  = '(X)'


  // Empty area considered square as zero.
  if (size.isEmpty) {
    return 0.0;
  }
  return size.width * size.height;
}

/// Returns whether two floating-point values are approximately equal.
bool _floatNear(double f1, double f2) {
  final absDiff = (f1 - f2).abs();
  return absDiff <= _kDefaultTolerance ||
      (absDiff / max(f1.abs(), f2.abs()) <= _kDefaultTolerance);
}
/*
 * Copyright (C) 2021-present The Kraken authors. All rights reserved.
 */

import 'package:flutter/scheduler.dart';

typedef DoubleCallback = void Function(double);
typedef VoidCallback = void Function();

mixin ScheduleFrameMixin {
  int _id = 1;
  final Map<int, bool> _animationFrameCallbackMap = {};

  int requestAnimationFrame(DoubleCallback callback) {
    int id = _id++;
    _animationFrameCallbackMap[id] = true;
    SchedulerBinding.instance!.addPostFrameCallback((Duration timeStamp) {
      if (_animationFrameCallbackMap.containsKey(id)) {
        _animationFrameCallbackMap.remove(id);
        double highResTimeStamp = timeStamp.inMicroseconds / 1000;
        callback(highResTimeStamp);
      }
    });
    SchedulerBinding.instance!.scheduleFrame();
    return id;
  }

  void cancelAnimationFrame(int id) {
    if (_animationFrameCallbackMap.containsKey(id)) {
      _animationFrameCallbackMap.remove(id);
    }
  }

  void requestBatchUpdate() {
    SchedulerBinding.instance!.scheduleFrame();
  }

  void disposeScheduleFrame() {
    _animationFrameCallbackMap.clear();
  }
}
/*
 * Copyright (C) 2021-present The Kraken authors. All rights reserved.
 */

import 'dart:ui';

import 'package:flutter/rendering.dart';
import 'package:kraken/css.dart';
import 'package:kraken/dom.dart';

/// Fps callback.
typedef FpsCallback = void Function(List<FpsInfo> fps);

class Fps {
  Fps._();

  static Fps? _instance;

  static Fps get instance {
    _instance ??= Fps._();
    return _instance!;
  }

  bool _started = false;
  final List<FpsCallback> _fpsCallbacks = [];

  void addFpsCallback(FpsCallback fpsCallback) {
    _fpsCallbacks.add(fpsCallback);
  }

  void start() async {
    if (!_started) {
      _started = true;

      ElementsBinding.instance!.addTimingsCallback((List<FrameTiming> timings) {
        if (_fpsCallbacks.isNotEmpty) {
          List<FpsInfo> fps = timings.map<FpsInfo>((timing) => FpsInfo(timing)).toList();
          for (var callback in _fpsCallbacks) {
            callback(fps);
          }
        }
      });
    }
  }

  void stop() {
    _started = false;
  }
}

class FpsInfo {
  final FrameTiming frameTiming;

  FpsInfo(this.frameTiming);

  int get fps => 1000 ~/ totalSpan;

  /// The duration in milliseconds to build the frame on the UI thread.
  double get uiSpan => _formatMS(frameTiming.buildDuration);

  /// The duration in milliseconds to rasterize the frame on the GPU thread.
  double get gpuSpan => _formatMS(frameTiming.rasterDuration);

  /// The duration in milliseconds during a lifetime of a frame.
  double get totalSpan => _formatMS(frameTiming.totalSpan);

  double _formatMS(Duration duration) => (duration.inMicroseconds * 0.001);

  @override
  String toString() {
    return 'Max: ${fps}fps, UI: ${uiSpan.toStringAsFixed(2)}ms, GPU: ${gpuSpan.toStringAsFixed(2)}ms, Total: ${totalSpan.toStringAsFixed(2)}ms';
  }
}

class RenderFpsOverlay extends RenderBox {
  Rend


0010524].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US)[tr it Clomax Dominion][v1.0].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US)[tr pl Nintendencja][v1.0].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US)[tr pt Thirteen][90%].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US)[tr ru IfritZ][v1.2-20031203].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US)[tr sv RoboBengt][v1.01b-19990816].png",
  "Named_Boxarts/Metal Gear (1988-06)(Ultra Soft)(US).png",
  "Named_Boxarts/Metal Gear (1989-12-13)(Konami)(EU)[tr es Chilensis][100%].png",
  "Named_Boxarts/Metal Gear (1989-12-13)(Konami)(EU).png",
  "Named_Boxarts/Metal Gear (Europe).png",
  "Named_Boxarts/Metal Gear (Japan).png",
  "Named_Boxarts/Metal Gear (USA).png",
  "Named_Boxarts/Metal Max (1991-05-24)(Data East)(JP)[b].png",
  "Named_Boxarts/Metal Max (1991-05-24)(Data East)(JP)[h][enlarged rom].png",
  "Named_Boxarts/Metal Max (1991-05-24)(Data East)(JP)[tr en Aeon Genesis][v0.01a].png",
  "Named_Boxarts/Metal Max (1991-05-24)(Data East)(JP)[tr zh MS emumax][v.20061221].png",
  "Named_Boxarts/Metal Max (1991-05-24)(Data East)(JP).png",
  "Named_Boxarts/Metal Max (Japan) (Beta) (1991-01-31).png",
  "Named_Boxarts/Metal Max (Japan) (Virtual Console).png",
  "Named_Boxarts/Metal Max (Japan).png",
  "Named_Boxarts/Metal Mech - Man & Machine (1991-03)(Jaleco)(US)[b].png",
  "Named_Boxarts/Metal Mech - Man & Machine (1991-03)(Jaleco)(US)[h EFX][iNES title].png",
  "Named_Boxarts/Metal Mech - Man & Machine (1991-03)(Jaleco)(US)[h Vimm][iNES title].png",
  "Named_Boxarts/Metal Mech - Man & Machine (1991-03)(Jaleco)(US)[h][iNES title].png",
  "Named_Boxarts/Metal Mech - Man & Machine (1991-03)(Jaleco)(US).png",
  "Named_Boxarts/Metal Slader Glory (1991-08-30)(HAL Kenkyuujo)(JP)[b].png",
  "Named_Boxarts/Metal Slader Glory (1991-08-30)(HAL Kenkyuujo)(JP)[h][enlarged rom].png",
  "Named_Boxarts/Metal Slader Glory (1991-08-30)(HAL Kenkyuujo)(JP).png",
  "Named_Boxarts/Metal Slader Glory (Japan) (Virtual Console).png",
  "Named_Boxarts/Metal Slader Glory (Japan).png",
  "Named_Boxarts/Metal Storm (1991-02)(Irem Corporation)(US)[b].png",
  "Named_Boxarts/Metal Storm (1991-02)(Irem Corporation)(US)[b2].png",
  "Named_Boxarts/Metal Storm (1991-02)(Irem Corporation)(US)[h Vimm][iNES title].png",
  "Named_Boxarts/Metal Storm (1991-02)(Irem Corporation)(US).png",
  "Named_Boxarts/Met


size = Pt(11)
                        cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
                        paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
                    except IndexError:
                         pass

    for id, x in zip([0,1,2,3,4,5,6],
                     [1.6,0.3,0.3,0.3,0.3,0.8,0.5]):
        for cell in table.columns[id].cells:
            cell.width = Inches(x)

    table.style = 'Table Grid'

    tablasPath = os.path.join(subareaPath, "Tablas")
    finalPath = os.path.join(tablasPath, "geh_r2_table.docx")
    doc.save(finalPath)

    return finalPath


AME="nesting">

nesting

protected int nesting

numNodesTraversed

protected int numNodesTraversed

numPasses

protected int numPasses

pag

protected final PAG pag

pointsTo

protected AllocAndContextSet pointsTo

queriedCallSites

protected final Set<DemandCSPointsTo.CallSiteAndContext> queriedCallSites

recursionDepth

protected int recursionDepth

refiningCallSite

protected boolean refiningCallSite

sccManager

protected OTFMethodSCCManager sccManager

upContextCache

protected Map<DemandCSPointsTo.VarContextAndUp,Map<<A HREF="../../../../soot/jimple/


; Generated with ikazuchi 1.0 by riidefi
; Object File: OceanRingPipeOutside
; Segments:
;     .text:       0x80190a80 -> 0x80191530
;     .data:       0x8058b0f4 -> 0x8058b1a0 (8058b19c -> 8058b1a0 (size 0004/0x0004) is greedily claimed anonymous data)
;     .sdata2:     0x806bc2a0 -> 0x806bc2c0 (806bc2bc -> 806bc2c0 (size 0004/0x0004) is greedily claimed anonymous data)

; Symbols Defined
; 80190a80 -> 80190af0 __ct__20OceanRingPipeOutsideFPC13OceanRingPipe
; 80190af0 -> 80190bd0 init__20OceanRingPipeOutsideFRC12JMapInfoIter
; 80190bd0 -> 80190c30 movement__20OceanRingPipeOutsideFv
; 80190c30 -> 80190cf8 initDisplayList__20OceanRingPipeOutsideFv
; 80190cf8 -> 80190d4c draw__20OceanRingPipeOutsideCFv
; 80190d4c -> 80191270 loadMaterial__20OceanRingPipeOutsideCFv
; 80191270 -> 801913d0 sendGD__20OceanRingPipeOutsideCFv
; 801913d0 -> 8019142c __dt__20OceanRingPipeOutsideFv
; 8019142c -> 8019144c GDOverflowCheck__13938
; 8019144c -> 801914a8 GDWrite_u16__13939
; 801914a8 -> 80191530 GDWrite_f32__13940
; 8058b0f4 -> 8058b124 qMtx2$55269
; 8058b124 -> 8058b19c __vt__20OceanRingPipeOutside
; 806bc2a0 -> 806bc2a4 @57279
; 806bc2a4 -> 806bc2a8 @57280
; 806bc2a8 -> 806bc2ac @58506
; 806bc2b0 -> 806bc2b4 @58604__59407
; 806bc2b4 -> 806bc2b8 @58605
; 806bc2b8 -> 806bc2bc @58662

; Exports
.global __ct__20OceanRingPipeOutsideFPC13OceanRingPipe
.global init__20OceanRingPipeOutsideFRC12JMapInfoIter
.global movement__20OceanRingPipeOutsideFv
.global initDisplayList__20OceanRingPipeOutsideFv
.global draw__20OceanRingPipeOutsideCFv
.global loadMaterial__20OceanRingPipeOutsideCFv
.global sendGD__20OceanRingPipeOutsideCFv
.global __dt__20OceanRingPipeOutsideFv
.global GDOverflowCheck__13938
.global GDWrite_u16__13939
.global GDWrite_f32__13940
.global qMtx2$55269
.global __vt__20OceanRingPipeOutside
.global ?257279
.global ?257280
.global ?258506
.global ?258604__59407
.global ?258605
.global ?258662

; Segments
.section .text
__ct__20OceanRingPipeOutsideFPC13OceanRingPipe:
.byte


, U+342e, U+3468, U+346a, U+3488, U+3492, U+34b5, U+34bc, U+34c1, U+34c7, U+34db, U+351f, U+353e, U+355d-355e, U+3563, U+356e, U+35a6, U+35a8, U+35c5, U+35da, U+35de, U+35f4, U+3605, U+3614, U+364a, U+3691, U+3696, U+3699, U+36cf, U+3761-3762, U+376b-376c, U+3775, U+378d, U+37c1, U+37e2, U+37e8, U+37f4, U+37fd, U+3800, U+382f, U+3836, U+3840, U+385c, U+3861, U+38a1, U+38ad, U+38fa, U+3917, U+391a, U+396f, U+39a4, U+39b8, U+3a5c, U+3a6e, U+3a73, U+3a85, U+3ac4, U+3acb, U+3ad6-3ad7, U+3aea, U+3af3, U+3b0e, U+3b1a, U+3b1c, U+3b22, U+3b35, U+3b6d, U+3b77, U+3b87-3b88, U+3b8d, U+3ba4, U+3bb6, U+3bc3, U+3bcd, U+3bf0, U+3bf3, U+3c0f, U+3c26, U+3cc3, U+3cd2, U+3d11, U+3d1e, U+3d31, U+3d4e, U+3d64, U+3d9a, U+3dc0, U+3dcc, U+3dd4, U+3e05, U+3e3f-3e40, U+3e60, U+3e66, U+3e68, U+3e83, U+3e8a, U+3e94, U+3eda, U+3f57, U+3f72, U+3f75, U+3f77, U+3fae, U+3fb1, U+3fc9, U+3fd7, U+3fdc, U+4039, U+4058;
}

/* [52] */
@font-face {
    font-family: 'GenJyuuGothicXP';
    font-style: normal;
    font-weight: 700;
    font-display: swap;
    src: url(./GenJyuuGothicX-P-Bold-3173c8c85b725024f378f4eceed1a494d0ed511a73207cded02d4264ea7640ae-52.woff2) format('woff2');
    unicode-range: U+32b5-332b, U+332d-3394;
}

/* [53] */
@font-face {
    font-family: 'GenJyuuGothicXP';
    font-style: normal;
    font-weight: 700;
    font-display: swap;
    src: url(./GenJyuuGothicX-P-Bold-3173c8c85b725024f378f4eceed1a494d0ed511a73207cded02d4264ea7640ae-53.woff2) format('woff2');
    unicode-range: U+31c8-31e3, U+31f0-321e, U+3220-3230, U+3232-32b4;
}

/* [54] */
@font-face {
    font-family: 'GenJyuuGothicXP';
    font-style: normal;
    font-weight: 700;
    font-display: swap;
    src: url(./GenJyuuGothicX-P-Bold-3173c8c85b725024f378f4eceed1a494d0ed511a7320


read) {
  RTC_DCHECK(signaling_thread_);
  RTC_DCHECK(worker_thread_);
}

QuicDataTransport::~QuicDataTransport() {}

bool QuicDataTransport::SetTransportChannel(
    cricket::QuicTransportChannel* channel) {
  if (!channel) {
    LOG(LS_ERROR) << "|channel| is NULL. Cannot set transport channel.";
    return false;
  }
  if (quic_transport_channel_) {
    if (channel == quic_transport_channel_) {
      LOG(LS_WARNING) << "Ignoring duplicate transport channel.";
      return true;
    }
    LOG(LS_ERROR) << "|channel| does not match existing transport channel.";
    return false;
  }

  LOG(LS_INFO) << "Setting QuicTransportChannel for QuicDataTransport";
  quic_transport_channel_ = channel;
  quic_transport_channel_->SignalIncomingStream.connect(
      this, &QuicDataTransport::OnIncomingStream);

  bool success = true;
  for (const auto& kv : data_channel_by_id_) {
    rtc::scoped_refptr<QuicDataChannel> data_channel = kv.second;
    if (!data_channel->SetTransportChannel(quic_transport_channel_)) {
      LOG(LS_ERROR)
          << "Cannot set QUIC transport channel for QUIC data channel "
          << kv.first;
      success = false;
    }
  }
  return success;
}

rtc::scoped_refptr<DataChannelInterface> QuicDataTransport::CreateDataChannel(
    const std::string& label,
    const DataChannelInit* config) {
  if (config == nullptr) {
    return nullptr;
  }
  if (data_channel_by_id_.find(config->id) != data_channel_by_id_.end()) {
    LOG(LS_ERROR) << "QUIC data channel already exists with id " << config->id;
    return nullptr;
  }
  rtc::scoped_refptr<QuicDataChannel> data_channel(
      new QuicDataChannel(signaling_thread_, worker_thread_, label, *config));
  if (quic_transport_channel_) {
    if (!data_channel->SetTransportChannel(quic_transport_channel_)) {
      LOG(LS_ERROR)
          << "Cannot set QUIC transport channel for QUIC data channel "
          << config->id;
    }
  }

  data_channel_by_id_[data_channel->id()] = data_channel;
  return data_channel;
}

void QuicDataTransport::DestroyDataChannel(int id) {
  data_channel_by_id_.erase(id);
}

bool QuicDataTransport::HasDataChannel(int id) const {
  return data_channel_by_id_.find(id) != data_channel_by_id_.end();
}

bool QuicDataTransport::HasDataChannels() const {
  return !data_channel_by_id_.empty();
}

// Called when a QUIC stream is created for incoming data.
void QuicDataTransport::OnIncomingStream(cricket::ReliableQuicStream* stream) {
  RTC_DCHECK(stream != nullptr);
  quic_stream_by_id_[stream->id()] = stream;
  stream->SignalDataReceived.connect(this, &QuicDataTransport::OnDataReceived);
}

// Called when the first QUIC stream frame is received for incoming data.
void QuicDataTransport::OnDataReceived(net::QuicStreamId id,
                                       const char* data,
                                       size_t len) {
  const auto& quic_stream_kv = quic_stream_by_id_.find(id);
  if (quic_stream_kv == quic_stream_by_id_.end()) {
    RTC_DCHECK(false);
    return;
  }
  cricket::ReliableQuicStream* stream = quic_stream_kv->second;
  stream->SignalDataReceived.disconnect(this);
  quic_stream_by_id_.erase(id);
  // Read the data channel ID and message ID.
  int data_channel_id;
  uint64_t message_id;
  size_t bytes_read;
  if (!ParseQuicDataMessageHeader(data, len, &data_channel_id, &message_id,


; STE Dial Sample Module - Example.

	opt	d+

	clr.w	-(sp)
	pea	filename
	move.w	#$3c,-(sp)
	trap	#1
	lea	8(sp),sp
	move.w	d0,handle

	pea	module
	move.l	#m_end-module,-(sp)
	move.w	handle,-(sp)
	move.w	#$40,-(sp)
	trap	#1
	lea	12(sp),sp

	move.w	handle,-(sp)
	move.w	#$3e,-(sp)
	trap	#1
	lea	4(sp),sp

	clr.w	-(sp)
	trap	#1

module:
	dc.w	128+1	; 12517 Hz STE Mono Samples.
	dc.l	chartab-module
	dc.l	sampletab-module
	dc.l	dtext-module

	even

chartab:
	dc.b	'1234567890ABCDEH'
	dc.b	0

	even

sampletab:
	dc.l	t_1-module,t_1e-module
	dc.w	60,01
	dc.l	t_2-module,t_2e-module
	dc.w	60,01
	dc.l	t_3-module,t_3e-module
	dc.w	60,01
	dc.l	t_4-module,t_4e-module
	dc.w	60,01
	dc.l	t_5-module,t_5e-module
	dc.w	60,01
	dc.l	t_6-module,t_6e-module
	dc.w	60,01
	dc.l	t_7-module,t_7e-module
	dc.w	60,01
	dc.l	t_8-module,t_8e-module
	dc.w	60,01
	dc.l	t_9-module,t_9e-module
	dc.w	60,01
	dc.l	t_0-module,t_0e-module
	dc.w	60,01
	dc.l	t_a-module,t_ae-module
	dc.w	60,01
	dc.l	t_b-module,t_be-module
	dc.w	60,01
	dc.l	t_c-module,t_ce-module
	dc.w	60,01
	dc.l	t_d-module,t_de-module
	dc.w	60,01
	dc.l	t_e-module,t_ee-module
	dc.w	60,01
	dc.l	t_h-module,t_he-module
	dc.w	60,01
	dc.l	0,0
	dc.w	0
	even


.pulumi.alicloud.vpn.inputs.GetConnectionsPlainArgs;
import com.pulumi.alicloud.vpn.inputs.GetCustomerGatewaysArgs;
import com.pulumi.alicloud.vpn.inputs.GetCustomerGatewaysPlainArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayVcoRoutesArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayVcoRoutesPlainArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayVpnAttachmentsArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayVpnAttachmentsPlainArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayZonesArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewayZonesPlainArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewaysArgs;
import com.pulumi.alicloud.vpn.inputs.GetGatewaysPlainArgs;
import com.pulumi.alicloud.vpn.outputs.GetConnectionsResult;
import com.pulumi.alicloud.vpn.outputs.GetCustomerGatewaysResult;
import com.pulumi.alicloud.vpn.outputs.GetGatewayVcoRoutesResult;
import com.pulumi.alicloud.vpn.outputs.GetGatewayVpnAttachmentsResult;
import com.pulumi.alicloud.vpn.outputs.GetGatewayZonesResult;
import com.pulumi.alicloud.vpn.outputs.GetGatewaysResult;
import com.pulumi.core.Output;
import com.pulumi.core.TypeShape;
import com.pulumi.deployment.Deployment;
import com.pulumi.deployment.InvokeOptions;
import com.pulumi.deployment.InvokeOutputOptions;
import java.util.concurrent.CompletableFuture;

public final class VpnFunctions {
    /**
     * The VPN connections data source lists lots of VPN connections resource information owned by an Alicloud account.
     *
     * > **NOTE:** Available since v1.18.0.
     *
     * ## Example Usage
     *
     * <pre>
     * {@code
     * package generated_program;
     *
     * import com.pulumi.Context;
     * import com.pulumi.Pulumi;
     * import com.pulumi.core.Output;
     * import com.pulumi.alicloud.vpn.VpnFunctions;
     * import com.pulumi.alicloud.vpn.inputs.GetConnectionsArgs;
     * import java.util.List;
     * import java.util.ArrayList;
     * import java.util.Map;
     * import java.io.File;
     * import java.nio.file.Files;
     * import java.nio.file.Paths;
     *
     * public class App {
     *     public static void main(String[] args) {
     *         Pulumi.run(App::stack);
     *     }
     *
     *     public static void stack(Context ctx) {
     *         final var foo = VpnFunctions.getConnections(GetConnectionsArgs.builder()
     *             .ids("fake-conn-id")
     *             .vpnGatewayId("fake-vpn-id")
     *             .customerGatewayId("fake-cgw-id")
     *             .outputFile("/tmp/vpnconn")
     *             .build());
     *
     *     }
     * }
     * }
     * </pre>
     *
     */
    public static Output<GetConnectionsResult> getConnections() {
        return getConnections(GetConnectionsArgs.Empty, InvokeOptions.Empty);
    }
    /**
     * The VPN connections data source lists lots of VPN connections resource information owned by an Alicloud account.
     *
     * > **NOTE:** Available since v1.18.0.
     *
     * ## Example Usage
     *
     * <pre>


diameter is 2 instead of 3.
        "preferred_material_correct_diameter": MagicMock(getMetaDataEntry = lambda x: 3)  # Correct approximate diameter.
    }
    empty_variant_node.machine.preferred_material = "preferred_material_correct_diameter"

    assert empty_variant_node.preferredMaterial(approximate_diameter = 3) == empty_variant_node.materials["preferred_material_correct_diameter"], "It should match only on the material with correct diameter."

def test_preferredMaterialDiameterNoMatch(empty_variant_node):
    """Tests the preferred material matching on a different material if the diameter is wrong."""

    empty_variant_node.materials = collections.OrderedDict()
    empty_variant_node.materials["some_different_material"] = MagicMock(getMetaDataEntry = lambda x: 3)  # This one first so that it gets iterated over first.
    empty_variant_node.materials["preferred_material"] = MagicMock(getMetaDataEntry = lambda x: 2)  # Wrong diameter.

    assert empty_variant_node.preferredMaterial(approximate_diameter = 3) == empty_variant_node.materials["some_different_material"], "It should match on another material with the correct diameter if the preferred one is unavailable."

def test_preferredMaterialDiameterPreference(empty_variant_node):
    """Tests that the material diameter is considered more important to match than
    the preferred diameter.
    """

    empty_variant_node.materials = collections.OrderedDict()
    empty_variant_node.materials["some_different_material"] = MagicMock(getMetaDataEntry = lambda x: 2)  # This one first so that it gets iterated over first.
    empty_variant_node.materials["preferred_material"] = MagicMock(getMetaDataEntry = lambda x: 2)  # Matches on ID but not diameter.
    empty_variant_node.materials["not_preferred_but_correct_diameter"] = MagicMock(getMetaDataEntry = lambda x: 3)  # Matches diameter but not ID.

    assert empty_variant_node.preferredMaterial(approximate_diameter = 3) == empty_variant_node.materials["not_preferred_but_correct_diameter"], "It should match on the correct diameter even if it's not the preferred one."


<Input
                type="email"
                required
                className="w-full"
                placeholder="Enter your email"
              />
            </Form.Item>
            <Form.Item label="Password" name="password" className="mb-4">
              <Input
                type="password"
                required
                className="w-full"
                placeholder="Enter your password"
              />
            </Form.Item>

            <Link
              to="/register"
              className="block text-center mt-4 text-blue-500 hover:text-blue-700"
            >
              Not a user? Register here
            </Link>
            <button
              className="w-full mt-6 mb-4 bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded focus:outline-none focus:shadow-outline"
              type="submit"
            >
              Login
            </button>
          </Form>

        {/* Image Section */}

          {/* Image section remains the same */}

  );
};

export default Login;
// Layout.js
import React, { useEffect, useState } from "react";
import "../styles/LayoutStyles.css";
import { adminMenu, userMenu, facultyMenu } from "./../Data/data";
import { Link, useLocation, useNavigate } from "react-router-dom";
import { useSelector } from "react-redux";
import { Badge, message } from "antd";
import jwt_decode from "jwt-decode"; // Import jwt-decode library

const Layout = ({ children }) => {
  const { user } = useSelector((state) => state.user);
  const location = useLocation();
  const navigate = useNavigate();
  const [layoutHeight, setLayoutHeight] = useState(window.innerHeight);

  useEffect(() => {
    const handleResize = () => {
      setLayoutHeight(window.innerHeight);
    };

    window.addEventListener("resize", handleResize);

    return () => {
      window.removeEventListener("resize", handleResize);
    };
  }, []);

  // logout function
  const handleLogout = () => {
    localStorage.clear();
    message.success("Logout Successfully");
    navigate("/login");
  };

  // Determine the SidebarMenu based on user's role
  let SidebarMenu;
  if (user?.isAdmin) {
    SidebarMenu = adminMenu;
  } else if (user?.isLecturer) {
    SidebarMenu = facultyMenu; // Use facultyMenu for lecturers
  } else {
    SidebarMenu = userMenu;
  }

  return (
    <>

Toggl Track

              {SidebarMenu.map((menu) => {
                const isActive = location.pathname === menu.path;
                return (
                  <div
                    key={menu.path}
                    className={`menu-item ${isActive && "active"}`}
                  >

                    <Link to={menu.path}>{menu.name}</Link>

                );
              })}
              <div className={`menu-item `} onClick={handleLogout}>

                <Link to="/login">Logout</Link>

            <div


的經驗值。";
TRIAL_FEATURE_1 = "參與上千種全新的任務！";
TRIAL_FEATURE_2 = "享受完整遊戲體驗";
TRIAL_FEATURE_LEVEL_CAP = "一路戰鬥升到%s級";
TRIAL_LEVEL_CAPPED = "已達體驗帳號等級上限。";
TRIAL_RESTRICTED = "你必須升級你的帳號才可使用此功能。";
TRIAL_UPGRADE_LOGOUT_WARNING = "為了完成此筆交易，系統會在%d秒後將你登出遊戲。";
TRILINEAR_FILTERING = "三線過濾";
TRINKET0SLOT = "飾品";
TRINKET0SLOT_UNIQUE = "飾品1";
TRINKET1SLOT = "飾品";
TRINKET1SLOT_UNIQUE = "飾品2";
TRIPLE_BUFFER = "三倍緩衝";
TRIVIAL_QUESTS_FILTER_DESCRIPTION = "這些任務大幅低於你目前的等級，且不會獎勵任何經驗值";
TRIVIAL_QUEST_DISPLAY = "|cff000000%s(低等級)|r";
TRIVIAL_QUEST_LABEL = "低等級";
TTS_CONFIRM_SAVE_SETTINGS = "你想要讓這個角色使用這台電腦儲存的文字轉語音設定嗎？如果你是從別台電腦登入，這麼做會覆蓋你先前的設定。";
TTS_LABEL = "文字轉語音";
TTS_SUBTEXT = "TTS description placeholder";
TURN_IN_ITEMS = "需要物品：";
TURN_IN_QUEST = "繳交";
TUTORIAL1 = "任務給予者的頭上都有一個驚嘆號(|TInterface\\OptionsFrame\\UI-OptionsFrame-NewFeatureIcon:0|t)。以|cffffd200右鍵點擊|r他們即可獲得任務。";
TUTORIAL10_DWARF = "你接到了一個擊殺|cffffd200石齶入侵者|r的任務。\n利用畫面右上角的小地圖來找到方向。";
TUTORIAL10_GNOME = "你接到了一個擊殺|cffffd200瘋狂的麻瘋地精|r的任務。\n利用畫面右上角的小地圖來找到方向。";
TUTORIAL10_HUMAN = "你接到了一個擊殺|cffffd200黑石作戰座狼|r的任務。牠們在修道院的北邊(也就是你現在位置的北邊)。|n利用畫面右上角的小地圖來找到方向。";
TUTORIAL10_NIGHTELF = "你接到了一個擊殺|cffffd200小夜刃豹|r的任務。\n利用畫面右上角的小地圖來找到方向。";
TUTORIAL10_ORC = "你接到了一個擊殺|cffffd200雜斑野豬|r的任務。\n利用畫面右上角的小地圖來找到方向。";
TUTORIAL10_SCOURGE = "


ent securities.
<ix:nonNumeric contextRef="c-1" name="us-gaap:ScheduleOfAvailableForSaleSecuritiesReconciliationTableTextBlock" id="f-935" escape="true">
The following is a summary of investment securities as of December 31:

TABLE 4.1: INVESTMENT SECURITIES

2024	2023

Description of Securities (Millions)
	<td colspan="3" style="padding:0 1pt


yString()));
      }
    }
  }

  /**
   * Test VLINKS command functionality. Verifies that vector set links can be retrieved correctly.
   */
  @Test
  @SinceRedisVersion("8.0.0")
  public void testVlinksBinaryWithScores(TestInfo testInfo) {
    byte[] testKey = (testInfo.getDisplayName() + ":test:vector:set:binary").getBytes();

    // Add some vectors to create a vector set with links
    float[] vector1 = { 1.0f, 0.0f };
    float[] vector2 = { 0.0f, 1.0f };
    float[] vector3 = { 1.0f, 1.0f };

    jedis.vadd(testKey, vector1, "element1".getBytes());
    jedis.vadd(testKey, vector2, "element2".getBytes());
    jedis.vadd(testKey, vector3, "element3".getBytes());

    // Get links for element1
    List<Map<byte[], Double>> links = jedis.vlinksWithScores(testKey, "element1".getBytes());
    assertNotNull(links);

    assertFalse(links.isEmpty());
    for (Map<byte[], Double> scores : links) {
      for (byte[] element : scores.keySet()) {
        assertTrue(Arrays.equals(element, "element2".getBytes())
            || Arrays.equals(element, "element3".getBytes()));
        assertTrue(scores.get(element) > 0.0);
      }
    }
  }

  /**
   * Test VLINKS with non-existent element. Verifies that VLINKS handles non-existent elements
   * correctly.
   */
  @Test
  @SinceRedisVersion("8.0.0")
  public void testVlinksNonExistent(TestInfo testInfo) {
    String testKey = testInfo.getDisplayName() + ":test:vector:set:nonexistent";

    // Add a vector first
    float[] vector = { 1.0f, 2.0f };
    jedis.vadd(testKey, vector, "existing_element");

    // Try to get links for non-existent element
    List<List<String>> links = jedis.vlinks(testKey, "non_existent_element");
    // Should return empty list or null for non-existent elements
    // Exact behavior depends on Redis implementation
    assertTrue(links == null || links.isEmpty());
  }

  /**
   * Test VRANDMEMBER command functionality. Verifies that random vector set members can be
   * retrieved correctly.
   */
  @Test
  @SinceRedisVersion("8.0.0")
  public void testVrandmember(TestInfo testInfo) {
    String testKey = testInfo.getDisplayName() + ":test:vector:set";

    // Add some vectors to the set
    float[] vector1 = { 1.0f, 0.0f };
    float[] vector2 = { 0.0f, 1.0f };
    float[] vector3 = { 1.0f, 1.0f };

    jedis.vadd(testKey, vector1, "element1");
    jedis.vadd(testKey, vector2, "element2");
    jedis.vadd(testKey, vector3, "element3");

    // Get a single random member
    String randomMember = jedis.vrandmember(testKey);
    assertNotNull(randomMember);

    // Should be one of the added elements
    assertTrue(randomMember.equals("element1") || randomMember.equals("element2")
        || randomMember.equals("element3"));
  }

  /**
   * Test VRANDMEMBER with count parameter. Verifies that multiple random members can be retrieved.
   */
  @Test
  @SinceRedisVersion("8.0.0")
  public void testVrandmemberWithCount(TestInfo testInfo) {
    String testKey = testInfo.getDisplayName() + ":test:vector:set:count";

    // Add multiple vectors
    for (int i = 1; i <= 5; i++) {
      float


任骨干，说明此人拥有专业技能杰出的声望，专业技能通常是晋升的决定因素。

### 医疗

情绪对病人的恢复有作用

免疫系统
- 免疫系统有记忆力。是“身体的大脑”
- 神经细胞与免疫细胞会互相释放信号
- 负面情绪会抑制免疫系统，以节省能量。远古人类需要这个机制。负面情绪包括愤怒、忧虑、抑郁。

敌意测试分数较低的，50岁死亡概率低。比吸烟、高血压、高胆固醇等，更为显著。

愤怒导致心脏病风险提高。尤其是慢性愤怒。如果压抑愤怒，一样导致心脏病风险提高。
忧虑削弱免疫系统，加速癌细胞转移，导致糖尿病，使海马体受损，记忆力下降。

### 育儿

情商会带带相传。

例如，
- 同理心缺失，养育孩子时，也会让孩子同理心缺失。
- 残暴，会让孩子也残暴。（例如，学习上一辈面对其它哭泣的孩子的做法）

### 创伤

这一章写的是心理创伤和应对方法，还写了一些解刨学机制。
---
layout: reading
---

## 《普京传》

（作者：王国章）

### 少年

普京在少年时期经常打架，甚至还总结出了自己的打架心得。他认为，他应该随时做好准备，一旦遇到任何不公平的事情，就要立即予以还击。在他看来，对于任何攻击或侮辱，只能用不计代价的攻击来洗刷。

1952年10月7日，在列宁格勒巴斯科夫胡同的一个大杂院里出生。

普京是幸运的，因为他在一个温馨的家庭中长大，不仅有疼爱他的爸爸妈妈，还有爷爷奶奶。
普京的爷爷是一名出色的厨师。因为他厨艺高超，在第二次世界大战结束后，被秘密邀请到莫斯科郊区的哥尔克镇工作，为当时的领导人列宁一家做厨师。列宁去世后，他又被安排在斯大林别墅，在那里一直做到退休。

普京原来有两个哥哥，都过早地夭折了，直到母亲41岁时，�


                        cspext.CpgExtent(),
                        &ibStartZeroes,
                        &cbZeroLength,
                        &pgnoStartRegionAligned,
                        &cpgRegionAligned ) );
                }

                // We can't trim a region that's smaller than a 64k block.
                if ( cpgRegionAligned != 0 )
                {
                    Assert( !cspext.FEmptyExtent() );

                    const PGNO pgnoEndRegionAligned = cspext.FEmptyExtent() ? 0 : pgnoStartRegionAligned + cpgRegionAligned - 1;

                    if ( !cspext.FEmptyExtent() )
                    {
                    }

                    (*pcprintf)( "%30s: %s[%5d]:\t%6d-%6d (%3d);\tA%6d-%6d (%3d) %s%s",
                                 SzNameOfTable( pfucb ),
                                 SzSpaceTreeType( pfucb ),
                                 Pcsr( pfucb )->Pgno(),
                                 // Unaligned:
                                 cspext.FEmptyExtent() ? 0 : cspext.PgnoFirst(),
                                 cspext.FEmptyExtent() ? cspext.PgnoMarker() : cspext.PgnoLast(),
                                 cspext.CpgExtent(),
                                 // Aligned region:
                                 pgnoStartRegionAligned,
                                 pgnoEndRegionAligned,
                                 cpgRegionAligned,
                                 FNDDeleted( pfucb->kdfCurr ) ? " (DEL)" : "",
                                 ( cspext.ErrCheckCorrupted( ) < JET_errSuccess ) ? " (COR)" : ""
                                 );

                    (*pcprintf)( " cpgSparseBefore: %3d", cpgSparseBeforeThisExtent );

                {
                    PIB pibFake;
                    pibFake.m_pinst = g_rgfmp[ pfucb->ifmp ].Pinst();
                    Call( ErrSPITrimRegion( pfucb->ifmp, &pibFake, pgnoEndRegionAligned, cpgRegionAligned, &cpgSparseBeforeThisExtent, &cpgSparseAfterThisExtent ) );

                    const CPG cpgSparseNewlyTrimmed = cpgSparseAfterThisExtent - cpgSparseBeforeThisExtent;
                    (*pcprintf)( " cpgSparseAfter: %3d cpgSparseNew: %3d", cpgSparseAfterThisExtent, cpgSparseNewlyTrimmed );

                    cpgAvailSparseBefore += cpgSparseBeforeThisExtent;
                    cpgAvailSparseAfter += cpgSparseAfterThisExtent;
                }

                    (*pcprintf)( "\n" );
                }

                cpgAvailTotal += cspext.CpgExtent();
            }

            err = ErrBTNext( pfucb, fDIRNull );
            if ( err < 0 )
            {
                if ( err != JET_errNoCurrentRecord )
                {
                    goto HandleError;
                }
                break;
            }
        }
    }

    *pcpgTotalAvail += cpgAvailTotal;
    *pcpgTotalAvailSparseBefore += cpgAvailSparseBefore;
    *pcpgTotalAvailSparseAfter += cpgAvailSparseAfter;

    if( pcprintf )
    {
        const CPG cpgSparseNewlyTrimmed = cpgAvailSparseAfter - cpgAvailSparseBefore;
        (*pcprintf)( "%s:\t%d trimmed (before), %d


 1)
    expect(priorityQueue.peek()).toBe(user1)

    priorityQueue.add(user2, 2)
    expect(priorityQueue.peek()).toBe(user1)

    priorityQueue.add(user3, 0)
    expect(priorityQueue.peek()).toBe(user3)
  })

  it('должен извлечь элементы из очереди согласно приоритету', () => {
    const priorityQueue = new PriorityQueue()

    priorityQueue.add(10, 1)
    priorityQueue.add(5, 2)
    priorityQueue.add(100, 0)
    priorityQueue.add(200, 0)

    expect(priorityQueue.poll()).toBe(100)
    expect(priorityQueue.poll()).toBe(200)
    expect(priorityQueue.poll()).toBe(10)
    expect(priorityQueue.poll()).toBe(5)
  })

  it('должен обновить приоритеты головных узлов', () => {
    const priorityQueue = new PriorityQueue()

    priorityQueue.add(10, 1)
    priorityQueue.add(5, 2)
    priorityQueue.add(100, 0)
    priorityQueue.add(200, 0)

    expect(priorityQueue.peek()).toBe(100)

    priorityQueue.changePriority(100, 10)
    priorityQueue.changePriority(10, 20)

    expect(priorityQueue.poll()).toBe(200)
    expect(priorityQueue.poll()).toBe(5)
    expect(priorityQueue.poll()).toBe(100)
    expect(priorityQueue.poll()).toBe(10)
  })

  it('должен обновить приоритеты внутренних узлов', () => {
    const priorityQueue = new PriorityQueue()

    priorityQueue.add(10, 1)
    priorityQueue.add(5, 2)
    priorityQueue.add(100, 0)
    priorityQueue.add(200, 0)

    expect(priorityQueue.peek()).toBe(100)

    priorityQueue.changePriority(200, 10)
    priorityQueue.changePriority(10, 20)

    expect(priorityQueue.poll()).toBe(100)
    expect(priorityQueue.poll()).toBe(5)
    expect(priorityQueue.poll()).toBe(200)
    expect(priorityQueue.poll()).toBe(10)
  })

  it('должен обновить приоритеты и добавить элемент', () => {
    const priorityQueue = new PriorityQueue()

    priorityQueue.add(10, 1)
    priorityQueue.add(5, 2)
    priorityQueue.add(100, 0)
    priorityQueue.add(200, 0)

    priorityQueue.changePriority(200, 10)
    priorityQueue.changePriority(10, 20)

    priorityQueue.add(15, 15)

    expect(priorityQueue.poll()).toBe(100)
    expect(priorityQueue.poll()).toBe(5)
    expect(priorityQueue.poll()).toBe(200)
    expect(priorityQueue.poll()).toBe(15)
    expect(priorityQueue.poll()).toBe(10)
  })

  it('должен определить наличие значений элементов', () => {
    const priorityQueue = new PriorityQueue()

    priorityQueue.add(10, 1)
    priorityQueue.add(5, 2)
    priorityQueue.add(100, 0)
    priorityQueue.add(200, 0)
    priorityQueue.add(15, 15)

    expect(priorityQueue.hasValue(70)).toBe(false)
    expect(priorityQueue.hasValue(15)).toBe(true)
  })
})
import Stack from '../stack'

describe('Stack', () => {
  it('должен создать пустой стек', () => {
    const stack = new Stack()
    expect(stack).not.toBeNull(


/* SLLIB.C      (c) Copyright Leland Lucius, 2000-2009               */
/*              Library for managing Standard Label tapes            */

/*
|| ----------------------------------------------------------------------------
||
|| SLLIB.C      (c) Copyright Leland Lucius, 2000-2009
||              Released under terms of the Q Public License.
||
|| Library for managing Standard Label tapes.
||
|| ----------------------------------------------------------------------------
*/

#include "hstdinc.h"

#define _SLLIB_C_
#define _HTAPE_DLL_

#include "hercules.h"
#include "sllib.h"

/*
|| Local constant data
*/

/*
|| Label IDs in EBCDIC
*/
static const char *sl_elabs[] =
{
    "\x00\x00\x00", /* Placeholder              */
    "\xE5\xD6\xD3", /* EBCDIC characters "VOL"  */
    "\xC8\xC4\xD9", /* EBCDIC characters "HDR"  */
    "\xE4\xC8\xD3", /* EBCDIC characters "UHL"  */
    "\xC5\xD6\xC6", /* EBCDIC characters "EOF"  */
    "\xC5\xD6\xE5", /* EBCDIC characters "EOV"  */
    "\xE4\xE3\xD3", /* EBCDIC characters "UTL"  */
};
#define SL_ELABS_MAX ( sizeof( sl_elabs ) / sizeof( sl_elabs[ 0 ] ) )

/*
|| Label IDs in ASCII
*/
static const char *sl_alabs[] =
{
    "\x00\x00\x00", /* Placeholder              */
    "\x56\x4f\x4c", /* ASCII characters "VOL"   */
    "\x48\x44\x52", /* ASCII characters "HDR"   */
    "\x55\x48\x4c", /* ASCII characters "UHL"   */
    "\x45\x4f\x46", /* ASCII characters "EOF"   */
    "\x45\x4f\x56", /* ASCII characters "EOV"   */
    "\x55\x54\x4c", /* ASCII characters "UTL"   */
};
#define SL_ALABS_MAX ( sizeof( sl_alabs ) / sizeof( sl_alabs[ 0 ] ) )

/*
|| Minimum and maximum ranges for each label type
*/
static const struct
{
    int min;
    int max;
}
sl_ranges[] =
{
    { 0, 0 },       /* Placeholder              */
    { 1, 1 },       /* ASCII characters "VOL"   */
    { 1, 2 },       /* ASCII characters "HDR"   */
    { 1, 8 },       /* ASCII characters "UHL"   */
    { 1, 2 },       /* ASCII characters "EOF"   */
    { 1, 2 },       /* ASCII characters "EOV"   */
    { 1, 8 },       /* ASCII characters "UTL"   */
};

/*
|| Text descriptions for errors
*/
static const char *sl_errstr[] =
{
    "No error",
    "Block size out of range",
    "Data set sequence out of range",
    "Invalid expiration date",
    "Missing or invalid job name",
    "Missing or invalid record length",
    "Owner string invalid or too long",
    "Missing or invalid record format",
    "Missing or invalid step name",
    "Invalid recording technique",
    "Volume sequence out of range",
    "Missing or invalid volume serial",
    "User data too long",
    "Label type invalid",
    "Label number invalid",
    "Invalid error code",
};
#define SL_ERRSTR_MAX ( sizeof( sl_errstr) / sizeof( sl_errstr[ 0 ] ) )

/*
|| Valid characters for a Standard Label
|| (from: SC26-4565-01 "3.4 Label Definition and Organization")
*/
static const char
sl_cset[] =
{
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !\"%&'()*+,-./:;<=>?"
};

/*
|| Valid record formats
*/
static const struct
{
    char *recfm;
    char f;
    char b;
    char c;
}
valfm[] =
{
    { "U",    'U', ' ', ' ' },
    { "UA",   'U', ' ', 'A' },
    { "UM",   'U', ' ', 'M' },
    { "F",    'F', ' ', ' ' },
    { "FA",   'F', ' ', 'A' },
    { "FM",   'F', ' ', 'M' },
    { "FB",   'F', 'B', ' ' },
    { "FBA",  'F', 'B', 'A' },
    { "FBM",  'F', 'B', 'M' },
    { "FS",   'F', 'S', ' ' },
    { "FSA",  'F', 'S', 'A' },
    { "FSM",  'F', 'S', 'M' },
    { "FBS",  'F', 'R', ' ' },
    { "FBSA", 'F', 'R', 'A' },
    { "FBSM", 'F', 'R', 'M' },
    { "V",    'V', ' ', ' ' },
    { "VA",   'V', ' ', 'A' },
    { "VM",   'V', ' ', 'M' },
    { "VB",   'V', 'B', ' ' },
    { "VBA",  'V', 'B', 'A' },
    { "VBM",  'V', 'B', 'M' },
    { "VS",   'V', 'S', ' ' },
    { "VSA",  'V', 'S', 'A' },
    { "VSM",  'V', 'S', 'M' },
    { "VBS",  'V', 'R', ' ' },
    { "VBSA", 'V', 'R', 'A' },
    { "VBSM", 'V', 'R', 'M' },
};
#define VALFMCNT ( sizeof( valfm ) / sizeof( valfm[ 0 ] ) )

/*==DOC==

    NAME
            sl_atoe - Translate input buffer from ASCII to EBCDIC

    SYNOPSIS
            #include "sllib.h"

            char *sl_atoe( void *dbuf, void *sbuf, int slen )

    DESCRIPTION
            Translates, and optionally copies, "sbuf" from ASCII to
            EBCDIC for "slen" characters.

            If "dbuf" is specified as NULL, then "sbuf" is translated in
            place.  Otherwise, "dbuf" specifies the buffer where the
            translated characters will be sto


n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nfunction mapToCurveSimpleSWU(Fp, opts) {\n    (0,_modular_js__WEBPACK_IMPORTED_MODULE_2__.validateField)(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4


lch(0.7 0.05 280);

  /* Brighter orange accent for dark mode visibility - #ffac4c */
  --accent: oklch(0.8 0.15 60);
  --accent-foreground: oklch(0.1 0.02 0);

  /* Brighter destructive for visibility */
  --destructive: oklch(0.75 0.28 25);
  --destructive-foreground: oklch(0.1 0.02 0);

  /* Subtle glowing borders */
  --border: oklch(0.65 0.15 280 / 0.15);
  --input: oklch(0.65 0.15 280 / 0.2);
  --ring: oklch(0.7 0.2 280 / 0.5);

  /* Dark mode chart colors - brighter for contrast */
  --chart-1: oklch(0.7 0.22 280); /* Brighter purple */
  --chart-2: oklch(0.75 0.24 350); /* Brighter pink */
  --chart-3: oklch(0.83 0.17 60);  /* Brighter orange */
  --chart-4: oklch(0.75 0.2 320); /* Brighter magenta */
  --chart-5: oklch(0.65 0.18 240); /* Brighter blue-purple */

  /* Dark sidebar with glass effect */
  --sidebar: oklch(0.2 0.04 280 / 0.6);
  --sidebar-foreground: oklch(0.96 0.02 0);
  --sidebar-primary: oklch(0.7 0.2 280);
  --sidebar-primary-foreground: oklch(0.1 0.02 0);
  --sidebar-accent: oklch(0.8 0.15 60);
  --sidebar-accent-foreground: oklch(0.1 0.02 0);
  --sidebar-border: oklch(0.65 0.15 280 / 0.15);
  --sidebar-ring: oklch(0.7 0.2 280 / 0.5);
}

@layer base {
  * {
    @apply border-border outline-ring/50;
  }
  body {
    @apply bg-background text-foreground bg-gradient-to-br from-primary/5 via-background to-secondary/5;
  }

  /* Modern typography */
  h1, h2, h3, h4, h5, h6 {
    @apply font-medium;
  }

  h1 {
    @apply text-4xl;
  }

  h2 {
    @apply text-3xl;
  }

  h3 {
    @apply text-2xl;
  }
}

/* Glassmorphic and futuristic design utility classes */
@layer components {
  .glass-card {
    @apply rounded-xl bg-white/20 dark:bg-black/20 backdrop-blur-md border border-white/20 dark:border-white/10 shadow-lg hover:shadow-xl transition-shadow;
  }

  .glass-input {
    @apply bg-white/10 dark:bg-white/5 backdrop-blur-sm border border-white/20 dark:border-white/10;
  }

  .glass-button {
    @apply backdrop-blur-sm hover:shadow-lg transition-all shadow-md;
  }

  .gradient-purple-pink {
    @apply bg-gradient-to-r from-primary to-secondary text-primary-foreground;
  }

  .gradient-pink-orange {
    @apply bg-gradient-to-r from-secondary to-accent text-secondary-foreground;
  }

  .gradient-purple-orange {
    @apply bg-gradient-to-r from-primary to-accent text-primary-foreground;
  }


 that produces a query containing [Key] items that
 * specifies where each page boundary exists within the full dataset. For example:
 *
 * The dataset `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]` ordered ascending with a page size of 2 would
 * produce page boundaries `[0, 2, 4, 6, 8]`.
 *
 * The dataset `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]` ordered ascending with a page size of 3 would
 * produce page boundaries `[0, 3, 6, 9]`.
 *
 * Callbacks made from [pageBoundariesProvider] may include an `anchor` key which, if present,
 * should appear in the resulting query.
 *
 * Because page boundaries are computed ahead of time, [PagingConfig.initialLoadSize] should match
 * [PagingConfig.pageSize]. Failing to do so will result in unexpected page sizes, as
 * [pageBoundariesProvider] is called a single time during the first call to [PagingSource.load] on
 * this source.
 *
 * Generally, it's only feasible to produce page boundaries using SQLite window functions. An
 * example query to generate page boundaries like shown above would look like the following.
 *
 * ```sql
 * SELECT value
 * FROM (
 *   SELECT
 *     value,
 *     CASE
 *       WHEN ((row_number() OVER(ORDER BY value ASC) - 1) % :limit) = 0 THEN 1
 *       WHEN value = :anchor THEN 1
 *       ELSE 0
 *     END page_boundary
 *   FROM numbers
 *   ORDER BY value ASC
 * )
 * WHERE page_boundary = 1;
 * ```
 *
 * SQLite window queries became available as of version 3.25.0. For this reason, consuming
 * applications will likely need a minSdk of 30 set _or_ bundle a SQLite module separate from the OS
 * provided module.
 *
 * An example query returned by [queryProvider] could look like:
 * ```sql
 * SELECT value FROM numbers
 * WHERE value >= :beginInclusive AND (value < :endExclusive OR :endExclusive IS NULL)
 * ORDER BY value ASC;
 * ```
 *
 * Queries will be executed on [context].
 *
 * This [PagingSource] _does not_ support jumping. If your use case requires jumping, use the offset
 * based [QueryPagingSource] function.
 */
@Suppress("FunctionName")
fun <Key : Any, RowType : Any> QueryPagingSource(
    transacter: TransacterBase,
    context: CoroutineContext,
    pageBoundariesProvider: (anchor: Key?, limit: Long) -> Query<Key>,
    queryProvider: (beginInclusive: Key, endExclusive: Key?) -> Query<RowType>,
): PagingSource<Key, RowType> = KeyedQueryPagingSource(
    queryProvider,
    pageBoundariesProvider,
    transacter,
    context,
)
plugins {
    alias(libs.plugins.app.kmp)
}

scaffold {
    useKotlinInject()
    optIn(
        "kotlinx.coroutines.ExperimentalCoroutinesApi",
        "kotlinx.coroutines.FlowPreview",
    )
}

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation(projects.core.base)
                implementation(projects.core.util)
                implementation(projects.data.featuredshows.api)
                implementation(projects.data.trendingshows.api)
                implementation(projects.data.upcomingshows.api)
                implementation(projects.data.search.api)
                implementation(projects.data.genre.api)

                api(libs.decompose.decompose)
                api(libs.essenty.lifecycle)
                api(libs.kotlinx.collections)

                implementation(libs.coroutines.core)
                implementation(libs.kotlinInject.runtime)
            }
        }

        commonTest {
            dependencies {
                implementation(projects.core.util.testing)
                implementation(projects.data.search.testing)


u=c.accesstoken;y(c.style)&&(u?i.pushUnique(n,u):(y(c._input.style)&&(i.error("Uses Mapbox map style, but did not set an access token."),o=!0),s=!0)),u&&i.pushUnique(a,u)}if(s){var h=o?d.noAccessTokenErrorMsg:d.missingStyleErrorMsg;throw i.error(h),new Error(h)}return n.length?(n.length>1&&i.warn(d.multipleTokensErrorMsg),n[0]):(a.length&&i.log(["Listed mapbox access token(s)",a.join(","),"but did not use a Mapbox map style, ignoring token(s)."].join(" ")),"")}(t,a);n.accessToken=o;for(var l=0;l<a.length;l++){var c=a[l],u=s(r,p,c),h=e[c],v=h._subplot;v||(v=new f(t,c),e[c]._subplot=v),v.viewInitial||(v.viewInitial={center:i.extendFlat({},h.center),zoom:h.zoom,bearing:h.bearing,pitch:h.pitch}),v.plot(u,e,t._promises)}},e.clean=function(t,e,r,n){for(var i=n._subplots.mapbox||[],a=0;a<i.length;a++){var o=i[a];!e[o]&&n[o]._subplot&&n[o]._subplot.destroy()}},e.toSVG=function(t){for(var e=t._fullLayout,r=e._subplots.mapbox,n=e._size,i=0;i<r.length;i++){var s=e[r[i]],f=s.domain,p=s._subplot.toImage("png");e._glimages.append("svg:image").attr({xmlns:l.svg,"xlink:href":p,x:n.l+n.w*f.x[0],y:n.t+n.h*(1-f.y[1]),width:n.w*(f.x[1]-f.x[0]),height:n.h*(f.y[1]-f.y[0]),preserveAspectRatio:"none"});var m=c.select(s._subplot.div);if(null!==m.select(".mapboxgl-ctrl-logo").node().offsetParent){var g=e._glimages.append("g");g.attr("transform",a(n.l+n.w*f.x[0]+10,n.t+n.h*(1-f.y[0])-31)),g.append("path").attr("d",d.mapboxLogo.path0).style({opacity:.9,fill:"#ffffff","enable-background":"new"}),g.append("path").attr("d",d.mapboxLogo.path1).style("opacity",.35).style("enable-background","new"),g.append("path").attr("d",d.mapboxLogo.path2).style("opacity",.35).style("enable-background","new"),g.append("polygon").attr("points",d.mapboxLogo.polygon).style({opacity:.9,fill:"#ffffff","enable-background":"new"})}var y=m.select(".mapboxgl-ctrl-attrib").text().replace("Improve this map",""),v=e._glimages.append("g"),x=v.append("text");x.text(y).classed("static-attribution",!0).attr({"font-size":12,"font-family":"Arial",color:"rgba(0, 0, 0, 0.75)","text-anchor":"end","data-unformatted":y});var _=u.bBox(x.node()),b=n.w*(f.x[1]-f.x[0]);if(_.width>b/2){var w=y.split("|").join("<br>");x.text(w).attr("data-unformatted",w).call(h.convertToTspans,t),_=u.bBox(x.node())}x.attr("transform",a(-3,8-_.height)),v.insert("rect",".stati


l4

P6265: !CAS [2] (maybe <- 0x3000032) (Int) (CBR)
add %i0, 12, %o5
lduw [%o5], %l6
mov %l6, %l7
! move %l7(lower) -> %o2(lower)
or %l7, %o2, %o2
mov %l4, %o3
cas [%o5], %l7, %o3
! move %o3(lower) -> %o3(upper)
sllx %o3, 32, %o3
add   %l4, 1, %l4

! cbranch
andcc %l0, 1, %g0
be,pt  %xcc, TARGET6265
nop
RET6265:

! lfsr step begin
srlx %l0, 1, %l7
xnor %l7, %l0, %l7
sllx %l7, 63, %l7
or  %l7, %l0, %l0
srlx %l0, 1, %l0

P6266: !CAS [4] (maybe <- 0x3000033) (Int)
add %i0, 64, %l3
lduw [%l3], %l7
mov %l7, %o5
! move %o5(lower) -> %o3(lower)
or %o5, %o3, %o3
mov %l4, %o4
cas [%l3], %o5, %o4
! move %o4(lower) -> %o4(upper)
sllx %o4, 32, %o4
add   %l4, 1, %l4

P6267: !CAS [4] (maybe <- 0x3000034) (Int) (LE)
! Change single-word-level endianess (big endian <-> little endian)
sethi %hi(0xff00ff00), %l3
or %l3, %lo(0xff00ff00), %l3
and %l4, %l3, %o5
srl %o5, 8, %o5
sll %l4, 8, %l6
and %l6, %l3, %l6
or %l6, %o5, %l6
srl %l6, 16, %o5
sll %l6, 16, %l6
srl %l6, 0, %l6
or %l6, %o5, %l6
wr %g0, 0x88, %asi
add %i0, 64, %l3
lduwa [%l3] %asi, %l7
mov %l7, %o5
! move %o5(lower) -> %o4(lower)
or %o5, %o4, %o4
!---- flushing int results buffer----
mov %o0, %l5
mov %o1, %l5
mov %o2, %l5
mov %o3, %l5
mov %o4, %l5
mov %l6, %o0
casa [%l3] %asi, %o5, %o0
! move %o0(lower) -> %o0(upper)
sllx %o0, 32, %o0
add   %l4, 1, %l4

P6268: !REPLACEMENT [15] (Int)
sethi %hi(0xc0), %o5
or %o5, %lo(0xc0),  %o5
sethi %hi(0x10000), %l3
or %l3, %lo(0x10000),  %l3
add %i3, %o5, %o5
add %o5, %l3, %o5
ld [%o5], %l6
st %l6, [%o5]
add %o5, %l3, %o5
ld [%o5], %l6
st %l6, [%o5]
add %o5, %l3, %o5
ld [%o5], %l6
st %l6, [%o5]
add %o5, %l3, %o5
ld [%o5], %l6
st %l6,


 org.mockito.kotlin.verify
import org.mockito.kotlin.whenever

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class FetchScheduledMeetingOccurrencesByChatUseCaseTest {

    private val callRepository: CallRepository = mock()

    private lateinit var underTest: FetchScheduledMeetingOccurrencesByChatUseCase

    @BeforeEach
    fun setUp() {
        underTest = FetchScheduledMeetingOccurrencesByChatUseCase(
            callRepository = callRepository
        )
    }

    @AfterEach
    fun tearDown() {
        reset(callRepository)
    }

    @Test
    fun `test that the list scheduled meeting occurrences by chat is successfully fetched with the correct arguments`() =
        runTest {
            val chatId = 123L
            val timeUpdateFactor = 789L
            val now = System.currentTimeMillis()
            val since = now - timeUpdateFactor
            val response = listOf(
                ChatScheduledMeetingOccurr(
                    schedId = 456L,
                    startDateTime = now + timeUpdateFactor,
                    endDateTime = now + timeUpdateFactor + 100L,
                    isCancelled = false
                )
            )
            whenever(
                callRepository.fetchScheduledMeetingOccurrencesByChat(
                    chatId = chatId,
                    since = since
                )
            ) doReturn response

            val actual = underTest(chatId = chatId, since = since)

            assertThat(actual).isEqualTo(response)
            verify(callRepository).fetchScheduledMeetingOccurrencesByChat(
                chatId = chatId,
                since = since
            )
        }
}
package mega.privacy.android.domain.usecase.meeting

import com.google.common.truth.Truth.assertThat
import kotlinx.coroutines.test.runTest
import mega.privacy.android.domain.entity.call.ChatCallStatus
import mega.privacy.android.domain.repository.CallRepository
import mega.privacy.android.domain.usecase.call.GetCurrentCallIdsInOtherChatsUseCase
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
import org.mockito.kotlin.any
import org.mockito.kotlin.mock
import org.mockito.kotlin.stub

class GetCurrentCallIdsInOtherChatsUseCaseTest {
    private lateinit var underTest: GetCurrentCallIdsInOtherChatsUseCase

    private val callRepository = mock<CallRepository>()

    private val chatId = 123L

    @BeforeEach
    internal fun setUp() {
        underTest = GetCurrentCallIdsInOtherChatsUseCase(callRepository = callRepository)
    }

    @Test
    fun `test that empty lists return empty`() = runTest {
        callRepository.stub {
            onBlocking { getCallHandleList(any()) }.thenReturn(emptyList())
        }

        assertThat(underTest(chatId)).isEqualTo(emptyList<Long>())
    }

    @Test
    fun `test that call in current chat is not returned`() = runTest {
        callRepository.stub {
            onBlocking { getCallHandleList(any()) }.thenReturn(listOf(chatId))
        }

        assertThat(underTest(chatId)).isEqualTo(emptyList<Long>())
    }

    @ParameterizedTest(name = "test that value found for status {0} is returned")
    @EnumSource(
        value = ChatCallStatus::class,
        names = ["Initial", "UserNoPresent", "Connecting", "Joining", "InProgress"]
    )
    internal fun `test value returned`(type: ChatCallStatus) = runTest {
        val expected = listOf(1234L)
        callRepository.stub {
            onBlocking { getCallHandleList(any()) }.thenReturn(e


Ipv4Addr` to `IpNetwork` with netmask 32.
    #[inline]
    fn from(ip: Ipv4Addr) -> Self {
        IpNetwork::V4(Ipv4Network::from(ip))
    }
}

impl From<Ipv6Addr> for IpNetwork {
    /// Converts `Ipv6Addr` to `IpNetwork` with netmask 128.
    #[inline]
    fn from(ip: Ipv6Addr) -> Self {
        IpNetwork::V6(Ipv6Network::from(ip))
    }
}

impl From<IpAddr> for IpNetwork {
    /// Converts `IpAddr` to `IpNetwork` with netmask 32 for IPv4 address and 128 for IPv6 address.
    fn from(ip: IpAddr) -> Self {
        match ip {
            IpAddr::V4(ip) => IpNetwork::from(ip),
            IpAddr::V6(ip) => IpNetwork::from(ip),
        }
    }
}

impl From<Ipv4Network> for IpNetwork {
    #[inline]
    fn from(network: Ipv4Network) -> Self {
        IpNetwork::V4(network)
    }
}

impl From<Ipv6Network> for IpNetwork {
    #[inline]
    fn from(network: Ipv6Network) -> Self {
        IpNetwork::V6(network)
    }
}

impl PartialEq<Ipv4Network> for IpNetwork {
    fn eq(&self, other: &Ipv4Network) -> bool {
        match self {
            IpNetwork::V4(v4) => v4 == other,
            IpNetwork::V6(_) => false,
        }
    }
}

impl PartialEq<Ipv6Network> for IpNetwork {
    fn eq(&self, other: &Ipv6Network) -> bool {
        match self {
            IpNetwork::V4(_) => false,
            IpNetwork::V6(v6) => v6 == other,
        }
    }
}

impl PartialEq<IpNetwork> for Ipv4Network {
    fn eq(&self, other: &IpNetwork) -> bool {
        match other {
            IpNetwork::V4(v4) => self == v4,
            IpNetwork::V6(_) => false,
        }
    }
}

impl PartialEq<IpNetwork> for Ipv6Network {
    fn eq(&self, other: &IpNetwork) -> bool {
        match other {
            IpNetwork::V4(_) => false,
            IpNetwork::V6(v6) => self == v6,
        }
    }
}

impl PartialOrd<Ipv4Network> for IpNetwork {
    fn partial_cmp(&self, other: &Ipv4Network) -> Option<Ordering> {
        match self {
            IpNetwork::V4(v4) => v4.partial_cmp(other),
            IpNetwork::V6(_) => Some(Ordering::Greater),
        }
    }
}

impl PartialOrd<IpNetwork> for Ipv4Network {
    fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {
        match other {
            IpNetwork::V4(v4) => self.partial_cmp(v4),
            IpNetwork::V6(_) => Some(Ordering::Less),
        }
    }
}

impl PartialOrd<Ipv6Network> for IpNetwork {
    fn partial_cmp(&self, other: &Ipv6Network) -> Option<Ordering> {
        match self {
            IpNetwork::V4(_) => Some(Ordering::Less),
            IpNetwork::V6(v6) => v6.partial_cmp(other),
        }
    }
}

impl PartialOrd<IpNetwork> for Ipv6Network {
    fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {
        match other {
            IpNetwork::V4(_) => Some(Ordering::Greater),
            IpNetwork


{
      let events: TimelineEvent[] = [];
      const step = (endTimestamp - startTimeStamp) / n;

      for (let i = startTimeStamp; i < endTimestamp; i += step) {
        let randomTime = Random.randomBetween(startTimeStamp, endTimestamp);
        const event = new TimelineEvent(randomTime, 'Hawkular', 'Hawkular Provider',
          'Some Message', 'Resource' + '-' + Random.randomBetween(10, 100),
          moment(i).format('MMMM Do YYYY, h:mm:ss a'), '0088ce', RowNumber.nextRow());

        events.push(event);

      }
      return events;
    }

  }

  /**
   * Random number generator
   */
  export class Random {
    public static randomBetween(min: number, max: number): number {
      return Math.floor(Math.random() * (max - min + 1)) + min;
    }
  }
  /**
   * RowNumber class used to calculate which row in the TimelineChart an Event should be placed.
   * This is so events don't pile up on each other. The next event will be placed on the next row
   * such that labels can be placed
   */
  class RowNumber {

    private static _currentRow = 0;

    /**
     * Returns a row number from 1 to 5 for determining which row an event should be placed on.
     * @returns {number}
     */
    public static nextRow(): number {
      const MAX_ROWS = 5;

      RowNumber._currentRow++;

      if (RowNumber._currentRow > MAX_ROWS) {
        RowNumber._currentRow = 1; // reset back to zero
      }
      // reverse the ordering of the numbers so that 1 becomes 5
      // so that the events are laid out from top -> bottom instead of bottom -> top
      return (MAX_ROWS + 1) - RowNumber._currentRow;
    }

  }

  const _module = angular.module('hawkular.charts');

  export class TimelineChartDirective {

    private static _CHART_HEIGHT = 150;
    private static _CHART_WIDTH = 750;

    public restrict = 'E';
    public replace = true;

    // Can't use 1.4 directive controllers because we need to support 1.3+
    public scope = {
      events: '=',
      startTimestamp: '@', // to provide for exact boundaries of start/stop times (if omitted, it will be calculated)
      endTimestamp: '@',
    };

    public link: (scope: any, element: ng.IAugmentedJQuery, attrs: any) => void;

    public events: TimelineEvent[];

    constructor($rootScope: ng.IRootScopeService) {

      this.link = (scope, element, attrs) => {

        // data specific vars
        let startTimestamp: number = +attrs.startTimestamp,
          endTimestamp: number = +attrs.endTimestamp,
          chartHeight: number = TimelineChartDirective._CHART_HEIGHT;

        // chart specific vars
        let margin = { top: 10, right: 5, bottom: 5, left: 10 },
          width = TimelineChartDirective._CHART_WIDTH - margin.left - margin.right,
          adjustedChartHeight = chartHeight - 50,
          height = adjustedChartHeight - margin.top - margin.bottom,
          innerChartHeight = height + margin.top,
          adjustedChartHeight2 = margin.top,
          yScale,
          timeScale,
          xAxis,
          xAxisGroup,
          brush,
          brushGroup,
          tip,
          chart,
          chartParent,
          svg;

        function TimelineHover(d: TimelineEvent) {
          return `

              Event Source:
              ${d.eventSource}

              Provider:
              ${d.provider}

            <div class='info-i


]
	bl sub_0202C1E4
	ldr r0, _0238CBD8 ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	mov r1, r4
	ldr r0, [r0]
	add r0, r0, #0x300
	ldrsh r0, [r0, #0x8c]
	bl ov18_0238ADA8
	ldr r2, _0238CBD8 ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	mov lr, #0
	ldr r1, [r2]
	mov ip, #1
	str lr, [r1, #0x3a0]
	ldr r1, [r2]
	mov r3, #0x38
	add r1, r1, #0x300
	strh r0, [r1, #0xaa]
	ldr r0, [r2]
	strb ip, [r0, #0x3a6]
	ldr r0, [r2]
	add r0, r0, #0x300
	strh lr, [r0, #0xa8]
	ldr r0, [r2]
	strb ip, [r0, #0x3ac]
	ldr r0, [r2]
	strb lr, [r0, #0x3ad]
	ldr r0, [r2]
	str r3, [r0, #0x80]
	b _0238CBD0
_0238CB8C:
	ldr r0, [r1]
	ldrsb r0, [r0, #0xb]
	bl IsAdvancedMenuActive2
	cmp r0, #0
	bne _0238CBD0
	ldr r0, _0238CBD8 ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	ldr r0, [r0]
	ldrsb r0, [r0, #0xb]
	bl GetAdvancedMenuResult
	mvn r1, #0
	cmp r0, r1
	bne _0238CBC8
	mov r0, #0x11
	bl ov18_0238BE28
	b _0238CBD0
_0238CBC8:
	mov r0, #0x36
	bl ov18_0238BE28
_0238CBD0:
	add sp, sp, #4
	ldmia sp!, {r3, r4, pc}
	.align 2, 0
_0238CBD8: .word OVERLAY18_UNKNOWN_POINTER__NA_238D620
	arm_func_end ov18_0238CAD4

	arm_func_start ov18_0238CBDC
ov18_0238CBDC: ; 0x0238CBDC
	ldr r0, _0238CBFC ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	mov r3, #0x3000
	ldr r2, [r0]
	mov r1, #0x37
	str r3, [r2, #0x88]
	ldr r0, [r0]
	str r1, [r0, #0x80]
	bx lr
	.align 2, 0
_0238CBFC: .word OVERLAY18_UNKNOWN_POINTER__NA_238D620
	arm_func_end ov18_0238CBDC

	arm_func_start ov18_0238CC00
ov18_0238CC00: ; 0x0238CC00
	stmdb sp!, {r4, lr}
	ldr r0, _0238CD84 ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	ldr r0, [r0]
	ldrsb r0, [r0, #0xb]
	bl GetAdvancedMenuResult
	ldr r1, _0238CD84 ; =OVERLAY18_UNKNOWN_POINTER__NA_238D620
	mov r4, r0
	ldr r0, [r1]
	ldrsb r0, [r0, #


)

def main(raw_dir: Path, repo_id: str, mode: str = "video", push_to_hub: bool = True):
    if mode not in ["video", "image", "keypoints"]:
        raise ValueError(mode)

    if (HF_LEROBOT_HOME / repo_id).exists():
        shutil.rmtree(HF_LEROBOT_HOME / repo_id)

    if not raw_dir.exists():
        download_raw(raw_dir, repo_id="lerobot-raw/pusht_raw")

    zarr_data = load_raw_dataset(zarr_path=raw_dir / "pusht_cchi_v7_replay.zarr")

    env_state = zarr_data["state"][:]
    agent_pos = env_state[:, :2]

    action = zarr_data["action"][:]
    image = zarr_data["img"]  # (b, h, w, c)

    if image.dtype == np.float32 and image.max() == np.float32(255):
        # HACK: images are loaded as float32 but they actually encode uint8 data
        image = image.astype(np.uint8)

    episode_data_index = {
        "from": np.concatenate(([0], zarr_data.meta["episode_ends"][:-1])),
        "to": zarr_data.meta["episode_ends"],
    }

    # Calculate success and reward based on the overlapping area
    # of the T-object and the T-area.
    coverage, keypoints = calculate_coverage(zarr_data)
    success = calculate_success(coverage, success_threshold=0.95)
    reward = calculate_reward(coverage, success_threshold=0.95)

    features = build_features(mode)
    dataset = LeRobotDataset.create(
        repo_id=repo_id,
        fps=10,
        robot_type="2d pointer",
        features=features,
        image_writer_threads=4,
    )
    episodes = range(len(episode_data_index["from"]))
    for ep_idx in episodes:
        from_idx = episode_data_index["from"][ep_idx]
        to_idx = episode_data_index["to"][ep_idx]
        num_frames = to_idx - from_idx

        for frame_idx in range(num_frames):
            i = from_idx + frame_idx
            idx = i + (frame_idx < num_frames - 1)
            frame = {
                "action": action[i],
                # Shift reward and success by +1 until the last item of the episode
                "next.reward": reward[idx : idx + 1],
                "next.success": success[idx : idx + 1],
                "task": PUSHT_TASK,
            }

            frame["observation.state"] = agent_pos[i]

            if mode == "keypoints":
                frame["observation.environment_state"] = keypoints[i]
            else:
                frame["observation.image"] = image[i]

            dataset.add_frame(frame)

        dataset.save_episode()

    if push_to_hub:
        dataset.push_to_hub()
        hub_api = HfApi()
        hub_api.create_tag(repo_id, tag=CODEBASE_VERSION, repo_type="dataset")

if __name__ == "__main__":
    # To try this script, modify the repo id with your own HuggingFace user (e.g cadene/pusht)
    repo_id = "lerobot/pusht"

    modes = ["video", "image", "keypoints"]
    # Uncomment if you want to try with a specific mode
    # modes = ["video"]
    # modes = ["image"]
    # modes = ["keypoints"]

    raw_dir = Path("data/lerobot-raw/pusht_raw")
    for mode in modes:
        if mode in ["image", "keypoints"]:
            repo_id += f"_{mode}"

        # download and load raw dataset, create LeRobotDataset, populate it, push to hub
        main(raw_dir, repo_id=repo_id, mode=mode)

        # Uncomment if you want to load the local dataset and explore it
        # dataset = LeRobotDataset(repo_id=repo_id)
        # breakpoint()


") + 1);
            slash = "/";
        } else {
            filepath = file1.substring(0, file1.lastIndexOf("/") + 1);
        }
    }

    /*
     * DataProvider fields:
     * lang, xml, xsl, gold file
     */
    @DataProvider(name = "parameters")
    public Object[][] getParameters() {

        return new Object[][]{
            {LAND_EN, "sort-alphabet-english.xml", "sort-alphabet-english.xsl", "sort-alphabet-english.out"},
            {LAND_PL, "sort-alphabet-polish.xml", "sort-alphabet-polish.xsl", "sort-alphabet-polish.out"},
            {LAND_RU, "sort-alphabet-russian.xml", "sort-alphabet-russian.xsl", "sort-alphabet-russian.out"},};
    }

    @Test(dataProvider = "parameters")
    public final void testTransform(String lang, String xml, String xsl, String gold)
            throws Exception {

        StringWriter sw = new StringWriter();
        // Create transformer factory
        TransformerFactory factory = TransformerFactory.newInstance();

        // Use the factory to create a template containing the xsl file
        Templates template = factory.newTemplates(new StreamSource(getClass().getResourceAsStream(xsl)));
        // Use the template to create a transformer
        Transformer xformer = template.newTransformer();
        xformer.setParameter("lang", lang);
        // Prepare the input and output files
        Source source = new StreamSource(getClass().getResourceAsStream(xml));

        /*
             * The following may be used to produce gold files.
             * Using however the original gold files, and compare without considering
             * the format
         */
        //String output = getClass().getResource(gold).getPath();
        //Result result = new StreamResult(new FileOutputStream(output));
        // use the following to verify the output against the pre-generated one
        Result result = new StreamResult(sw);

        // Apply the xsl file to the source file and write the result to the
        // output file
        xformer.transform(source, result);

        String out = sw.toString();

        List<String> lines = Files.readAllLines(Paths.get(filepath + gold));
        String[] resultLines = out.split("\n");
        int i = 0;

        // the purpose is to test sort, so ignore the format of the output
        for (String line : lines) {
            Assert.assertEquals(resultLines[i++].trim(), line.trim());
        }
    }
}
/*
 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

module xmlwrapperprovider {
    requires java.xml;

    provides javax.xml.parsers.DocumentBuilderFactory with xwp.DocumentBuilderFactoryWrapper;
    provides javax.xml.parsers.SAXParserFactory with xwp.SAXParserFactoryWrapper;
    provides javax.xml.stream.XMLInputFactory with xwp.


o();
    unsafe {
        qiniu_ng_str_t::from_optional_str_unchecked(
            request
                .headers()
                .get(&HeaderName::new(ucstr::from_ptr(header_name).to_string().unwrap()))
                .as_ref()
                .map(|header_value| header_value.as_ref()),
        )
    }
    .tap(|_| {
        let _ = qiniu_ng_http_request_t::from(request);
    })
}

/// @brief 获取 HTTP 请求的 Headers 键值对
/// @param[in] request HTTP 请求实例
/// @retval qiniu_ng_str_map_t 返回 HTTP 请求的 Headers 键值对
/// @warning 务必记得 `qiniu_ng_str_map_t` 需要在使用完毕后调用 `qiniu_ng_str_map_free()` 释放内存。
#[no_mangle]
pub extern "C" fn qiniu_ng_http_request_get_headers(request: qiniu_ng_http_request_t) -> qiniu_ng_str_map_t {
    let request: &Request = request.into();
    let src_headers = request.headers();
    let mut dest_headers = Box::new(HashMap::<Box<ucstr>, Box<ucstr>, RandomState>::with_capacity(
        src_headers.len(),
    ));
    src_headers.iter().for_each(|(header_name, header_value)| {
        dest_headers.insert(
            UCString::from_str(header_name.as_ref()).unwrap().into_boxed_ucstr(),
            UCString::from_str(header_value.as_ref()).unwrap().into_boxed_ucstr(),
        );
    });
    let _ = qiniu_ng_http_request_t::from(request);
    dest_headers.into()
}

/// @brief 设置 HTTP 请求的 Header
/// @param[in] request HTTP 请求实例
/// @param[in] header_name HTTP 请求的 Header 名称
/// @param[in] header_value HTTP 请求的 Header 值
#[no_mangle]
pub extern "C" fn qiniu_ng_http_request_set_header(
    request: qiniu_ng_http_request_t,
    header_name: *const qiniu_ng_char_t,
    header_value: *const qiniu_ng_char_t,
) {
    let request: &mut Request = request.into();
    if let Some(header_value) = unsafe { header_value.as_ref() } {
        request.headers_mut().insert(
            HeaderName::new(unsafe { ucstr::from_ptr(header_name) }.to_string().unwrap()),
            unsafe { ucstr::from_ptr(header_value) }.to_string().unwrap().into(),
        );
    } else {
        request.headers_mut().remove(&HeaderName::new(
            unsafe { ucstr::from_ptr(header_name) }.to_string().unwrap(),
        ));
    }
    let _ = qiniu_ng_http_request_t::from(request);
}

/// @brief 获取 HTTP 请求体
/// @param[in] request HTTP 请求实例
/// @param[out] body_ptr 用于返回 HTTP 请求体地址。如果传入 `NULL` 表示不获取 `body_ptr`，但不影响 `body_size` 的获取
/// @param[out] body_size 用于返回 HTTP 请求体长度，单位为字节。如果传入 `NULL` 表示不


_hwfn,
						      qp,
						      &cq_prod);

		if (rc)
			return rc;

		qp->cq_prod = cq_prod;

		rc = qed_roce_sp_destroy_qp_requester(p_hwfn, qp);
	} else {
		DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "0\n");
	}

	return rc;
}

static void qed_roce_free_real_icid(struct qed_hwfn *p_hwfn, u16 icid)
{
	struct qed_rdma_info *p_rdma_info = p_hwfn->p_rdma_info;
	u32 start_cid, cid, xcid;

	/* an even icid belongs to a responder while an odd icid belongs to a
	 * requester. The 'cid' received as an input can be either. We calculate
	 * the "partner" icid and call it xcid. Only if both are free then the
	 * "cid" map can be cleared.
	 */
	start_cid = qed_cxt_get_proto_cid_start(p_hwfn, p_rdma_info->proto);
	cid = icid - start_cid;
	xcid = cid ^ 1;

	spin_lock_bh(&p_rdma_info->lock);

	qed_bmap_release_id(p_hwfn, &p_rdma_info->real_cid_map, cid);
	if (qed_bmap_test_id(p_hwfn, &p_rdma_info->real_cid_map, xcid) == 0) {
		qed_bmap_release_id(p_hwfn, &p_rdma_info->cid_map, cid);
		qed_bmap_release_id(p_hwfn, &p_rdma_info->cid_map, xcid);
	}

	spin_unlock_bh(&p_hwfn->p_rdma_info->lock);
}

void qed_roce_dpm_dcbx(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
{
	u8 val;

	/* if any QPs are already active, we want to disable DPM, since their
	 * context information contains information from before the latest DCBx
	 * update. Otherwise enable it.
	 */
	val = qed_rdma_allocated_qps(p_hwfn) ? true : false;
	p_hwfn->dcbx_no_edpm = (u8)val;

	qed_rdma_dpm_conf(p_hwfn, p_ptt);
}

int qed_roce_setup(struct qed_hwfn *p_hwfn)
{
	return qed_spq_register_async_cb(p_hwfn, PROTOCOLID_ROCE,
					 qed_roce_async_event);
}

int qed_roce_init_hw(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
{
	u32 ll2_ethertype_en;

	qed_wr(p_hwfn, p_ptt, PRS_REG_ROCE_DEST_QP_MAX_PF, 0);

	p_hwfn->rdma_prs_search_reg = PRS_REG_SEARCH_ROCE;

	ll2_ethertype_en = qed_rd(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN);
	qed_wr(p_hwfn, p_ptt, PRS_REG_LIGHT_L2_ETHERTYPE_EN,
	       (ll2_ethertype_en | 0x01));

	if (qed_cxt_get_proto_cid_start(p_hwfn, PROTOCOLID_ROCE) % 2) {
		DP_NOTICE(p_hwfn, "The first RoCE's cid should be even\n");
		return -EINVAL;
	}

	DP_VERBOSE(p_hwfn, QED_MSG_RDMA, "Initializing HW - Done\n");
	return 0;
}


conduit::Get)
                                        .with_path("/api/v1/crates/foo/1.0.0")));
    assert!(!::json::<V>(&mut r).version.yanked);

    // yank it
    let mut r = ok_resp!(middle.call(req.with_method(conduit::Delete)
                                        .with_path("/api/v1/crates/foo/1.0.0/yank")));
    assert!(::json::<O>(&mut r).ok);
    assert!(File::open(&path).read_to_string().unwrap().as_slice()
                             .contains("\"yanked\":true"));
    let mut r = ok_resp!(middle.call(req.with_method(conduit::Get)
                                        .with_path("/api/v1/crates/foo/1.0.0")));
    assert!(::json::<V>(&mut r).version.yanked);

    // un-yank it
    let mut r = ok_resp!(middle.call(req.with_method(conduit::Put)
                                        .with_path("/api/v1/crates/foo/1.0.0/unyank")));
    assert!(::json::<O>(&mut r).ok);
    assert!(File::open(&path).read_to_string().unwrap().as_slice()
                             .contains("\"yanked\":false"));
    let mut r = ok_resp!(middle.call(req.with_method(conduit::Get)
                                        .with_path("/api/v1/crates/foo/1.0.0")));
    assert!(!::json::<V>(&mut r).version.yanked);
}

#[test]
fn yank_not_owner() {
    let (_b, app, middle) = ::app();
    let mut req = ::req(app, conduit::Delete, "/api/v1/crates/foo/1.0.0/yank");
    ::mock_user(&mut req, ::user("foo"));
    ::mock_crate(&mut req, ::krate("foo"));
    ::mock_user(&mut req, ::user("bar"));
    let mut response = ok_resp!(middle.call(&mut req));
    ::json::<::Bad>(&mut response);
}

#[test]
fn bad_keywords() {
    let (_b, app, middle) = ::app();
    {
        let mut krate = ::krate("foo");
        krate.keywords.push("super-long-keyword-name-oh-no".to_string());
        let mut req = new_req_full(app.clone(), krate, "1.0.0", Vec::new());
        ::mock_user(&mut req, ::user("foo"));
        let mut response = ok_resp!(middle.call(&mut req));
        ::json::<::Bad>(&mut response);
    }
    {
        let mut krate = ::krate("foo");
        krate.keywords.push("?@?%".to_string());
        let mut req = new_req_full(app.clone(), krate, "1.0.0", Vec::new());
        ::mock_user(&mut req, ::user("foo"));
        let mut response = ok_resp!(middle.call(&mut req));
        ::json::<::Bad>(&mut response);
    }
    {
        let mut krate = ::krate("foo");
        for i in range(0, 100u) {
            krate.keywords.push(format!("kw{}", i));
        }
        let mut req = new_req_full(app.clone(), krate, "1.0.0", Vec::new());
        ::mock_user(&mut req, ::user("foo"));
        let mut response = ok_resp!(middle.call(&mut req));
        ::json::<::Bad>(&mut response);
    }
}
<gh_stars>0
use structopt::StructOpt;
us


GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 quad_perm:[0,1,2,3]
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0xe4,0x00,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_mirror
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x40,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_half_mirror
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x41,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_shl:1
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x01,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_shl:15
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x0f,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_shr:1
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x11,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_shr:15
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x1f,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_ror:1
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x21,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_ror:15
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x2f,0x01,0xff]
// W64-ERR: :[[@LINE-2]]:{{[0-9]+}}: error: operands are not valid for this GPU or mode

v_cmp_nlg_f32 vcc_lo, v1, v2 row_share:0 row_mask:0xf bank_mask:0xf
// W32: encoding: [0xfa,0x04,0x34,0x7c,0x01,0x50,0x01,0xff]
//


   /// Amount voucher can be redeemed for
    #[serde(with = "bigint_ser")]
    pub amount: BigInt,
    /// (optional) Can extend channel min_settle_height if needed
    pub min_settle_height: ChainEpoch,

    /// (optional) Set of lanes to be merged into `lane`
    pub merges: Vec<Merge>,

    /// Sender's signature over the voucher (sign on none)
    pub signature: Option<Signature>,
}

/// Modular Verification method
#[derive(Debug, Clone, PartialEq, Serialize_tuple, Deserialize_tuple)]
pub struct ModVerifyParams {
    pub actor: Address,
    pub method: MethodNum,
    pub data: Serialized,
}

/// Payment Verification parameters
#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct PaymentVerifyParams {
    pub extra: Serialized,
    // TODO revisit these to see if they should be arrays or optional
    #[serde(with = "serde_bytes")]
    pub proof: Vec<u8>,
}

#[derive(Serialize_tuple, Deserialize_tuple)]
pub struct UpdateChannelStateParams {
    pub sv: SignedVoucher,
    #[serde(with = "serde_bytes")]
    pub secret: Vec<u8>,
    #[serde(with = "serde_bytes")]
    pub proof: Vec<u8>,
}

impl From<SignedVoucher> for UpdateChannelStateParams {
    fn from(sv: SignedVoucher) -> Self {
        UpdateChannelStateParams {
            proof: vec![],
            secret: vec![],
            sv,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use encoding::{from_slice, to_vec};

    #[test]
    fn signed_voucher_serialize_optional_unset() {
        let v = SignedVoucher {
            time_lock_min: 1,
            time_lock_max: 2,
            lane: 3,
            nonce: 4,
            amount: BigInt::from(5),
            signature: Some(Signature::new_bls(b"doesn't matter".to_vec())),
            ..Default::default()
        };
        let bz = to_vec(&v).unwrap();
        assert_eq!(
            hex::encode(&bz),
            hex::encode(
                &hex::decode("8a010240f6030442000500804f02646f65736e2774206d6174746572").unwrap()
            )
        );
        assert_eq!(from_slice::<SignedVoucher>(&bz).unwrap(), v);
    }
}
<reponame>manojgop/AEADs
//! Carryless multiplication over GF(2^128) based on the PCLMULQDQ CPU intrinsics
//! on `x86` and `x86_64` target architectures.
//!
//! More information can be found in the Intel whitepaper:
//! https://software.intel.com/sites/default/files/managed/72/cc/clmul-wp-rev-2.02-2014-04-20.pdf
use crate::Block;
#[cfg(target_arch = "x86")]
use core::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use core::arch::x86_64::*;

pub(crate) struct Element(__m128i);

const BS_MASK1: i64 = 0x00010203_04050607;
const BS_MASK2: i64 = 0x08090A0B_0C0D0E0F;

macro_rules! xor {
    ($e1:expr, $e2:expr $(,)?) => {
        _mm_xor_si128($e1, $e2)
    };
    ($head:expr, $($tail:expr),* $(,)?) => {
        _mm_xor_si128($head, xor!($($tail ,)*))
    };
}

impl Element {
    pub(crate) fn new() -> Self {
        Self(unsafe { _mm_setzero_si128() })
    }

    #[allow(clippy::cast_ptr_alignment)]
    #[allow(clippy::many_single_char_names)]
    pub(crate) fn mul_sum(&mut self, a: &Block, b: &Block) {


ProviderOrFamily>? get allTransitiveDependencies =>
      _allTransitiveDependencies;

  @override
  String? get name => r'hasFeedbackProvider';
}

/// 8. 특정 날짜의 저널에 피드백이 있는지 확인 (title이 있거나 song이 있는 경우)
///
/// Copied from [hasFeedback].
class HasFeedbackProvider extends AutoDisposeProvider<bool> {
  /// 8. 특정 날짜의 저널에 피드백이 있는지 확인 (title이 있거나 song이 있는 경우)
  ///
  /// Copied from [hasFeedback].
  HasFeedbackProvider(
    DateTime date,
  ) : this._internal(
          (ref) => hasFeedback(
            ref as HasFeedbackRef,
            date,
          ),
          from: hasFeedbackProvider,
          name: r'hasFeedbackProvider',
          debugGetCreateSourceHash:
              const bool.fromEnvironment('dart.vm.product')
                  ? null
                  : _$hasFeedbackHash,
          dependencies: HasFeedbackFamily._dependencies,
          allTransitiveDependencies:
              HasFeedbackFamily._allTransitiveDependencies,
          date: date,
        );

  HasFeedbackProvider._internal(
    super._createNotifier, {
    required super.name,
    required super.dependencies,
    required super.allTransitiveDependencies,
    required super.debugGetCreateSourceHash,
    required super.from,
    required this.date,
  }) : super.internal();

  final DateTime date;

  @override
  Override overrideWith(
    bool Function(HasFeedbackRef provider) create,
  ) {
    return ProviderOverride(
      origin: this,
      override: HasFeedbackProvider._internal(
        (ref) => create(ref as HasFeedbackRef),
        from: from,
        name: null,
        dependencies: null,
        allTransitiveDependencies: null,
        debugGetCreateSourceHash: null,
        date: date,
      ),
    );
  }

  @override
  AutoDisposeProviderElement<bool> createElement() {
    return _HasFeedbackProviderElement(this);
  }

  @override
  bool operator ==(Object other) {
    return other is HasFeedbackProvider && other.date == date;
  }

  @override
  int get hashCode {
    var hash = _SystemHash.combine(0, runtimeType.hashCode);
    hash = _SystemHash.combine(hash, date.hashCode);

    return _SystemHash.finish(hash);
  }
}

mixin HasFeedbackRef on AutoDisposeProviderRef<bool> {
  /// The parameter `date` of this provider.
  DateTime get date;
}

class _HasFeedbackProviderElement extends AutoDisposeProviderElement<bool>
    with HasFeedbackRef {
  _HasFeedbackProviderElement(super.provider);

  @override
  DateTime get date => (origin as HasFeedbackProvider).date;
}
// ignore_for_file: type=lint
// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member
import 'package:animate_do/animate_do.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';

import '../details_page.dart';

class ShakeWidget extends StatelessWidget {
  const ShakeWidget({
    Key? key,
    required this.shakes,
    required this.shakesImg,
    required this.price,
  }) : super(key: key);

  final String shakes;
  final String shakesImg;
  final String price;

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: () {},
      child: Padding(
        padding: const EdgeInsets.only(top: 20, bottom: 20, right: 20),
        child: Stack(
          children: [
            Center(
              child: SlideInRight(
                duration: Duration(milliseconds: 100),
                child: Container(
                  height: 220,
                  width: 200,
                  decoration: BoxDecoration(
                    borderRadius: BorderRadius.only(
                      topLeft: Radius.circular(300),
                      topRight: Radius.circular(30),
                      bottomLeft: Radius.circular(30),
                      bottomRight: Radius.circular(30),
                    ),
                    boxShadow: [
                      BoxShadow(
                          color: Colors.redAccent.w