 instead of signer?
	PermanodeOfSignerAttrValue(ctx context.Context, signer blob.Ref, attr, val string) (blob.Ref, error)

	// PathsOfSignerTarget queries the index about "camliPath:"
	// URL-dispatch attributes.
	//
	// It returns a list of all the path claims that have been signed
	// by the provided signer and point at the given target.
	//
	// This is used when editing a permanode, to figure work up
	// the name resolution tree backwards ultimately to a
	// camliRoot permanode (which should know its base URL), and
	// then the complete URL(s) of a target can be found.
	PathsOfSignerTarget(ctx context.Context, signer, target blob.Ref) ([]*camtypes.Path, error)

	// All Path claims for (signer, base, suffix)
	PathsLookup(ctx context.Context, signer, base blob.Ref, suffix string) ([]*camtypes.Path, error)

	// Most recent Path claim for (signer, base, suffix) as of
	// provided time 'at', or most recent if 'at' is nil.
	PathLookup(ctx context.Context, signer, base blob.Ref, suffix string, at time.Time) (*camtypes.Path, error)

	// EdgesTo finds references to the provided ref.
	//
	// For instance, if ref is a permanode, it might find the parent permanodes
	// that have ref as a member.
	// Or, if ref is a static file, it might find static directories which contain
	// that file.
	// This is a way to go "up" or "back" in a hierarchy.
	//
	// opts may be nil to accept the defaults.
	EdgesTo(ref blob.Ref, opts *camtypes.EdgesToOpts) ([]*camtypes.Edge, error)

	// EnumerateBlobMeta calls fn for each blob known to the
	// indexer (which may be a subset of all total blobs, since
	// the indexer is typically configured to not see non-metadata
	// blobs). The blobs may be sent in any order.  If the context
	// finishes, the return error is ctx.Err().
	// If the provided function returns false, iteration ends with a nil
	// return value.
	EnumerateBlobMeta(context.Context, func(camtypes.BlobMeta) bool) error
}
/*
Copyright 2011 The Perkeep Authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package schema

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"math/rand"
	"testing"

	"perkeep.org/pkg/blob"
	"perkeep.org/pkg/test"
)

var ctxbg = context.Background()

var testFetcher = &test.Fetcher{}

var blobA = &test.Blob{Contents: "AAAAAaaaaa"}
var blobB = &test.Blob{Con


margin: 0.5rem 0;
  }

  .markdown-body code {
    @apply bg-muted text-foreground;
    padding: 0.125rem 0.25rem;
    border-radius: 0.25rem;
    font-size: 0.75rem;
  }

  /* Compact, clean tables with Tailwind green shades */
  .markdown-body table {
    @apply w-full border-collapse;
    margin: 0.5rem 0;
    font-size: 12px;
    background-color: theme("colors.green.50");
    border-radius: 0.5rem;
    overflow: hidden;
    border: 2px solid theme("colors.green.200");
  }

  .markdown-body th,
  .markdown-body td {
    @apply text-left;
    padding: 0.3rem 0.4rem;
    border: none;
    border-bottom: 1px solid theme("colors.green.200");
  }

  .markdown-body th {
    @apply font-bold text-green-950;
    background-color: theme("colors.green.800");
    color: theme("colors.green.50");
    padding: 0.375rem 0.5rem;
    font-size: 0.8125rem;
    letter-spacing: 0.025em;
  }

  .markdown-body td {
    @apply bg-transparent;
  }

  .markdown-body tr:nth-child(even) td {
    background-color: theme("colors.green.100");
  }

  .markdown-body tr:hover td {
    background-color: theme("colors.green.200");
  }

  /* Bold text with dark green emphasis */
  .markdown-body strong,
  .markdown-body b {
    @apply font-semibold text-green-700;
  }
}
.blog-articles {
  display: grid;
  grid-gap: 1rem;
  column-gap: var(--grid-mobile-horizontal-spacing);
  row-gap: var(--grid-mobile-vertical-spacing);
}

.blog-articles .card-wrapper {
  width: 100%;
}

@media screen and (min-width: 750px) {
  .blog-articles {
    grid-template-columns: 1fr 1fr;
    column-gap: var(--grid-desktop-horizontal-spacing);
    row-gap: var(--grid-desktop-vertical-spacing);
  }

  .blog-articles--collage > *:nth-child(3n + 1),
  .blog-articles--collage > *:nth-child(3n + 2):last-child {
    grid-column: span 2;
    text-align: center;
  }

  .blog-articles--collage > *:nth-child(3n + 1) .card,
  .blog-articles--collage > *:nth-child(3n + 2):last-child .card {
    text-align: center;
  }

  .blog-articles--collage > *:nth-child(3n + 1) .article-card__image--small .ratio::before,
  .blog-articles--collage > *:nth-child(3n + 2):last-child .article-card__image--small .ratio::before {
    padding-bottom: 22rem;
  }

  .blog-articles--collage > *:nth-child(3n + 1) .article-card__image--medium .ratio::before,
  .blog-articles--collage > *:nth-child(3n + 2):last-child .article-card__image--medium .ratio::before {
    padding-bottom: 44rem;
  }

  .blog-articles--collage > *:nth-child(3n + 1) .article-card__image--large .ratio::before,
  .blog-articles--collage > *:nth-child(3n + 2):last-child .article-card__image--large .ratio::before


19)
o52.Anchored = true
o52.FormFactor = Enum.FormFactor.Custom
o52.Size = Vector3.new(0.5, 1, 1)
o52.CFrame = CFrame.new(-78.5759964, 5.23453045, 218.190002, 1.66321428e-007, 0.258803427, -0.965930045, -1.20923602e-007, 0.965929985, 0.258803457, 1, 7.37591748e-008, 1.91950321e-007)
o52.BottomSurface = Enum.SurfaceType.Smooth
o52.Color = Color3.new(0.498039, 0.556863, 0.392157)
o52.Position = Vector3.new(-78.5759964, 5.23453045, 218.190002)
o53.Parent = o4
o53.BrickColor = BrickColor.new("Grime")
o53.Position = Vector3.new(-77.1899948, 4.03557444, 218.190002)
o53.Rotation = Vector3.new(4.12399504e-006, 3.72762725e-006, -14.9985886)
o53.Anchored = true
o53.FormFactor = Enum.FormFactor.Custom
o53.Size = Vector3.new(4.30000067, 0.600000381, 0.50000006)
o53.CFrame = CFrame.new(-77.1899948, 4.03557444, 218.190002, 0.96593225, 0.258795261, 6.50593677e-008, -0.258795261, 0.96593225, -7.19772899e-008, -8.14703256e-008, 5.26881294e-008, 1)
o53.BottomSurface = Enum.SurfaceType.Smooth
o53.TopSurface = Enum.SurfaceType.Smooth
o53.Color = Color3.new(0.498039, 0.556863, 0.392157)
o53.Position = Vector3.new(-77.1899948, 4.03557444, 218.190002)
o54.Parent = o53
o55.Parent = o4
o55.BrickColor = BrickColor.new("Grime")
o55.Position = Vector3.new(-75.4850159, 4.40660381, 218.190002)
o55.Rotation = Vector3.new(90.0000458, 75.0007095, -90.0000381)
o55.Anchored = true
o55.FormFactor = Enum.FormFactor.Custom
o55.Size = Vector3.new(0.5, 1, 1)
o55.CFrame = CFrame.new(-75.4850159, 4.40660381, 218.190002, -1.77226013e-007, 0.258807153, 0.965929031, 8.02105191e-008, 0.965929091, -0.258807123, -1, 3.16103126e-008, -1.9194681e-007)
o55.BottomSurface = Enum.SurfaceType.Smooth
o55.Color = Color3.new(0.498039, 0.556863, 0.392157)
o55.Position = Vector3.new(-75.4850159, 4.40660381, 218.190002)
o56.Parent = o4
o56.BrickColor = BrickColor.new("Grime")
o56.Position = Vector3.new(-88.0809326, 6.07933426, 214.040009)
o56.Rotation = Vector3.new(90, 75.0008163, 90.0000076)
o56.Anchored = true
o56.FormFactor = Enum.FormFactor.Symmetric
o56.Size = Vector3.new(9, 1, 1)
o56.CFrame = CFrame.new(-88.0809326, 6.07933426, 214.040009, -2.78438783e-008, -0.258805394,


'state': 'TX'
  },
  {
    '_id': '78938',
    'city': 'ELLINGER',
    'loc': [-96.69663, 29.845915],
    'pop': 374,
    'state': 'TX'
  },
  {
    '_id': '78940',
    'city': 'FAYETTEVILLE',
    'loc': [-96.646317, 29.886789],
    'pop': 2290,
    'state': 'TX'
  },
  {
    '_id': '78941',
    'city': 'FLATONIA',
    'loc': [-97.098685, 29.709493],
    'pop': 2934,
    'state': 'TX'
  },
  {
    '_id': '78942',
    'city': 'GIDDINGS',
    'loc': [-96.93322000000001, 30.177725],
    'pop': 6799,
    'state': 'TX'
  },
  {
    '_id': '78944',
    'city': 'INDUSTRY',
    'loc': [-96.518849, 29.971789],
    'pop': 1258,
    'state': 'TX'
  },
  {
    '_id': '78945',
    'city': 'LA GRANGE',
    'loc': [-96.885988, 29.903978],
    'pop': 10019,
    'state': 'TX'
  },
  {
    '_id': '78946',
    'city': 'LEDBETTER',
    'loc': [-96.761276, 30.238307],
    'pop': 806,
    'state': 'TX'
  },
  {
    '_id': '78947',
    'city': 'LEXINGTON',
    'loc': [-97.052387, 30.419144],
    'pop': 3138,
    'state': 'TX'
  },
  {
    '_id': '78948',
    'city': 'LINCOLN',
    'loc': [-96.970159, 30.317693],
    'pop': 1228,
    'state': 'TX'
  },
  {
    '_id': '78949',
    'city': 'MULDOON',
    'loc': [-97.100562, 29.799305],
    'pop': 8,
    'state': 'TX'
  },
  {
    '_id': '78950',
    'city': 'NEW ULM',
    'loc': [-96.537963, 29.814248],
    'pop': 689,
    'state': 'TX'
  },
  {
    '_id': '78953',
    'city': 'ROSANKY',
    'loc': [-97.311875, 29.924122],
    'pop': 1345,
    'state': 'TX'
  },
  {
    '_id': '78954',
    'city': 'ROUND TOP',
    'loc': [-96.734058, 30.041131],
    'pop': 1127,
    'state': 'TX'
  },
  {
    '_id': '78956',
    'city': 'SCHULENBURG',
    'loc': [-96.91056399999999, 29.688247],
    'pop': 3703,
    'state': 'TX'
  },
  {
    '_id': '78957',
    'city': 'SMITHVILLE',
    'loc': [-97.149396, 30.017813],
    'pop': 5244,
    'state': 'TX'
  },
  {
    '_id': '78959',
    'city': 'WAELDER',
    'loc': [-97.295798, 29.6868],
    'pop': 1105,
    'state': 'TX'
  },
  {
    '_id': '78962',
    'city': 'WEIMAR',


pub enum AppError {
    CreateApi(ApiError),
    Migrate(MigrationError),
    NoConfig,
    PgConnect(PgError),
    ReadConfig(ConfigError),
    StartServer(HyperError),
}

impl fmt::Display for AppError {
    fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
        use self::AppError::*;
        match self {
            CreateApi(err) => write!(out, "Could not create API client: {}", err),
            Migrate(err) => write!(out, "Migration error: {}", err),
            NoConfig => write!(out, "Path to configuration file is not provided"),
            PgConnect(err) => write!(out, "PostgreSQL: {}", err),
            ReadConfig(err) => write!(out, "{}", err),
            StartServer(err) => write!(out, "Could not start server for webhooks: {}", err),
        }
    }
}

impl Error for AppError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        use self::AppError::*;
        Some(match self {
            CreateApi(err) => err,
            Migrate(err) => err,
            NoConfig => return None,
            PgConnect(err) => err,
            ReadConfig(err) => err,
            StartServer(err) => err,
        })
    }
}
use super::super::{
    types::{Color, Type},
    Expression,
};
use super::{Anchor, Visibility};
use serde::Deserialize;

#[derive(Deserialize, Debug)]
pub(crate) struct HillshadeLayerPaint {
    #[serde(rename = "hillshade-accent-color", default = "default_accent_color")]
    pub accent_color: Expression,
    #[serde(rename = "hillshade-exaggeration", default = "default_exaggeration")]
    pub exaggeration: Expression,
    #[serde(
        rename = "hillshade-highlight-color",
        default = "default_highlight_color"
    )]
    pub highlight_color: Expression,
    #[serde(
        rename = "hillshade-illumination-anchor",
        default = "default_illumination_anchor"
    )]
    pub illumination_anchor: Anchor,
    #[serde(
        rename = "hillshade-illumination-direction",
        default = "default_illumination_direction"
    )]
    pub illumination_direction: Expression,
    #[serde(rename = "hillshade-shadow-color", default = "default_shadow_color")]
    pub shadow_color: Expression,
}

#[derive(Deserialize, Debug, Default)]
pub(crate) struct HillshadeLayerLayout {
    #[serde(default, rename = "visibility")]
    pub visibility: Visibility,
}

fn default_accent_color() -> Expression {
    Expression::Type(Type::Color(Color::new_with_string("#000000").unwrap()))
}

fn default_exaggeration() -> Expression {
    Expression::Type(Type::Number(0.5))
}

fn default_highlight_color() -> Expression {
    Expression::Type(Type::Color(Color::new_with_string("#FFFFFF").unwrap()))
}

fn default_illumination_anchor() -> Anchor {
    Anchor::Viewport
}

