vaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2024.08.29 at 03:15:31 AM IST
//

package net.authorize.api.contract.v1;

import jakarta.xml.bind.annotation.XmlAccessType;
import jakarta.xml.bind.annotation.XmlAccessorType;
import jakarta.xml.bind.annotation.XmlSeeAlso;
import jakarta.xml.bind.annotation.XmlType;

/**
 *
Java class for customerProfileBaseType complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="customerProfileBaseType">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <element name="merchantCustomerId" minOccurs="0">
 *           <simpleType>
 *             <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *               <maxLength value="20"/>
 *             </restriction>
 *           </simpleType>
 *         </element>
 *         <element name="description" minOccurs="0">
 *           <simpleType>
 *             <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *               <maxLength value="255"/>
 *             </restriction>
 *           </simpleType>
 *         </element>
 *         <element name="email" minOccurs="0">
 *           <simpleType>
 *             <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *               <maxLength value="255"/>
 *             </restriction>
 *           </simpleType>
 *         </element>
 *       </sequence>
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "customerProfileBaseType", propOrder = {
    "merchantCustomerId",
    "description",
    "email"
})
@XmlSeeAlso({
    CustomerProfileType.class,
    CustomerProfileExType.class
})
public class CustomerProfileBaseType {

    protected String merchantCustomerId;
    protected String description;
    protected String email;

    /**
     * Gets the value of the merchantCustomerId property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getMerchantCustomerId() {
        return merchantCustomerId;
    }

    /**
     * Sets the value of the merchantCustomerId property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setMerchantCustomerId(String value) {
        this.merchantCustomerId = value;
    }

    /**
     * Gets the value of the description property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getDescription() {
        return description;
    }

    /**
     * Sets the value of the description property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setDescription(String value) {
        this.description = value;
    }

    /**
     * Gets the value of the


XT nine_char    '9'
CONST_XT minus_char   '-'
CONST_XT offset_9_a   'a'-'9'-1  | offset between ASCII codes for '0' and 'a'
CONST_XT pad          _pad_hi
CONST_XT cell         CELL_BYTES
CONST_XT xta          XTA_BYTES
CONST_XT stack_start  _dstack_lo + 2*CELL_BYTES
CONST_XT app_start    _app_lo
CONST_XT app_bytes    _app_hi - _app_lo
CONST_XT cp_init      _bss_end
CONST_XT dolist_ptr   _dolist

||
|| Higher-level execution tokens
||

|
| Header of list execution token
|
.macro LIST_XT label
	.align XTA_BYTES
\label :
	.dc.l _dolist
.endm

|
| Shorthand for simple list execution tokens without branches,
| exiting at the end
|
.macro XT label tokens:vararg
LIST_XT \label
	.. \tokens exit
.endm

XT xta_aligned_store  store

XT twodrop  drop drop
XT twodup   over over
XT rot      tor swap rfrom swap
XT nip      swap drop
XT inc      one plus
XT sub      negate plus
XT incvar   dup at inc swap store
XT varplus  dup at rot plus swap store

XT cellinc       cell plus
XT celldec       cell sub
XT cells         dup plus dup plus
XT cell_aligned  cell aligned
XT xta_aligned   xta  aligned

| ( s -- b n ) return byte address 'b' and length 'n' for counted string 's'
XT count   dup inc swap cat

|
| The algorithms for umdiv_mod and ummul are transcribed from "eForth and Zen",
| pages 53 and 55.
|

| ( udl udh u -- ur uq )  divide double unsigned number, return remainder and quotient
LIST_XT umdiv_mod
	.. twodup ult
	.. qbranch 1f
	..   negate
	..   thirty_one tor
	     | for
2:	..     tor
	..     dup umplus
	..     tor tor dup umplus
	..     rfrom plus dup
	..     rfrom rat swap
	..     tor umplus
	..     rfrom or
	..     qbranch 3f
	..       tor drop
	..       inc rfrom
	..       branch 4f
	       | else
3:	..       drop
	       | then
4:	..     rfrom
	..   next 2b
	..   drop swap exit
1:	.. drop twodrop neg_one dup
	.. exit

| ( u1 u2 -- udl udh ) return double product of two unsigned numbers
LIST_XT ummul
	.. zero swap
	.. thirty_one tor
1:	..   dup umplus tor tor
	..   dup umplus
	..   rfrom plus
	..   rfrom
	..   qbranch 2f
	..     tor over umplus rfrom plus
2:	.. next 1b
	.. rot drop exit

| ( u ul uh -- f ) true if u is within ul (inclusive) and uh (exclusive)
XT within  over sub tor sub rfrom ult

| ( n - n ) absolute value of 'n'
LIST_XT abs
	.. dup zless qbranch 1f negate
1:	.. exit

| ( a1 a2 u -- ) copy u bytes from a1 to a2
CODE_XT cmove
	move.l d4,d7 ; POPD
	move.l d4,a2 ; POPD
	move.


async fn get_pet_by_id(pet_id: u64) -> Pet {
//! #         Pet {
//! #             id: pet_id,
//! #             age: None,
//! #             name: "lightning".to_string(),
//! #         }
//! #     }
//! # }
//! # use utoipa::Component;
//! #
//! # #[derive(Component)]
//! # struct Pet {
//! #   id: u64,
//! #   name: String,
//! #   age: Option<i32>,
//! # }
//! # use utoipa::OpenApi;
//! #[derive(OpenApi)]
//! #[openapi(handlers(pet_api::get_pet_by_id), components(Pet))]
//! struct ApiDoc;
//!
//! println!("{}", ApiDoc::openapi().to_pretty_json().unwrap());
//! ```
//! # Go beyond the surface
//!
//! * See how to serve OpenAPI doc via Swagger UI check [`utoipa-swagger-ui`][utoipa_swagger] crate for more details.
//! * Browse to [examples](https://github.com/juhaku/utoipa/tree/master/examples) for more comprehensinve examples.
//! * Modify generated OpenAPI at runtime check [`Modify`] trait for more details.
//! * More about OpenAPI security in [security documentation][security].
//!
//! [path]: attr.path.html
//! [rocket_path]: attr.path.html#rocket_extras-support-for-rocket
//! [actix_path]: attr.path.html#actix_extras-support-for-actix-web
//! [serde]: derive.Component.html#partial-serde-attributes-support
//!
//! [security]: openapi/security/index.html
//! [component_derive]: derive.Component.html

pub mod openapi;

pub use utoipa_gen::*;

/// Trait for implementing OpenAPI specification in Rust.
///
/// This trait is derivable and can be used with `#[derive]` attribute. The derived implementation
/// will use Cargo provided environment variables to implement the default information. For a details of
/// `#[derive(Component)]` refer to [derive documentation][derive].
///
/// # Examples
///
/// Below is derived example of `OpenApi`.
/// ```rust
/// use utoipa::OpenApi;
/// #[derive(OpenApi)]
/// #[openapi(handlers())]
/// struct OpenApiDoc;
/// ```
///
/// This manual `OpenApi` trait implementation is approximately equal to the above derived one except the derive
/// implementation will by default use the Cargo environment variables to set defaults for *application name,
/// version, application description, license, author name & email*.
///
///```rust
/// struct OpenApiDoc;
///
/// impl utoipa::OpenApi for OpenApiDoc {
///     fn openapi() -> utoipa::openapi::OpenApi {
///         use utoipa::{Component, Path};
///         utoipa::openapi::OpenApiBuilder::new()
///             .info(utoipa::openapi::InfoBuilder::new()
///                 .title("application name")
///                 .version("version")
///                 .description(Some("application description"))
///                 .license(Some(utoipa::openapi::License::new("MIT")))
///                 .contact(
///                     Some(utoipa::openapi::ContactBuilder::new()
///                         .name(Some("author name"))
///                         .email(Some("author email")).build()),
///             ).build())
///             .paths(utoipa::openapi::path::Paths::new())
///             .components(Some(utoipa::openapi::Components::new()))
///             .build()
///     }
/// }
/// ```
/// [derive]: derive.OpenApi.html
pub trait OpenApi {
    fn openapi() -> openapi::OpenApi;
}

/// Trait for implementing OpenAPI Schema object.
///
/// This trait is deriveable and can be used with `[#derive]` attribute. Fo


 : MainAPI() {
    override var mainUrl = "https://neonime.watch"
    override var name = "Neonime"
    override val hasQuickSearch = false
    override val hasMainPage = true
    override var lang = "id"
    override val hasDownloadSupport = true

    override val supportedTypes = setOf(
        TvType.Anime,
        TvType.AnimeMovie,
        TvType.OVA
    )

    companion object {
        fun getType(t: String): TvType {
            return if (t.contains("OVA") || t.contains("Special")) TvType.OVA
            else if (t.contains("Movie")) TvType.AnimeMovie
            else TvType.Anime
        }

        fun getStatus(t: String): ShowStatus {
            return when (t) {
                "Ended"  -> ShowStatus.Completed
                "OnGoing" -> ShowStatus.Ongoing
                "Ongoing" -> ShowStatus.Ongoing
                "In Production" -> ShowStatus.Ongoing
                "Returning Series" -> ShowStatus.Ongoing
                else -> ShowStatus.Completed
            }
        }
    }

    override val mainPage = mainPageOf(
        "$mainUrl/episode/page/" to "Episode Terbaru",
        "$mainUrl/tvshows/page/" to "Anime Terbaru",
        "$mainUrl/movies/page/" to "Movie",
    )

    override suspend fun getMainPage(page: Int, request: MainPageRequest): HomePageResponse {
        val document = app.get(request.data + page).document
        val home = document.select("tbody tr,div.item").mapNotNull {
                it.toSearchResult()
            }
        return newHomePageResponse(request.name, home)
    }

    private fun getProperAnimeLink(uri: String): String {
        return when {
            uri.contains("/episode") -> {
                val title = uri.substringAfter("$mainUrl/episode/").let { tt ->
                    val fixTitle = Regex("(.*)-\\d{1,2}x\\d+").find(tt)?.groupValues?.getOrNull(1).toString()
                    when {
                        !tt.contains("-season") && !tt.contains(Regex("-1x\\d+")) && !tt.contains("one-piece") -> "$fixTitle-season-${Regex("-(\\d{1,2})x\\d+").find(tt)?.groupValues?.getOrNull(1).toString()}"
                        tt.contains("-special") -> fixTitle.replace(Regex("-x\\d+"), "")
                        !fixTitle.contains("-subtitle-indonesia") -> "$fixTitle-subtitle-indonesia"
                        else -> fixTitle
                    }
                }

//                title = when {
//                    title.contains("youkoso-jitsuryoku") && !title.contains("-season") -> title.replace("-e-", "-e-tv-")
//                    else -> title
//                }

                "$mainUrl/tvshows/$title"
            }
            else -> uri
        }
    }

    private fun Element.toSearchResult(): AnimeSearchResponse? {
        val title = this.selectFirst("td.bb a")?.ownText() ?: this.selectFirst("h2")?.text() ?: return null
        val href = getProperAnimeLink(fixUrl(this.select("a").attr("href")))
        val posterUrl = fixUrl(this.select("img").attr("data-src"))
        val epNum = this.selectFirst("td.bb span")?.text()?.let { eps ->
            Regex("Episode\\s?([0-9]+)").find(eps)?.groupValues?.getOrNull(1)?.toIntOrNull()
        }

        return newAnimeSearchResponse(title, href, TvType.Anime) {
            this.posterUrl = posterUrl
            addSub(epNum)
        }

    }

    override suspend fun search(query: String): List<SearchResponse> {
        val link = "$mainUrl/?s=$query"
        val document = app.get(link).document

        return docume


sts
.as-para--typeset 						{ margin: 0 0 rhythm(2, $para) 0; }
.as-list--typeset 						{ margin: 0 0 rhythm(2, $para) 0; }

.as-unordered-list--typeset 			{ @extend .as-list--typeset; margin-left: 1em; @include unordered; }
.as-ordered-list--typeset 				{ @extend .as-unordered-list--typeset; @include ordered; }
.as-blockquote--typeset 				{ @extend .as-blockquote; margin: rhythm(6, $quote) 0; }

// Use on parent element to style elements within. E.g an article page
.is-typeset {
	.headline	{ @extend .as-heading__headline; 	@extend .as-heading__headline--typeset; }
	h1			{ @extend .as-heading__largest; 	@extend .as-heading__largest--typeset; }
	h2 			{ @extend .as-heading__large; 		@extend .as-heading__large--typeset; }
	h3			{ @extend .as-heading__medium; 		@extend .as-heading__medium--typeset; }
	h4 			{ @extend .as-heading__normal; 		@extend .as-heading__normal--typeset; }
	h5			{ @extend .as-heading__small; 		@extend .as-heading__small--typeset; }
	h6			{ @extend .as-heading__smallest; 	@extend .as-heading__smallest--typeset; }
	p 			{ @extend .as-para--typeset; }
	ol			{ @extend .as-ordered-list--typeset; }
	ul 			{ @extend .as-unordered-list--typeset; }
	li 			{ @extend .as-list--typeset; }
	blockquote 	{ @extend .as-blockquote--typeset; }
}

/* Tomorrow Night Theme */
/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
/* Original theme - https://github.com/chriskempson/tomorrow-theme */
/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */

/* Tomorrow Comment */
.hljs-comment {
  color: #969896;
}