fn default_illumination_direction() -> Expression {
    Expression::Type(Type::Number(335.0))
}

fn default_shadow_color() -> Expression {
    Expression::Type(Type::Color(Color::new_with_string("#000000").unwrap()))
}
use leetcode_811::solution1::Solution;

fn main() {
  let cpdomains = vec!["9001 discuss.leetcode.com".to_string()];
  let result = Solution:


'''
Задача 60
Объединение пары в простое число
Простые числа 3, 7, 109 и 673 достаточно замечательны. Если взять любые два из них и
объединить их в произвольном порядке, в результате всегда получится простое число.
Например, взяв 7 и 109, получатся простые числа 7109 и 1097. Сумма этих четырех простых
чисел, 792, представляет собой наименьшую сумму элементов множества из четырех простых
чисел, обладающих данным свойством.

Найдите наименьшую сумму элементов множества из 5 простых чисел, для которых объединение
любых двух даст новое простое число.

'''
from time import time
from sympy import nextprime, isprime

def func(x, y):
    res = (isprime(int(str(x) + str(y)))) and (isprime(int(str(y) + str(x))))
    return res

def func_2(x, y):
    res = True
    for i in range(len(x)):
        res = res and (isprime(int(str(x[i]) + str(y)))) and (isprime(int(str(y) + str(x[i]))))
    return res

def main():
    start = time()

    z = 9000
    x_ = [2, ]
    while True:
        y = nextprime(x_[0])
        while True:
            if func(x_[0], y):
                x_.append((x_[0], y))
                y = nextprime(y)
            else:
                y = nextprime(y)
            if y > z:
                break
        x_2 = [x_[0], ]
        for i in range(1, len(x_)):
            y = nextprime(x_[i][1])
            while True:
                if func_2(x_[i], y):
                    x_2.append((x_[i][0], x_[i][1], y))
                    y = nextprime(y)
                else:
                    y = nextprime(y)
                if y > z:
                    break
        x_ = [x_2[0], ]
        for i in range(1, len(x_2)):
            y = nextprime(x_2[i][2])
            while True:
                if func_2(x_2[i], y):
                    x_.append((x_2[i][0], x_2[i][1], x_2[i][2], y))
                    y = nextprime(y)
                else:
                    y = nextprime(y)
                if y > z:
                    break
        x_2 = [x_[0], ]
        for i in range(1, len(x_)):
            y = nextprime(x_[i][3])

            while True:
                if func_2(x_[i], y):
                    x_2.append((x_[i][0], x_[i][1], x_[i][2], x_[i][3], y))
                    y = nextprime(y)
                else:
                    y = nextprime(y)
                if y > z:
                    break
        if len(x_2) >= 2:            break
        x_ = [nextprime(x_2[0]), ]

    print(f"""{sum(x_2[1])} -наименьшая сумма элементов множества из 5 простых чисел {x_2[1]},
для которых объединение любых двух даст новое простое число. """)

    print(f"Program running time {round(time() - start, 2)} sec.")

if __name__ == "__main__":
    main()


 = 0x177245385090

// setup parses the bzip2 header.
func (bz2 *reader) setup(needMagic bool) error {
	br := &bz2.br

	if needMagic {
		magic := br.ReadBits(16)
		if magic != bzip2FileMagic {
			return StructuralError("bad magic value")
		}
	}

	t := br.ReadBits(8)
	if t != 'h' {
		return StructuralError("non-Huffman entropy encoding")
	}

	level := br.ReadBits(8)
	if level < '1' || level > '9' {
		return StructuralError("invalid compression level")
	}

	bz2.fileCRC = 0
	bz2.blockSize = 100 * 1000 * (level - '0')
	if bz2.blockSize > len(bz2.tt) {
		bz2.tt = make([]uint32, bz2.blockSize)
	}
	return nil
}

func (bz2 *reader) Read(buf []byte) (n int, err error) {
	if bz2.eof {
		return 0, io.EOF
	}

	if !bz2.setupDone {
		err = bz2.setup(true)
		brErr := bz2.br.Err()
		if brErr != nil {
			err = brErr
		}
		if err != nil {
			return 0, err
		}
		bz2.setupDone = true
	}

	n, err = bz2.read(buf)
	brErr := bz2.br.Err()
	if brErr != nil {
		err = brErr
	}
	return
}

func (bz2 *reader) readFromBlock(buf []byte) int {
	// bzip2 is a block based compressor, except that it has a run-length
	// preprocessing step. The block based nature means that we can
	// preallocate fixed-size buffers and reuse them. However, the RLE
	// preprocessing would require allocating huge buffers to store the
	// maximum expansion. Thus we process blocks all at once, except for
	// the RLE which we decompress as required.
	n := 0
	for (bz2.repeats > 0 || bz2.preRLEUsed < len(bz2.preRLE)) && n < len(buf) {
		// We have RLE data pending.

		// The run-length encoding works like this:
		// Any sequence of four equal bytes is followed by a length
		// byte which contains the number of repeats of that byte to
		// include. (The number of repeats can be zero.) Because we are
		// decompressing on-demand our state is kept in the reader
		// object.

		if bz2.repeats > 0 {
			buf[n] = byte(bz2.lastByte)
			n++
			bz2.repeats--
			if bz2.repeats == 0 {
				bz2.lastByte = -1
			}
			continue
		}

		bz2.tPos = bz2.preRLE[bz2.tPos]
		b := byte(bz2.tPos)
		bz2.tPos >>= 8
		bz2.preRLEUsed++

		if bz2.byteRepeats == 3 {
			bz2.repeats = uint(b)
			bz2.byteRepeats = 0
			continue
		}

		if bz2.lastByte == int(b) {
			bz2.byteRepeats++
		} else {
			bz2.byteRepeats = 0
		}
		bz2.lastByte = int(b)

		buf[n] = b
		n++
	}

	return n
}

func (bz2 *reader) read(buf []byte) (int, error) {
	for {
		n := bz2.readFromBlock(buf)
		if n > 0 {
			bz2.blockCRC = updateCRC(bz2.blockCRC, buf[:n])
			return n, nil
		}

		// End of block. Check CRC.
		if bz2.blockCRC != bz2.wantBlockCRC {
			bz2.br.err = StructuralError("block checksum mismatch")
			return 0, bz2.br.err
		}

		// Find next block.
		br := &bz2


(xsize*ysize), sizeof(double) );
00480   if( image->data == NULL ) error("not enough memory.");
00481
00482   /* set image size */
00483   image->xsize = xsize;
00484   image->ysize = ysize;
00485
00486   return image;
00487 }

Here is the call graph for this function:

<map name="lsd_8c_a29_cgraph_map">
<area href="lsd_8c.html#a16" shape="rect" coords="194,8,245,34" alt="">
</map>

           image_double new_image_double_ptr
          (
          unsigned int
           xsize,

          unsigned int
           ysize,

          double *
           data

          )
           [static]

Create a new image_double of size 'xsize' times 'ysize' with the data pointed by 'data'.

Definition at line 493 of file lsd.c.

References image_double_s::data, error(), image_double, <a class="el" href="


onError("Expected to be called with $expectedParam1 and $expectedParam2, but was called with $p1 and $p2")
        }
        counter++
    }

    fun assertSuccess() {
        if (counter != 1) {
            throw AssertionError("Expected to be called once, but was called $counter times")
        }
    }
}

class EnsureCalledOnceWithTwoParamsAndResult<T, U, R>(
    private val expectedParam1: T,
    private val expectedParam2: U,
    private val result: R,
) : (T, U) -> R {
    private var counter = 0
    override fun invoke(p1: T, p2: U): R {
        if (p1 != expectedParam1 || p2 != expectedParam2) {
            throw AssertionError("Expected to be called with $expectedParam1 and $expectedParam2, but was called with $p1 and $p2")
        }
        counter++
        return result
    }

    fun assertSuccess() {
        if (counter != 1) {
            throw AssertionError("Expected to be called once, but was called $counter times")
        }
    }
}

/**
 * Shortcut for [<T, R> ensureCalledOnceWithParam] with Unit result.
 */
fun <T> ensureCalledOnceWithParam(param: T, block: (callback: EnsureCalledOnceWithParam<T, Unit>) -> Unit) {
    ensureCalledOnceWithParam(param, block, Unit)
}

fun <T, R> ensureCalledOnceWithParam(param: T, block: (callback: EnsureCalledOnceWithParam<T, R>) -> R, result: R) {
    val callback = EnsureCalledOnceWithParam(param, result)
    block(callback)
    callback.assertSuccess()
}

fun <P1, P2> ensureCalledOnceWithTwoParams(param1: P1, param2: P2, block: (callback: EnsureCalledOnceWithTwoParams<P1, P2>) -> Unit) {
    val callback = EnsureCalledOnceWithTwoParams(param1, param2)
    block(callback)
    callback.assertSuccess()
}
/*
 * Copyright 2025 New Vector Ltd.
 *
 * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 * Please see LICENSE files in the repository root for full details.
 */

package io.element.android.detektrules

import io.github.detekt.psi.fileName
import io.gitlab.arturbosch.detekt.api.CodeSmell
import io.gitlab.arturbosch.detekt.api.Config
import io.gitlab.arturbosch.detekt.api.Debt
import io.gitlab.arturbosch.detekt.api.Entity
import io.gitlab.arturbosch.detekt.api.Issue
import io.gitlab.arturbosch.detekt.api.Rule
import io.gitlab.arturbosch.detekt.api.Severity
import org.jetbrains.kotlin.psi.KtPropertyDelegate

class ByPreferencesDataStoreRule(config: Config) : Rule(config) {
    override val issue: Issue = Issue(
        id = "ByPreferencesDataStoreNotAllowed",
        severity = Severity.Style,
        description = "Avoid using `by preferencesDataStore(...)`, use `PreferenceDataStoreFactory.create(name)`instead.",
        debt = Debt.FIVE_MINS,
    )

    override fun visitPropertyDelegate(delegate: KtPropertyDelegate) {
        super.visitPropertyDelegate(delegate)

        if (delegate.containingKtFile.fileName == "DefaultPreferencesDataStoreFactory.kt") {
            // Skip the rule for the DefaultPreferencesDataStoreFactory implementation
            return
        }

        if (delegate.text.startsWith("by preferencesDataStore")) {
            report(CodeSmell(
                issue = issue,
                entity = Entity.from(delegate),
                message = "Use `PreferenceDataStoreFactory.create(name)` instead of `by preferencesDataStore(...)`."
            ))
        }
    }
}
/*
 * Copyright 2024 New Vector Ltd.
 *
 * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
 * Please see LICENSE files in the repository root for


************************************/
		protected override void InitDuration(int subSong)
		{
			InitializeSound();
			MarkPositionAsVisited(0);
		}

		/********************************************************************/
		/// <summary>
		/// Return the total number of positions. You only need to derive
		/// from this method, if your player have one position list for all
		/// channels and can restart on another position than 0
		/// </summary>
		/********************************************************************/
		protected override int GetTotalNumberOfPositions()
		{
			return sequences[0].Length;
		}

		/********************************************************************/
		/// <summary>
		/// Create a snapshot of all the internal structures and return it
		/// </summary>
		/********************************************************************/
		protected override ISnapshot CreateSnapshot()
		{
			return new Snapshot(playingInfo, instruments);
		}

		/********************************************************************/
		/// <summary>
		/// Initialize internal structures based on the snapshot given
		/// </summary>
		/********************************************************************/
		protected override bool SetSnapshot(ISnapshot snapshot, out string errorMessage)
		{
			errorMessage = string.Empty;

			// Start to make a clone of the snapshot
			Snapshot currentSnapshot = (Snapshot)snapshot;
			Snapshot clonedSnapshot = new Snapshot(currentSnapshot.PlayingInfo, currentSnapshot.Instruments);

			playingInfo = clonedSnapshot.PlayingInfo;
			instruments = clonedSnapshot.Instruments;

			UpdateModuleInformation();

			return true;
		}
		#endregion

		#region Private methods
		/********************************************************************/
		/// <summary>
		/// Test the file to see if it's a SidMon 1.0 player and extract
		/// needed information
		/// </summary>
		/********************************************************************/
		private AgentResult TestModule(byte[] buffer)
		{
			// SC68 support are handled in a converter, so ignore these modules here
			if ((buffer[0] == 0x53) && (buffer[1] == 0x43) && (buffer[2] == 0x36) && (buffer[3] == 0x38))
				return AgentResult.Unknown;

			if (!ExtractInfoFromInitFunction(buffer))
				return AgentResult.Unknown;

			if (!ExtractInfoFromPlayFunction(buffer))
				return AgentResult.Unknown;

			return AgentResult.Ok;
		}

		/********************************************************************/
		/// <summary>
		/// Try to find the init function in the player and extract needed
		/// information from it
		/// </summary>
		/********************************************************************/
		private bool ExtractInfoFromInitFunction(byte[] searchBuffer)
		{
			int searchLength = searchBuffer.Length;
			int index, channel;

			for (index = 0; index < searchLength - 2; index += 2)
			{
				if ((searchBuffer[index] == 0x41) && (searchBuffer[index + 1] == 0xfa))
					break;
			}

			if (index >= (searchLength - 4))
				return false;

			baseOffset = ((searchBuffer[index + 2] << 8) | searchBuffer[index + 3]) + index + 2;

			sequenceOffsets = new int[4];
			index += 4;

			for (channel = 0; (index < searchLength - 2) && (channel < 4); index += 2)
			{
				if ((searchBuffer[index] == 0xd1) && (searchBuffer[index + 1] == 0xe8))
					sequenceOffsets[channel++] = (((sbyte)searchBuffer[index + 2] << 8) | searchBuffer[index + 3]) + baseOffset;
			}

			if (index >= (searchLength - 4))
				return false;

			for (; index < searchLength - 2; index += 2)
			{
				if (((searchBuffer[index] == 0x70) && (searchBuffer[index + 1] == 0x03)) || ((searchBuffer[index] == 0x20) && (searchBuffer[index + 1] == 0x3c)


block;
            color: var(--background-color, ${backgroundColorBase});
            width: 1px;
        }
        .word {
            display: flex;
        }
        .char {
            width: 0;
            overflow: hidden;
        }
        .cursor {
            background-color: var(--color, ${colorBase});
            color: var(--color, ${colorBase});
        }
        .cursor:before {
            content: 'X';
        }
        slot,
        ::slotted(*) {
            display: none;
        }
    `;
};
import { validateDSNPMessageId } from "./identifiers";

describe("validateDSNPMessageId", () => {
  const validDSNPMessageIds = [
    "dsnp://0123456789ABCDEF/0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF", // Uppercase
    "dsnp://0123456789abcdef/0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", // Lowercase
  ];

  const invalidDSNPMessageIds = [
    "dsnp://badbadbad/0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF", // Bad user id
    "dsnp://0123456789ABCDEF/badbadbad", // Bad message id
    "dsnp://0123456789ABCDE/0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF", // User id too short
    "dsnp://0123456789ABCDEFA/0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF", // User id too long
    "dsnp://0123456789ABCDEF/0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDE", // Message id too short
  ];

  for (const id of validDSNPMessageIds) {
    it(`returns true for "${id}"`, () => {
      expect(validateDSNPMessageId(id)).toEqual(true);
    });
  }

  for (const id of invalidDSNPMessageIds) {
    it(`returns false for "${id}"`, () => {
      expect(validateDSNPMessageId(id)).toEqual(false);
    });
  }
});
import {
  IOwsUser,
  ISearchResponse
} from "./Interfaces";

export function GetDateFqlString (date: Date): string {
  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`; // 1900-01-01
}

const months: string[] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ];
export function ToVeryShortDateString (date: Date, showDate: boolean, showMonth: boolean, showYear: boolean): string {
  // e.g. 18 Aug 09
  let ds: string = "";
  if (showDate) {
    ds = date.getDate().toString();
  }
  if (showMonth) {
    if (ds.length > 0) {
      ds += " ";
    }
    ds += months[date.getMonth()];
  }
  if (showYear) {
    if (ds.length > 0) {
      ds += " ";
    }
    ds += `'${date.getFullYear().toString().substr(2)}`;
  }
  return ds;
}

export function ToColloquialDateString (then: Date): string {
  let returnString: string = ToVeryShortDateString(then, true, true, true);
  const now: Date = new Date();
  const minsInHr: number = 60;

  const isSameDay: boolean = then.getFullYear() === now.getFullYear() && then.getMonth() === now.getMonth() && then.getDate() === now.getDate();
  if (isSameDay) {
      if (now > then) {
          const totalMinutesAgo: number = (now.getHours() * minsInHr) + now.getMinutes() - (then.getHours() * minsInHr) - then.getMinutes();
          const hoursAgo: number = Math.floor(totalMinutesAgo / minsInHr);
          cons


@postfix)"}]}});hljs.registerLanguage("lisp",function(b){var e="[a-zA-Z_\\-\\+\\*\\/\\<\\=\\>\\&\\#][a-zA-Z0-9_\\-\\+\\*\\/\\<\\=\\>\\&\\#!]*",c="\\|[^]*?\\|",r="(\\-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|\\-)?\\d+)?",a={cN:"shebang",b:"^#!",e:"$"},i={cN:"literal",b:"\\b(t{1}|nil)\\b"},l={cN:"number",v:[{b:r,r:0},{b:"#(b|B)[0-1]+(/[0-1]+)?"},{b:"#(o|O)[0-7]+(/[0-7]+)?"},{b:"#(x|X)[0-9a-fA-F]+(/[0-9a-fA-F]+)?"},{b:"#(c|C)\\("+r+" +"+r,e:"\\)"}]},t=b.inherit(b.QSM,{i:null}),d=b.C(";","$",{r:0}),n={cN:"variable",b:"\\*",e:"\\*"},u={cN:"keyword",b:"[:&]"+e},N={b:e,r:0},o={b:c},s={b:"\\(",e:"\\)",c:["self",i,t,l,N]},v={cN:"quoted",c:[l,t,n,u,s,N],v:[{b:"['`]\\(",e:"\\)"},{b:"\\(quote ",e:"\\)",k:"quote"},{b:"'"+c}]},f={cN:"quoted",v:[{b:"'"+e},{b:"#'"+e+"(::"+e+")*"}]},g={cN:"list",b:"\\(\\s*",e:"\\)"},q={eW:!0,r:0};return g.c=[{cN:"keyword",v:[{b:e},{b:c}]},q],q.c=[v,f,g,i,l,t,d,n,u,o,N],{i:/\S/,c:[l,a,i,t,d,v,f,g,N]}});hljs.registerLanguage("rsl",function(e){return{k:{keyword:"float color point normal vector matrix while for if do return else break extern continue",built_in:"abs acos ambient area asin atan atmosphere attribute calculatenormal ceil cellnoise clamp comp concat cos degrees depth Deriv diffuse distance Du Dv environment exp faceforward filterstep floor format fresnel incident length lightsource log match max min mod noise normalize ntransform opposite option phong pnoise pow printf ptlined radians random reflect refract renderinfo round setcomp setxcomp setycomp setzcomp shadow sign sin smoothstep specular specularbrdf spline sqrt step tan texture textureinfo trace transform vtransform xcomp ycomp zcomp"},i:"</",c:[e.CLCM,e.CBCM,e.QSM,e.ASM,e.CNM,{cN:"preprocessor",b:"#",e:"$"},{cN:"shader",bK:"surface displacement light volume imager",e:"\\("},{cN:"shading",bK:"illuminate illuminance gather",e:"\\("}]}});hljs.registerLanguage("scheme",function(e){var t="[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",r="(\\-|\\+)?\\d+([./]\\d+)?",i=r+"[+\\-]"+r+"i",a={built_in:"case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules ' * + , ,@ - ... / ; < <= = => > >= ` abs acos angle append apply asin assoc assq as


 SHAPE = "RECT" COORDS="19,559,398,574" HREF = "../../OtlEventMonitor/TOmniEventMonitor.html#Detach(IOmniTaskControl)">
<AREA SHAPE = "RECT" COORDS="19,574,398,589" HREF = "../../OtlEventMonitor/TOmniEventMonitor.html#Detach(IOmniThreadPool)">
<AREA SHAPE = "RECT" COORDS="19,771,398,786" HREF = "../../OtlEventMonitor/TOmniEventMonitor.html#OnTaskUndeliveredMessage">
<AREA SHAPE = "RECT" COORDS="17,71,178,138" HREF = "../../OtlEventMonitor/TOmniEventMonitorClass.html">
<AREA SHAPE = "RECT" COORDS="14,274,401,790" HREF = "../../OtlEventMonitor/TOmniEventMonitor.html">
<AREA SHAPE = "RECT" COORDS="10,16,167,52" HREF = "../../OtlEventMonitor/TOmniMonitorTaskEvent.html">
</MAP>
</BODY>
</HTML>
<HTML>
<HEAD>
<!-- Generated by CodeGear RAD Studio on 16.2.2017 9:23:19 -->
<STYLE TYPE="text/css">@import "../../stylesheet.css";</STYLE>
<TITLE>Map file for default.txvpck.html</TITLE>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"><BASE TARGET=classFrame><SCRIPT LANGUAGE = "JavaScript">
function doClick
(imageHref) {
if (parent.imageFrame != null)
   parent.imageFrame.location.href = imageHref;}
function loadImage() {
try {
  if (parent.isAppletFirstTime == true) {
     parent.isAppletFirstTime = false;
     return;
  }
  if (parent.packageListFrame.document.navigApplet == null) { return; }
  var imageFileName = "OtlLogger/doc-files/default.txvpck.html.gif";
  var myWidth = document.body.scrollWidth;
  if (myWidth <= document.body.clientWidth) myWidth = document.images[0].width+25;
  var myHeight = document.body.scrollHeight;
  if (myHeight <= document.body.clientHeight) myHeight = document.images[0].height+25;
    parent.packageListFrame.document.navigApplet.loadView(imageFileName, myWidth, myHeight);
  resizeSpot();
  moveSpot();
 }catch(Exception){}
}
function resizeSpot() {
try{
   if (parent.packageListFrame.document.navigApplet == null) { return; }
    parent.packageListFrame.document.navigApplet.setSpotSize(document.body.clientWidth, document.body.clientHeight);
    parent.packageListFrame.document.navigApplet.repaint();
 }catch(Exception){}
}
function moveSpot() {
try{
   if (parent.packageListFrame.document.navigApplet == null) { return; }
    parent.packageListFrame.document.navigApplet.moveSpot(document.body.scrollLeft, document.body.scrollTop);
 }catch(Exception){}
}
</SCRIPT>
</HEAD>

<BODY onLoad="loadImage()" onResize="resizeSpot()" onScroll="moveSpot()"><IMG SRC = "default.txvpck.html.gif" USEMAP = "#Beauty"><MAP NAME = "Beauty"><AREA SHAPE = "RECT" COORDS="15,137,182,152" HREF = "../../OtlLogger/TOmniLogger.html#GetEventList(TStringList)">
<AREA SHAPE = "RECT" COORDS="15,167,182,182" HREF = "../../OtlLogger/TOmniLogger.html#Log(string)">
<AREA SHAPE = "RECT" COORDS="15,


oferi mai multe informații în ","openIssueMessage_button":"monitorul nostru pentru erori.","openIssueMessage_post":" Te rugăm să incluzi informațiile de mai jos prin copierea și lipirea în problema GitHub.","sceneContent":"Conținutul scenei:"},"roomDialog":{"desc_intro":"Poți invita alte persoane pentru a colabora la scena actuală.","desc_privacy":"Nu te îngrijora. Sesiunea utilizează criptarea integrală, astfel încât orice desenezi va rămâne privat. Nici măcar serverul nostru nu va putea vedea pe ce ai lucrat.","button_startSession":"Pornire sesiune","button_stopSession":"Oprire sesiune","desc_inProgressIntro":"Sesiunea de colaborare în direct este în curs de desfășurare.","desc_shareLink":"Distribuie acest URL persoanelor cu care dorești să colaborezi:","desc_exitSession":"Oprirea sesiunii te va deconecta de la sală, însă vei putea lucra în continuare, pe plan local, cu scena. Reține că această opțiune nu va afecta alte persoane, iar acestea vor putea să colaboreze în continuare pe versiunea lor.","shareTitle":"Alătură-te unei sesiuni de colaborare în direct pe Excalidraw"},"errorDialog":{"title":"Eroare"},"exportDialog":{"disk_title":"Salvare pe disc","disk_details":"Exportă datele scenei pe un fișier din care poți importa mai târziu.","disk_button":"Salvare în fișier","link_title":"URL partajabil","link_details":"Exportă ca URL doar în citire.","link_button":"Exportare în URL","excalidrawplus_description":"Salvează scena în spațiul de lucru Excalidraw+.","excalidrawplus_button":"Exportare","excalidrawplus_exportError":"Excalidraw+ nu a putut fi exportat în acest moment..."},"helpDialog":{"blog":"Citește blogul nostru","click":"clic","deepSelect":"Selectare de adâncime","deepBoxSelect":"Selectare de adâncime în casetă și prevenire glisare","curvedArrow":"Săgeată curbată","curvedLine":"Linie curbată","documentation":"Documentație","doubleClick":"dublu clic","drag":"glisare","editor":"Editor","editSelectedShape":"Editează forma selectată (text/săgeată/linie)","github":"Ai întâmpinat o problemă? Trimite un raport","howto":"Urmărește ghidurile noastre","or":"sau","preventBinding":"Împiedică legarea săgeții","shapes":"Forme","shortcuts":"Comenzi rapide de la tastatură","textFinish":"Finalizează editarea (editor de text)","textNewLine":"Adaugă o linie nouă (editor de text)","title":"Ajutor","view":"Vizualizare","zoomToFit":"Transfocare pentru a cuprinde totul","zoomToSelection":"Transfocare la selecție"},"clearCanvasDialog":{"title":"Ștergere pânză"},"publishDialog":{"title":"Publicare bibliotecă","itemName":"Denumirea elementului","authorName":"Numele autorului","githubUsername":"Numele de utilizator GitHub","twitterUsername":"Numele de utilizator Twitter","libraryName":"Denumirea bibliotecii","libraryDesc":"Descrierea bibliotecii","website":"Pagină de internet","placeholder":{"authorName":"Numele sau numele tău de utilizator","libraryName":"Numele bibliotecii tale","libraryDesc":"Descrierea bibliotecii tale pentru a ajuta oamenii să înțeleagă utilizarea acesteia","githubHandle":"Numele de utilizator GitHub (op


 &mut x, &mut y, c, s, k, p);
        givens_rot_right((c, s), u.slice_mut(s![0..n, k..k + 2]));
    }
}

pub fn qr_algorithm_symmetric(mut m: MatrixViewMut, mut u: MatrixViewMut, opts: &QROptions) {
    let n = m.shape()[0];
    let mut p = n - 1;
    let mut i = 0;

    while p > 0 && i < opts.iterations {
        let s = wilkinson_shift(m.view(), p);
        symmetric_qr_step(m.view_mut(), u.view_mut(), p, s);
        if eigval_collapsed(opts.eps, m[[p, p - 1]], m[[p - 1, p - 1]], m[[p, p]]) {
            p -= 1;
        }
        i += 1;
    }
}
pub const READ: i32 = 3;
pub const WRITE: i32 = 4;
pub const REBOOT: i32 = 88;
pub const VERSION: i32 = 2;
use arrayvec::ArrayVec;

#[cfg(test)]
use alloc::{vec, vec::Vec};

use super::{ascii, DataEncodingError, EncodingContext};

const SHIFT1: u8 = 0;
const SHIFT2: u8 = 1;
const SHIFT3: u8 = 2;
const UPPER_SHIFT: u8 = 30;

#[inline(always)]
pub(super) fn low_ascii_to_c40_symbols(ctx: &mut ArrayVec<u8, 6>, ch: u8) {
    match ch {
        // Basic set
        b' ' => ctx.push(3),
        ch @ b'0'..=b'9' => ctx.push(ch - b'0' + 4),
        ch @ b'A'..=b'Z' => ctx.push(ch - b'A' + 14),
        // Shift 1 set
        ch @ 0..=31 => {
            ctx.push(SHIFT1);
            ctx.push(ch);
        }
        // Shift 2 set
        ch @ 33..=47 => {
            ctx.push(SHIFT2);
            ctx.push(ch - 33);
        }
        ch @ 58..=64 => {
            ctx.push(SHIFT2);
            ctx.push(ch - 58 + 15);
        }
        ch @ 91..=95 => {
            ctx.push(SHIFT2);
            ctx.push(ch - 91 + 22);
        }
        // Shift 3
        ch @ 96..=127 => {
            ctx.push(SHIFT3);
            ctx.push(ch - 96);
        }
        _ => unreachable!(),
    }
}

pub(super) fn in_base_set(ch: u8) -> bool {
    matches!(ch, b' ' | b'0'..=b'9' | b'A'..=b'Z')
}

pub(super) fn val_size(ch: u8) -> u8 {
    match ch {
        b' ' | b'0'..=b'9' | b'A'..=b'Z' => 1,
        0..=31 | 33..=47 | 58..=64 | 91..=127 => 2,
        ch => 2 + val_size(ch - 128),
    }
}

/// Encode three C40 values into two codewords.
pub(super) fn write_three_values<T: EncodingContext>(ctx: &mut T, c1: u8, c2: u8, c3: u8) {
    let enc = 1600 * c1 as u16 + 40 * c2 as u16 + c3 as u16 + 1;
    ctx.push((enc >> 8) as u8);
    ctx.push((enc & 0xFF) as u8);
}

pub(super) fn handle_end<T>(
    ctx: &mut T,
    last_ch: u8,
    mut buf: ArrayVec<u8, 6>,
) -> Result<(), DataEncodingError>
where
    T: EncodingContext,
{
    assert!(buf.len() <= 2);

    // this method is called after a requested mode switch if and only if
    // there are characters left
    let mode_switch = ctx.has_more_characters();
    if !ctx.has_more_characters() {
        let size_left = ctx
            .symbol_size_left(buf.len())
            .ok_or(DataEncodingError::TooMuchOrIllegalData)?;
        match (size_left + buf.len(), buf.len()) {
            // c


3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) ÷ [999.0] LEFT-POINTING ANGLE BRACKET (OP) ÷ [0.3]
× 50005 × 0308 × 0020 ÷ 2329 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] LEFT-POINTING ANGLE BRACKET (OP) ÷ [0.3]
× 50005 × 0025 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [24.03] PERCENT SIGN (PO) ÷ [0.3]
× 50005 × 0020 ÷ 0025 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [7.01] SPACE (SP) ÷ [18.0] PERCENT SIGN (PO) ÷ [0.3]
× 50005 × 0308 × 0025 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [24.03] PERCENT SIGN (PO) ÷ [0.3]
× 50005 × 0308 × 0020 ÷ 0025 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] PERCENT SIGN (PO) ÷ [0.3]
× 50005 × 0024 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [24.03] DOLLAR SIGN (PR) ÷ [0.3]
× 50005 × 0020 ÷ 0024 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [7.01] SPACE (SP) ÷ [18.0] DOLLAR SIGN (PR) ÷ [0.3]
× 50005 × 0308 × 0024 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [24.03] DOLLAR SIGN (PR) ÷ [0.3]
× 50005 × 0308 × 0020 ÷ 0024 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] DOLLAR SIGN (PR) ÷ [0.3]
× 50005 × 0022 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [19.01] QUOTATION MARK (QU) ÷ [0.3]
× 50005 × 0020 ÷ 0022 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [7.01] SPACE (SP) ÷ [18.0] QUOTATION MARK (QU) ÷ [0.3]
× 50005 × 0308 × 0022 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [19.01] QUOTATION MARK (QU) ÷ [0.3]
× 50005 × 0308 × 0020 ÷ 0022 ÷	#  × [0.3] <reserved-50005> (XX_AL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] QUOTATION MARK (QU) ÷ [0.3]
× 50005 × 0020 ÷	#


// to Felts
func getFeltsFromBytes(blockSize int) func(bytes []byte) []*felt.Felt {
	return func(bytes []byte) []*felt.Felt {
		rounded := utils.ByteRounder(blockSize)(bytes)

		chunks := utils.Split(rounded, blockSize)

		feltSlice := make([]*felt.Felt, len(chunks))
		for i, chunk := range chunks {
			feltSlice[i] = felt.New().SetBytes(chunk)
		}
		return feltSlice
	}
}

// Write splits the input either into 32 or 16 length byte chunks
// (depending on the BlockSize), converts them to Felts and
// appends these Felts to the pedersenHash's input
func (ph *pedersenHash) Write(input []byte) (int, error) {
	if ph.is128 {
		ph.input = append(ph.input, getFeltsFromBytes(BlockSize128)(input)...)
	} else {
		ph.input = append(ph.input, getFeltsFromBytes(BlockSize)(input)...)
	}
	return len(input), nil
}

// checkSum returns the fixed length (32 bytes) hash of the
// pedersenHash's input
func (ph *pedersenHash) checkSum() [Size]byte {
	return hashing.Hash(ph.input...).Bytes32()
}

// Sum appends the checksum of the pedersenHash's input to the
// bytes slice that was passed in and returns the resulting slice
func (ph *pedersenHash) Sum(in []byte) []byte {
	hash := ph.checkSum()
	return append(in, hash[:]...)
}

// Sum splits the input into 32 length byte chunks and returns
// the fixed length (32 bytes) checksum of these chunks
func Sum(data []byte) [Size]byte {
	var ph pedersenHash
	ph.Reset()
	ph.Write(data)
	return ph.checkSum()
}

// Sum128 splits the input into 16 length byte chunks and returns
// the fixed length (32 bytes) checksum of these chunks
func Sum128(data []byte) [Size]byte {
	var ph pedersenHash
	ph.Reset()
	ph.is128 = true
	ph.Write(data)
	return ph.checkSum()
}

func ByteRounderFactory(n int) func(byteSlice []byte) []byte {
	return func(byteSlice []byte) []byte {
		rem := len(byteSlice) % n
		rem = (n - rem) % n
		byteSliceRounded := append(make([]byte, rem), byteSlice...)
		return byteSliceRounded
	}
}

func RandFeltBytes(n int) []byte {
	numb, _ := big.NewInt(0).SetString("3618502788666131213697322783095070105623107215331596699973092056135872020480", 10)
	randNumb, _ := rand.Int(rand.Reader, numb)
	randBytes := randNumb.Bytes()

	randBytesRounded := ByteRounderFactory(n)(randBytes)

	return randBytesRounded[:n]
}
package merkle

// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// These tests were taken from https://


 origin, vec3_t axis[3], int lateTime, int clientID = -1, int modelNum = -1, int boltNum = -1 );
	void	CreateEffect( CPrimitiveTemplate *fx, int clientID, int lateTime );