/* Tomorrow Red */
.hljs-variable,
.hljs-attribute,
.hljs-tag,
.hljs-regexp,
.ruby .hljs-constant,
.xml .hljs-tag .hljs-title,
.xml .hljs-pi,
.xml .hljs-doctype,
.html .hljs-doctype,
.css .hljs-id,
.css .hljs-class,
.css .hljs-pseudo {
  color: #cc6666;
}

/* Tomorrow Orange */
.hljs-number,
.hljs-preprocessor,
.hljs-pragma,
.hljs-built_in,
.hljs-literal,
.hljs-params,
.hljs-constant {
  color: #de935f;
}

/* Tomorrow Yellow */
.ruby .hljs-class .hljs-title,
.css .hljs-rule .hljs-attribute {
  color: #f0c674;
}

/* Tomorrow Green */
.hljs-string,
.hljs-value,
.hljs-inheritance,
.hljs-header,
.hljs-name,
.ruby .hljs-symbol,
.xml .hljs-cdata {
  color: #b5bd68;
}

/* Tomorrow Aqua */
.hljs-title,
.css .hljs-hexcolor {
  color: #8abeb7;
}

/* Tomorrow Blue */
.hljs-function,
.python .hljs-decorator,
.python .hljs-title,
.ruby .hljs-function .hljs-title,
.ruby .hljs-title .hljs-keyword,
.perl .hljs-sub,
.javascript .hljs-title,
.coffeescript .hljs-title {
  color: #81a2be;
}

/* Tomorrow Purple */
.hljs-keyword,
.javascript .hljs


:
//!
//!- State is represented by counter, which is incremented to produce new value, hence making
//!it easy to predict how state would change.
//!- The code is short and simple, only taking minimum amount of operations to produce uniform output.
//!- `key` must have close to equal number of zeroes and ones for optimal output.
//!This crate provides single key for use, to have more see [gist](https://gist.githubusercontent.com/DoumanAsh/6e2b862242b7863c5119320ed5dae863/raw/2d17fd5937f158b62b8acdb4f5d590e310331b16/keys)

#![no_std]
#![warn(missing_docs)]

use core::sync::atomic::{AtomicU64, Ordering};

///Sample key to be used with algorithm
pub const KEY: u64 = 0x548c9decbce65297;

#[inline]
///Generates random number.
///
///- `counter` - Integer counter which acts as state. Should be increased to generate new
///number.
///- `key` - Integer which in general should be irregular bit pattern with approximately equal
///number of zeros and ones. Generally should be constant, but can be changed when new range of
///random numbers is required.
pub const fn rand(counter: u64, key: u64) -> u32 {
    let mut x = counter.wrapping_mul(key);
    let y = x;
    let z = y.wrapping_add(key);

    x = x.wrapping_mul(x).wrapping_add(y);
    x = (x >> 32) | (x << 32);

    x = x.wrapping_mul(x).wrapping_add(z);
    x = (x >> 32) | (x << 32);

    x = x.wrapping_mul(x).wrapping_add(y);
    x = (x >> 32) | (x << 32);

    (x.wrapping_mul(x).wrapping_add(z) >> 32) as u32
}

#[derive(Debug)]
///Stateful representation of algorithm.
///
///Increments counter on each generation using the same key.
pub struct Rand {
    counter: AtomicU64,
    key: u64,
}

impl Rand {
    #[inline(always)]
    ///Creates new instance with provided key.
    pub const fn new(key: u64) -> Self {
        Self::with_counter(0, key)
    }

    #[inline]
    ///Creates new instance with provided key and initial value of counter.
    pub const fn with_counter(counter: u64, key: u64) -> Self {
        Self {
            counter: AtomicU64::new(counter),
            key,
        }
    }

    #[inline]
    ///Sets new counter value, returning old one
    pub fn set_counter(&self, counter: u64) -> u64 {
        self.counter.swap(counter, Ordering::AcqRel)
    }

    #[inline]
    ///Gets current value of counter
    pub fn counter(&self) -> u64 {
        self.counter.load(Ordering::Acquire)
    }

    #[inline]
    ///Generates new `u32`
    pub fn next_u32(&self) -> u32 {
        rand(self.counter.fetch_add(1, Ordering::AcqRel), self.key)
    }

    #[inline]
    ///Generates new `u32` in range `0..to`
    pub fn next_u32_up(&self, to: u32) -> u32 {
        #[inline(always)]
        fn mul_high_u32(a: u32, b: u32) -> u32 {
            (((a as u64) * (b as u64)) >> 32) as u32
        }

        //https://lemire.me/blog/2016/06/30/fast-random-shuffling/
        let mut result = self.next_u32();
        let mut hi = mul_


/// <summary>
        /// Gets the area of an Extents3d.
        /// </summary>
        /// <param name="extents">The extents.</param>
        /// <returns>The area.</returns>
        [Obsolete("Use `.ToExtents2d().GetArea()` instead.")]
        public static double GetArea(this Extents3d extents) // newly 20130514
        {
            return (extents.MaxPoint.X - extents.MinPoint.X) * (extents.MaxPoint.Y - extents.MinPoint.Y);
        }

        /// <summary>
        /// Gets the area of an Extents2d.
        /// </summary>
        /// <param name="extents">The extents.</param>
        /// <returns>The area.</returns>
        public static double GetArea(this Extents2d extents) // newly 20130514
        {
            return (extents.MaxPoint.X - extents.MinPoint.X) * (extents.MaxPoint.Y - extents.MinPoint.Y);
        }

#endregion

#region Point algorithms

        /// <summary>
        /// Gets an empty Point3d
        /// </summary>
        public static Point3d NullPoint3d { get; } = new Point3d(double.NaN, double.NaN, double.NaN);

        /// <summary>
        /// Determines if a Point3d is empty.
        /// </summary>
        /// <param name="p">The point.</param>
        /// <returns>The result.</returns>
        public static bool IsNull(this Point3d p)
        {
            return double.IsNaN(p.X);
        }

        /// <summary>
        /// Converts Point3d to Point2d.
        /// </summary>
        /// <param name="point">The Point3d.</param>
        /// <returns>A Point2d.</returns>
        public static Point2d ToPoint2d(this Point3d point)
        {
            return new Point2d(point.X, point.Y);
        }

        /// <summary>
        /// Converts Point2d to Point3d.
        /// </summary>
        /// <param name="point">The Point2d.</param>
        /// <returns>A Point3d.</returns>
        public static Point3d ToPoint3d(this Point2d point)
        {
            return new Point3d(point.X, point.Y, 0);
        }

        /// <summary>
        /// Gets the convex hull of multiple points.
        /// </summary>
        /// <param name="source">The source collection.</param>
        /// <returns>The convex hull.</returns>
        public static List<Point3d> GetConvexHull(List<Point3d> source)
        {
            var points = new List<Point3d>();
            var collection = new List<Point3d>();
            var num = 0;
            source.Sort((p1, p2) => (p1.X - p2.X == 0) ? (int)(p1.Y - p2.Y) : (int)(p1.X - p2.X));

            points.Add(source[0]);
            points.Add(source[1]);
            for (num = 2; num <= (source.Count - 1); num++)
            {
                points.Add(source[num]);
                while ((points.Count >= 3) && !IsTurnRight(points[points.Count - 3], points[points.Count - 2], points[points.Count - 1]))
                {
                    points.RemoveAt(points.Count - 2);
                }
            }
            collection.Add(source[source.Count - 1]);
            collection.Add(source[source.Count - 2]);
            for (num = source.Count - 2; num >= 0; num--)
            {
                collection.Add(source[num]);
                while ((collection.Count >= 3) && !IsTurnRight(collection[collection.Count - 3], collection[collection.Count - 2], collection[collection.Count - 1]))
                {
                    collection.RemoveAt(collection.Count - 2);
                }


lated to remove the following dynos: %v\n", removeDynos)
	return removeDynos, allocatingNewDynos, nil
}

func (this *Deployment) syncNodes() ([]*Node, error) {
	type NodeSyncResult struct {
		node *Node
		err  error
	}

	syncStep := make(chan NodeSyncResult)
	for _, node := range this.Config.Nodes {
		go func(node *Node) {
			c := make(chan error, 1)
			go func() { c <- this.syncNode(node) }()
			go func() {
				time.Sleep(NODE_SYNC_TIMEOUT_SECONDS * time.Second)
				c <- fmt.Errorf("Sync operation to node '%v' timed out after %v seconds", node.Host, NODE_SYNC_TIMEOUT_SECONDS)
			}()
			// Block until chan has something, at which point syncStep will be notified.
			syncStep <- NodeSyncResult{node, <-c}
		}(node)
	}

	availableNodes := []*Node{}

	// Wait for all the syncs to finish or timeout, and collect available nodes.
	for _ = range this.Config.Nodes {
		syncResult := <-syncStep
		if syncResult.err == nil {
			availableNodes = append(availableNodes, syncResult.node)
		}
	}

	if len(availableNodes) == 0 {
		return availableNodes, fmt.Errorf("No available nodes. This is probably very bad for all apps running on this deployment system.")
	}
	return availableNodes, nil
}

func (this *Deployment) startDynos(availableNodes []*Node, titleLogger io.Writer) ([]Dyno, error) {
	// Now we've successfully sync'd and we have a list of nodes available to deploy to.
	addDynos := []Dyno{}

	dynoGenerator, err := this.Server.NewDynoGenerator(availableNodes, this.Application.Name, this.Version)
	if err != nil {
		return addDynos, err
	}

	type StartResult struct {
		dyno Dyno
		err  error
	}
	startedChannel := make(chan StartResult)

	startDynoWrapper := func(dynoGenerator *DynoGenerator, process string) {
		dyno, err := this.startDyno(dynoGenerator, process)
		startedChannel <- StartResult{dyno, err}
	}

	numDesiredDynos := 0

	// First deploy the changes and start the new dynos.
	for process, numDynos := range this.Application.Processes {
		for i := 0; i < numDynos; i++ {
			go startDynoWrapper(dynoGenerator, process)
			numDesiredDynos++
		}
	}

	if numDesiredDynos > 0 {
		timeout := time.After(DEPLOY_TIMEOUT_SECONDS * time.Second)
	OUTER:
		for {
			select {
			case result := <-startedChannel:
				if result.err != nil {
					// Then attempt start it again.
					fmt.Fprintf(titleLogger, "Retrying starting app dyno %v on host %v, failure reason: %v\n", result.dyno.Process, result.dyno.Host, result.err)
					go startDynoWrapper(dynoGenerator, result.dyno.Process)
				} else {
					addDynos = append(addDynos, result.dyno)
					if len(addDynos) == numDesiredDynos {
						fmt.Fprintf(titleLogger, "Successfully started app on %v total dynos\n", numDesiredDynos)
						break OUTER
					}
				}
			case <-timeout:
				return addDynos, fmt.Errorf("Start operation timed out after %v seconds", DEPLOY_TIMEOUT_SECONDS)
			}


uest failed, set the message for the user
      setLoading(false);
      setData(loginData);
    }
  };
};
/**
 * 玩家信息
 */
namespace models {
    export class UserItem {
        /**
         * 玩家数据
         */
        public dwGameID = 0;
        public dwUserID = 0;

        public wFaceID = 0;
        public dwCustomID = 0;

        public cbGender = df.GENDER_MANKIND;
        public cbMemberOrder = 0;

        private wTableID = df.INVALID_TABLE ;
        private wChairID = df.INVALID_CHAIR;
        public cbUserStatus = 0;

        public lGold = 0;
        public lScore = 0;

        public dwWinCount = 0;
        public dwLostCount = 0;
        public dwDrawCount = 0;
        public dwFleeCount = 0;
        public dwExperience = 0;

        public szNickName = "";
        public szExternUID = "";
        public szHeadURL = "";

        /**
         * 用户经纬度
         */
        public dGlobalPosLng = 0.0;
        public dGlobalPosLat = 0.0;

        /**
         * 构造拷贝
         */
        constructor(item?: UserItem) {
            if (null != item) {
                this.dwGameID = item.dwGameID;
                this.dwUserID = item.dwUserID;

                this.wFaceID = item.wFaceID;
                this.dwCustomID = item.dwCustomID;

                this.cbGender = item.cbGender;
                this.cbMemberOrder = item.cbMemberOrder;

                this.wTableID = item.wTableID;
                this.wChairID = item.wChairID;
                this.cbUserStatus = item.cbUserStatus;

                this.lScore = item.lScore;
                this.lGold = item.lGold;

                this.dwWinCount = item.dwWinCount;
                this.dwLostCount = item.dwLostCount;
                this.dwDrawCount = item.dwDrawCount;
                this.dwFleeCount = item.dwFleeCount;
                this.dwExperience = item.dwExperience;

                this.szNickName = item.szNickName;
                this.szHeadURL = item.szHeadURL;

                /**
                 * 用户经纬度
                 */
                this.dGlobalPosLng = item.dGlobalPosLng;
                this.dGlobalPosLat = item.dGlobalPosLat;
            }
        }

        public set TableID(wTableID: number) {
            this.wTableID = wTableID;
        }
        public get TableID() {
            return this.wTableID;
        }

        public set ChairID(wChairID: number) {
            this.wChairID = wChairID;
        }
        public get ChairID() {
            return this.wChairID;
        }

    }
}import { Events } from '#lib/types/Enums';
import { sleep } from '#utils/Promisified/sleep';
import { Time } from '@sapphire/time-utilities';
import { RESTJSONErrorCodes } from 'discord-api-types/v6';
import type { MessageOptions } from 'discord.js';
import { Message, Structures } from 'discord.js';

export class ArchAngelMessage extends Structures.get('Message') {
	public async nuke(time = 0): Promise<Message> {
		if (this.deleted) return this;
		if (time === 0) return this.nukeNow();

		const lastEditedTimestamp = this.editedTimestamp;
		await sleep(time);
		return !this.deleted && this.editedTimestamp === lastEditedTimestamp ? this.nukeNow() : (this as Message);
	}

	public async prompt(content: string, time = 30000


Provider", reflect.TypeOf((*MockProviderRegistry)(nil).StorageProvider), arg0)
	return &MockProviderRegistryStorageProviderCall{Call: call}
}

// MockProviderRegistryStorageProviderCall wrap *gomock.Call
type MockProviderRegistryStorageProviderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockProviderRegistryStorageProviderCall) Return(arg0 storage.Provider, arg1 error) *MockProviderRegistryStorageProviderCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockProviderRegistryStorageProviderCall) Do(f func(storage.ProviderType) (storage.Provider, error)) *MockProviderRegistryStorageProviderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockProviderRegistryStorageProviderCall) DoAndReturn(f func(storage.ProviderType) (storage.Provider, error)) *MockProviderRegistryStorageProviderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StorageProviderTypes mocks base method.
func (m *MockProviderRegistry) StorageProviderTypes() ([]storage.ProviderType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StorageProviderTypes")
	ret0, _ := ret[0].([]storage.ProviderType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StorageProviderTypes indicates an expected call of StorageProviderTypes.
func (mr *MockProviderRegistryMockRecorder) StorageProviderTypes() *MockProviderRegistryStorageProviderTypesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageProviderTypes", reflect.TypeOf((*MockProviderRegistry)(nil).StorageProviderTypes))
	return &MockProviderRegistryStorageProviderTypesCall{Call: call}
}

// MockProviderRegistryStorageProviderTypesCall wrap *gomock.Call
type MockProviderRegistryStorageProviderTypesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockProviderRegistryStorageProviderTypesCall) Return(arg0 []storage.ProviderType, arg1 error) *MockProviderRegistryStorageProviderTypesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockProviderRegistryStorageProviderTypesCall) Do(f func() ([]storage.ProviderType, error)) *MockProviderRegistryStorageProviderTypesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockProviderRegistryStorageProviderTypesCall) DoAndReturn(f func() ([]storage.ProviderType, error)) *MockProviderRegistryStorageProviderTypesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
// Copyright 2025 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.