public:

	CFxScheduler();

	void	LoadSave_Read();
	void	LoadSave_Write();
	void	FX_CopeWithAnyLoadedSaveGames();

	int		RegisterEffect( const char *file, bool bHasCorrectPath = false );	// handles pre-caching

	// Nasty overloaded madness
	void	PlayEffect( int id, vec3_t org, bool isPortal = false );							// uses a default up axis
	void	PlayEffect( int id, vec3_t org, vec3_t fwd, bool isPortal = false );				// builds arbitrary perp. right vector, does a cross product to define up
	void	PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo=-1, const int entNum=-1, bool isPortal = false, int iLoopTime = false, bool isRelative = false );
	void	PlayEffect( const char *file, vec3_t org, bool isPortal = false );					// uses a default up axis
	void	PlayEffect( const char *file, vec3_t org, vec3_t fwd, bool isPortal = false );		// builds arbitrary perp. right vector, does a cross product to define up
	void	PlayEffect( const char *file, vec3_t origin, vec3_t axis[3], const int boltInfo, const int entNum, bool isPortal = false, int iLoopTime = false, bool isRelative = false );

	//for muzzle
	void	PlayEffect( const char *file, int clientID, bool isPortal = false );

#ifdef _IMMERSION	// for ff-system
	void	PlayEffect( int id, int clientNum, vec3_t org, vec3_t fwd, bool isPortal = false );
	void	PlayEffect( const char *file, int clientNum, vec3_t origin, vec3_t forward, bool isPortal = false );
#endif // _IMMERSION

	void	StopEffect( const char *file, const int boltInfo, bool isPortal = false );	//find a scheduled Looping effect with these parms and kill it

	void	AddScheduledEffects( bool portal );								// call once per CGame frame [rww ammendment - twice now actually, but first only renders portal effects]

	int		NumScheduledFx()	{ return mFxSchedule.size();	}
	void	Clean(bool bRemoveTemplates = true, int idToPreserve = 0);	// clean out the system

	// FX Override functions
	SEffectTemplate		*GetEffectCopy( int fxHandle, int *newHandle );
	SEffectTemplate		*GetEffectCopy( const char *file, int *newHandle );

	CPrimitiveTemplate	*GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName );
};

//-------------------
// The one and only
//-------------------
extern CFxScheduler theFxScheduler;

#endif // FX_SCHEDULER_H_INC