package service

import (
	"testing"

	"github.com/juju/tc"
	"go.uber.org/mock/gomock"

	"github.com/juju/juju/core/errors"
	modeltesting "github.com/juju/juju/core/model/testing"
	corestorage "github.com/juju/juju/core/storage"
	domainstorage "github.com/juju/juju/domain/storage"
	storageerrors "github.com/juju/juju/domain/storage/errors"
	loggertesting "github.com/juju/juju/internal/logger/testing"
	"github.com/juju/juju/internal/storage"
	"github.com/juju/juju/internal/testhe


.symmetric(
                    horizontal: 32,
                    vertical: 16,
                  ),
                  shape: RoundedRectangleBorder(
                    borderRadius: BorderRadius.circular(30),
                  ),
                ),
                child: const Text(
                  'Add to Cart',
                  style: TextStyle(fontSize: 18),
                ),
              ),
            ),
          ),
        ],
      ),
    );
  }
}
import 'dart:async';

import 'package:candy_store/cart_info.dart';
import 'package:candy_store/cart_list_item.dart';
import 'package:candy_store/cart_repository.dart';
import 'package:candy_store/product_list_item.dart';

class InMemoryCartRepository implements CartRepository {
  CartInfo _cartInfo = CartInfo(
    items: {},
    totalPrice: 0,
    totalItems: 0,
  );

  CartInfo get cartInfo => _cartInfo;

  final StreamController<CartInfo> _cartInfoController =
  StreamController<CartInfo>.broadcast();

  @override
  Stream<CartInfo> get cartInfoStream => _cartInfoController.stream;

  @override
  Future<CartInfo> get cartInfoFuture async => _cartInfo.copyWith(
    items: Map.unmodifiable(_cartInfo.items),
  );

  @override
  Future<void> addToCart(ProductListItem item) async {
    await Future.delayed(const Duration(seconds: 3));
    CartListItem? existingItem = _cartInfo.items[item.id];
    if (existingItem != null) {
      existingItem = CartListItem(
        product: existingItem.product,
        quantity: existingItem.quantity + 1,
      );
      _cartInfo.items[item.id] = existingItem;
    } else {
      final cartItem = CartListItem(
        product: item,
        quantity: 1,
      );
      _cartInfo.items[item.id] = cartItem;
    }
    _cartInfo.totalItems++;
    _cartInfo.totalPrice += item.price;

    final cartInfo = _cartInfo.copyWith(
      items: Map.unmodifiable(_cartInfo.items),
    );

    _cartInfoController.add(cartInfo);
  }

  @override
  Future<void> removeFromCart(CartListItem item) async {
    await Future.delayed(const Duration(seconds: 3));
    // throw Exception('Could not remove item from cart')
    CartListItem? existingItem = _cartInfo.items[item.product.id];
    if (existingItem != null) {
      if (existingItem.quantity > 1) {
        existingItem = CartListItem(
          product: existingItem.product,
          quantity: existingItem.quantity - 1,
        );
        _cartInfo.items[item.product.id] = existingItem;
      } else {
        _cartInfo.items.remove(item.product.id);
      }
    }
    _cartInfo.totalItems--;
    _cartInfo.totalPrice -= item.product.price;

    final cartInfo = _cartInfo.copyWith(
      items: Map.unmodifiable(_cartInfo.items),
    );

    _cartInfoController.add(cartInfo);
  }

  void dispose() {
    _cartInfoController.close();
  }
}
import 'package:flutter_driver/flutter_driver.dart';
import 'package:test/test.dart';

void main() {
  group('Drinks Test', () {

    FlutterDriver driver;

    final teaTypeFinder = find.byValueKey('Tea_drink_type');
    final blackTeaCardFinder = find.byValueKey('


FirstAndAfter))
	}
}

func Test_DDLCheckBigintInsteadOfDecimal(t *testing.T) {
	rule := rulepkg.RuleHandlerMap[rulepkg.DDLCheckBigintInsteadOfDecimal].Rule

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"create table t1(id_next decimal(10,2),id int,total_money decimal)",
		newTestResult().addResult(rulepkg.DDLCheckBigintInsteadOfDecimal, "id_next,total_money"))

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"create table t1(total_money decimal,remain_money decimal,id int)",
		newTestResult().addResult(rulepkg.DDLCheckBigintInsteadOfDecimal, "total_money,remain_money"))

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(), "create table t1(remain_money bigint)",
		newTestResult())

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"alter table exist_db.exist_tb_2 modify column total_money decimal",
		newTestResult().addResult(rulepkg.DDLCheckBigintInsteadOfDecimal, "total_money"))

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"alter table exist_db.exist_tb_2 modify column total_money bigint",
		newTestResult())

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"alter table exist_db.exist_tb_2 add column remain_money decimal",
		newTestResult().addResult(rulepkg.DDLCheckBigintInsteadOfDecimal, "remain_money"))

	runSingleRuleInspectCase(rule, t, "", DefaultMysqlInspect(),
		"alter table exist_db.exist_tb_2 change column id old_money decimal",
		newTestResult().addResult(rulepkg.DDLCheckBigintInsteadOfDecimal, "old_money"))
}

func Test_PerfectParse(t *testing.T) {
	runSingleRuleInspectCase(rulepkg.RuleHandlerMap[rulepkg.DMLCheckWhereIsInvalid].Rule, t, "", DefaultMysqlInspect(), `
SELECT * FROM exist_db.exist_tb_1;
OPTIMIZE TABLE exist_db.exist_tb_1;
SELECT * FROM exist_db.exist_tb_2;
`, newTestResult().addResult(rulepkg.DMLCheckWhereIsInvalid),
		newTestResult().add(driverV2.RuleLevelWarn, "", "语法错误或者解析器不支持，请人工确认SQL正确性"),
		newTestResult().addResult(rulepkg.DMLCheckWhereIsInvalid))
}

func Test_DDLCheckCreateView(t *testing.T) {
	for _, sql := range []string{
		`create view v as select * from t1`,
	} {
		runSingleRuleInspectCase(rulepkg.RuleHandlerMap[rulepkg.DDLCheckCreateView].Rule, t, "", DefaultMysqlInspect(), sql, newTestResult().addResult(rulepkg.DDLCheckCreateView))
	}

	for _, sql := range []string{
		`create table t1(id int)`,
	} {
		runSingleRuleInspectCase(rulepkg.RuleHandlerMap[rulepkg.DDLCheckCreateView].Rule, t, "", DefaultMysqlInspect(), sql, newTestResult())
	}
}

func Test_DDLCheckCreateTrigger(t *testing.T) {
	for _, sql := range []string{
		`create trigger my_trigger before insert on t1 for each row insert into t2(id, c1) values(1, '2');`,
		`CREATE TRIGGER my_


getAndroidId()
        playbook.authorize(any())
        srsSubmissionSettings.setOtp(any())
        tekCalculations.transformToKeyHistoryInExternalFormat(any(), any())
        checkInsRepo.completedCheckIns
        checkInsTransformer.transform(any(), any())
        playbook.submit(any())
        checkInsRepo.updatePostSubmissionFlags(any<List<CheckIn>>())
        timeStamper.nowUTC
        submissionReporter.reportAt(any())
        srsSubmissionSettings.resetOtp()
        analyticsSrsKeySubmissionRepository.collectSrsSubmissionAnalytics(any(), any())
    }

    private fun instance() = SrsSubmissionRepository(
        playbook = playbook,
        appConfigProvider = appConfigProvider,
        tekCalculations = tekCalculations,
        checkInsRepo = checkInsRepo,
        checkInsTransformer = checkInsTransformer,
        deviceAttestation = deviceAttestation,
        srsSubmissionSettings = srsSubmissionSettings,
        androidIdProvider = androidIdProvider,
        timeStamper = timeStamper,
        submissionReporter = submissionReporter,
        srsDevSettings = srsDevSettings,
        analyticsSrsKeySubmissionRepository = analyticsSrsKeySubmissionRepository
    )
}
package de.rki.coronawarnapp.covidcertificate.signature.core

import de.rki.coronawarnapp.SecurityProvider
import de.rki.coronawarnapp.covidcertificate.DaggerCovidCertificateTestComponent
import de.rki.coronawarnapp.covidcertificate.common.certificate.DccQrCodeExtractor
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_EXPIRED
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_NOT_YET_VALID
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_NO_MATCH
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_OID_MISMATCH_RC
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_OID_MISMATCH_TC
import de.rki.coronawarnapp.covidcertificate.common.exception.InvalidHealthCertificateException.ErrorCode.HC_DSC_OID_MISMATCH_VC
import de.rki.coronawarnapp.server.protocols.internal.dgc.DscListOuterClass.DscList
import de.rki.coronawarnapp.util.toOkioByteString
import io.kotest.assertions.throwables.shouldNotThrow
import io.kotest.assertions.throwables.shouldThrow
import io.kotest.matchers.s


 you use absolute paths in imports inside large monorepos:
// https://github.com/facebook/create-react-app/issues/253.
// It works similar to `NODE_PATH` in Node itself:
// https://nodejs.org/api/modules.html#modules_loading_from_the_global_folders
// Note that unlike in Node, only *relative* paths from `NODE_PATH` are honored.
// Otherwise, we risk importing Node.js core modules into an app instead of Webpack shims.
// https://github.com/facebook/create-react-app/issues/1023#issuecomment-265344421
// We also resolve them to make sure all tools using them work consistently.
const appDirectory = fs.realpathSync(process.cwd());
process.env.NODE_PATH = (process.env.NODE_PATH || '')
  .split(path.delimiter)
  .filter(folder => folder && !path.isAbsolute(folder))
  .map(folder => path.resolve(appDirectory, folder))
  .join(path.delimiter);

// Grab NODE_ENV and REACT_APP_* environment variables and prepare them to be
// injected into the application via DefinePlugin in Webpack configuration.
const REACT_APP = /^REACT_APP_/i;

function getClientEnvironment(publicUrl) {
  const raw = Object.keys(process.env)
    .filter(key => REACT_APP.test(key))
    .reduce(
      (env, key) => {
        env[key] = process.env[key];
        return env;
      },
      {
        // Useful for determining whether we’re running in production mode.
        // Most importantly, it switches React into the correct mode.
        NODE_ENV: process.env.NODE_ENV || 'development',
        // Useful for resolving the correct path to static assets in `public`.
        // For example, <img src={process.env.PUBLIC_URL + '/img/logo.png'} />.
        // This should only be used as an escape hatch. Normally you would put
        // images into the `src` and `import` them in code to get their paths.
        PUBLIC_URL: publicUrl,
      }
    );
  // Stringify all values so we can feed into Webpack DefinePlugin
  const stringified = {
    'process.env': Object.keys(raw).reduce((env, key) => {
      env[key] = JSON.stringify(raw[key]);
      return env;
    }, {}),
  };

  return { raw, stringified };
}

module.exports = getClientEnvironment;
'use strict';

// Do this as the first thing so that any code reading it knows the right env.
process.env.BABEL_ENV = 'production';
process.env.NODE_ENV = 'production';

// Makes the script crash on unhandled rejections instead of silently
// ignoring them. In the future, promise rejections that are not handled will
// terminate the Node.js process with a non-zero exit code.
process.on('unhandledRejection', err => {
  throw err;
});

// Ensure environment variables are read.
require('../config/env');

const path = require('path');
const chalk = require('react-dev-utils/chalk');
const fs = require('fs-extra');
const webpack = require('webpack');
const configFactory = require('../config/webpack.config');
const paths = require('../config/paths');
const checkRequiredFiles = require('react-dev-utils/checkRequiredFiles');
const formatWebpackMessages = require('react-dev-utils/formatWebpackMessages');
const printHostingInstructions = require('react-dev-utils/printHostingInstructions');
const FileSizeReporter = require('react-dev-utils/FileSizeReporter');
const printBuildError = require('react-dev-utils/printBuildError');

const measureFileSizesBeforeBuild =
  FileSizeReporter.measureFileSizesBeforeBuild;
const printFileSizesAfterBuild = FileSizeReporter.printFileSizesAfterBuild;
const useYarn = fs.existsSync(paths.yarnLockFile);

//


teCommand_DrawVert
  db $70,$71

  db $21,$83
  db $02.VRAMWriteCommand_DrawVert
  db $72,$73

  db $21,$1D
  db $82.VRAMWriteCommand_DrawVert
  db $6E,$6F

  db $21,$4E
  db $10.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $74

  db $21,$4F
  db $10.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $75

  db VRAMWriteCommand_Stop

  ;VRAM Data for title screen (palettes, attributes and tiles)
Layout_TitleScreen_F8D9

  ;Palette
  db $3F,$00					;VRAM pos to write to
  db $0D						;write 13 bytes

;  If Version = JP
;    db $0F,$2C,$38,$02				;tile palette 0
;  else
    db $0F,$2C,$38,$12 				;US (or revision 1) Version brightens "Donkey Kong" title
;  endif
  db $0F,$27,$27,$27				;tile palette 1
  db $0F,$30,$30,$30				;tile palette 2
  db $0F						;so, you're telling me that palette 3 has only a single color update?

  db $3F,$11					;next location
  db $01						;a single byte of update (sprite palette 0, used for cursor)
  db $25						;

  db $23,$E0
  db $10.VRAMWriteCommand_Repeat			;16 bytes of repeated update
  db $55

  db $23,$F0
  db $08.VRAMWriteCommand_Repeat
  db $AA

  ;from here actually draw title screen
  db $20,$83
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$84
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$85
  db $01
  db $62

  db $21,$05
  db $01
  db $62

  db $20,$A6
  db $03.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$88
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$89
  db $01
  db $62

  db $21,$09
  db $01
  db $62

  db $20,$8A
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$8C
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$AD
  db $C2
  db $62

  db $20,$CE
  db $02.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$8F
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$91
  db $05.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$B2
  db $02.VRAMWriteCommand_Repeat.VRAMWriteCommand_DrawVert
  db $62

  db $20,$B3
  db $01
  db $62

  db $


//
//     Generated by class-dump 3.5 (64 bit).
//
//     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//

#import "NSObject.h"

#import "IDEAnalysisToolService.h"

@class DVTFileDataType, DVTFilePath, IDEAnalysisTool, IDELaunchParametersSnapshot, IDERunDestination, NSMutableDictionary, NSString;

@interface XRXcodeAnalysisService : NSObject <IDEAnalysisToolService>
{
    DVTFileDataType *_runnableUTIType;
    id _runnableLocation;
    DVTFilePath *_runnableBuildProductPath;
    IDERunDestination *_runDestination;
    int _pidForAttaching;
    NSString *_appNameForAttaching;
    IDEAnalysisTool *_currentTool;
    NSMutableDictionary *_currentToolForPlatformDict;
    IDEAnalysisTool *_analysisTool;
    IDELaunchParametersSnapshot *_launchParameters;
}

+ (id)_apppleInternalTemplatesPath;
+ (id)_homePrefsTemplatesPath;
+ (id)_instrumentsAppTemplatesPath;
+ (id)_platformsPath;
+ (id)_developerAppsPath;
+ (id)_analysisToolsForPlugin:(id)arg1 platform:(id)arg2;
+ (id)_analysisToolsForPlatform:(id)arg1;
+ (id)_analysisToolsDictForAllPlatforms;
+ (id)_analysisToolsAtPath:(id)arg1 type:(int)arg2;
+ (id)sharedPlatformToAnalysisToolsMap;
+ (id)_sharedGraphicsDetectiveTool;
+ (id)_anyPlatformID;
+ (id)_graphicsPerformanceDetectivePath;
+ (id)analysisToolWithIdentifier:(id)arg1 platformIdentifier:(id)arg2;
+ (id)analysisToolsForPlatformIdentifier:(id)arg1;
+ (void)addUniqueTools:(id)arg1 toArray:(id)arg2;
@property(copy) DVTFilePath *runnableLocation; // @synthesize runnableLocation=_runnableLocation;
@property(copy) DVTFilePath *runnableBuildProductPath; // @synthesize runnableBuildProductPath=_runnableBuildProductPath;
@property(copy) IDERunDestination *runDestination; // @synthesize runDestination=_runDestination;
@property(retain) IDELaunchParametersSnapshot *launchParameters; // @synthesize launchParameters=_launchParameters;
- (void).cxx_destruct;
- (void)setAttachRunnablePID:(int)arg1 applicationName:(id)arg2;
- (id)operationWithWorkingDirectory:(id)arg1 workspaceFilePath:(id)arg2 projectFilePath:(id)arg3 outError:(id *)arg4;
- (CDUnknownBlockType)_operationBlockWithWorkingDirectory:(id)arg1 workspaceFilePath:(id)arg2 projectFilePath:(id)arg3;
- (void)_launch:(id)arg1 WithConfigFile:(id)arg2;
- (id)_analysisAppPathForType:(int)arg1;
- (id)_instrumentsPath;
@property(retain) IDEAnalysisTool *analysisTool; // @synthesize analysisTool=_analysisTool;
- (id)_currentToolForPlatformDict;
- (id)_currentPlatformIdentifier;
- (id)initWithRunnableUTIType:(id)arg1;

// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;

@end


            duration: 650,
            yoyo: true,
            repeat: -1
        })
        this.player2Tween = this.tweens.add({
            targets: this.player2Text,
            scaleX: 1.05,
            scaleY: 1.05,
            ease: 'Cubic.easeInOut',
            duration: 650,
            yoyo: true,
            repeat: -1
        })
        this.player2Tween.pause()
    }

    public update(): void {
        this.bgtile.tilePositionX += 4

        for (let joystick of (this.game as RuimteGruis).Arcade.Joysticks) {
            joystick.update()
            if      (joystick.Left)     this.switchPlayerMode(1)
            else if (joystick.Right)    this.switchPlayerMode(2)
        }

        // spacebar start
        if (this.cursors.space.isDown) {
            this.nextGame()
        }

        // Select single player or two player game
        if (this.cursors.left.isDown) {
            this.switchPlayerMode(1)
        }
        else if (this.cursors.right.isDown) {
            this.switchPlayerMode(2)
        }
    }

    private  switchPlayerMode(players: number) {

        switch(players) {
            case 1:
                this.player1Text.setColor('rgb(221,48,212)')
                this.player2Text.setColor('#FFF')

                this.player1Tween.resume()
                this.player2Tween.pause()
                // switch setting / config / mode number of players
                this.mode = Mode.Single
                break;
            case 2:
                this.player1Text.setColor('#FFF')
                this.player2Text.setColor('rgb(221,48,212)')

                this.player1Tween.pause()
                this.player2Tween.resume()
                this.mode = Mode.TwoPlayer
                break;
        }

    }

    private nextGame() {
        this.registry.set("mode", this.mode)
        // this.registry.set("bombs", 3)
        // this.registry.set("life", 300)
        for (let i = 0; i <= this.mode; i++) {
            let player = new Player(i);
            (this.game as RuimteGruis).Player = player
        }

        document.removeEventListener("joystick0button0", this.nextGameListener)
        document.removeEventListener("joystick1button0", this.nextGameListener)

        this.scene.start('GameScene')
    }
}

export enum Mode {
    Single      = 0,
    TwoPlayer   = 1
}

const intitalState = {
    contacts: {
        isLoading: null,
        error: null,
        data: null
    }

}

type Action = {
    type: string,
    payload: string[]
}

const contactsReducer = (state = intitalState, action: Action) => {
    const { type, payload } = action
    switch(type) {
        case "GET ALL CONTACTS REQUEST":
            return {...state, contacts: {
                isloading: true,
                error:null,
                data:null
            }
        }
        case "GET ALL CONTACTS SUCCESS":
            return {...state, contacts: {
                isloading:false,
                error: false,
                data: payload
            }
        }
        case "GET ALL CONTACTS FAIL":
            return {...state, contacts: {
                isLoading: false,
                error: payload,
                data: false
            }}
        default:
            return state
        }

}

export d


orld, m_prevLocalToWorld);
			}
			if (starting || !m_wasVisible)
			{
				m_prevLocalToWorld = m_currLocalToWorld;
			}
			m_wasVisible = m_meshRenderer.isVisible;
		}

		internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, Quality quality)
		{
			if (!m_initialized || m_error || !m_meshRenderer.isVisible)
			{
				return;
			}
			bool flag = ((int)m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
			if (flag && (!flag || !m_moved))
			{
				return;
			}
			int num = (flag ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255);
			Matrix4x4 value = ((!m_obj.FixedStep) ? (m_owner.PrevViewProjMatrixRT * (Matrix4x4)m_prevLocalToWorld) : (m_owner.PrevViewProjMatrixRT * (Matrix4x4)m_currLocalToWorld));
			renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", value);
			renderCB.SetGlobalFloat("_AM_OBJECT_ID", (float)num * 0.003921569f);
			renderCB.SetGlobalFloat("_AM_MOTION_SCALE", flag ? scale : 0f);
			int num2 = ((quality != Quality.Mobile) ? 2 : 0);
			for (int i = 0; i < m_sharedMaterials.Length; i++)
			{
				MaterialDesc materialDesc = m_sharedMaterials[i];
				int shaderPass = num2 + (materialDesc.coverage ? 1 : 0);
				if (materialDesc.coverage)
				{
					Texture mainTexture = materialDesc.material.mainTexture;
					if (mainTexture != null)
					{
						materialDesc.propertyBlock.SetTexture("_MainTex", mainTexture);
					}
					if (materialDesc.cutoff)
					{
						materialDesc.propertyBlock.SetFloat("_Cutoff", materialDesc.material.GetFloat("_Cutoff"));
					}
				}
				renderCB.DrawMesh(m_mesh, m_transform.localToWorldMatrix, m_owner.Instance.SolidVectorsMaterial, i, shaderPass, materialDesc.propertyBlock);
			}
		}
	}
}


PROTO_0:
  NEWTABLE R1 1 0
  SETTABLEKS R0 R1 K0 ["__networking"]
  GETUPVAL R4 0
  FASTCALL2 SETMETATABLE R1 R4 [+4]
  MOVE R3 R1
  GETIMPORT R2 K2 [setmetatable]
  CALL R2 2 1
  RETURN R2 1

PROTO_1:
  GETTABLEKS R3 R0 K0 ["__networking"]
  LOADK R6 K1 ["voice"]
  LOADK R8 K2 ["/v1/settings/universe/"]
  MOVE R9 R1
  CONCAT R7 R8 R9
  DUPTABLE R8 K4 [{"Body"}]
  SETTABLEKS R2 R8 K3 ["Body"]
  NAMECALL R4 R3 K5 ["post"]
  CALL R4 4 -1
  RETURN R4 -1

PROTO_2:
  GETTABLEKS R3 R0 K0 ["__networking"]
  LOADK R6 K1 ["voice"]
  LOADK R8 K2 ["/v1/settings/universe/avatarvideo/"]
  MOVE R9 R1
  CONCAT R7 R8 R9
  DUPTABLE R8 K4 [{"Body"}]
  SETTABLEKS R2 R8 K3 ["Body"]
  NAMECALL R4 R3 K5 ["post"]
  CALL R4 4 -1
  RETURN R4 -1

PROTO_3:
  GETTABLEKS R2 R0 K0 ["__networking"]
  LOADK R5 K1 ["voice"]
  LOADK R7 K2 ["/v1/settings/universe/"]
  MOVE R8 R1
  CONCAT R6 R7 R8
  NAMECALL R3 R2 K3 ["get"]
  CALL R3 3 -1
  RETURN R3 -1

PROTO_4:
  GETTABLEKS R1 R0 K0 ["__networking"]
  LOADK R4 K1 ["voice"]
  LOADK R5 K2 ["/v1/settings"]
  NAMECALL R2 R1 K3 ["get"]
  CALL R2 3 -1
  RETURN R2 -1

PROTO_5:
  NAMECALL R1 R0 K0 ["voiceUserSettingsGET"]
  CALL R1 1 1
  NAMECALL R1 R1 K1 ["await"]
  CALL R1 1 1
  GETTABLEKS R3 R1 K2 ["responseBody"]
  GETTABLEKS R2 R3 K3 ["isAvatarChatEnabled"]
  RETURN R2 1

PROTO_6:
  GETIMPORT R0 K1 [game]
  LOADK R2 K2 ["VoiceChatService"]
  NAMECALL R0 R0 K3 ["GetService"]
  CALL R0 2 1
  GETIMPORT R1 K1 [game]
  LOADK R3 K4 ["ServiceVisibilityService"]
  NAMECALL R1 R1 K3 ["GetService"]
  CALL R1 2 1
  MOVE R4 R0
  LOADB R5 1
  NAMECALL R2 R1 K5 ["SetServiceVisibilityPreference"]
  CALL R2 3 0
  RETURN R0 0

PROTO_7:
  MOVE R4 R1
  NAMECALL R2 R0 K0 ["voiceUniverseSettingsGET"]
  CALL R2 2 1
  NAMECALL R2 R2 K1 ["await"]
  CALL R2 1 1
  DUPTABLE R3 K4 [{"audioEnabled", "videoEnabled"}]
  GETTABLEKS R5 R2 K5 ["responseBody"]
  GETTABLEKS R4 R5 K6 ["isUniverseEnabledForVoice"]
  SETTABLEKS R4 R3 K2 ["audioEnabled"]
  GETTABLEKS R5 R2 K5 ["responseBody"]
  GETTABLE


it-text-decoration:none;text-decoration:none;} .oNgpa:hover,.oNgpa:focus{color:#FEFEFE;} .oNgpa:hover{color:#FEFEFE;-webkit-text-decoration:none;text-decoration:none;}
/* sc-component-id: sc-jtRlXQ */
.hiZBuY{margin-left:8px;font-family:CNN,"Helvetica Neue",Helvetica,Arial,Utkal,sans-serif;-webkit-font-smoothing:antialiased;font-weight:400;margin-left:0;font-size:15px;} @media (max-width:480px){.hiZBuY{font-size:18px;}}
/* sc-component-id: sc-global-3896621741 */
body,body.pg-error-page{padding-top:40px;}

/* sc-component-id: Box-sc-1fet97o-0 */
.bQmsQJ{display:none;margin-left:8px;} @media screen and (min-width:1024px){.bQmsQJ{display:block;}}.fyifOt{display:block;} @media screen and (min-width:1024px){.fyifOt{display:none;}}.fAJFBm{padding:0px;}.cApVqV{margin-top:24px;margin-bottom:24px;}
/* sc-component-id: Cell-i0zvfi-0 */
.laaVcq{height:100%;min-width:0;margin-bottom:32px;grid-column-end:span 4;} @media screen and (min-width:768px){.laaVcq{grid-column-end:span 8;}} @media screen and (min-width:1024px){.laaVcq{grid-column-end:span 12;}}.dxrNOP{height:100%;min-width:0;grid-column-end:span 4;} @media screen and (min-width:768px){.dxrNOP{grid-column-end:span 8;}} @media screen and (min-width:1024px){.dxrNOP{grid-column-end:span 12;}}
/* sc-component-id: Grid-sc-1kcyc0j-0 */
.hFujui{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));grid-auto-flow:row;grid-auto-rows:minmax(0,auto);grid-gap:16px;height:auto;margin-left:16px;margin-right:16px;margin-top:0px;margin-bottom:0px;} @media screen and (min-width:768px){.hFujui{grid-template-columns:repeat(8,minmax(0,1fr));}} @media screen and (min-width:1024px){.hFujui{grid-template-columns:repeat(12,minmax(0,1fr));}} @media screen and (min-width:768px){.hFujui{grid-gap:24px;}} @media screen and (min-width:1024px){.hFujui{grid-gap:32px;}} @media screen and (min-width:768px){.hFujui{max-width:720px;}} @media screen and (min-width:1024px){.hFujui{max-width:964px;}} @media screen and (min-width:1280px){.hFujui{max-width:1248px;}} @media screen and (min-width:768px){.hFujui{margin-left:auto;margin-right:auto;}}
/* sc-component-id: Text-sc-1amvtpj-0 */
.gYetWy{color:inherit;font-weight:700;line-height:inherit;margin:0px;font-family:CNN,"Helvetica Neue",Helvetica,Arial,Utkal,sans-serif;-webkit-font-smoothing:antialiased;} @media screen and (min-width:1024px){.gYetWy{font-size:14px;}}
/* sc-component-id: Text-sc-1amvtpj-0-span */
.jKFEoX{font-size:12px;font-weight:700;-webkit-letter-spacing


: 400;
    font-display: swap;
    src: url('//s1.hdslb.com/bfs/static/jinkela/long/font/HarmonyOS_Regular.ao.woff2') format('woff2');
    unicode-range: U+5c7f, U+5c81-5c82, U+5c8c, U+5c94, U+5c96-5c97, U+5c9a-5c9b, U+5ca9, U+5cad, U+5cb3, U+5cb8,
        U+5cbf, U+5ccb, U+5cd9, U+5ce1, U+5ce5-5ce6, U+5ce8, U+5cea, U+5ced, U+5cf0, U+5cfb, U+5d02, U+5d07, U+5d0e,
        U+5d14, U+5d16, U+5d1b, U+5d24, U+5d29, U+5d2d, U+5d34, U+5d3d, U+5d4c, U+5d58, U+5d6c, U+5d82, U+5d99, U+5dc5,
        U+5dcd, U+5ddd-5dde, U+5de1-5de2, U+5de5-5de9, U+5deb, U+5dee, U+5df1-5df4, U+5df7, U+5dfe, U+5e01-5e03,
        U+5e05-5e06, U+5e08, U+5e0c, U+5e10-5e11, U+5e15-5e16, U+5e18, U+5e1a-5e1d, U+5e26-5e27, U+5e2d-5e2e,
        U+5e37-5e38, U+5e3c-5e3d, U+5e42, U+5e44-5e45, U+5e4c, U+5e54-5e55, U+5e61-5e62, U+5e72-5e74, U+5e76, U+5e78,
        U+5e7a-5e7d;
}

@font-face {
    font-family: 'HarmonyOS_Regular';
    font-style: normal;
    font-weight: 400;
    font-display: swap;
    src: url('//s1.hdslb.com/bfs/static/jinkela/long/font/HarmonyOS_Regular.ap.woff2') format('woff2');
    unicode-range: U+5b85, U+5b87-5b89, U+5b8b-5b8c, U+5b8f, U+5b95, U+5b97-5b9e, U+5ba0-5ba4, U+5ba6, U+5baa-5bab,
        U+5bb0, U+5bb3-5bb6, U+5bb9, U+5bbd-5bbf, U+5bc2, U+5bc4-5bc7, U+5bcc, U+5bd0, U+5bd2-5bd3, U+5bdd-5bdf, U+5be1,
        U+5be4-5be5, U+5be8, U+5bf0, U+5bf8-5bfc, U+5bff, U+5c01, U+5c04, U+5c06, U+5c09-5c0a, U+5c0f, U+5c11, U+5c14,
        U+5c16, U+5c18, U+5c1a, U+5c1d, U+5c24, U+5c27, U+5c2c, U+5c31, U+5c34, U+5c38-5c3a, U+5c3c-5c42, U+5c45,
        U+5c48-5c4b,


rrain::Node *nodes = renderTerrain->GetNodes();
				cdc::Vector3 center{nodes->center[0], nodes->center[1], nodes->center[2]};
				cdc::Vector3 extents{nodes->extents[0], nodes->extents[1], nodes->extents[2]};

				cdc::CullingBox box;
				box.SetFromCenterAndExtents(center, extents);

				cdc::BasicCullingVolume cullingVolume;
				cullingVolume.m_data.box = box;
				cullingVolume.m_type = cdc::kVolumeBox;

				cullingVolume.Transform(instanceMatrix);
				visible = cdc::Intersects(cullingVolume, cullingFrustum);
			}

			if (visible) {
				cdc::IRenderTerrain::Node *nodes = renderTerrain->GetNodes();
				fbs.push_back(FloatingButton{
						{nodes->center[0], nodes->center[1], nodes->center[2], 1},
						"[render terrain]",
						{.renderTerrain=renderTerrain}
					});
				static_cast<cdc::PCDX11RenderTerrain*>(renderTerrain)->hackDraw(rti, &instanceMatrix);
			}
		};

		// draw cells
		for (auto& unit : StreamTracker) {
			if (!unit.used)
				continue;

			cdc::Level *level = unit.level;
			if (!level)
				continue;

			cdc::CellGroupData *cellGroupData = level->pSceneData;
			if (!cellGroupData)
				continue;

			uint32_t numCells = cellGroupData->header->numTotalCells;
			for (uint32_t i=0; i < numCells; i++) {
				cdc::CellData *cell = cellGroupData->cells[i];

				// draw streamgroup meshes
				if (cell->pHeader && drawStreamGroups) {
					cdc::CellStreamGroupData *streamgroup = cell->pHeader->streamGroup50;
					if (streamgroup && streamgroup->resolveObject && isLoaded(streamgroup->resolveObject)) {
						dtp::IntermediateMesh *im = cdc::GetIMFPointerFromId(cell->pHeader->streamGroupDtp54);
						if (im && im->m_type == cdc::IMFType_TerrainInstance) {
							auto *rt = (cdc::IRenderTerrain *)im->pRenderModel;
							putTerrain(rt, cdc::identity4x4);
						}
					}
				}

				// draw renderterrain
				if (cell->pTerrainData && drawCellMeshes) {
					cdc::IRenderTerrain *rt = cell->pTerrainData->pTerrain;
					putTerrain(rt, cdc::identity4x4);
				}

				// draw rendermesh (these are for occlusion culling only, presumably)
				if (cell->renderMesh && drawCellBoxes) {
					auto *cellRMIDrawable = new RMIDrawableBase(cell->renderMesh);
					recycleRMI.emplace_back(cellRMIDrawable);
					auto *rmi = static_cast<cdc::PCDX11RenderModelInstance*>(cellRMIDrawable->rmi);
					rmi->baseMask = 0x1002; // normals & composite
					rmi->accessInstanceData()->instanceParams[0] = { // assign a distinguishable color for this cell
						halton[i].x,
						halton[i].y,
						halton[i].z,
						1.0f
					};
					cellRMIDrawable


 in key
    const_cast<uint8_t*>(kExternalHmacTestCase0Key),   // Key
    8,                                                 // Octets in data
    const_cast<uint8_t*>(kExternalHmacTestCase0Data),  // Data
    10,                                                // Octets in tag
    const_cast<uint8_t*>(kExternalHmacFakeTag),        // Tag
    NULL                                               // Pointer to next
                                                       // testcase
};

static const char kExternalHmacDescription[] =
    "external hmac sha-1 authentication";

// srtp_auth_type_t external_hmac is the hmac metaobject

static const srtp_auth_type_t external_hmac = {
    external_hmac_alloc,
    external_hmac_dealloc,
    external_hmac_init,
    external_hmac_compute,
    external_hmac_update,
    external_hmac_start,
    const_cast<char*>(kExternalHmacDescription),
    const_cast<srtp_auth_test_case_t*>(&kExternalHmacTestCase0),
    EXTERNAL_HMAC_SHA1};

srtp_err_status_t external_hmac_alloc(srtp_auth_t** a,
                                      int key_len,
                                      int out_len) {
  uint8_t* pointer;

  // Check key length - note that we don't support keys larger
  // than 20 bytes yet
  if (key_len > 20)
    return srtp_err_status_bad_param;

  // Check output length - should be less than 20 bytes/
  if (out_len > 20)
    return srtp_err_status_bad_param;

  // Allocate memory for auth and hmac_ctx_t structures.
  pointer = new uint8_t[(sizeof(ExternalHmacContext) + sizeof(srtp_auth_t))];
  if (pointer == NULL)
    return srtp_err_status_alloc_fail;

  // Set pointers
  *a = reinterpret_cast<srtp_auth_t*>(pointer);
  // `external_hmac` is const and libsrtp expects `type` to be non-const.
  // const conversion is required. `external_hmac` is constant because we don't
  // want to increase global count in Chrome.
  (*a)->type = const_cast<srtp_auth_type_t*>(&external_hmac);
  (*a)->state = pointer + sizeof(srtp_auth_t);
  (*a)->out_len = out_len;
  (*a)->key_len = key_len;
  (*a)->prefix_len = 0;

  return srtp_err_status_ok;
}

srtp_err_status_t external_hmac_dealloc(srtp_auth_t* a) {
  rtc::ExplicitZeroMemory(a, sizeof(ExternalHmacContext) + sizeof(srtp_auth_t));

  // Free memory
  delete[] a;

  return srtp_err_status_ok;
}

srtp_err_status_t external_hmac_init(void* state,
                                     const uint8_t* key,
                                     int key_len) {
  if (key_len > HMAC_KEY_LENGTH)
    return srtp_err_status_bad_param;

  ExternalHmacContext* context = static_cast<ExternalHmacContext*>(state);
  memcpy(context->key, key, key_len);
  context->key_length = key_len;
  return srtp_err_status_ok;
}

srtp_err_status_t external_hmac_start(void* /*state*/) {
  return srtp_err_status_ok;
}

srtp_err_status_t external_hmac_update(void* /*state*/,
                                       const uint8_t* /*message*/,
                                       int /*msg_octets*/) {
  return srtp_err_statu


circular(12),
      borderSide: const BorderSide(
        color: Colors.green,
        width: 2,
      ),
    ),
    border: OutlineInputBorder(
      borderRadius: BorderRadius.circular(12),
    ),
  ),
  textTheme: const TextTheme(
    bodyText1: TextStyle(color: Colors.white),
    bodyText2: TextStyle(color: Colors.white),
  ),
);

extension ShowSnackBar on BuildContext {
  /// Extention method to easily display error snack bar.
  void showErrorSnackbar(String text) {
    ScaffoldMessenger.of(this).showSnackBar(
      SnackBar(
        content: Text(
          text,
          style: const TextStyle(color: Color(0xFFFFFFFF)),
        ),
        backgroundColor: Colors.red,
      ),
    );
  }
}
import 'dart:io';

import 'package:postgrest/postgrest.dart';
import 'package:test/test.dart';

import 'custom_http_client.dart';
import 'reset_helper.dart';

void main() {
  const rootUrl = 'http://localhost:3000';
  late PostgrestClient postgrest;
  late PostgrestClient postgrestCustomHttpClient;
  final resetHelper = ResetHelper();
  group("Default http client", () {
    setUpAll(() async {
      postgrest = PostgrestClient(rootUrl);

      await resetHelper.initialize(postgrest);
    });

    tearDown(() async {
      await postgrest.dispose();
    });

    setUp(() {
      postgrest = PostgrestClient(rootUrl);
    });

    tearDown(() async {
      await resetHelper.reset();
    });

    test('basic select table', () async {
      final res = await postgrest.from('users').select<PostgrestList>();
      expect(res.length, 4);
    });

    test('stored procedure', () async {
      final res = await postgrest.rpc('get_status', params: {
        'name_param': 'supabot',
      });
      expect(res, 'ONLINE');
    });

    test('select on stored procedure', () async {
      final List res = await postgrest.rpc(
        'get_username_and_status',
        params: {'name_param': 'supabot'},
      ).select('status');
      expect(
        (res.first as Map<String, dynamic>)['status'],
        'ONLINE',
      );
    });

    test('stored procedure returns void', () async {
      final res = await postgrest.rpc('void_func');
      expect(res, isNull);
    });

    test('custom headers', () async {
      final postgrest = PostgrestClient(rootUrl, headers: {'apikey': 'foo'});
      expect(postgrest.headers['apikey'], 'foo');
    });

    test('override X-Client-Info', () async {
      final postgrest = PostgrestClient(
        rootUrl,
        headers: {'X-Client-Info': 'supabase-dart/0.0.0'},
      );
      expect(
        postgrest.headers['X-Client-Info'],
        'supabase-dart/0.0.0',
      );
    });

    test('auth', () async {
      postgrest = PostgrestClient(rootUrl).setAuth('foo');
      expect(
        postgrest.headers['Authorization'],
        'Bearer foo',
      );
    });

    test('switch schema', () async {
      final postgrest = PostgrestClient(rootUrl, schema: 'personal');
      final res = await postgrest.from('users').select<PostgrestList>();
      expect(res.length, 5);
    });

    test('on_conflict upsert', () async {
      final res = await postgrest.from('users').upsert(
        {'username': 'dragarcia', 'status': 'OFFLINE'},
        onConflict: 'username',
      )


,no(d),a),o&&(o.vnode.el=t.el,li(o,t.el)),u},g=(e,t="[",n="]")=>{let o=0;for(;e;)if((e=i(e))&&oo(e)&&(e.data===t&&o++,e.data===n)){if(0===o)return i(e);o--}return e},m=(e,t,n)=>{const o=t.parentNode;o&&o.replaceChild(e,t);let r=n;for(;r;)r.vnode.el===t&&(r.vnode.el=r.subTree.el=e),r=r.parent},b=e=>1===e.nodeType&&"TEMPLATE"===e.tagName;return[(e,t)=>{if(!t.hasChildNodes())return n(null,e,t),pn(),void(t._vnode=e);d(t.firstChild,e,null,null,null),pn(),t._vnode=e},d]}const io="data-allow-mismatch",ao={0:"text",1:"children",2:"class",3:"style",4:"attribute"};function lo(e,t){if(0===t||1===t)for(;e&&!e.hasAttribute(io);)e=e.parentElement;const n=e&&e.getAttribute(io);if(null==n)return!1;if(""===n)return!0;{const e=n.split(",");return!(0!==t||!e.includes("children"))||n.split(",").includes(ao[t])}}const so=N().requestIdleCallback||(e=>setTimeout(e,1)),co=N().cancelIdleCallback||(e=>clearTimeout(e));const uo=e=>!!e.type.__asyncLoader;
/*! #__NO_SIDE_EFFECTS__ */function fo(e){g(e)&&(e={loader:e});const{loader:t,loadingComponent:n,errorComponent:o,delay:r=200,hydrate:i,timeout:a,suspensible:l=!0,onError:s}=e;let c,u=null,d=0;const f=()=>{let e;return u||(e=u=t().catch((e=>{if(e=e instanceof Error?e:new Error(String(e)),s)return new Promise(((t,n)=>{s(e,(()=>t((d++,u=null,f()))),(()=>n(e)),d+1)}));throw e})).then((t=>e!==u&&u?u:(t&&(t.__esModule||"Module"===t[Symbol.toStringTag])&&(t=t.default),c=t,t))))};return Qn({name:"AsyncComponentWrapper",__asyncLoader:f,__asyncHydrate(e,t,n){const o=i?()=>{const o=i((()=>{n()}),(t=>function(e,t){if(oo(e)&&"["===e.data){let n=1,o=e.nextSibling;for(;o;){if(1===o.nodeType){if(!1===t(o))break}else if(oo(o))if("]"===o.data){if(0===--n)break}else"["===o.data&&n++;o=o.nextSibling}}else t(e)}(e,t)));o&&(t.bum||(t.bum=[])).push(o),(t.u||(t.u=[])).push((()=>!0))}:n;c?o():f().then((()=>!t.isUnmounted&&o()))},get __asyncResolved(){return c},setup(){const e=qi;if(_n(e),c)return()=>po(c,e);const t=t=>{u=null,$t(t,e,13,!o)};if(l&&e.suspense||oa)return f().then((t=>()=>po(t,e))).catch((e


3, 230, 58, 255)) ?: Color(253, 230, 58, 255)),(colorFilter?.filter(Color(218, 194, 3, 255)) ?: Color(218, 194, 3, 255))), MultipleGradientPaint.CycleMethod.NO_CYCLE, MultipleGradientPaint.ColorSpaceType.SRGB, AffineTransform(0.449398010969162f, -0.21649199724197388f, 0.5644159913063049f, 1.171617031097412f, -1.4322880506515503f, 2.5461080074310303f))
g.paint = paint
g.fill(shape)
paint = colorFilter?.filter(Color(196, 160, 0, 255)) ?: Color(196, 160, 0, 255)
stroke = BasicStroke(1.0000005f,0,0,4.0f,null,0.0f)
if (generalPath == null) {
   generalPath = GeneralPath()
} else {
   generalPath!!.reset()
}
generalPath!!.moveTo(14.780848f, 22.793568f)
generalPath!!.curveTo(13.985353f, 27.080402f, 15.414814f, 36.746067f, 21.040081f, 42.487564f)
generalPath!!.curveTo(25.386835f, 42.628857f, 35.03017f, 39.06988f, 41.571175f, 32.290527f)
generalPath!!.curveTo(32.335f, 27.773815f, 26.034647f, 16.567549f, 21.135868f, 19.007853f)
generalPath!!.lineTo(14.780848f, 22.793568f)
generalPath!!.closePath()
shape = generalPath
g.paint = paint
g.stroke = stroke
g.draw(shape)
g.composite = AlphaComposite.getInstance(3, 1.0f * origAlpha)
// _0_0_4
paint = LinearGradientPaint(Point2D.Double(9.105389595031738, 38.82814407348633), Point2D.Double(10.146956443786621, 30.140830993652344), floatArrayOf(0.0f,1.0f), arrayOf((colorFilter?.filter(Color(196, 160, 0, 255)) ?: Color(196, 160, 0, 255)),(colorFilter?.filter(Color(196, 160, 0, 0)) ?: Color(196, 160, 0, 0))), MultipleGradientPaint.CycleMethod.NO_CYCLE, MultipleGradientPaint.ColorSpaceType.SRGB, AffineTransform(0.866025984287262f, -0.5f, 0.7974910140037537f, 1.3812940120697021f, -15.699090003967285f, -9.225098609924316f))
stroke = BasicStroke(0.9999999f,1,0,4.0f,null,0.0f)
if (generalPath == null) {
   generalPath = GeneralPath()
} else {
   generalPath!!.reset()
}
generalPath!!.moveTo(16.33836f, 24.367273f)
generalPath!!.curveTo(18.687374f, 30.637545f, 18.827803f, 37.155575f, 23.522142f, 42.28716f)
shape = generalPath
g.paint = paint
g.stroke = stroke
g.draw(shape)
g.composite = AlphaComposite.getInstance(3, 0.46153846f * origAlpha)
// _0_0_5
paint = colorFilter?.filter(Color(255, 255, 255, 255)) ?: Color(255, 255, 255, 255)
stroke = BasicStroke(0.99999976f,0,0,4.0f,null,0.0f)
if (generalPath == null) {
   generalPath = GeneralPath()


 ^ val.wrapping_shr(31) as i16
        }
    }

    /// Clamps the given value to the [0, 16_777_215] range.
    #[inline]
    pub fn clamp_u24(val: u32) -> u32 {
        if val & !0x00ff_ffff == 0 {
            val
        }
        else {
            0x00ff_ffff
        }
    }

    /// Clamps the given value to the [-8_388_608, 8_388_607] range.
    #[inline]
    pub fn clamp_i24(val: i32) -> i32 {
        if val.wrapping_add(0x0080_0000) & !0x00ff_ffff == 0 {
            val as i32
        }
        else {
            0x007f_ffff ^ val.wrapping_shr(31) as i32
        }
    }

    /// Clamps the given value to the [0, 4_294_967_295] range.
    #[inline]
    pub fn clamp_u32(val: u64) -> u32 {
        if val & !0xffff_ffff == 0 {
            val as u32
        }
        else {
            0xffff_ffff
        }
    }

    /// Clamps the given value to the [-2_147_483_648, 2_147_483_647] range.
    #[inline]
    pub fn clamp_i32(val: i64) -> i32 {
        if val.wrapping_add(0x8000_0000) & !0xffff_ffff == 0 {
            val as i32
        }
        else {
            0x7fff_ffff ^ val.wrapping_shr(63) as i32
        }
    }

    /// Clamps the given value to the [-1.0, 1.0] range.
    #[inline]
    pub fn clamp_f32(val: f32) -> f32 {
        // This slightly inelegant code simply returns min(max(1.0, val), -1.0). In release mode on
        // platforms with SSE2 support, it will compile down to 4 SSE instructions with no branches,
        // thereby making it the most performant clamping implementation for floating-point samples.
        let mut clamped = val;
        clamped = if clamped >  1.0 {  1.0 } else { clamped };
        clamped = if clamped < -1.0 { -1.0 } else { clamped };
        clamped
    }

    /// Clamps the given value to the [-1.0, 1.0] range.
    #[inline]
    pub fn clamp_f64(val: f64) -> f64 {
        let mut clamped = val;
        clamped = if clamped >  1.0 {  1.0 } else { clamped };
        clamped = if clamped < -1.0 { -1.0 } else { clamped };
        clamped
    }

    #[cfg(test)]
    mod tests {
        use std::{u8, i8, u16, i16, u32, i32, u64, i64};
        use super::*;

        #[test]
        fn verify_clamp() {
            assert_eq!(clamp_u8(256u16),   u8::MAX);
            assert_eq!(clamp_u8(u16::MAX), u8::MAX);

            assert_eq!(clamp_i8(  128i16), i8::MAX);
            assert_eq!(clamp_i8( -129i16), i8::MIN);
            assert_eq!(clamp_i8(i16::MAX), i8::MAX);
            assert_eq!(clamp_i8(i16::MIN), i8::MIN);

            assert_eq!(clamp_u16(65536u32), u16::MAX);
            assert_eq!(clamp_u16(u32::MAX), u16::MAX);

            assert_eq!(clamp_i16( 32_768i32), i16::MAX);
            assert_eq!(clamp_i16(-32_769i32), i16::MIN);
            assert_eq!(clamp


totally random feedback
			bsr 		random1
			move.b  	d0,(a6)+	; totally random operator sync
			bsr 		random99
			move.b  	d0,(a6)+	; totally random LFO speed
			clr.b   	(a6)+    ; no LFO delay
			bsr 		random99
			move.b  	d0,(a6)+	; totally random PMD
			bsr 		random99
			move.b  	d0,(a6)+	; totally random AMD
			bsr 		random1
			move.b  	d0,(a6)+	; totally random LFO sync
			bsr 		random5
			move.b  	d0,(a6)+	; totally random LFO waveform
			bsr 		random3 	; 75% of the time PMS is zero
			tst.b   	d7
			bne 		.25
			bsr 		random7 	; 25% of the time PMS is totally random
			move.b  	d0,(a6)+
			bra 		.26
.25 		clr.b   	(a6)+
.26 		move.b  	#24,(a6)	; transposition: = C3
									; note: function parameters are unchanged

			rts 					; return

;*****************************************************************************;
;   rand  --  routine to un-intelligently randomize ws or wb slot
;   input: x1.l --> area to be randomized
;*****************************************************************************;

 .global rand

rand		movem.l 	#$FFFE,-(a7)

			move.l  	x1,a6   		; a6 --> area to be randomized
			lea 		disttabl,a5 	; a5 --> distortion table
			lea 		parminfo,a4 	; a4 --> parminfo

			move.l  	#158,d7 		; counter: 158 to 0
.loop   	tst.b   	0(a5,d7.l)
			beq 		.next
			move.w  	d7,d0
			mulu		#8,d0
			move.b  	1(a4,d0.w),d0   ; d0.b = high mark
			cmpi.b  	#1,d0
			bne 		.3
			bsr 		random1
			bra 		.x
.3  		cmpi.b  	#3,d0
			bne 		.5
			bsr 		random3
			bra 		.x
.5  		cmpi.b  	#5,d0
			bne 		.7
			bsr 		random5
			bra 		.x
.7  		cmpi.b  	#7,d0
			bne 		.12
			bsr 		random7
			bra 		.x
.12 		cmpi.b  	#12,d0
			bne 		.14
.12x		bsr 		random15
			subq.b  	#3,d0
			blt 		.12x
			bra 		.x
.14 		cmpi.b  	#14,d0
			bne 		.31
.14x		bsr 		random15
			subq.b  	#1,d0
			blt 		.14x
			bra 		.x
.31 		cmpi.b  	#31,d0
			bne 		.48
			bsr 		random31
			bra 		.x
.48 		cmpi.b  	#48,d0
			bne 		.99
.48x		bsr 		random63
			sub.b   	#15,d0
			blt 		.48x
			bra 		.x
.99 		bsr 		random99

.x  		move.b  	d0,0(a6,d7.l)

.next   	subq.l  	#1,d7
			bge 		.loop

			movem.l 	(a7)+,#$7FFF
			rts

;**************


e3bd784e/pkg/meta/boltdb/boltdb.go#L1665
[2]https://github.com/project-zot/zot/commit/002ac62d8a15bf0cba010b3ba7bde86f9837b613
[3]https://github.com/project-zot/zot/security/advisories/GHSA-c9p4-xwr9-rfhx |总结果：29，高严重性：2，时间戳：2024年3月5日 19:52:41
开始日期：2024年3月3日；结束日期：2024年3月4日

| 编号 | CVE ID | 基本评分 | 严重性 | 描述 | 参考链接 |
|-----|--------|------------|----------|-------------|------------|
| 1 | CVE-2024-25016 | 7.5  | HIGH | IBM MQ 和 IBM MQ Appliance 的 9.0、9.1、9.2、9.3 LTS 和 9.3 CD 版本可能存在一个远程未经身份验证的攻击者利用不正确的缓冲逻辑导致服务拒绝的问题。IBM X-Force ID: 281279。 | [1]https://exchange.xforce.ibmcloud.com/vulnerabilities/281279
[2]https://www.ibm.com/support/pages/node/7123139 |
| 2 | CVE-2024-2147 | 7.3  | HIGH | 在SourceCodester在线移动管理商店1.0中发现了一个漏洞，被评定为高危级别。此问题影响文件/admin/login.php中的某个未知功能。参数username的操纵会导致SQL注入。攻击可以远程发起。这个漏洞已经被公开披露，并可能被利用。该漏洞的标识符是VDB-255500。 | [1]https://github.com/vanitashtml/CVE-Dumps/blob/main/Sql%20Injection%20Authentication%20Bypass%20in%20Mobile%20Management%20Store.md
[2]https://vuldb.com/?ctiid.255500
[3]https://vuldb.com/?id.255500 |总结果：136，高严重性：6，时间戳：2024-08-18 08:10:13
开始日期：现在；结束日期：2024年8月17日

| 序号 | CVE ID | 基础分数 | 严重性 | 描述 | 参考资料 |
|-----|--------|------------|----------|-------------|------------|
| 1 | CVE-2024-6500 | 10.0  | CRITICAL | InPost for WooCommerce插件和InPost PL插件用于WordPress，在所有版本直至且包括1.4.0（对于InPost for WooCommerce）以及1.4.4（对于InPost PL）中都存在未经授权的访问和数据删除漏洞，原因是`parse_request`函数缺少权限检查。这使得未授权攻击者能够读取并删除Windows服务器上的任意文件。在Linux服务器上，仅会删除WordPress安装内的文件，但所有文件都可以被读取。

请注意，上述信息基于您提供的内容进行翻译，实际的漏洞描述可能需要根据具体的软件版本、环境配置以及安全策略来详细评估。在处理此类问题时，建议遵循官方的安全指南或联系软件供应商以获取最新的安全更新和补救措施。 | [1]https://plugins.trac.wordpress.org/browser/inpost-for-woocommerce/trunk/src/In


n * @see http://www.w3.org/TR/cssom-view/#dom-element-clientwidth\\n */\\nElement.prototype.clientWidth;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-element-clientheight\\n */\\nElement.prototype.clientHeight;\\n\\n// http://www.w3.org/TR/cssom-view/#extensions-to-the-htmlelement-interface\\n\\n/**\\n * @type {Element}\\n * @see http://www.w3.org/TR/cssom-view/#dom-htmlelement-offsetparent\\n */\\nHTMLElement.prototype.offsetParent;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-htmlelement-offsettop\\n */\\nHTMLElement.prototype.offsetTop;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-htmlelement-offsetleft\\n */\\nHTMLElement.prototype.offsetLeft;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-htmlelement-offsetwidth\\n */\\nHTMLElement.prototype.offsetWidth;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-htmlelement-offsetheight\\n */\\nHTMLElement.prototype.offsetHeight;\\n\\n\\n// http://www.w3.org/TR/cssom-view/#extensions-to-the-range-interface\\n\\n/**\\n * @return {!ClientRectList}\\n * @see http://www.w3.org/TR/cssom-view/#dom-range-getclientrects\\n */\\nRange.prototype.getClientRects = function() {};\\n\\n/**\\n * @return {!ClientRect}\\n * @see http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect\\n */\\nRange.prototype.getBoundingClientRect = function() {};\\n\\n\\n// http://www.w3.org/TR/cssom-view/#extensions-to-the-mouseevent-interface\\n\\n// MouseEvent: screen{X,Y} and client{X,Y} are in DOM Level 2/3 Event as well,\\n// so it seems like a specification issue. I've emailed www-style@w3.org in\\n// hopes of resolving the conflict, but in the mean time they can live here\\n// (http://lists.w3.org/Archives/Public/www-style/2012May/0039.html).\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-screenx\\n */\\n//MouseEvent.prototype.screenX;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-screeny\\n */\\n//MouseEvent.prototype.screenY;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-pagex\\n */\\nMouseEvent.prototype.pageX;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-pagey\\n */\\nMouseEvent.prototype.pageY;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-clientx\\n */\\n//MouseEvent.prototype.clientX;\\n\\n/**\\n * @type {number}\\n * @see http://www.w3.org/TR/cssom-view/#dom-mouseevent-clien";
a.a+='ty\\n */\\n//M


 function () {
      if (document.readyState === "interactive" || document.readyState === "complete") {
        fn();
      }
    });
  }
}import {Question} from "../pages/game/question";
/**
 * Created by Administrador on 23/02/2017.
 */

export const Online: boolean = true;
export const Users: any[] = [
    {user: "Camilo", documento: "1.144.054.421", puntos: 20},
    {user: "Juan David", documento: "1.057.478.211", puntos: 50},
    {user: "Jorge", documento: "1.871.214.781", puntos: 10},
];

export const Sponsors: any[] = [
    {name: "Bavaria", imgUrl: "img/logo-bavaria.jpg"},
    {name: "Kool Aid", imgUrl:"img/koolaid.png"}
];

export const Raffles: any[] = [
    {time:"2017-02-02", winners:[
        {name:"Camilo", prize:"Moto eléctrica"},
        {name:"Juan David", prize:"Carro eléctrico"},
        {name: "Jorge", prize: "Bicicleta"}
    ]},
    {time:"2017-02-15", winners:[
        {name:"Carlos", prize:"Carro eléctrico"},
        {name:"Andrés", prize:"Lavadora"},
        {name: "Mario", prize: "DVD"}
    ]}
];

export const Tickets: any[] = [
    {number:"23894566", "valid":"Abril"},
    {number:"23892133", "valid":"Julio"},
    {number:"31324566", "valid":"Noviembre"},
];

export const Questions: Question[] = [
    new Question(
        "¿A qué se le llama \"No potable\"?",
        ["A una parte de África", "Al agua que no es apta para el consumo humano", "A un animal peligroso"],
        1
    ),
    new Question(
        "¿Qué es el reciclaje?",
        ["La reutilización de ciertos materiales", "Un sistema de almacenamiento", "La explotación de arrecifes"],
        0
    ),
    new Question(
        "Un ejemplo de recurso renovable es:",
        ["El petróleo", "El agua", "Ninguna de las anteriores"],
        1
    )
];
import { BaseSchemes, GetSchemes, NodeEditor, NodeId } from 'rete'

import { BaseArea, BaseAreaPlugin } from '../base'

type Schemes = GetSchemes<BaseSchemes['Node'] & { selected?: boolean }, any>

/**
 * Selector's accumulate function, activated when the ctrl key is pressed
 */
export function accumulateOnCtrl() {
  let pressed = false

  function keydown(e: KeyboardEvent) {
    if (e.key === 'Control') pressed = true
  }
  function keyup(e: KeyboardEvent) {
    if (e.key === 'Control') pressed = false
  }

  document.addEventListener('keydown', keydown)
  document.addEventListener('keyup', keyup)

  return {
    active() {
      return pressed
    },
    destroy() {
      document.removeEventListener('keydown', keydown)
      document.removeEventListener('keyup', keyup)
    }
  }
}

export type SelectorEntity = { label: string, id: string, unselect(): void, translate(dx: number, dy: number): void }

/**
 * Selector class. Used to collect selected entities (nodes, connections, etc.) and synchronize them (select, unselect, translate, etc.).
 * Can be extended to add custom functionality.
 */
export class Selector<E extends SelectorEntity> {
  entities = new Map<string, E>()
  pickId: string | null = null

  isSelected(entity: Pick<E, 'label' | 'id'>) {
    return this.entities.has(`${entity.label}_${entity.id}`)
  }

  add(enti


(val int) {
    // 修改 VF 表：val 对应的 freq 加一
    freq := this.valToFreq[val] + 1
    this.valToFreq[val] = freq
    // 修改 FV 表：在 freq 对应的列表加上 val
    if this.freqToVals[freq] == nil {
        this.freqToVals[freq] = stack.New()
    }
    this.freqToVals[freq].Push(val)
    // 更新 maxFreq
    if freq > this.maxFreq {
        this.maxFreq = freq
    }
}

func (this *FreqStack) Pop() int {
    // 修改 FV 表：pop 出一个 maxFreq 对应的元素 v
    vals := this.freqToVals[this.maxFreq]
    v := vals.Pop().(int)
    // 修改 VF 表：v 对应的 freq 减一
    freq := this.valToFreq[v] - 1
    this.valToFreq[v] = freq
    // 更新 maxFreq
    if vals.Len() == 0 {
        // 如果 maxFreq 对应的元素空了
        this.maxFreq--
    }
    return v
}
```

```java
// by labuladong (java)
class FreqStack {
    // 记录 FreqStack 中元素的最大频率
    int maxFreq = 0;
    // 记录 FreqStack 中每个 val 对应的出现频率，后文就称为 VF 表
    HashMap<Integer, Integer> valToFreq = new HashMap<>();
    // 记录频率 freq 对应的 val 列表，后文就称为 FV 表
    HashMap<Integer, Stack<Integer>> freqToVals = new HashMap<>();

    public void push(int val) {
        // 修改 VF 表：val 对应的 freq 加一
        int freq = valToFreq.getOrDefault(val, 0) + 1;
        valToFreq.put(val, freq);
        // 修改 FV 表：在 freq 对应的列表加上 val
        freqToVals.putIfAbsent(freq, new Stack<>());
        freqToVals.get(freq).push(val);
        // 更新 maxFreq
        maxFreq = Math.max(maxFreq, freq);
    }

    public int pop() {
        // 修改 FV 表：pop 出一个 maxFreq 对应的元素 v
        Stack<Integer> vals = freqToVals.get(maxFreq);
        int v = vals.pop();
        // 修改 VF 表：v 对应的 freq 减一
        int freq = valToFreq.get(v) - 1;
        valToFreq.put(v, freq);
        // 更新 maxFreq
        if (vals.isEmpty()) {
            // 如果 maxFreq 对应的元素空了
            maxFreq--;
        }
        return v;
    }
}
```

```javascript
// by chatGPT (javascript)
/**
 * @param {number} val
 * @return {void}
 */
var FreqStack = function() {
    // 记录 FreqStack 中元素的最大频率
    this.maxFreq = 0;
    // 记录 FreqStack 中每个 val 对应的出现频率，后文就称为 VF 表
    this.valToFreq = new Map();
    // 记录频率 freq 对应的 val 列表，后文就称为 FV 表
    this.freqToVals = new Map();
};

/**
 * @param {number} va


s in a cycle:
        6 7 4 2
 */
static void PrintNodesInCycle(struct Graph *pGraph, long v, struct Stack *pNodesOnStack) {
    // Get an iterator of the stack
    StackIterator it = GetIterator(pNodesOnStack);

    cycles++;

    if (pGraph->isDirected) {
        printf("\n\t\t****************** Cycle %ld detected (directed) *****************\n\t\t", cycles);
    } else {
        printf("\n\t\t****************** Cycle %ld detected (undirected) *****************\n\t\t", cycles);
    }
    /*
        v == 2
        Stack: 6  7  4  2  0

        Nodes in a cycle:
        6 7 4 2
     */
    PrintStack(pNodesOnStack);
    printf("\t\tnode %ld is on stack\n", v);
    printf("\t\tNodes in a cycle: \n\t\t");
    // visit each element
    while (HasNext(&it)) {
        STACK_ITEM_T nodeId = NextItem(&it);
        printf("%ld ", nodeId);
        if (nodeId == v) {
            break;
        }
    }
    printf("\n\t\t****************************************************************\n");
}

static int DetectCycle(struct Graph *pGraph, long u, int *visited, struct Stack *pNodesOnStack) {
    visited[u] = 1;
    pGraph->pNodes[u].onstack = 1;
    // Push u onto the data stack
    StackPush(pNodesOnStack, u);

    imgCnt++;
    if (pGraph->isDirected) {
        GenOneImage(pGraph, "HasCycleDirected", "images/HasCycleDirected", imgCnt, visited);
    } else {
        GenOneImage(pGraph, "HasCycleUndirected", "images/HasCycleUndirected", imgCnt, visited);
    }
    int cycleDetected = 0;

    // recursively visit the adjacent nodes of u, if they have not been visited yet
    for(long v = 0; v < pGraph->n; v++) {
        if (MatrixElement(pGraph, u, v)) {
            if (!visited[v]) {
                if (DetectCycle(pGraph, v, visited, pNodesOnStack)) {
                    cycleDetected = 1;
#ifdef STOP_DETECTION_AT_FIRST_CYCLE
                    break;
#endif
                }
            } else {
                int nodesInCycle = GetNumOfNodesInCycle(pGraph, v, pNodesOnStack);
                if (nodesInCycle > 0) {
                    if (!pGraph->isDirected) {
                        /*
                            In an undirected graph,

                            an edge 'n0 -- n2' is represented as two directed edges:

                                n0 -> n2
                                n2 -> n0

                            We should not treat n2 -> n0 and n0 -> n2 as a cycle in an undirected edge.
                            So we need to check it here.

                        */
                        if (nodesInCycle == 2) {
                            continue;
                        }
                    }
                    PrintNodesInCycle(pGraph, v, pNodesOnStack);
                    cycleDetected = 1;
#ifdef  STOP_DETECTION_AT_FIRST_CYCLE
                    break;
#endif
                }
            }
        }
    }
    StackPop(pNodesOnStack);
    pGraph->pNodes[u].onstack = 0;
    return cycleDetected;
}

int HasCycle(struct Graph *pGraph) {
    int cyclic = 0;
    int *visited = (int *) malloc(pGraph->n * sizeof(int));
    struct Stack *pNodesOnStack = CreateStack();
    //memset(visited, 0, sizeof(int) * p


 = ShadcnPointArcTween(
      begin: _cornerFor(begin!, diagonal.endId),
      end: _cornerFor(end!, diagonal.endId),
    );
    _dirty = false;
  }

  double _diagonalSupport(Offset centersVector, _BorderRadiusCorner diagonal) {
    final Offset delta = _cornerFor(begin!, diagonal.endId) -
        _cornerFor(begin!, diagonal.beginId);
    final double length = delta.distance;
    return centersVector.dx * delta.dx / length +
        centersVector.dy * delta.dy / length;
  }

  Offset _cornerFor(Rect rect, _CornerType id) {
    return switch (id) {
      _CornerType.topLeft => rect.topLeft,
      _CornerType.topRight => rect.topRight,
      _CornerType.bottomLeft => rect.bottomLeft,
      _CornerType.bottomRight => rect.bottomRight,
    };
  }

  ShadcnPointArcTween? get beginArc {
    if (begin == null) {
      return null;
    }
    if (_dirty) {
      _initialize();
    }
    return _beginArc;
  }

  late ShadcnPointArcTween _beginArc;
  ShadcnPointArcTween? get endArc {
    if (end == null) {
      return null;
    }
    if (_dirty) {
      _initialize();
    }
    return _endArc;
  }

  late ShadcnPointArcTween _endArc;

  @override
  set begin(Rect? value) {
    if (value != begin) {
      super.begin = value;
      _dirty = true;
    }
  }

  @override
  set end(Rect? value) {
    if (value != end) {
      super.end = value;
      _dirty = true;
    }
  }

  @override
  Rect lerp(double t) {
    if (_dirty) {
      _initialize();
    }
    if (t == 0.0) {
      return begin!;
    }
    if (t == 1.0) {
      return end!;
    }
    return Rect.fromPoints(_beginArc.lerp(t), _endArc.lerp(t));
  }
}

T _findMax<T>(Iterable<T> input, _KeyFunc<T> keyFunc) {
  late T maxValue;
  double? maxKey;
  for (final T value in input) {
    final double key = keyFunc(value);
    if (maxKey == null || key > maxKey) {
      maxValue = value;
      maxKey = key;
    }
  }
  return maxValue;
}

const List<_BorderRadiusCorner> _allDiagonals = <_BorderRadiusCorner>[
  _BorderRadiusCorner(_CornerType.topLeft, _CornerType.bottomRight),
  _BorderRadiusCorner(_CornerType.bottomRight, _CornerType.topLeft),
  _BorderRadiusCorner(_CornerType.topRight, _CornerType.bottomLeft),
  _BorderRadiusCorner(_CornerType.bottomLeft, _CornerType.topRight),
];

typedef _KeyFunc<T> = double Function(T input);

enum _CornerType { topLeft, topRight, bottomLeft, bottomRight }

class _BorderRadiusCorner {
  const _BorderRadiusCorner(this.beginId, this.endId);
  final _CornerType beginId;
  final _CornerType endId;
}

const double _kOnAxisDelta = 2.0;

class ShadcnPointArcTween extends Tween<Offset> {
  ShadcnPointArcTween({
    super.begin,
    super.end,
  });

  bool _dirty = true;

  void _initialize() {
    assert(this.begin != null);
    assert(this.end != null);

    final Offset begin = this.begin!;
    final Offset end = this.end!;

    // An explanation with a diagram can be found at https://goo.gl/vMSdRg
    final Offset delta = end - begin;
    final double deltaX = delta.dx.abs();
    final double deltaY = delta.dy.abs();
    final double distanceFromAtoB = delta.distance;
    final Offset c = Offset(end.dx, begin.dy);

    double sweepAngle() => 2.0 * asin(distanceFromAtoB / (2.0 * _radius!));

    if (deltaX > _kOnAxisDelta && deltaY > _kOnAxisDelta) {
      if (deltaX < deltaY) {
        _radius =
            distanceFromAtoB * distanceFromAtoB / (c - begin).distance / 2.0;
        _center = Offset(end.dx


s less dampening, knob right is more dampening
    invertedFreq = invertedFreq * invertedFreq; // also square it for exponential taper (more control over lower frequencies)
    verb.SetLpFreq(600.0 + invertedFreq * (16000.0 - 600.0));

    if (vReverbTime < 0.01) { // if knob < 1%, set reverb to 0
        verb.SetFeedback(0.0);
    } else if (vReverbTime >= 0.01 && vReverbTime <= 0.1) {
        verb.SetFeedback(vReverbTime * 6.4 ); // Reverb time range 0.0 to 0.6 for 1% to 10% knob turn (smooth ramping to useful reverb time values, i.e. 0.6 to 1)
    } else {
        verb.SetFeedback(vReverbTime * 0.4 + 0.6); // Reverb time range 0.6 to 1.0
    }

    // CHORUS //

    float lfoLeft = vCfreq;
    float lfoRight = vCfreq;
    float delayLeft = 0.75;
    float delayRight = 0.75;

    if (pswitch1[1] == true) { // Right
        delayLeft = 0.2;
        delayRight = 0.95;
    } else if (pswitch1[0] == false && pswitch1[1] == false) { // center
        lfoRight = 1.0 - vCfreq; // inverted right lfo frequency
    }
    chorus.SetLfoFreq(lfoLeft, lfoRight);
    chorus.SetLfoDepth(vCdepth);
    chorus.SetDelay(delayLeft, delayRight);

    float sendl, sendr, wetl, wetr;
    float chorusL, chorusR;
    float pitchL, pitchR;
    float effectsL, effectsR;

    for(size_t i = 0; i < size; i++)
    {

        // Process your signal here
        if(bypass)
        {
            // Could do a trails mode here

            out[0][i] = in[0][i];
            out[1][i] = in[1][i];

        }
        else
        {

            float inL = in[0][i];
            float inR = in[1][i];

            // Routing

            if (pswitch2[0] == true) { //left Chorus into Reverb

                chorusL = chorus.Process(inL);
                chorusR = chorus.GetRight();

                sendl = chorusL;
                sendr = chorusR;
                verb.Process(sendl, sendr, &wetl, &wetr);

                pitchL = pitch.Process(wetl);
                pitchR = pitchRight.Process(wetr);

                effectsL = pitchL;
                effectsR = pitchR;

            } else if (pswitch2[1] == true) { // right Reverb into Chorus

                sendl = inL;
                sendr = inL;
                verb.Process(sendl, sendr, &wetl, &wetr);

                pitchL = pitch.Process(wetl);
                pitchR = pitchRight.Process(wetr);

                chorusL = chorus.Process((pitchL + pitchR) / 2.0);
                chorusR = chorus.GetRight();

                effectsL = chorusL;
                effectsR = chorusR;

            } else {        // center parallel
                chorusL = chorus.Process(inL);
                chorusR = chorus.GetRight();

                sendl = inL;
                sendr = inL;
                verb.Process(sendl, sendr, &wetl, &wetr);

                pitchL = pitch.Process(wetl);
                pitchR = pitchRight.Process(wetr);

                effectsL = chorusL + pitchL;
                effectsR = chorusR + pitchR;

            }

            // Final


          [JetBrains.Annotations.NotNull] string locationGuid,
                       [CanBeNull] string loadtypeGuid,
                       [JetBrains.Annotations.NotNull] string deviceCategory)
        {
            HouseholdKey = householdKey;
            ThisDeviceType = deviceType;
            DeviceGuid = deviceGuid;
            LocationGuid = locationGuid;
            LoadtypeGuid = loadtypeGuid;
            DeviceCategory = deviceCategory;
            unchecked
            {
                _hashCode = LocationGuid.GetHashCode();
                if(loadtypeGuid!= null) {
                    _hashCode = (_hashCode * 397) ^ loadtypeGuid.GetHashCode();
                }

                _hashCode = (_hashCode * 397) ^ DeviceGuid.GetHashCode();
                _hashCode = (_hashCode * 397) ^ HouseholdKey.Key.GetHashCode();
                _hashCode= (_hashCode * 397) ^ (int)ThisDeviceType;
            }
            //needed for the makekey due to compiler error
            FullKey = "";
            FullKey= MakeKey();
        }
        */
        //public override bool Equals(object obj) {
        //    return obj is OefcKey other && Equals(other);
        //}
        [JetBrains.Annotations.NotNull]
        public  string MakeKey()
        {
            return HouseholdKey + "#" +
                   ThisDeviceType + "#" +
                   DeviceInstanceGuid + "#" +
                   LocationGuid + "#" +
                   LoadtypeGuid + "#" + DeviceCategory;
        }
        [JetBrains.Annotations.NotNull]
        public override string ToString()
        {
            return   FullKey;
        }

        //public bool Equals(OefcKey other)
        //{
        //    return FullKey.Equals(other.FullKey);
        //}

        //public static bool operator ==(in OefcKey point1, OefcKey point2) => point1.Equals(point2);

        //public static bool operator !=(in OefcKey point1, OefcKey point2) => !point1.Equals(point2);

        public StrGuid LoadtypeGuid { get; }

        [JetBrains.Annotations.NotNull]
        public string DeviceCategory { get; }

        public StrGuid LocationGuid { get; }

        public StrGuid DeviceInstanceGuid { get; }
        [JetBrains.Annotations.NotNull]
        public HouseholdKey HouseholdKey { get; }
        public OefcDeviceType ThisDeviceType { get; }
    }
}


		end
	elseif (e.self:Class() == "Warrior" and e.item:GetID() == 60330 and e.corpse:GetNPCTypeID() == 303129) then
		local qglobals = eq.get_qglobals(e.self);
		if (qglobals["warrior_epic"] == "20") then
			if (qglobals["warr_chest_causeway"] == nil) then
				eq.spawn2(893, 0, 0, e.self:GetX(), e.self:GetY(), e.self:GetZ(), e.self:GetHeading()); -- a chest (epic 2.0)
				eq.set_global("warr_chest_causeway", "1", 5, "F");
			end
			return 0;
		else
			return 1;
		end
	elseif (e.self:Class() == "Berserker" and e.item:GetID() == 17349 and e.corpse:GetNPCTypeID() == 303081) then
		local qglobals = eq.get_qglobals(e.self);
		if (qglobals["berserk_epic"] == "9") then
			if (qglobals["ber_chest_causeway"] == nil) then
				eq.spawn2(893, 0, 0, e.self:GetX(), e.self:GetY(), e.self:GetZ(), e.self:GetHeading()); -- a chest (epic 2.0)
				eq.set_global("ber_chest_causeway", "1", 5, "F");
			end
			return 0;
		else
			return 1;
		end
	elseif (e.self:Class() == "Beastlord"  and (e.item:GetID() == 57012 or e.item:GetID() == 57013)) then
		local qglobals = eq.get_qglobals(e.self);
		if (qglobals["beast_epic"] == "18") then
			return 0;
		else
			return 1;
		end
	elseif (e.self:Class() == "Enchanter"  and (e.item:GetID() == 52951)) then
		local qglobals = eq.get_qglobals(e.self);
		if (qglobals["ench_epic"] == "9") then
			if (qglobals["ench_chest_causeway"] == nil) then
				eq.spawn2(893, 0, 0, e.self:GetX(), e.self:GetY(), e.self:GetZ(), e.self:GetHeading()); -- a chest (epic 2.0)
				eq.set_global("ench_chest_causeway", "1", 5, "F");
			end
			return 0;
		else
			return 1;
		end
	end
end