1, [sp, #0x6c]
	ldr     r0, [sp, #0x18]
	lsl     r1, r1, #5
	blx     Function_20a8224_LoadTexOBJ
	add     r0, r4, #0x4
	str     r0, [sp, #0x1c]
	ldr     r0, [sp, #0x68]
	ldr     r2, [sp, #0x5c]
	str     r0, [sp, #0x0]
	mov     r0, #0x1
	str     r0, [sp, #0x4]
	ldr     r0, [r5, #0x24]
	ldr     r3, [sp, #0x60]
	add     r1, sp, #0x1c
	bl      Function_21d785c
	str     r0, [r4, #0x0]
	cmp     r0, #0x0
	bne     branch_21da610
	bl      ErrorHandling
.thumb
branch_21da610: @ 21da610 :thumb
	ldrh    r1, [r4, #0x2c]
	ldr     r0, [r4, #0x0]
	.hword  0x1c89 @ add r1, r1, #0x2
	bl      Function_2021e90
	ldr     r0, [r5, #0x40]
	bl      Function_21d5ec8
	mov     r2, r0
	mov     r0, r5
	mov     r1, r4
	bl      Function_21da63c
	ldr     r1, [sp, #0x14]
	mov     r0, r6
	bl      InitEncryptPkmnData_Part1Again
	add     sp, #0x40
	pop     {r3-r7,pc}
@ 0x21da636

.align 2
.word 0x300010 @ 0x21da638

.thumb
Function_21da63c: @ 21da63c :thumb
	push    {r4-r6,lr}
	cmp     r2, #0x0
	beq     branch_21da682
	mov     r3, #0x1
	mov     r0, r2
	tst     r0, r3
	beq     branch_21da65a
	ldrh    r0, [r1, #0x30]
	cmp     r0, #0x0
	bne     branch_21da65a
	ldr     r0, [r1, #0x0]
	mov     r1, r3
	bl      Function_2021fe0
	pop     {r4-r6,pc}
@ 0x21da65a

.thumb
branch_21da65a: @ 21da65a :thumb
	mov     r3, #0x0
	mov     r4, #0x1
	mov     r0, #0x2
.thumb
branch_21da660: @ 21da660 :thumb
	mov     r5, r0
	lsl     r5, r3
	tst     r5, r2
	beq     branch_21da67c
	mov     r5, r4
	ldrh    r6, [r1, #0x2e]
	lsl     r5, r3
	tst     r5, r6
	bne     branch_21da67c
	ldr     r0, [r1, #0x0]
	mov     r1, r4
	bl      Function_2021fe0
	pop     {r4-r6,pc}
@ 0x21da67c

.thumb
branch_21da67c: @ 21da67c :thumb
	.hword  0x1c5b @ add r3, r3, #0x1
	cmp     r3, #0x6
	blt     branch_21da660
.thumb
branch_21da682: @ 21da682 :t


__(cmpl $(1*node_size),%nargs)
        __(je local_label(all_args_popped))
        __(pop %arg_y)
        __(cmpl $(2*node_size),%nargs)
        __(je local_label(all_args_popped))
local_label(pop_arg_x):
        __(pop %arg_x)
local_label(all_args_popped):
        /* If all args fit in registers but some were pushed */
        /* by the caller, discard the reserved frame that the caller */
        /* pushed.         */
        __(cmpw %imm0_w,%nargs_w)
        __(je local_label(go))
        __(cmpl $(nargregs*node_size),%nargs)
        __(ja local_label(go))
        __(addq $(2*node_size),%rsp)
local_label(go):
        __(jmp *%ra0)
	/* vpush args from the lexpr until we have only */
	/* three left, then assign them to arg_x, arg_y, */
	/* and arg_z. */
8:      __(cmpw $(4*node_size),%imm0_w)
        __(lea -1*node_size(%imm0),%imm0)
        __(push -node_size(%imm1))
        __(lea -1*node_size(%imm1),%imm1)
9:      __(jne 8b)
        __(movq -node_size*1(%imm1),%arg_x)
        __(movq -node_size*2(%imm1),%arg_y)
        __(movq -node_size*3(%imm1),%arg_z)
        __(jmp *%ra0)

	/* lexpr count is two: set arg_y, arg_z from the */
	/* lexpr, maybe vpop arg_x */
2:      __(cmpl $(2*node_size),%nargs)
        __(movq -node_size*1(%imm1),%arg_y)
        __(movq -node_size*2(%imm1),%arg_z)
        __(jne local_label(pop_arg_x))
        __(jmp *%ra0)
	/* lexpr count is one: set arg_z from the lexpr, */
	/* maybe vpop arg_y, arg_x  */
1:      __(movq -node_size*1(%imm1),%arg_z)
        __(jmp local_label(maybe_pop_yx))
_endsubp(spread_lexprz)

/* Callback index in %r11 */
_spentry(callback)
	__(push %rbp)
	__(movq %rsp,%rbp)
	/* C scalar args   */
	__(push %carg0)	/* -8(%rbp)   */
	__(push %carg1)
	__(push %carg2)
	__(push %carg3)
	__ifndef(`WINDOWS')
	__(push %carg4)
	__(push %carg5)
	__endif
	/* FP arg regs   */
	__ifdef(`WINDOWS')
	__(subq $4*8,%rsp)
	__(movq %xmm0,3*8(%rsp))	/* -40(%rbp) */
	__(movq %xmm1,2*8(%rsp))
	__(movq %xmm2,1*8(%rsp))
	__(movq %xmm3,0*8(%rsp))
	__else
	__(subq $8*8,%rsp)
	__(movq %xmm0,7*8(%rsp))	/* -56(%rbp) */
	__(movq %xmm1,6*8(%rsp))
	__(movq %xmm2,5*8(%rsp))
	__(movq %xmm3,4*8(%rsp))
	__(movq %xmm4,3*8(%rsp))
	__(movq %xmm5,2*8(%rsp))
	__(movq %x


-family: 'Lora', serif;
  font-size: 26px;
  line-height: 39px;
  font-size: 2.6rem;
  line-height: 3.9000000000000004rem;
  font-weight: 400;
}
/*-------------------------------------------------------------------*/
/* 2.16 FOOTER
---------------------------------------------------------------------*/
.lgx-footer {
  background: #2e2841;
  color: #fff;
  text-align: center;
}
.lgx-footer .lgx-footer-bg {
  background: url('http://placehold.it/1920x1002') bottom left no-repeat;
  -webkit-background-size: auto auto, cover;
  -o-background-size: auto auto, cover;
  -moz-background-size: auto auto, cover;
  background-size: auto auto, cover;
}
.lgx-footer .lgx-inner {
  background: rgba(46, 40, 65, 0.9);
  margin: 0 auto;
}
.lgx-footer .lgx-subscriber-area {
  margin-bottom: 4.2rem;
}
.lgx-footer .lgx-subscriber-area .title {
  font-family: 'Lora', serif;
  font-size: 26px;
  line-height: 39px;
  font-size: 2.6rem;
  line-height: 3.9000000000000004rem;
  font-weight: 400;
  margin: 0 0 2.6rem;
}
.lgx-footer .lgx-subscriber-area .subscribe-form {
  background: rgba(255, 255, 255, 0.5);
  padding: .8rem;
  border-radius: 4px;
  display: block;
  overflow: hidden;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .form-group {
  margin-bottom: 0;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .lgx-input-form,
.lgx-footer .lgx-subscriber-area .subscribe-form .lz-submit-btn {
  float: left;
  -webkit-box-shadow: 0 4px 10px rgba(0, 0, 0, 0.25);
  -moz-box-shadow: 0 4px 10px rgba(0, 0, 0, 0.25);
  box-shadow: 0 4px 10px rgba(0, 0, 0, 0.25);
  height: 52px;
  border-radius: 4px;
  border: none;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .lgx-input-form {
  width: 80%;
  padding-left: 2rem;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .lz-submit-btn {
  width: 19%;
  margin-left: 1%;
  font-family: 'Oswald', sans-serif;
  background: #42bd41;
  color: #fff;
  text-transform: uppercase;
  -webkit-transition: all 0.3s ease-in-out 0s;
  -moz-transition: all 0.3s ease-in-out 0s;
  -o-transition: all 0.3s ease-in-out 0s;
  transition: all 0.3s ease-in-out 0s;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .lz-submit-btn:hover {
  background: #dc4e41;
}
.lgx-footer .lgx-subscriber-area .subscribe-form .lz-submit-btn:hover span {
  display: block;
  -webkit-animation-name: zoomIn;
  animation-name: zoomIn;
  -webkit-transform-origin: center;
  transform-origin: center;
  animation-duration: 500ms;
  animation-timing-function: linear;
}
.lgx-footer .lgx-logo {
  margin-bottom: 4.2rem;
}
.lgx-footer .footer-social {


InputAttribute
    {
        public HobbyInput()
        {
            Type = "checkbox";
        }
        public override object Data => new object[] {
            new { value


 "MichaelColorCodeBright",
  "TrevorColorCodeBright",
  "NeutralColorCodeBright",
  "Kifflom",
  "MP_job_load_01",
  "MP_job_load_02",
  "MP_job_preload",
  "MP_job_preload_blend",
  "NG_filmnoir_BW01",
  "NG_filmnoir_BW02",
  "NG_filmic01",
  "NG_filmic02",
  "NG_filmic03",
  "NG_filmic04",
  "NG_filmic05",
  "NG_filmic06",
  "NG_filmic07",
  "NG_filmic08",
  "NG_filmic09",
  "NG_filmic10",
  "NG_filmic11",
  "NG_filmic12",
  "NG_filmic13",
  "NG_filmic14",
  "NG_filmic15",
  "NG_filmic16",
  "NG_filmic17",
  "NG_filmic18",
  "NG_filmic19",
  "NG_filmic20",
  "underwater",
  "underwater_deep",
  "NoAmbientmult",
  "superDARK",
  "CAMERA_BW",
  "Forest",
  "micheal",
  "TREVOR",
  "FRANKLIN",
  "Tunnel",
  "carpark",
  "NEW_abattoir",
  "Vagos",
  "cops",
  "Bikers",
  "BikersSPLASH",
  "VagosSPLASH",
  "CopsSPLASH",
  "VAGOS_new_garage",
  "VAGOS_new_hangout",
  "NEW_jewel",
  "frankilnsAUNTS_new",
  "frankilnsAUNTS_SUNdir",
  "StreetLighting",
  "NEW_tunnels",
  "NEW_yellowtunnels",
  "NEW_tunnels_hole",
  "NEW_tunnels_ditch",
  "Paleto",
  "new_bank",
  "ReduceDrawDistance",
  "ReduceDrawDistanceMission",
  "lightpolution",
  "NEW_lesters",
  "ReduceDrawDistanceMAP",
  "reducewaterREF",
  "Garage",
  "LightPollutionHills",
  "NewMicheal",
  "NewMichealupstairs",
  "NewMichealstoilet",
  "NewMichealgirly",
  "WATER_port",
  "WATER_salton",
  "WATER_river",
  "FIB_interview",
  "NEW_station_unfinished",
  "cashdepot",
  "cashdepotEMERGENCY",
  "FrankilinsHOUSEhills",
  "HicksbarNEW",
  "NOdirectLight",
  "SALTONSEA",
  "TUNNEL_green",
  "NewMicheal_night",
  "WATER_muddy",
  "WATER_shore",
  "damage",
  "hitped",
  "dying",
  "overwater",
  "whitenightlighting",
  "TUNNEL_yellow",
  "buildingTOP",
  "WATER_lab",
  "cinema",
  "fireDEPT",
  "ranch",
  "TUNNEL_white",
  "V_recycle_mainroom",
  "V_recycle_dark",
  "V_recycle_light",
  "lightning_weak",
  "lightning_strong",
  "lightning_cloud",
  "gunclubrange",
  "NoAmbientmult_interior",
  "FullAmbientmult_interior",
  "StreetLightingJunction",
  "StreetLightingtraffic",
  "Multipayer_spectatorCam",
  "INT_NoAmbientmult",
  "INT_NoAmbientmult_art",


":"article",
        "imgurl":"http://cms-bucket.ws.126.net/2019/06/20/215947bc1bef46fd800fd9d9ca1f7a9e.png?imageView&thumbnail=190y120",
        "add1":"",
        "add2":"",
        "add3":""
    },
    {
        "title":"外设厂商开始生产新iPhone专用镜头保护膜",
        "docurl":"https://tech.163.com/19/0620/12/EI460QKA00097U7S.html",
        "commenturl":"http://comment.tie.163.com/EI460QKA00097U7S.html",
        "tienum":3,
        "tlastid":"通信",
        "tlink":"http://tech.163.com/telecom/",
        "label":"通信",
        "keywords":[
            {
                "akey_link":"http://tech.163.com/keywords/4/d/4fdd62a4819c/1.html",
                "keyname":"保护膜"
            }
        ],
        "time":"06/20/2019 12:17:06",
        "newstype":"article",
        "imgurl":"http://cms-bucket.ws.126.net/2019/06/20/552b931a0fe64b059664a7358cc232ed.png?imageView&thumbnail=190y120",
        "add1":"",
        "add2":"",
        "add3":""
    },
    {
        "title":"京东物流618战报：非京东平台业务收入增幅超120%",
        "docurl":"https://tech.163.com/19/0620/10/EI4169FI00097U7R.html",
        "commenturl":"http://comment.tie.163.com/EI4169FI00097U7R.html",
        "tienum":46,
        "tlastid":"互联网",
        "tlink":"http://tech.163.com/internet/",
        "label":"互联网",
        "keywords":[
            {
                "akey_link":"http://tech.163.com/keywords/0/3/003600310038/1.html",
                "keyname":"618"
            },
            {
                "akey_link":"http://tech.163.com/keywords/4/a/4eac4e1c/1.html",
                "keyname":"京东"
            },
            {
                "akey_link":"http://tech.163.com/keywords/7/6/72696d41/1.html",
                "keyname":"物流"
            }
        ],
        "time":"06/20/2019 10:52:42",
        "newstype":"article",
        "imgurl":"http://cms-bucket.ws.126.net/2019/06/20/3e43858203da4440ae2ba756b5909733.png?imageView&thumbnail=190y120",
        "add1":"",
        "add2":"",
        "add3":""
    },
    {
        "title":"任正非答美媒：华为年营收真降300亿美元也是小事",
        "docurl":"https://tech.163.com/19/0620/10/EI3UBF7500097U7S.html",
        "commenturl":"http://comment.tie.163.com/EI3UBF7500097U7S.html",
        "tienum":2719,
        "tlastid":"通信",
        "tlink


.indexOf(ut.charAt(Qn++)),An=St.indexOf(ut.charAt(Qn++)),Xr=Wr<<2|Re>>4,g=(Re&15)<<4|Ti>>2,ki=(Ti&3)<<6|An,cr=cr+String.fromCharCode(Xr),Ti!==64&&(cr=cr+String.fromCharCode(g)),An!==64&&(cr=cr+String.fromCharCode(ki));while(Qn<ut.length);return cr};function oe(ut){try{for(var St=ao(ut),cr=new Uint8Array(St.length),Xr=0;Xr<St.length;++Xr)cr[Xr]=St.charCodeAt(Xr);return cr}catch{throw new Error("Converting base64 string to bytes failed.")}}function de(ut){if(to(ut))return oe(ut.slice(ci.length))}var ve={Math,Int8Array,Int32Array,Uint8Array,Float32Array,Float64Array},Pe={a:mi,b:T,c:E,d:ql,e:al,f:sl,g:Cl,h:Ml,i:Ms,j:Xo,k:So,l:ca,m:Us,n:Fc,o:Eo,p:qt},ye=function(ut,St,cr){var Xr=new ut.Int8Array(cr),g=new ut.Int32Array(cr),ki=new ut.Uint8Array(cr),Wr=new ut.Float32Array(cr),Re=new ut.Float64Array(cr),Ti=St.o|0,An=St.p|0,Qn=ut.Math.floor,En=ut.Math.abs,ln=ut.Math.sqrt,$n=ut.Math.pow,ji=ut.Math.cos,Gi=ut.Math.sin,an=ut.Math.tan,ea=ut.Math.acos,Yh=ut.Math.asin,Hs=ut.Math.atan,Ko=ut.Math.atan2,fu=ut.Math.ceil,fl=ut.Math.imul,hu=ut.Math.min,Sn=ut.Math.max,ha=ut.Math.clz32,gi=St.b,Fe=St.c,_i=St.d,Kh=St.e,Vc=St.f,Is=St.g,Kf=St.h,Xl=St.i,Ie=24160;function hl(m){return Xr=new Int8Array(m),ki=new Uint8Array(m),g=new Int32Array(m),Wr=new Float32Array(m),Re=new Float64Array(m),cr=m,!0}function hc(m){m=m|0;var A=0;return A=Ie,Ie=Ie+m|0,Ie=Ie+15&-16,A|0}function Hc(){return Ie|0}function rf(m){m=m|0,Ie=m}function Zf(m,A){m=m|0,A=A|0,Ie=m}function Jf(m,A){m=m|0,A=A|0;var y=0,w=0,C=0;return(m|0)<0?(A=2,A|0):(m|0)>13780509?(


202J"
          + " \001(\0132\037.google.cloud.compute.v1.RouterB\003\340A\002B\r\n"
          + "\013_request_id\"\361\001\n"
          + "\036PatchRuleFirewallPolicyRequest\022 \n"
          + "\017firewall_policy\030\321\212\306\355\001 \001(\tB\003\340A\002\022Z\n"
          + "\035firewall_policy_rule_resource\030\203\337\272w \001"
          + "(\0132+.google.cloud.compute.v1.FirewallPolicyRuleB\003\340A\002\022\031\n"
          + "\010priority\030\244\363\241\324\001 \001(\005H\000\210\001\001\022\032\n\n"
          + "request_id\030\313\201\331\021 \001(\tH\001\210\001\001B\013\n"
          + "\t_priorityB\r\n"
          + "\013_request_id\"\233\002\n"
          + "%PatchRuleNetworkFirewallPolicyRequest\022 \n"
          + "\017firewall_policy\030\321\212\306\355\001 \001(\tB\003\340A\002\022Z\n"
          + "\035firewall_policy_rule_resource\030\203\337\272w"
          + " \001(\0132+.google.cloud.compute.v1.FirewallPolicyRuleB\003\340A\002\022\031\n"
          + "\010priority\030\244\363\241\324\001 \001(\005H\000\210\001\001\022!\n"
          + "\007project\030\231\226\301l \001(\tB\r"
          + "\340A\002\362G\007project\022\032\n\n"
          + "request_id\030\313\201\331\021 \001(\tH\001\210\001\001B\013\n"
          + "\t_priorityB\r\n"
          + "\013_request_id\"\302\002\n"
          + "+PatchRuleRegionNetworkFirewallPolicyRequest\022 \n"
          + "\017firewall_policy\030\321\212\306\355\001 \001(\tB\003\340A\002\022Z\n"
          + "\035firewall_policy_rule_resource\030\203\337\272w"
          + " \001(\0132+.google.cloud.compute.v1.FirewallPolicyRuleB\003\340A\002\022\031\n"
          + "\010priority\030\244\363\241\324\001 \001(\005H\000\210\001\001\022!\n"
          + "\007project\030\231\226\301l \001(\tB\r"
          + "\340A\002\362G\007project\022\037\n"
          + "\006region\030\364\315\240B \001(\tB\014\340A\002\362G\006region\022\032\n\n"
          + "request_id\030\313\201\331\021 \001(\tH\001\210\001\001B\013\n"
          + "\t_priorityB\r\n"
          + "\013_request_id\"\357\002\n"
          + "$PatchRuleRegionSecurityPolicyRequest\022\031\n"
          + "\010priority\030\244\363\241\324\001 \001(\005H\000\210\001\001\022!\n"
          + "\007project\030\231\226\301l \001(\tB\r"
          + "\340A\002\362G\007project\022\037\n"
          + "\006region\030\364\315\240B \001(\tB\014\340A\002\362G\006region\022\037\n"


B)].apply(null, [ZS, DP]) : IQ()[V9(EB)](M0, s8)][Uh()[CQ(ZE)](PE, dw, q4, cF, Ps(Ps(Th)), hg)][QB(typeof IQ()[V9(qz)], 'undefined') ? IQ()[V9(EB)](JW, gg) : IQ()[V9(EK)](pT, tB)], mR()[CA(Xm)].apply(null, [YP, Gt, LL]))[gE()[B4(kE)](Ps(Th), tK, M5, VP)](wI[IQ()[V9(YB)].call(null, ZS, DP)][Uh()[CQ(ZE)](PE, dw, q4, nb, JK, dC)][mR()[CA(OK)](Ps([]), kx, UX)], sh()[dE(PE)].apply(null, [kE, TF, rw, Pm, Ks, Gv]))[V0(typeof gE()[B4(ht)], IF('', [][[]])) ? gE()[B4(kE)].apply(null, [DP, Ps([]), M5, VP]) : gE()[B4(OW)](Hl, zB, Xd, PP)](R3H);
                    var s7H = jLH();
                    s7H[Lt()[D1(Ks)](El, XR, SD, s6)](gE()[B4(JK)].apply(null, [d9, NQ, d7, FR]), NTH, Ps(Ps({})));
                    s7H[gE()[B4(GB)](qh, wd, r2, Ab)] = function() {
                        HK.push(tt);
                        pP(s7H[sh()[dE(vA)](j9, YR, XR, ZM, Q0, Lv)], vQ[M0]) && vSH && vSH(s7H);
                        HK.pop();
                    }
                    ;
                    s7H[V0(typeof IQ()[V9(zx)], 'undefined') ? IQ()[V9(hg)].call(null, fS, R9) : IQ()[V9(EB)](JK, KU)]();
                    HK.pop();
                };
                var r5H = function() {
                    HK.push(nb);
                    var B2H = pP(arguments[Lt()[D1(Th)](vB, FR, c0, RU)], vQ[q4]) && V0(arguments[Th], undefined) ? arguments[Th] : Ps([]);
                    var ppH = pP(arguments[Lt()[D1(Th)](dC, Ps([]), c0, RU)], XR) && V0(arguments[XR], undefined) ? arguments[XR] : Ps(Ps(z7));
                    var G2H = new (wI[mR()[CA(Ks)].call(null, FP, Vt, mS)])();
                    if (B2H) {
                        G2H[Lt()[D1(R9)](PE, Ps(Ps(Th)), ZE, Y4)](V0(typeof IQ()[V9(El)], IF([], [][[]])) ? IQ()[V9(nb)].apply(null, [UV, YA]) : IQ()[V9(EB)](vh, zC));
                    }
                    if (ppH) {
                        G2H[Lt()[D1(R9)](dK, bm, ZE, Y4)](V0(typeof Lt()[D1(JK)], 'undefined') ? Lt()[D1(bm)](VP, Hb, Bv, cx) : Lt()[D1(j9)](Ps(Ps([])), YB, zW, Bc));
                    }
                    if (pP(G2H[gE()[B4(mN)](GB, hE, kn, Bv)], Th)) {
                        try {
                            var NOH = HK.length;
                            var EpH = Ps(cY);
                            J6H(wI[IQ()[V9(VF)](dx, Bl)][JB()[FW(Hb)](nC, hE, N1, F4, x1, Sg)](G2H)[IQ()[V9(Z0)].apply(null, [Nz, LM])](gE()[B4(VR)


15px}.tox[dir=rtl] .tox-hue-slider-thumb{margin-right:-1px}.tox[dir=rtl] .tox-rgb-form label{margin-left:.5em}.tox .tox-toolbar .tox-swatches,.tox .tox-toolbar__overflow .tox-swatches,.tox .tox-toolbar__primary .tox-swatches{margin:2px 0 3px 4px}.tox .tox-collection--list .tox-collection__group .tox-swatches-menu{border:0;margin:-4px 0}.tox .tox-swatches__row{display:flex}.tox .tox-swatch{height:30px;transition:transform .15s,box-shadow .15s;width:30px}.tox .tox-swatch:focus,.tox .tox-swatch:hover{box-shadow:0 0 0 1px rgba(127,127,127,.3) inset;transform:scale(.8)}.tox .tox-swatch--remove{align-items:center;display:flex;justify-content:center}.tox .tox-swatch--remove svg path{stroke:#e74c3c}.tox .tox-swatches__picker-btn{align-items:center;background-color:transparent;border:0;cursor:pointer;display:flex;height:30px;justify-content:center;outline:0;padding:0;width:30px}.tox .tox-swatches__picker-btn svg{fill:#222f3e;height:24px;width:24px}.tox .tox-swatches__picker-btn:hover{background:#dee0e2}.tox div.tox-swatch:not(.tox-swatch--remove) svg{display:none;fill:#222f3e;height:24px;margin:calc((30px - 24px)/ 2) calc((30px - 24px)/ 2);width:24px}.tox div.tox-swatch:not(.tox-swatch--remove) svg path{fill:#fff;paint-order:stroke;stroke:#222f3e;stroke-width:2px}.tox div.tox-swatch:not(.tox-swatch--remove).tox-collection__item--enabled svg{display:block}.tox:not([dir=rtl]) .tox-swatches__picker-btn{margin-left:auto}.tox[dir=rtl] .tox-swatches__picker-btn{margin-right:auto}.tox .tox-comment-thread{background:#fff;position:relative}.tox .tox-comment-thread>:not(:first-child){margin-top:8px}.tox .tox-comment{background:#fff;border:1px solid #ccc;border-radius:3px;box-shadow:0 4px 8px 0 rgba(34,47,62,.1);padding:8px 8px 16px 8px;position:relative}.tox .tox-comment__header{align-items:center;color:#222f3e;display:flex;justify-content:space-between}.tox .tox-comment__date{color:#222f3e;font-size:12px;line-height:18px}.tox .tox-comment__body{color:#222f3e;font-size:14px;font-style:normal;font-weight:400;line-height:1.3;margin-top:8px;position:relative;text-transform:initial}.tox .tox-comment__body textarea{resize:none;white-space:normal;width:100%}.tox .tox-comment__expander{padding-top:8px}.tox .tox-comment__expander p{color:rgba(34,47,62,.7);font-size:14px;font-style:normal}.tox .tox-comment__body p{margin:0}.tox .tox-comment__buttonspacing{padding-top:16px;text-align:center}.tox .tox-comment-thread__overlay::after{background:#fff;bottom:0;content:"";display:flex;left:0;opacity:.9;position:absolute;right:0;top:0;z-index:5}.tox .tox-comment__reply{display:flex;flex-shrink:0;flex-wrap:wrap;justify-content:flex-end;margin-top:8px}.tox .tox-comment__reply>:fi


hy">ProdCharacteristic	Dimensions, color etc.

 otherCharacteristics 	Σ	0..*	CodeableConcept	Other codeable characteristics

 Documentation for this format

UML Diagram (Legend)

 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="370.1600000000001" id="n24" version="1.1" height="144.0">  <defs>
    <filter x="0" width="200%" y="0" id="shadowA" height="200%">
      <feOffset result="offOut" dx="3" in="SourceGraphic" dy="3"></feOffset>
      <feColorMatrix result="matrixOut" in="offOut" values="0.2 0 0 0 0 0 0.2 0 0 0 0 0 0.2 0 0 0 0 0 1 0" type="matrix"></feColorMatrix>
      <feGaussianBlur result="blurOut" stdDev


  position: relative;
  float: left;
  max-height: 1px;
  overflow: hidden;
  z-index: -1;
  padding: 0;
  margin: 0;
  pointer-events: none;
  flex-grow: inherit;
  flex-shrink: 0;
  flex-basis: 0;
}

.simplebar-height-auto-observer {
  box-sizing: inherit;
  display: block;
  opacity: 0;
  position: absolute;
  top: 0;
  left: 0;
  height: 1000%;
  width: 1000%;
  min-height: 1px;
  min-width: 1px;
  overflow: hidden;
  pointer-events: none;
  z-index: -1;
}

.simplebar-track {
  z-index: 1;
  position: absolute;
  right: 0;
  bottom: 0;
  pointer-events: none;
  overflow: hidden;
}

[data-simplebar].simplebar-dragging .simplebar-content {
  pointer-events: none;
  -moz-user-select: none;
       user-select: none;
  -webkit-user-select: none;
}
[data-simplebar].simplebar-dragging .simplebar-track {
  pointer-events: all;
}

.simplebar-scrollbar {
  position: absolute;
  left: 0;
  right: 0;
  min-height: 10px;
}
.simplebar-scrollbar:before {
  position: absolute;
  content: "";
  background: #9cb7d2;
  border-radius: 7px;
  left: 2px;
  right: 2px;
  opacity: 0;
  transition: opacity 0.2s linear;
}
.simplebar-scrollbar.simplebar-visible:before {
  opacity: 0.5;
  transition: opacity 0s linear;
}

.simplebar-track.simplebar-vertical {
  top: 0;
  width: 11px;
}
.simplebar-track.simplebar-vertical .simplebar-scrollbar:before {
  top: 2px;
  bottom: 2px;
}
.simplebar-track.simplebar-horizontal {
  left: 0;
  height: 11px;
}
.simplebar-track.simplebar-horizontal .simplebar-scrollbar {
  right: auto;
  left: 0;
  top: 2px;
  height: 7px;
  min-height: 0;
  min-width: 10px;
  width: auto;
}
.simplebar-track.simplebar-horizontal .simplebar-scrollbar:before {
  height: 100%;
  left: 2px;
  right: 2px;
}

/* Rtl support */
[data-simplebar-direction=rtl] .simplebar-track.simplebar-vertical {
  right: auto;
  left: 0;
}

.hs-dummy-scrollbar-size {
  direction: rtl;
  position: fixed;
  opacity: 0;
  visibility: hidden;
  height: 500px;
  width: 500px;
  overflow-y: hidden;
  overflow-x: scroll;
}

.simplebar-hide-scrollbar {
  position: fixed;
  left: 0;
  visibility: hidden;
  overflow-y: scroll;
  scrollbar-width: none;
  -ms-overflow-style: none;
}

@media (min-width: 768px) {
  .footer-wrapper.container,
  .pc-content.container {
    max-width: 540px;
  }
}
@media (min-width: 992px) {
  .footer-wrapper.container,
  .pc-content.container {
    max-width: 720px;
  }
}
@media (min-width: 1200px) {
  .footer-wrapper.container,
  .pc-content.container {
    max-width: 960px;
  }
}
@media (min-w


  "Blue",
    "Red",
    "Purple",
    "Core",
    "Rainbow"
}

celesteEnums.dash_switch_sides = {
    "Up",
    "Down",
    "Left",
    "Right"
}

celesteEnums.tentacle_sides = {
    "Up",
    "Down",
    "Left",
    "Right"
}

celesteEnums.tentacle_fear_distance = {
    "close",
    "medium",
    "far"
}

celesteEnums.move_block_directions = {
    "Up",
    "Down",
    "Left",
    "Right"
}

celesteEnums.spike_directions = {
    "Up",
    "Down",
    "Left",
    "Right"
}

celesteEnums.tentacle_effect_directions = {
    "Top",
    "Bottom",
    "Left",
    "Right"
}

celesteEnums.planet_effect_sizes = {
    "big",
    "small",
    "Planets/big",
    "Planets/small"
}

celesteEnums.trigger_spike_directions = {
    "Up",
    "Down",
    "Left",
    "Right"
}

celesteEnums.spring_orientations = {
    "Floor",
    "WallLeft",
    "WallRight"
}

celesteEnums.track_spinner_speeds = {
    "Slow",
    "Normal",
    "Fast"
}

celesteEnums.fake_wall_modes = {
    "Wall",
    "Block"
}

celesteEnums.condition_block_conditions = {
    "Key",
    "Button",
    "Strawberry"
}

celesteEnums.spike_types = {
    "default",
    "outline",
    "cliffside",
    "tentacles",
    "reflection"
}

celesteEnums.crumble_block_textures = {
    "default",
    "cliffside"
}

celesteEnums.wood_platform_textures = {
    "default",
    "cliffside"
}

celesteEnums.kevin_axes = {
    "both",
    "horizontal",
    "vertical"
}

celesteEnums.npc_npcs = {
    "granny_00_house",
    "theo_01_campfire",
    "theo_02_campfire",
    "theo_03_escaping",
    "theo_03_vents",
    "oshiro_03_lobby",
    "oshiro_03_hallway",
    "oshiro_03_hallway2",
    "oshiro_03_bigroom",
    "oshiro_03_breakdown",
    "oshiro_03_suite",
    "oshiro_03_rooftop",
    "granny_04_cliffside",
    "theo_04_cliffside",
    "theo_05_entrance",
    "theo_05_inmirror",
    "evil_05",
    "theo_06_plateau",
    "granny_06_intro",
    "badeline_06_crying",
    "granny_06_ending",
    "theo_06_ending",
    "granny_07x",
    "theo_08_inside",
    "granny_08_inside",
    "granny_09_outside",
    "granny_09_inside",
    "gravestone_10",
    "granny_10_never"
}

celesteEnums.seeker_statue_hatches = {
    "Distance",
    "PlayerRightOfX"
}

celesteEnums.badeline_boss_shooting_patterns = {
    0, 1, 2, 3, 4,
    5, 6, 7, 8, 9,
    10, 11, 12, 13,
    14, 15
}

celesteEnums.slider_surfaces = {
    "Ceiling",
    "LeftWall",
    "RightWall",
    "Floor"
}


mp(0, 0, &mut int_input, &input, false);
        let mut block_count = 0;
        let mut i = 2;
        let mut pad_pos: (i64, i64) = (0, 0);
        let mut ball_pos: (i64, i64) = (0, 0);

        let mut game_state = vec![vec![0;100];30];
        //get game state
        loop {
            //detect score
            if output.return_val[i-2] == -1 && output.return_val[i-1] == 0 {
                score = output.return_val[i];
                i += 3;
                if i >= output.return_val.len() {
                    break;
                }
                continue;
            }

            //get metadata
            match output.return_val[i] {
                2 => block_count += 1, //count block
                3 => pad_pos = (output.return_val[i-2], output.return_val[i-1]), //get paddle pos
                4 => ball_pos = (output.return_val[i-2], output.return_val[i-1]), //get ball pos
                _ => ()
            }

            //store game state
            game_state[output.return_val[i-1] as usize][output.return_val[i-2] as usize] = output.return_val[i];
            i += 3;
            if i >= output.return_val.len() {
                break;
            }
        }

        //update input
        input = match (pad_pos.0).cmp(&ball_pos.0) {
            Ordering::Less => vec![1], //pad's x < ball's x
            Ordering::Equal => vec![0],
            Ordering::Greater => vec![-1],
        };

        if block_count == 0 {
            break;
        }

        //print game state
        println!("block: {}, score: {}", block_count, score);
        for row in game_state.iter() {
            for col in row.iter() {
                match col {
                    0 => print!(" "),
                    1 => print!("#"),
                    2 => print!("+"),
                    3 => print!("="),
                    4 => print!("o"),
                    _ => ()
                }
            }
            println!();
        }
    }

    Ok(())
}

fn intcode_comp(
    mut curr_pos: usize,
    mut relative_base: i64,
    int_input: &mut Vec<i64>,
    cpu_input: &Vec<i64>,
    debug: bool,
) -> IntcodeStatus {
    //big memory init
    if int_input.len() < 10000 { int_input.extend(vec![0;10000].iter()) };
    //virtual cpu parsing logic
    let status: IntcodeReturnStatus;
    let mut curr_arg = 0;
    let mut output: Vec<i64> = Vec::new();
    if debug {
        println!("Input: {:?}", cpu_input);
    }
    loop {
        if curr_pos > int_input.len() - 1 {
            panic!("vector index overflow at {}", curr_pos);
        }

        //parsing opcode
        let instruction = int_input[curr_pos];
        let opcode = instruction % 100;
        //killing opcode early if 99
        if opcode == 99 {
            status = IntcodeReturnStatus::Halted;
            break;
        };

        //parsing param and storing appropriate param val
        let param_mode = (instruction - opcode) / 100;
        let mut param_vec: Vec<u8> = param_mode.digits().rev().collect();
        while param_vec.len() < 3 {
            param_vec.push(0);
        }
        let mut param_vec_iter = param_vec.iter();

        //debugger
        if debug {
            println!("Curr_pos: {}", curr_pos);
            println!("Opcode: {}", opcode);
            println!("Param: {:?}", param_vec);
            println!("Relative Base: {}", relative_base);
            println!("Next: {} {} {}", int_input[curr_pos + 1], int_input[curr


ataComponentIsAliveTest()
        {
            var entityManager = IoCManager.Resolve<IEntityManager>();

            var dummy = entityManager.CreateEntityUninitialized(new("dummy"));

            Assert.That(dummy, Is.Not.Null);
            Assert.That(entityManager.IsAlive(dummy), Is.True);
            Assert.That(entityManager.IsDeadAndBuried(dummy), Is.False);

            var metaDataComp = entityManager.GetComponent<MetaDataComponent>(dummy);

            Assert.That(metaDataComp.Liveness, Is.EqualTo(EntityGameLiveness.Alive));
            Assert.That(metaDataComp.IsAlive, Is.EqualTo(true));
            Assert.That(metaDataComp.IsDeadAndBuried, Is.EqualTo(false));

            metaDataComp.Liveness = EntityGameLiveness.Hidden;

            Assert.That(metaDataComp.IsAlive, Is.EqualTo(false));
            Assert.That(metaDataComp.IsDeadAndBuried, Is.EqualTo(false));

            metaDataComp.Liveness = EntityGameLiveness.DeadAndBuried;

            Assert.That(metaDataComp.IsAlive, Is.EqualTo(false));
            Assert.That(metaDataComp.IsDeadAndBuried, Is.EqualTo(true));
        }
    }
}


from utils import logger

logger = logger()

def score(texts, outputs, targets, printer = print):
    # use macro accuracy for each tag in ["B", "I", "E"]

    gold_b, gold_i, gold_e = 0, 0, 0
    correct_b, correct_i, correct_e = 0, 0, 0
    attempt_b, attempt_i, attempt_e = 0, 0, 0

    for o, t in zip(outputs, targets):
        o = o.replace(" <EOS> ", "<EOS>")
        t = t.replace(" <EOS> ", "<EOS>")
        t_tokens = []
        for t_token in t.split(' '):
            if '<EOS>' in t_token:

                # single-word sentence take the E tag
                t_subtokens = t_token.split('<EOS>')

                gold_e += (len(t_subtokens) - 1)
                t_tokens.extend([(k, "E") for k in t_subtokens[:-1]])

                t_tokens.append((t_subtokens[-1], "B"))
                gold_b += 1

            else:
                t_tokens.append((t_token, "I"))
                gold_i += 1
        for o_token in o.split(' '):
            if '<EOS>' in o_token:
                o_subtokens = o_token.split('<EOS>')

                # single-word sentences take the E tag
                for o_subtoken in o_subtokens[:-1]:
                    attempt_e += 1
                    if (o_subtoken, "E") in t_tokens:
                        correct_e += 1

                attempt_b += 1
                if (o_subtokens[-1], "B") in t_tokens:
                    correct_b += 1

            else:
                if (o_token, "I") in t_tokens:
                    correct_i += 1
                attempt_i += 1

    # show sample
    for i in range(3):
        printer("Input sentence:     %s\n" % texts[i])
        printer("Actual sentence:    %s\n" % targets[i])
        printer("Predicted sentence: %s\n" % outputs[i])
        printer("=====================================================================\n")

    if 0 in [attempt_i, attempt_b, attempt_e]:
        print([attempt_i, attempt_b, attempt_e])
        return 0, 0, 0
    else:
        b_p, b_r = correct_b / attempt_b, correct_b / gold_b
        i_p, i_r = correct_i / attempt_i, correct_i / gold_i
        e_p, e_r = correct_e / attempt_e, correct_e / gold_e

        b_f1 = b_p * b_r * 2 / (b_p + b_r)
        i_f1 = i_p * i_r * 2 / (i_p + i_r)
        e_f1 = e_p * e_r * 2 / (e_p + e_r)

        macro_p = (b_p + i_p + e_p) / 3
        macro_r = (b_r + i_r + e_r) / 3
        macro_f1 = (b_f1 + i_f1 + e_f1) / 3

        printer(f"|    |  P  |  R  | F1  |\n"
                f"------------------------\n"
                f"|Begi|{'%.3f' % b_p}|{'%.3f' % b_r}|{'%.3f' % b_f1}|\n"
                f"|  In|{'%.3f' % i_p}|{'%.3f' % i_r}|{'%.3f' % i_f1}|\n"
                f"| End|{'%.3f' % e_p}|{'%.3f' % e_r}|{'%.3f' % e_f1}|\n"
                f"|Macr|{'%.3f' % macro_p}|{'%.3f' % macro_r}|{'%.3f' % macro_f1}|\n")
        return macro_p, macro_r, macro_f1


import pygame, sys
from pygame.locals import *
#khởi tạo pygame
pygame.init()

WINDOWWIDTH = 400 # Chiều dài cửa sổ
WINDOWHEIGHT = 300 # Chiều cao cửa sổ

#tạo màn hình hiển thị
DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
pygame.display.set_caption('game')
# Tạo sẵn các màu sắc
BLACK = (  0,   0,   0)
WHITE = (255, 255, 255)
RED   = (255,   0,   0)
GREEN = (  0, 255,   0)
BLUE  = (  0,   0, 255)

### Xác định FPS ###
FPS = 60
fpsClock = pygame.time.Clock()

car_x = 0 # Hoành độ của xe
car_y = 0# Tung độ của xe
car_width = 50  # Chiều rộng xe
car_height = 50  # Chiều cao xe
car_speed = 5 # tóc độ của xe
carSurface = pygame.Surface((100, 50), SRCALPHA)
pygame.draw.polygon(carSurface, RED, ((15, 0), (65, 0), (85, 15), (100, 15), (100, 40), (0, 40), (0, 15)))
pygame.draw.circle(carSurface, GREEN, (15, 40), 10)
pygame.draw.circle(carSurface, GREEN, (85, 40), 10)
#thêm hình ảnh cho game
img = pygame.image.load('minimal spotify cover.jpg')
img = pygame.transform.scale(img, (50, 70))
img_rect = img.get_rect(center = (0, 100))

up = right = left = down = False

#vòng lặp game
while True:
    #đặt màu nền trắng
    DISPLAYSURF.fill(WHITE)
    # thêm hình ảnh
    DISPLAYSURF.blit(carSurface, (car_x, car_y))
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
    # sự kiện ấn phím
    if event.type == KEYDOWN:
        if event.key == K_UP:
            up = True
        if event.key == K_DOWN:
            down = True
        if event.key == K_LEFT:
            left = True
        if event.key == K_RIGHT:
            right = True
    # sự kiện thả phím
    if event.type == KEYUP:
        if event.key == K_UP:
            up = False
        if event.key == K_DOWN:
            down = False
        if event.key == K_LEFT:
            left = False
        if event.key == K_RIGHT:
            right = False
    # di chuyển xe lên, xuống, trái, phải
    if up and car_y > 0:
        car_y -= car_speed
    if down and car_y < WINDOWHEIGHT - car_height:
        car_y += car_speed
    if left and car_x > 0:
        car_x -= car_speed
    if right and car_x < WINDOWWIDTH - car_width:
        car_x += car_speed

    pygame.display.update()
    fpsClock.tick(FPS)


	assert.DirExists(t, filepath.Join(outputDir, "ArgoCD"))
				assert.DirExists(t, filepath.Join(outputDir, "ArgoEvents"))

				// Root files should exist in cone mode
				assert.FileExists(t, filepath.Join(outputDir, "README.md"))
			},
		},
		{
			name:  "cone mode with single directory",
			paths: []string{"Gradle"},
			cone:  true,
			verify: func(t *testing.T, outputDir string) {
				// Verify only Gradle directory exists
				assert.DirExists(t, filepath.Join(outputDir, "Gradle"))
				assert.FileExists(t, filepath.Join(outputDir, "README.md"))

				// Other directories should not exist
				assert.NoDirExists(t, filepath.Join(outputDir, "ArgoCD"))
				assert.NoDirExists(t, filepath.Join(outputDir, "ArgoEvents"))
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			outputDir := t.TempDir()

			err := executeClone(t, testRepoURL, outputDir, &commands.CloneOptions{
				RawPaths: tc.paths,
				Cone:     tc.cone,
			})
			require.NoError(t, err)

			tc.verify(t, outputDir)
		})
	}
}

func TestCloneWithAuthentication_Integration(t *testing.T) {
	test.IntegrationTest(t)
	t.Parallel()

	t.Run("valid token authentication", func(t *testing.T) {
		t.Parallel()
		// Skip if no GitHub token is available
		token := os.Getenv("GIT_TOKEN")
		if token == "" {
			t.Skip("GIT_TOKEN not set, skipping authenticated clone test")
		}

		outputDir := t.TempDir()

		// Test with token authentication
		err := executeClone(t, testRepoURL, outputDir, &commands.CloneOptions{
			Token:    token,
			AuthType: "basic",
		})
		require.NoError(t, err)

		assert.DirExists(t, filepath.Join(outputDir, ".git"))
	})

	t.Run("invalid token authentication", func(t *testing.T) {
		t.Parallel()
		// Use a private repository URL that requires authentication
		privateRepoURL := "https://github.com/kubeshop/testkube-private-test.git"
		outputDir := t.TempDir()

		// Test with invalid token
		err := executeClone(t, privateRepoURL, outputDir, &commands.CloneOptions{
			Token:    "invalid-token-12345",
			AuthType: "basic",
		})

		// Should fail with authentication error
		assert.Error(t, err)
		assert.Contains(t, err.Error(), "cloning repository")
	})

	t.Run("username without password", func(t *testing.T) {
		t.Parallel()
		outputDir := t.TempDir()

		// Test with username only (should work for public repos)
		err := executeClone(t, testRepoURL, outputDir, &commands.CloneOptions{
			Username: "testuser",
			AuthType: "basic",
		})
		require.NoError(t, err)

		assert.DirExists(t, filepath.Join(outputDir, ".git"))
	})

	t.Run("header authentication with token", func(t *testing.T) {
		t.Parallel()
		token := os.Getenv("GIT_TOKEN")
		if token == "" {
			t.Skip("GIT_TOKEN not set, skipping header auth test")
		}

		outputDir := t.TempDir()

		// Test with header authentication
		err := executeClone(t, testRepoURL, outputDir, &commands.CloneOptions{
			Token:    token,
			AuthType: "header",
		})
		require.NoError(t, err)

		as


    action="store_true",
        default=False,
        help="(optional) use known Simos12.2 AES keys instead of Simos18.1/18.6",
    )
    parser.add_argument(
        "--simos16",
        dest="simos16",
        action="store_true",
        default=False,
        help="(optional) use known Simos16 AES keys instead of Simos18.1/18.6",
    )
    parser.add_argument(
        "--dsg",
        dest="dsg",
        action="store_true",
        default=False,
        help="(optional) use DSG decryption algorithm",
    )
    parser.add_argument(
        "--dq381",
        dest="dq381",
        action="store_true",
        default=False,
        help="(optional) use DSG decryption algorithm",
    )

    parser.add_argument(
        "--outdir",
        type=str,
        default="",
        help="(optional) output directory, otherwise files will be output to current directory",
    )

    args = parser.parse_args()

    flash_info = simos18.s18_flash_info
    if args.simos122:
        flash_info = simos122.s122_flash_info
    if args.simos1810:
        flash_info = simos1810.s1810_flash_info
    if args.simos1841:
        flash_info = simos184.s1841_flash_info
    if args.simos16:
        flash_info = simos16.s16_flash_info
    if args.simos10:
        flash_info = simos10.s10_flash_info
    if args.simos8:
        flash_info = simos8.s8_flash_info
    if args.dq381:
        flash_info = dq381.dsg_flash_info
    if args.dsg:
        flash_info = dq250mqb.dsg_flash_info

    file_data = Path(args.file).read_text()

    (data_blocks, allowed_boxcodes) = extract_odx(file_data, flash_info, args.dsg)
    for data_block in data_blocks:
        print(data_block)
        with open(os.path.join(args.outdir, data_block), "wb") as dataFile:
            dataFile.write(data_blocks[data_block])


 a failure to restore items from the Favorites table.
     *
     * @param favoritesId The id of the item type from [Favorites] that was not restored.
     * @param count number of items that failed to restore.
     * @param error error type for why the data was not restored.
     */
    open fun logFavoritesItemsRestoreFailed(
        favoritesId: Int,
        count: Int,
        @RestoreError error: String?
    ) {
        // no-op
    }

    /**
     * Uses the current [restoreEventLogger] to report its results to the [backupManager]. Use when
     * done restoring items for Launcher.
     */
    open fun reportLauncherRestoreResults() {
        // no-op
    }
}
/*
 * Copyright (C) 2024 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.launcher3.model

import android.content.pm.LauncherApps
import android.content.pm.ShortcutInfo
import android.os.UserHandle
import android.text.TextUtils
import com.android.launcher3.LauncherModel.ModelUpdateTask
import com.android.launcher3.logging.FileLog
import com.android.launcher3.model.PackageUpdatedTask.OP_ADD
import com.android.launcher3.model.PackageUpdatedTask.OP_REMOVE
import com.android.launcher3.model.PackageUpdatedTask.OP_SUSPEND
import com.android.launcher3.model.PackageUpdatedTask.OP_UNAVAILABLE
import com.android.launcher3.model.PackageUpdatedTask.OP_UNSUSPEND
import com.android.launcher3.model.PackageUpdatedTask.OP_UPDATE
import java.util.function.Consumer

/**
 * Implementation of {@link LauncherApps#Callbacks} which converts various events to corresponding
 * model tasks
 */
class ModelLauncherCallbacks(private var taskExecutor: Consumer<ModelUpdateTask>) :
    LauncherApps.Callback() {

    override fun onPackageAdded(packageName: String, user: UserHandle) {
        taskExecutor.accept(PackageUpdatedTask(OP_ADD, user, packageName))
    }

    override fun onPackageChanged(packageName: String, user: UserHandle) {
        taskExecutor.accept(PackageUpdatedTask(OP_UPDATE, user, packageName))
    }

    override fun onPackageLoadingProgressChanged(
        packageName: String,
        user: UserHandle,
        progress: Float
    ) {
        taskExecutor.accept(PackageIncrementalDownloadUpdatedTask(packageName, user, progress))
    }

    override fun onPackageRemoved(packageName: String, user: UserHandle) {
        FileLog.d(TAG, "package removed received $packageName")
        taskExecutor.accept(PackageUpdatedTask(OP_REMOVE, user, packageName))
    }

    override fun onPackagesAvailable(
        vararg packageNames: String,
        user: UserHandle,
        replacing: Boolean
    ) {
        taskExecutor.accept(PackageUpdatedTask(OP_UPDATE, user, *packageNames))
    }

    override fun onPackagesSuspended(vararg packageNames: String, user: UserHandle) {
        taskExecutor.accept(PackageUpdatedTask(OP_SUSPEND, user, *packageNames))
    }

    override fun onPackagesUnavailable(
        packageNames: Array<String>,
        user: UserHandle,
        replacing: Boolean
    ) {
        if (!replacing) {


if defined(TCCR2A) && defined(COM2A1)
			case TIMER2A:
				// connect pwm to pin on timer 2, channel A
				sbi(TCCR2A, COM2A1);
				OCR2A = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR2A) && defined(COM2B1)
			case TIMER2B:
				// connect pwm to pin on timer 2, channel B
				sbi(TCCR2A, COM2B1);
				OCR2B = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR3A) && defined(COM3A1)
			case TIMER3A:
				// connect pwm to pin on timer 3, channel A
				sbi(TCCR3A, COM3A1);
				OCR3A = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR3A) && defined(COM3B1)
			case TIMER3B:
				// connect pwm to pin on timer 3, channel B
				sbi(TCCR3A, COM3B1);
				OCR3B = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR3A) && defined(COM3C1)
			case TIMER3C:
				// connect pwm to pin on timer 3, channel C
				sbi(TCCR3A, COM3C1);
				OCR3C = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR4A) && defined(COM4A1)
			case TIMER4A:
				// connect pwm to pin on timer 4, channel A
				sbi(TCCR4A, COM4A1);
				OCR4A = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR4A) && defined(COM4B1)
			case TIMER4B:
				// connect pwm to pin on timer 4, channel B
				sbi(TCCR4A, COM4B1);
				OCR4B = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR4A) && defined(COM4C1)
			case TIMER4C:
				// connect pwm to pin on timer 4, channel C
				sbi(TCCR4A, COM4C1);
				OCR4C = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR5A) && defined(COM5A1)
			case TIMER5A:
				// connect pwm to pin on timer 5, channel A
				sbi(TCCR5A, COM5A1);
				OCR5A = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR5A) && defined(COM5B1)
			case TIMER5B:
				// connect pwm to pin on timer 5, channel B
				sbi(TCCR5A, COM5B1);
				OCR5B = val; // set pwm duty
				break;
			#endif

			#if defined(TCCR5A) && defined(COM5C1)
			case TIMER5C:
				// connect pwm to pin on timer 5, channel C
				sbi(TCCR5A, COM5C1);
				OCR5C = val; // set pwm duty
				break;
			#endif

			case NOT_ON_TIMER:
			default:
				if (val < 128) {
					digitalWrite(pin, LOW);
				} else {
					digitalWrite(pin, HIGH);
				}
		}
	}
}


catalogs/{catalogIds}", method = RequestMethod.DELETE)
  public @ResponseBody
  ResponseEntity<?> multiDelete(@PathVariable("catalogIds") List<String> catalogIds) {
    for (String catalogId : catalogIds) {
      Catalog deleteCatalog = catalogRepository.findOne(catalogId);
      if (deleteCatalog == null) {
        LOGGER.warn("Fail to find deleting catalog : {}", catalogId);
        continue;
      }

      catalogRepository.delete(deleteCatalog);
      catalogTreeService.deleteTree(deleteCatalog);
    }

    return ResponseEntity.noContent().build();
  }

  @RequestMapping(path = "/catalogs/favorite/my", method = RequestMethod.GET)
  public @ResponseBody
  ResponseEntity<?> findFavoriteCatalogs(@RequestParam(value = "projection", required = false, defaultValue = "default") String projection) {
    List<Catalog> favoriteCatalogs = catalogService.findFavoriteCatalogs();
    return ResponseEntity.ok(
        ProjectionUtils.toListResource(projectionFactory, catalogProjections.getProjectionByName(projection), favoriteCatalogs)
    );
  }

  @RequestMapping(value = "/catalogs/{catalogId}/favorite/{action:attach|detach}", method = RequestMethod.POST)
  public ResponseEntity <?> manageFavorite(@PathVariable("catalogId") String catalogId, @PathVariable("action") String action) {
    switch (action) {
      case "attach":
        favoriteService.addFavorite(DomainType.CATALOG, catalogId);
        break;
      case "detach":
        favoriteService.removeFavorite(DomainType.CATALOG, catalogId);
        break;
    }
    return ResponseEntity.noContent().build();
  }

  /**
   * Find Category sort by used count
   */
  @RequestMapping(path = "/catalogs/popularity", method = RequestMethod.GET)
  public @ResponseBody
  ResponseEntity<?> findCatalogsByPopularity(@RequestParam(value = "nameContains", required = false) String nameContains,
                                             Pageable pageable) {
    Page<CatalogCountDTO> catalogs = catalogService.getCatalogsWithCount(nameContains, pageable);
    return ResponseEntity.ok(this.pagedResourcesAssembler.toResource(catalogs));
  }
}
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package app.metatron.discovery.domain.mdm.lineage;

import static app.metatron.discovery.domain.mdm.MetadataErrorCodes.LINEAGE_NODE_COUNT_DONE;

import app.metatron.discovery.domain.mdm.Metadata;
import app.metatron.discovery.domain.mdm.MetadataRepository;
import app.metatron.discovery.domain.mdm.lineage.LineageMap.ALIGNMENT;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LineageMapService {

  private static Logger LOGGER = LoggerFactory.getLogger(LineageMapService.class);

  @Autowired
  LineageEdgeRepository edgeRepository;

  @Autowired


			dir = 0,
			actor = 900016,
			nameColor = "#ff0000",
			paintingFadeOut = {
				time = 0.5,
				side = 0
			},
			shake = {
				speed = 1,
				number = 3
			},
			typewriter = {
				speed = 0.05,
				speedUp = 0.01
			},
			painting = {
				alpha = 0.3,
				time = 1
			}
		},
		{
			side = 1,
			nameColor = "#ff0000",
			dir = 0,
			actor = 900016,
			actorName = "{namecode:67}",
			say = "On my command! Full-speed south! Let's intercept the Z-fleet.",
			shake = {
				speed = 1,
				number = 3
			},
			typewriter = {
				speed = 0.05,
				speedUp = 0.01
			},
			painting = {
				alpha = 0.3,
				time = 1
			}
		}
	}
}


// *** WARNING: this file was generated by pulumi-language-dotnet. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Pulumi.Serialization;

namespace Pulumi.AwsNative.AppFlow.Inputs
{

    public sealed class FlowTaskArgs : global::Pulumi.ResourceArgs
    {
        /// <summary>
        /// Operation to be performed on provided source fields
        /// </summary>
        [Input("connectorOperator")]
        public Input<Inputs.FlowConnectorOperatorArgs>? ConnectorOperator { get; set; }

        /// <summary>
        /// A field value on which source field should be validated
        /// </summary>
        [Input("destinationField")]
        public Input<string>? DestinationField { get; set; }

        [Input("sourceFields", required: true)]
        private InputList<string>? _sourceFields;

        /// <summary>
        /// Source fields on which particular


n=list(map(int,input().split()))[0]
mp=[input() for _ in range(n)]
for i in mp:
	for j in i:
		print(j,end=",")
	print()