TER_ATTRIBUTE, "einsteindb.alter", "attribute");
lazy_static_namespaced_keyword_value!(DB_CARDINALITY, "einsteindb", "cardinality");
lazy_static_namespaced_keyword_value!(DB_CARDINALITY_MANY, "einsteindb.cardinality", "many");
lazy_static_namespaced_keyword_value!(DB_CARDINALITY_ONE, "einsteindb.cardinality", "one");
lazy_static_namespaced_keyword_value!(DB_FULLTEXT, "einsteindb", "fulltext");
lazy_static_namespaced_keyword_value!(DB_IDENT, "einsteindb", "solitonid");
lazy_static_namespaced_keyword_value!(DB_INDEX, "einsteindb", "index");
lazy_static_namespaced_keyword_value!(DB_INSTALL_ATTRIBUTE, "einsteindb.install", "attribute");
lazy_static_namespaced_keyword_value!(DB_IS_COMPONENT, "einsteindb", "isComponent");
lazy_static_namespaced_keyword_value!(DB_NO_HISTORY, "einsteindb", "noHistory");
lazy_static_namespaced_keyword_value!(DB_PART_DB, "einsteindb.part", "einsteindb");
lazy_static_namespaced_keyword_value!(DB_RETRACT, "einsteindb", "retract");
lazy_static_namespaced_keyword_value!(DB_TYPE_BOOLEAN, "einsteindb.type", "boolean");
lazy_static_namespaced_keyword_value!(DB_TYPE_DOUBLE, "einsteindb.type", "double");
lazy_static_namespaced_keyword_value!(DB_TYPE_INSTANT, "einsteindb.type", "instant");
lazy_static_namespaced_keyword_value!(DB_TYPE_KEYWORD, "einsteindb.type", "keyword");
lazy_static_namespaced_keyword_value!(DB_TYPE_LONG, "einsteindb.type", "long");
lazy_static_namespaced_keyword_value!(DB_TYPE_REF, "einsteindb.type", "ref");
lazy_static_namespaced_keyword_value!(DB_TYPE_STRING, "einsteindb.type", "string");
lazy_static_namespaced_keyword_value!(DB_TYPE_URI, "einsteindb.type", "uri");
lazy_static_namespaced_keyword_value!(DB_TYPE_UUID, "einsteindb.type", "uuid");
lazy_static_namespaced_keyword_value!(DB_UNIQUE, "einsteindb", "unique");
lazy_static_namespaced_keyword_value!(DB_UNIQUE_IDcauset, "einsteindb.unique", "idcauset");
lazy_static_namespaced_keyword_value!(DB_UNIQUE_VALUE, "einsteindb.unique", "value");
lazy_static_namespaced_keyword_value!(DB_VALUE_TYPE, "einsteindb", "valueType");
<filename>src/curve.rs<gh_stars>10-100
use std::ops::{Index, IndexMut};

/// A heap allocated structure for representing a value curve.
pub struct Curve<T>(Vec<T>);

impl<T> Curve<T>
where
    T: Default + Clone + Copy + From<f32> + Into<f32>,
{
    /// Constructs a `Curve` from a slice of values.
    ///
    /// # Examples
    ///
    /// ```
    /// use gamemath::Curve;
    ///
    /// let c: Curve<f32> = Curve::new(&[0.0, 10.0, 5.0, 0.0]);
    ///
    /// assert_eq!(c[0], 0.0);
    /// assert_eq!(c[1], 10.0);
    /// assert_eq!(c[2], 5.0);
    /// assert_eq!(c[3], 0.0);
    /// ```
    pub fn new(values: &[T]) -> Curve<T> {
        Curve { 0: values.into() }


F],\n table_b2a_base64[(C)&0x3F]])\n for A,B,C in a]\n \n final=s[length -final_length:]\n if final_length ==0:\n  snippet=''\n elif final_length ==1:\n  a=final[0]\n  snippet=table_b2a_base64[(a >>2)&0x3F]+  table_b2a_base64[(a <<4)&0x3F]+'=='\n else :\n  a=final[0]\n  b=final[1]\n  snippet=table_b2a_base64[(a >>2)&0x3F]+  table_b2a_base64[((a <<4)|(b >>4)&0xF)&0x3F]+  table_b2a_base64[(b <<2)&0x3F]+'='\n return bytes(''. join(result)+snippet+'\\n',__BRYTHON__. charset)\n \ndef a2b_qp(s,header=False ):\n inp=0\n odata=[]\n while inp <len(s):\n  if s[inp]=='=':\n   inp +=1\n   if inp >=len(s):\n    break\n    \n   if (s[inp]=='\\n')or (s[inp]=='\\r'):\n    if s[inp]!='\\n':\n     while inp <len(s)and s[inp]!='\\n':\n      inp +=1\n    if inp <len(s):\n     inp +=1\n   elif s[inp]=='=':\n   \n    odata. append('=')\n    inp +=1\n   elif s[inp]in hex_numbers and s[inp+1]in hex_numbers:\n    ch=chr(int(s[inp:inp+2],16))\n    inp +=2\n    odata. append(ch)\n   else :\n    odata. append('=')\n  elif header and s[inp]=='_':\n   odata. append(' ')\n   inp +=1\n  else :\n   odata. append(s[inp])\n   inp +=1\n return bytes(''. join(odata),__BRYTHON__. charset)\n \ndef b2a_qp(data,quotetabs=False ,istext=True ,header=False ):\n ''\n\n\n\n\n \n MAXLINESIZE=76\n \n \n lf=data. find('\\n')\n crlf=lf >0 and data[lf -1]=='\\r'\n \n inp=0\n linelen=0\n odata=[]\n while inp <len(data):\n  c=data[inp]\n  if (c >'~'or\n  c =='='or\n  (header and c =='_')or\n  (c =='.'and linelen ==0 and (inp+1 ==len(data)or\n  data[inp+1]=='\\n'or\n  data[inp+1]=='\\r'))or\n  (not istext and (c =='\\r'or c =='\\n'))or\n  ((c =='\\t'or c ==' ')and (inp+1 ==len(data)))or\n  (c <=' 'and c !='\\r'and c !='\\n'and\n  (quotetabs or (not quotetabs and (c !='\\t'and c !=' '))))):\n   linelen +=3\n   if linelen >=MAXLINESIZE:\n    odata. append('=')\n    if crlf:odata. append('\\r')\n    odata. append('\\n')\n    linelen=3\n   odata. append('='+two_hex_digi


import numpy as np
import colorlover as cl
from numpy import ndarray
from plotly.offline import plot

class PotvinChart(object):

    def __init__(self, time_by_forces: ndarray, step_size: float):

        forces_by_time = np.array(time_by_forces).T
        motor_unit_count, steps = forces_by_time.shape
        sim_duration = steps * step_size
        times = np.arange(0.0, sim_duration, step_size)

        # Setting colors for plot.
        potvin_scheme = [
            'rgb(115, 0, 0)',
            'rgb(252, 33, 23)',
            'rgb(230, 185, 43)',
            'rgb(107, 211, 100)',
            'rgb(52, 211, 240)',
            'rgb(36, 81, 252)',
            'rgb(0, 6, 130)'
        ]

        # It's hacky but also sorta cool.
        c = cl.to_rgb(cl.interp(potvin_scheme, motor_unit_count))
        c = [val.replace('rgb', 'rgba') for val in c]
        c = [val.replace(')', ',{})') for val in c]

        # Assing non-public attributes
        self._step_size = step_size
        self._forces_by_time = forces_by_time
        self._c = c
        self._times = times

        # Assign public attributes
        self.motor_unit_count = motor_unit_count

    def _get_color(self, trace_index: int) -> str:
        # The first and every 20th trace should be full opacity
        alpha = 0.2
        if trace_index == 0 or ((trace_index + 1) % 20 == 0):
            alpha = 1.0
        color = self._c[trace_index].format(alpha)
        return color

    def display(self) -> None:
        # Per Motor Unit Force
        data = []
        for i, t in enumerate(self._forces_by_time):
            trace = dict(
                x=self._times,
                y=t,
                name=i + 1,
                marker=dict(
                    color=self._get_color(i)
                ),
            )
            data.append(trace)

        layout = dict(
            title='Motor Unit Forces by Time',
            yaxis=dict(
                title='Motor unit force (relative to MU1 tetanus)'
            ),
            xaxis=dict(
                title='Time (s)'
            )
        )

        fig = dict(
            data=data,
            layout=layout
        )
        plot(fig, filename='forces-by-time.html', validate=False)


>

V4L2_PIX_FMT_UYVY ('UYVY')	Up	V4L2_PIX_FMT_YVU420 ('YV12'), V4L2_PIX_FMT_YUV420 ('YU12')

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<TITLE
>V4L2 ioctl()</TITLE
><META
NAME="GENERATOR"
CONTENT="Modular DocBook HTML Stylesheet Version 1.79"><LINK
REL="HOME"
TITLE="Video for Linux Two API Specification"
HREF="book1.htm"><LINK
REL="UP"
TITLE="Function Reference"
HREF="r7624.htm"><LINK
REL="PREVIOUS"
TITLE="V4L2 close()"
HREF="r7626.htm"><LINK
REL="NEXT"
TITLE="ioctl VIDIOC_CROPCAP"
HREF="r7771.htm">

Video for Linux Two API Specification: Revision 0.24

Prev		Next

V4L2 ioctl()

Name
v4l2-ioctl -- Program a V4L2 device

Synopsis

#include <sys/ioctl.h>

int ioctl(int fd, int request, void *argp);

Arguments

fd

File descriptor returned by open().

request

V4L2 ioctl request code as defined in the videodev.h header file, for example
VIDIOC_QUERYCAP.

argp

Pointer to a function parameter, usually a structure.</P


FromDatabase(getString(3)))
            return category
        }
    }

    private fun getBooleanFromDatabase(isSolved: String?) =
            // Json stores booleans as true/false strings, whereas SQLite stores them as 0/1 values.
            isSolved?.length == 1 && Integer.valueOf(isSolved) == 1

    /**
     * Looks for a category with a given id.

     * @param categoryId Id of the category to look for.
     *
     * @return The found category.
     */
    fun getCategoryWith(categoryId: String): Category {
        val selectionArgs = arrayOf(categoryId)
        val data = readableDatabase
                .query(CategoryTable.NAME, CategoryTable.PROJECTION,
                        "${CategoryTable.COLUMN_ID}=?", selectionArgs,
                        null, null, null)
                .also { it.moveToFirst() }
        return getCategory(data)
    }

    /**
     * Scooooooooooore!

     * @return The score over all Categories.
     */
    fun getScore() = with(getCategories()) { sumBy { it.score } }

    /**
     * Updates values for a category.

     * @param category The category to update.
     */
    fun updateCategory(category: Category) {
        val index = categories.indexOfFirst { it.id == category.id }
        if (index != -1) {
            with (categories) {
                removeAt(index)
                add(index, category)
            }
        }

        val categoryValues = createContentValuesFor(category)
        writableDatabase.update(CategoryTable.NAME,
                categoryValues,
                "${CategoryTable.COLUMN_ID}=?",
                arrayOf(category.id))
        val quizzes = category.quizzes
        updateQuizzes(writableDatabase, quizzes)
    }

    /**
     * Updates a list of given quizzes.

     * @param writableDatabase The database to write the quizzes to.
     *
     * @param quizzes          The quizzes to write.
     */
    private fun updateQuizzes(writableDatabase: SQLiteDatabase, quizzes: List<Quiz<*>>) {
        var quiz: Quiz<*>
        val quizValues = ContentValues()
        val quizArgs = arrayOfNulls<String>(1)
        for (i in quizzes.indices) {
            quiz = quizzes[i]
            quizValues.clear()
            quizValues.put(QuizTable.COLUMN_SOLVED, quiz.solved)

            quizArgs[0] = quiz.question
            writableDatabase.update(QuizTable.NAME, quizValues,
                    "${QuizTable.COLUMN_QUESTION}=?", quizArgs)
        }
    }

    /**
     * Resets the contents of Topeka's database to it's initial state.
     */
    fun reset() {
        with(writableDatabase) {
            delete(CategoryTable.NAME, null, null)
            delete(QuizTable.NAME, null, null)
            fillCategoriesAndQuizzes(this)
        }
    }

    /**
     * Creates objects for quizzes according to a category id.

     * @param categoryId The category to create quizzes for.
     * @param database   The database containing the quizzes.
     * @return The found quizzes or an empty list if none were available.
     */
    @SuppressLint("Recycle")
    private fun getQuizzes(categoryId: String, database: SQLiteDatabase): List<Quiz<*>> {
        val quizzes = ArrayList<Quiz<*>>()

        val cursor = database.query(QuizTable.NAME,
                QuizTable.PROJECTION,
                "${QuizTable.FK_CATEGORY} LIKE ?", arrayOf(categoryId),
                null, null, null)
        cursor.moveToFirst()
        do quizzes.add(createQuizDueToType(cursor)) while (cursor.moveToNext())
        return quizzes
    }

    /**
     * Creates a quiz corresponding to the projection provided from a cursor row.
     * Currently only [QuizTable.PROJECTION] is supported.

     * @param cursor The Cursor containing the data.
     * @r


dulta | mujer adulta | mujer joven | niño joven | niño ',
    ),
    Emoji(
      '👩👩👧👧',
      'adulta | mujer adulta | mujer chica | joven | niña chica | joven | niña ',
    ),
    Emoji(
      '👨👦',
      'adulto | hombre joven | niño ',
    ),
    Emoji(
      '👨👦👦',
      'adulto | hombre joven | niño joven | niño ',
    ),
    Emoji(
      '👨👧',
      'adulto | hombre chica | joven | niña ',
    ),
    Emoji(
      '👨👧👦',
      'adulto | hombre chica | joven | niña joven | niño ',
    ),
    Emoji(
      '👨👧👧',
      'adulto | hombre chica | joven | niña chica | joven | niña ',
    ),
    Emoji(
      '👩👦',
      'adulta | mujer joven | niño ',
    ),
    Emoji(
      '👩👦👦',
      'adulta | mujer joven | niño joven | niño ',
    ),
    Emoji(
      '👩👧',
      'adulta | mujer chica | joven | niña ',
    ),
    Emoji(
      '👩👧👦',
      'adulta | mujer chica | joven | niña joven | niño ',
    ),
    Emoji(
      '👩👧👧',
      'adulta | mujer chica | joven | niña chica | joven | niña ',
    ),
    Emoji(
      '🗣',
      'cabeza | cabeza parlante | cara | hablar | silueta ',
    ),
    Emoji(
      '👤',
      'busto | silueta | silueta de busto',
    ),
    Emoji(
      '👥',
      'bustos | dos siluetas de bustos | siluetas',
    ),
    Emoji(
      '🫂',
      'abrazo | adiós | despedida | gracias | personas abrazándose | saludo',
    ),
    Emoji(
      '👣',
      'huellas | huellas de pies | pies',
    ),
    Emoji(
      '🧳',
      'equipaje | maleta | viajar',
    ),
    Emoji(
      '🌂',
      'accesorios | lluvia | paraguas | paraguas cerrado',
    ),
    Emoji(
      '☂',
      'lluvia | paraguas | paraguas abierto ',
    ),
    Emoji(
      '🧵',
      'aguja | carrete | coser | costura | hilo',
    ),
    Emoji(
      '🧶',
      'bola | croché | ovillo | punto | tejer',
    ),
    Emoji(
      '👓',
      'accesorios | gafas | ojo | ropa',
    ),
    Emoji(
      '🕶',
      'gafas | gafas de sol | ojo | oscuras | sol ',


 const WAVE_FORMAT_AMR_WB: u32 = 29538u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_AMR_WP: u32 = 29539u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_ANTEX_ADPCME: u32 = 51u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_APTX: u32 = 37u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_AUDIOFILE_AF10: u32 = 38u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_AUDIOFILE_AF36: u32 = 36u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_BTV_DIGITAL: u32 = 1024u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CANOPUS_ATRAC: u32 = 99u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CIRRUS: u32 = 96u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CODIAN: u32 = 41252u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_COMVERSE_INFOSYS_AVQSBC: u32 = 41217u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_COMVERSE_INFOSYS_G723_1: u32 = 41216u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_COMVERSE_INFOSYS_SBC: u32 = 41218u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CONGRUENCY: u32 = 141u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CONTROL_RES_CR10: u32 = 55u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CONTROL_RES_VQLPC: u32 = 52u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CONVEDIA_G729: u32 = 140u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CREATIVE_ADPCM: u32 = 512u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CREATIVE_FASTSPEECH10: u32 = 515u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CREATIVE_FASTSPEECH8: u32 = 514u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CS2: u32 = 608u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CS_IMAADPCM: u32 = 57u32;
#[doc = "*Required features: `\"Win32_Media_Multimedia\"`*"]
pub const WAVE_FORMAT_CUSEEME: u32 = 7939u32;
#[doc


orflow/mac/tensorflow-0.9.0-py2-none-any.whl

# Ubuntu/Linux 64-bit, CPU 전용, Python 3.4
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.9.0-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU 버전, Python 3.4
# CUDA toolkit 7.5 와 CuDNN v4 필수. 다른 버전을 사용하려면 아래 "소스에서 설치" 섹션을 참고하세요.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.9.0-cp34-cp34m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, CPU 전용, Python 3.5
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.9.0-cp35-cp35m-linux_x86_64.whl

# Ubuntu/Linux 64-bit, GPU 버전, Python 3.5
# CUDA toolkit 7.5 와 CuDNN v4 필수. 다른 버전을 사용하려면 아래 "소스에서 설치" 섹션을 참고하세요.
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.9.0-cp35-cp35m-linux_x86_64.whl

# Mac OS X, CPU 전용, Python 3.4 or 3.5:
(tensorflow)$ export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/tensorflow-0.9.0-py3-none-any.whl
```

마지막으로 텐서플로우를 설치합니다:

```bash
# Python 2
(tensorflow)$ pip install --upgrade $TF_BINARY_URL

# Python 3
(tensorflow)$ pip3 install --upgrade $TF_BINARY_URL
```

Virtualenv 활성화하고 [설치 테스트](#test-the-tensorflow-installation)를 할 수 있습니다.

텐서플로우 작업을 마쳤을 때에는 환경을 비활성화 합니다.

```bash
(tensorflow)$ deactivate

$  # 프롬프트가 원래대로 되돌아 옵니다
```

나중에 텐서플로우를 다시 사용하려면 Virtualenv 환경을 다시 활성화해야 합니다:

```bash
$ source ~/tensorflow/bin/activate  # bash를 사용할 경우
$ source ~/tensorflow/bin/activate.csh  # csh을 사용할 경우
(tensorflow)$  # 프롬프트가 변경되었습니다
# 텐서플로우를 사용한 프로그램을 �


Status: []ItemStatus{
						{
							DefinitionName: "def4",
							Name:           "name4",
							Status:         StateFailed,
						},
						{
							DefinitionName: "def42",
							Name:           "name42",
							Status:         StateFailed,
						},
					},
					PhaseTraceIDs: common.PhaseTraceID{
						"key": propagation.MapCarrier{
							"key1": "value1",
							"key2": "value2",
						},
						"key22": propagation.MapCarrier{
							"key122": "value122",
							"key222": "value222",
						},
					},
					Status: StateFailed,
				},
			},
			wantErr: false,
			wantObj: &v1.KeptnAppVersion{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "some-keptn-app-name",
					Namespace: "",
					Labels: map[string]string{
						"some-label": "some-label-value",
					},
					Annotations: map[string]string{
						"some-annotation": "some-annotation-value",
					},
				},
				Spec: v1.KeptnAppVersionSpec{
					KeptnAppSpec: v1.KeptnAppSpec{
						Version:  "1.2.3",
						Revision: 1,
						Workloads: []v1.KeptnWorkloadRef{
							{
								Name:    "workload-1",
								Version: "1.2.3",
							},
							{
								Name:    "workload-2",
								Version: "4.5.6",
							},
						},
					},
					KeptnAppContextSpec: v1.KeptnAppContextSpec{
						DeploymentTaskSpec: v1.DeploymentTaskSpec{
							PreDeploymentTasks: []string{
								"some-pre-deployment-task1",
							},
							PostDeploymentTasks: []string{
								"some-post-deployment-task2",
							},
							PreDeploymentEvaluations: []string{
								"some-pre-evaluation-task1",
							},
							PostDeploymentEvaluations: []string{
								"some-pre-evaluation-task2",
							},
						},
					},
					AppName:         "app",
					PreviousVersion: "1.0",
					TraceId: map[string]string{
						"key1": "value1",
						"key2": "value2",
					},
				},
				Status: v1.KeptnAppVersionStatus{
					PreDeploymentStatus:            v1common.StateFailed,
					PostDeploymentStatus:           v1common.StateFailed,
					PreDeploymentEvaluationStatus:  v1common.StateFailed,
					PostDeploymentEvaluationStatus: v1common.StateFailed,
					WorkloadOverallStatus:          v1common.StateFailed,
					WorkloadStatus: []v1.WorkloadStatus{
						{
							Workload: v1.KeptnWorkloadRef{
								Name:    "name1",
								Version: "1",
							},
							Status: v1common.StateFailed,
						},
						{
							Workload: v1.KeptnWorkloadRef{
								Name:    "name2",
								Version: "2",
							},
							Status: v1common.StateFailed,
						},
					},
					CurrentPhase: "phase",
					PreDeploymentTaskStatus: []v1.ItemStatus{
						{
							DefinitionName: "def1",
							Name:           "name1",
							Status:         v1common.StateFailed,
						},
						{
							DefinitionName: "def12",
							Name:           "name12",
							Status:         v1common.StateFailed,
						},
					},
					PostDeploymentTaskStatus: []v1.ItemStatus{
						{
							DefinitionName: "def2",
							Name:           "name2",
							Status:         v1common.StateFailed,
						},
						{
							DefinitionNam


#1,>w5_stack=stack32#26
# asm 2: str <w5=r0,>w5_stack=[sp,#100]
str r0,[sp,#100]

# qhasm: w6_stack = w6
# asm 1: str <w6=int32#9,>w6_stack=stack32#27
# asm 2: str <w6=r8,>w6_stack=[sp,#104]
str r8,[sp,#104]

# qhasm: w7_stack = w7
# asm 1: str <w7=int32#10,>w7_stack=stack32#28
# asm 2: str <w7=r9,>w7_stack=[sp,#108]
str r9,[sp,#108]

# qhasm: w8_stack = w8
# asm 1: str <w8=int32#11,>w8_stack=stack32#29
# asm 2: str <w8=r10,>w8_stack=[sp,#112]
str r10,[sp,#112]

# qhasm: w10_stack = w10
# asm 1: str <w10=int32#8,>w10_stack=stack32#30
# asm 2: str <w10=r7,>w10_stack=[sp,#116]
str r7,[sp,#116]

# qhasm: w11_stack = w11
# asm 1: str <w11=int32#12,>w11_stack=stack32#31
# asm 2: str <w11=r11,>w11_stack=[sp,#120]
str r11,[sp,#120]

# qhasm: w12_stack = w12
# asm 1: str <w12=int32#13,>w12_stack=stack32#32
# asm 2: str <w12=r12,>w12_stack=[sp,#124]
str r12,[sp,#124]

# qhasm: w13_stack = w13
# asm 1: str <w13=int32#3,>w13_stack=stack32#33
# asm 2: str <w13=r2,>w13_stack=[sp,#128]
str r2,[sp,#128]

# qhasm: w14_stack = w14
# asm 1: str <w14=int32#5,>w14_stack=stack32#34
# asm 2: str <w14=r4,>w14_stack=[sp,#132]
str r4,[sp,#132]

# qhasm: w15_stack = w15
# asm 1: str <w15=int32#6,>w15_stack=stack32#35
# asm 2: str <w15=r5,>w15_stack=[sp,#136]
str r5,[sp,#136]

# qhasm: r0 = r0_stack
# asm 1: ldr >r0=int32#1,<r0_stack=stack32#36
# asm 2: ldr >r0=r0,<r0_stack=[sp,#140]
ldr r0,[sp,#140]

# qhasm: r1 = r1_stack
# asm 1: ldr >r1=int32#3,<r1_stack=stack32#37
# asm 2: ldr >r1=r2,<r1_stack=[sp,#144]
ldr r2,[sp,#144]

# qhasm: r2 = r2_stack
# asm 1: ldr >r2=int32#5,<r2_stack=stack32#38
# asm 2: ldr >r2=r4,<r2_stack=[sp,#148]
ldr r4


emperatureC_decode_ber,
	FANSTemperatureC_encode_der,
	FANSTemperatureC_decode_xer,
	FANSTemperatureC_encode_xer,
	FANSTemperatureC_decode_uper,
	FANSTemperatureC_encode_uper,
	0,	/* Use generic outmost tag fetcher */
	asn_DEF_FANSTemperatureC_tags_1,
	sizeof(asn_DEF_FANSTemperatureC_tags_1)
		/sizeof(asn_DEF_FANSTemperatureC_tags_1[0]), /* 1 */
	asn_DEF_FANSTemperatureC_tags_1,	/* Same as above */
	sizeof(asn_DEF_FANSTemperatureC_tags_1)
		/sizeof(asn_DEF_FANSTemperatureC_tags_1[0]), /* 1 */
	&asn_PER_type_FANSTemperatureC_constr_1,
	0, 0,	/* No members */
	0	/* No specifics */
};


hAnyPrefix;
    final matchAnySuffix = this.matchAnySuffix;
    final matchAnyTag = this.matchAnyTag;
    final matchObjectAge = this.matchObjectAge;
    final matchObjectSize = this.matchObjectSize;
    return {
      if (matchAnyPrefix != null) 'MatchAnyPrefix': matchAnyPrefix,
      if (matchAnySuffix != null) 'MatchAnySuffix': matchAnySuffix,
      if (matchAnyTag != null) 'MatchAnyTag': matchAnyTag,
      if (matchObjectAge != null) 'MatchObjectAge': matchObjectAge,
      if (matchObjectSize != null) 'MatchObjectSize': matchObjectSize,
    };
  }

  _s.XmlElement toXml(String elemName, {List<_s.XmlAttribute>? attributes}) {
    final matchAnyPrefix = this.matchAnyPrefix;
    final matchAnySuffix = this.matchAnySuffix;
    final matchAnyTag = this.matchAnyTag;
    final matchObjectAge = this.matchObjectAge;
    final matchObjectSize = this.matchObjectSize;
    final $children = <_s.XmlNode>[
      if (matchAnyPrefix != null)
        _s.XmlElement(_s.XmlName('MatchAnyPrefix'), [],
            matchAnyPrefix.map((e) => _s.encodeXmlStringValue('Prefix', e))),
      if (matchAnySuffix != null)
        _s.XmlElement(_s.XmlName('MatchAnySuffix'), [],
            matchAnySuffix.map((e) => _s.encodeXmlStringValue('Suffix', e))),
      if (matchAnyTag != null)
        _s.XmlElement(_s.XmlName('MatchAnyTag'), [],
            matchAnyTag.map((e) => e.toXml('Tag'))),
      if (matchObjectAge != null) matchObjectAge.toXml('MatchObjectAge'),
      if (matchObjectSize != null) matchObjectSize.toXml('MatchObjectSize'),
    ];
    final $attributes = <_s.XmlAttribute>[
      ...?attributes,
    ];
    return _s.XmlElement(
      _s.XmlName(elemName),
      $attributes,
      $children,
    );
  }
}

///

class StorageLensTag {
  ///

  final String key;

  ///

  final String value;

  StorageLensTag({
    required this.key,
    required this.value,
  });
  factory StorageLensTag.fromXml(_s.XmlElement elem) {
    return StorageLensTag(
      key: _s.extractXmlStringValue(elem, 'Key')!,
      value: _s.extractXmlStringValue(elem, 'Value')!,
    );
  }

  Map<String, dynamic> toJson() {
    final key = this.key;
    final value = this.value;
    return {
      'Key': key,
      'Value': value,
    };
  }

  _s.XmlElement toXml(String elemName, {List<_s.XmlAttribute>? attributes}) {
    final key = this.key;
    final value = this.value;
    final $children = <_s.XmlNode>[
      _s.encodeXmlStringValue('Key', key),
      _s.encodeXmlStringValue('Value', value),
    ];
    final $attributes = <_s.XmlAttribute>[
      ...?attributes,
    ];
    return _s.XmlElement(
      _s.XmlName(elemName),
      $attributes,
      $children,
    );
  }
}

class SubmitMultiRegionAccessPointRoutesRequest {
  /// The Amazon Web Services account ID for the owner of the Multi-Region Access
  /// Point.
  final String accountId;

  /// The Multi-Region Access Point ARN.
  final String mrap;

  /// The different routes that make up the new route configuration. Active routes
  /// return a value of 100, and passive routes return a value of
  /// 0.
  final List<MultiRegionAccessPointRoute> routeUpdates;

  SubmitMultiRegionAccessPointRoutesRequest({
    required this.accountId,
    required this.mrap,
    required this.routeUpdates,
  });

  Map<


        tradeChatFilter: Int,
    ) : this(
        publicChatFilter.toUByte(),
        tradeChatFilter.toUByte(),
    )

    public val publicChatFilter: Int
        get() = _publicChatFilter.toInt()
    public val tradeChatFilter: Int
        get() = _tradeChatFilter.toInt()
    override val category: ServerProtCategory
        get() = GameServerProtCategory.HIGH_PRIORITY_PROT

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as ChatFilterSettings

        if (_publicChatFilter != other._publicChatFilter) return false
        if (_tradeChatFilter != other._tradeChatFilter) return false

        return true
    }

    override fun hashCode(): Int {
        var result = _publicChatFilter.hashCode()
        result = 31 * result + _tradeChatFilter.hashCode()
        return result
    }

    override fun toString(): String =
        "ChatFilterSettings(" +
            "publicChatFilter=$publicChatFilter, " +
            "tradeChatFilter=$tradeChatFilter" +
            ")"
}
package net.rsprot.protocol.game.outgoing.misc.player

import net.rsprot.protocol.ServerProtCategory
import net.rsprot.protocol.game.outgoing.GameServerProtCategory
import net.rsprot.protocol.message.OutgoingGameMessage
import net.rsprot.protocol.message.util.estimateTextSize

/**
 * Message game packet is used to send a normal game message in
 * the player's chatbox.
 *
 * Game message types (note: names without asterisk are official from a leak):
 * ```
 * | Id  |                Type                |
 * |-----|:----------------------------------:|
 * | 0   |        chattype_gamemessage        |
 * | 1   |          chattype_modchat          |
 * | 2   |         chattype_publicchat        |
 * | 3   |        chattype_privatechat        |
 * | 4   |           chattype_engine          |
 * | 5   |  chattype_loginlogoutnotification  |
 * | 6   |       chattype_privatechatout      |
 * | 7   |       chattype_modprivatechat      |
 * | 9   |        chattype_friendschat        |
 * | 11  |  chattype_friendschatnotification  |
 * | 14  |         chattype_broadcast         |
 * | 26  |      chattype_snapshotfeedback     |
 * | 27  |        chattype_obj_examine        |
 * | 28  |        chattype_npc_examine        |
 * | 29  |        chattype_loc_examine        |
 * | 30  |     chattype_friendnotification    |
 * | 31  |     chattype_ignorenotification    |
 * | 41  |           chattype_clan*           |
 * | 43  |        chattype_clan_system*       |
 * | 44  |        chattype_clan_guest*        |
 * | 46  |     chattype_clan_guest_system*    |
 * | 90  |         chattype_autotyper         |
 * | 91  |        chattype_modautotyper       |
 * | 99  |          chattype_console          |
 * | 101 |          chattype_tradereq         |
 * | 102 |           chattype_trade           |
 * | 103 |       chattype_chalreq_trade       |
 * | 104 |    chattype_chalreq_friendschat    |
 * | 105 |            chattype_spam           |
 * | 106 |       chattype_playerrelated       |
 * | 107 |        chattype_10sectimeout       |
 * | 108 |          chattype_welcome*         |
 * | 109 | chattype_clan_creation_invitation* |
 * | 110 |    chattype_clan_wars_challenge*   |
 * | 111 |      chattype_gim_form_group*      |
 * | 112 |      chattype_gim_group_with*      |
 * ```
 *
 * @property type the type of the message to send (see table above)
 * @property name the name of the target player who is making a request.
 * This property is only for messages such as "X wishes to trade with you


 string = "Tinolang Manok (Chicken Tinola) is a refreshing chicken soup made with bone-chicken, papaya, fresh spinach and ginger-flavored broth.";

  imgSrcBicolExpress: string = "assets/images/Menu/Specialties/bicol express.png";
  definitionBicolExpress: string = "Bicol Express is pure comfort food! With pork cubes cooked in coconut milk and chili peppers, it's rich, creamy, spicy and delicious! Serve with steamed rice for a hearty and big flavored meal! Bicol Express.";

  imgSrcBulalo: string = "assets/images/Menu/Specialties/bulalo.png";
  definitionBulalo: string = "A beef soup comprised of shank with bone marrow still inside the bone, Bulalo is considered to be one of the most favorite main dishes in the Philippines.";

  imgSrcMenudo: string = "assets/images/Menu/Specialties/menudo.png";
  definitionMenudo: string = "Menudo is a popular Filipino pork dish. It is usually served during gatherings and fiestas. There are a lot of variations to the menudo recipe-some add hotdog slices, raisins, chunks of pickles, and even additional seasonings that amp up the umami flavors of this pork tomato stew.";

  foodTitle: string ="";
  foodResult: string = "";
  foodResultDefinition: string = "";
  constructor() { }

  ngOnInit() {
  }

  foodCheck(foodName: string):void{
    if(foodName == "sinigang"){
      this.foodTitle="Sinigang";
      this.foodResult=this.imgSrcSinigang;
      this.foodResultDefinition=this.definitionSinigang;
    } else if (foodName == "adobo"){
      this.foodTitle="Adobo";
      this.foodResult=this.imgSrcAdobo;
      this.foodResultDefinition=this.definitionAdobo;
    } else if (foodName =="karekare"){
      this.foodTitle="Kare-Kare";
      this.foodResult=this.imgSrcKareKare;
      this.foodResultDefinition=this.definitionKareKare;
    } else if (foodName =="tinola"){
      this.foodTitle="Tinola";
      this.foodResult=this.imgSrcTinola;
      this.foodResultDefinition=this.definitionTinola;
    } else if (foodName =="bicolExpress"){
      this.foodTitle="Bicol Express";
      this.foodResult=this.imgSrcBicolExpress;
      this.foodResultDefinition=this.definitionBicolExpress;
    } else if (foodName =="bulalo"){
      this.foodTitle="Bulalo";
      this.foodResult=this.imgSrcBulalo;
      this.foodResultDefinition=this.definitionBulalo;
    } else if (foodName =="menudo"){
      this.foodTitle="Menudo";
      this.foodResult=this.imgSrcMenudo;
      this.foodResultDefinition=this.definitionMenudo;
    }
  }
  returnFood(){

    return
  }
}

let statSyncMocks: any[] = [];

export function statSync(...args: any[]) {
   const  mock = statSyncMocks.shift();
   if (typeof mock !== 'function') {
      throw new Error(`fs.statSync called without configuring a mock`);
   }

   return mock(...args);
}

export function addStatSyncMock(fn: any) {
   statSyncMocks.push(fn);
}

export function assertMocksUsed() {
   if (statSyncMocks.length) {
      throw new Error(`fs.afterEach: statSync has ${statSyncMocks.length} unused mocks`);
   }
}

const mockFs = {
   statSync,
}

export default mockFs;
import { Injectable, Provider } from '@angular/core';
import { Http, Response, URLSearchParams, RequestOptions, Headers } from


al [Texture] to apply. Defaults to a white texture.
  /// - [colors]: An optional list of [Color] objects. If provided, `colors[0]`
  ///   is applied to all vertices.
  void drawPoly(List<double> vertices, {List<double>? uvs, Texture? texture, ColorList? colors}) {
    int vCount = vertices.length ~/ 2;
    if (vCount < 3) {
      warn("Can't render polygon. At least 3 vertices required.");
      return;
    }

    if (uvs != null && uvs.length != vertices.length) {
      warn("Can't render Polygon. UVs and Vertices have to be of same length.");
      return;
    }

    _prepareRenderState(_PrimitiveType.triangles, texture: texture);

    for (var i = 0; i < vCount; i++) {
      var x = vertices[i * 2];
      var y = vertices[i * 2 + 1];
      var u = uvs?[i * 2] ?? 0.0;
      var v = uvs?[i * 2 + 1] ?? 0.0;
      _transfromAndAddVertices(x, y, u, v, getColorFromList(colors, 0, _encodedColor));
    }
  }

  /// Draws a filled triangle with the specified vertex coordinates and texture coordinates.
  ///
  /// - [x1],[y1], [x2],[y2], [x3],[y3]: Coordinates of the three triangle vertices.
  /// - [u1],[v1], [u2],[v2], [u3],[v3]: Texture coordinates for each corresponding vertex.
  /// - [texture]: An optional [Texture] to apply. Defaults to a white texture.
  /// - [colors]: An optional list of [Color] objects for per-vertex coloring.
  ///   `colors[0]` for first vertex, `colors[1]` for second, `colors[2]` for third.
  void drawTriangle(
    double x1,
    double y1,
    double x2,
    double y2,
    double x3,
    double y3,
    double u1,
    double v1,
    double u2,
    double v2,
    double u3,
    double v3, {
    Texture? texture,
    ColorList? colors,
  }) {
    _prepareRenderState(_PrimitiveType.triangles, texture: texture);

    _transfromAndAddVertices(x1, y1, u1, v1, getColorFromList(colors, 0, _encodedColor));
    _transfromAndAddVertices(x2, y2, u2, v2, getColorFromList(colors, 1, _encodedColor));
    _transfromAndAddVertices(x3, y3, u3, v3, getColorFromList(colors, 2, _encodedColor));
  }

  /// Draws a [Texture] or a portion of it onto a quad.
  ///
  /// - [tex]: The [Texture] to draw.
  /// - [srcX], [srcY]: Top-left x,y coordinates of the source rectangle within the texture. Defaults to (0,0).
  /// - [srcWidth], [srcHeight]: Width and height of the source rectangle. Defaults to texture dimensions.
  /// - [x], [y]: Top-left x,y coordinates of the destination rectangle on the canvas. Defaults to (0,0).
  /// - [width], [height]: Width and height of the destination rectangle. Defaults to source dimensions.
  /// - [colors]: An optional list of [Color] objects for per-vertex coloring (tinting).
  ///   Colors are applied in order: top-left, bottom-left, top-right, bottom-right of the quad.
  void drawTexture(
    Texture tex, {
    double? srcX,
    double? srcY,
    double? srcWidth,
    double? srcHeight,
    double? x,
    double? y,
    double? width,
    double? height,
    ColorList? colors,
  }) {
    _prepareRenderState(_PrimitiveType.quads, texture: tex);

    final texW = tex.width.toDouble();
    final texH = tex.height.toDouble


 the incoming
	   argument stack slots, since this avoid having to use any PIC
	   references.  We also thus avoid having to allocate a register
	   window.

	   VIS instructions are used to facilitate the formation of
	   easier constants, and the propagation of the sign bit.  */

#define TWO_TWENTYTHREE	0x4b000000		/* 2**23 */

#define ZERO		%f10			/* 0.0 */
#define SIGN_BIT	%f12			/* -0.0 */

ENTRY (__lrintf)
	sethi	%hi(TWO_TWENTYTHREE), %o2
	fzeros	ZERO

	fnegs	ZERO, SIGN_BIT
	st	%o2, [%sp + STACK_BIAS + 128]
	fabss	%f1, %f14

	ld	[%sp + STACK_BIAS + 128], %f16
	fcmps	%fcc3, %f14, %f16

	fmovsuge %fcc3, ZERO, %f16
	fands	%f1, SIGN_BIT, SIGN_BIT

	fors	%f16, SIGN_BIT, %f16
	fadds	%f1, %f16, %f5
	fsubs	%f5, %f16, %f0
	fabss	%f0, %f0
	fors	%f0, SIGN_BIT, %f0
	fstox	%f0, %f4
	std	%f4, [%sp + STACK_BIAS + 128]
	retl
	 ldx	[%sp + STACK_BIAS + 128], %o0
END (__lrintf)
libm_alias_float (__lrint, lrint)

strong_alias (__lrintf, __llrintf)
libm_alias_float (__llrint, llrint)


c3 52 63 50 	subl3 r2,(r3),r0
   1ade2:	1f 04       	blssu 1ade8 <La_dividend>
   1ade4:	d0 50 63    	movl r0,(r3)
   1ade7:	04          	ret

0001ade8 <La_dividend>:
   1ade8:	d0 63 50    	movl (r3),r0
   1adeb:	04          	ret

0001adec <bcopy>:
   1adec:	7c 00       	.word 0x007c # Entry mask: < r6 r5 r4 r3 r2 >
   1adee:	d0 ac 04 51 	movl 0x4(ap),r1
   1adf2:	d0 ac 08 53 	movl 0x8(ap),r3
   1adf6:	d0 ac 0c 56 	movl 0xc(ap),r6
   1adfa:	d1 51 53    	cmpl r1,r3
   1adfd:	14 0a       	bgtr 1ae09 <bcopy+0x1d>
   1adff:	19 17       	blss 1ae18 <bcopy+0x2c>
   1ae01:	04          	ret
   1ae02:	c2 50 56    	subl2 r0,r6
   1ae05:	28 50 61 63 	movc3 r0,(r1),(r3)
   1ae09:	3c 8f ff ff 	movzwl $0xffff,r0
   1ae0d:	50
   1ae0e:	d1 56 50    	cmpl r6,r0
   1ae11:	14 ef       	bgtr 1ae02 <bcopy+0x16>
   1ae13:	28 56 61 63 	movc3 r6,(r1),(r3)
   1ae17:	04          	ret
   1ae18:	c0 56 51    	addl2 r6,r1
   1ae1b:	c0 56 53    	addl2 r6,r3
   1ae1e:	3c 8f ff ff 	movzwl $0xffff,r0
   1ae22:	50
   1ae23:	11 18       	brb 1ae3d <bcopy+0x51>
   1ae25:	c2 50 56    	subl2 r0,r6
   1ae28:	c2 50 51    	subl2 r0,r1
   1ae2b:	c2 50 53    	subl2 r0,r3
   1ae2e:	28 50 61 63 	movc3 r0,(r1),(r3)
   1ae32:	3c 8f ff ff 	movzwl $0xffff,r0
   1ae36:	50
   1ae37:	c2 50 51    	subl2 r0,r1
   1ae3a:	c2 50 53    	subl2 r0,r3
   1ae3d:	d1 56 50    	cmpl r6,r0
   1ae40:	14 e3       	bgtr 1ae25 <bcopy+0x39>
   1ae42:	c2 56 51    	subl2 r6,r1
   1ae45:	c2 56 53    	subl2 r6,r3
   1ae48:	28 56 61 63 	movc3 r6,(r1),(r3)
   1ae4c:	04          	ret
   1ae4d:	01          	nop

0001ae4e <getpagesize>:
   1ae4e:	00 00       	.word 0x0000 # Entry mask: < >
   1ae50:	c2 14 5e    	subl2 $0x14,sp
   1ae53:	d0 ef db 3f 	movl 3ee34 <__guard_local>,0xfffffff8(fp)
   1ae57:	02 00 ad f8
   1ae5b:	d5 ef 6f 43 	tstl 6f1d0 <pagsz.0>


cked;
            Cursor.visible = false;
        }
        else
        {
            Cursor.lockState = CursorLockMode.None;
            Cursor.visible = true;
        }

        if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
        {
            if (Input.GetKey(KeyCode.W)) { transform.position += transform.forward * normalMoveSpeed * fastMoveFactor * Time.deltaTime; }
            if (Input.GetKey(KeyCode.S)) { transform.position -= transform.forward * normalMoveSpeed * fastMoveFactor * Time.deltaTime; }
            if (Input.GetKey(KeyCode.D)) { transform.position += transform.right * normalMoveSpeed   * fastMoveFactor * Time.deltaTime; }
            if (Input.GetKey(KeyCode.A)) { transform.position -= transform.right * normalMoveSpeed   * fastMoveFactor * Time.deltaTime; }
            if (Input.GetKey(KeyCode.Q)) { transform.position += transform.up * climbSpeed * fastMoveFactor * Time.deltaTime; }
            if (Input.GetKey(KeyCode.Z)) { transform.position -= transform.up * climbSpeed * fastMoveFactor * Time.deltaTime; }
        }
        else
        {
            if (Input.GetKey(KeyCode.W)) { transform.position += transform.forward * normalMoveSpeed * Time.deltaTime; }
            if (Input.GetKey(KeyCode.S)) { transform.position -= transform.forward * normalMoveSpeed * Time.deltaTime; }
            if (Input.GetKey(KeyCode.D)) { transform.position += transform.right * normalMoveSpeed * Time.deltaTime; }
            if (Input.GetKey(KeyCode.A)) { transform.position -= transform.right * normalMoveSpeed * Time.deltaTime;}
            if (Input.GetKey(KeyCode.Q)) { transform.position += transform.up * climbSpeed * Time.deltaTime; }
            if (Input.GetKey(KeyCode.Z)) { transform.position -= transform.up * climbSpeed * Time.deltaTime; }

        }

        if (Input.GetKeyDown(KeyCode.End))
        {
         //   Screen.lockCursor = (Screen.lockCursor == false) ? true : false;
        }
    }
}


Float(this[attrName]);
  };

  _proto.enumeratedString = function enumeratedString(attrName) {
    return this[attrName];
  };

  _proto.decimalResolution = function decimalResolution(attrName) {
    var res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);

    if (res === null) {
      return undefined;
    }

    return {
      width: parseInt(res[1], 10),
      height: parseInt(res[2], 10)
    };
  };

  AttrList.parseAttrList = function parseAttrList(input) {
    var match,
        attrs = {};
    ATTR_LIST_REGEX.lastIndex = 0;

    while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
      var value = match[2],
          quote = '"';

      if (value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1) {
        value = value.slice(1, -1);
      }

      attrs[match[1]] = value;
    }

    return attrs;
  };

  return AttrList;
}();

/* harmony default export */ var attr_list = (AttrList);
// CONCATENATED MODULE: ./src/utils/codecs.ts
// from http://mp4ra.org/codecs.html
var sampleEntryCodesISO = {
  audio: {
    'a3ds': true,
    'ac-3': true,
    'ac-4': true,
    'alac': true,
    'alaw': true,
    'dra1': true,
    'dts+': true,
    'dts-': true,
    'dtsc': true,
    'dtse': true,
    'dtsh': true,
    'ec-3': true,
    'enca': true,
    'g719': true,
    'g726': true,
    'm4ae': true,
    'mha1': true,
    'mha2': true,
    'mhm1': true,
    'mhm2': true,
    'mlpa': true,
    'mp4a': true,
    'raw ': true,
    'Opus': true,
    'samr': true,
    'sawb': true,
    'sawp': true,
    'sevc': true,
    'sqcp': true,
    'ssmv': true,
    'twos': true,
    'ulaw': true
  },
  video: {
    'avc1': true,
    'avc2': true,
    'avc3': true,
    'avc4': true,
    'avcp': true,
    'drac': true,
    'dvav': true,
    'dvhe': true,
    'encv': true,
    'hev1': true,
    'hvc1': true,
    'mjp2': true,
    'mp4v': true,
    'mvc1': true,
    'mvc2': true,
    'mvc3': true,
    'mvc4': true,
    'resv': true,
    'rv60': true,
    's263': true,
    'svc1': true,
    'svc2': true,
    'vc-1': true,
    'vp08': true,
    'vp09': true
  }
};

function isCodecType(codec, type) {
  var typeCodes = sampleEntryCodesISO[type];
  return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
}

function isCodecSupportedInMp4(codec, type) {
  return MediaSource.isTypeSupported((type || 'video') + "/mp4;codecs=\"" + codec + "\"");
}

// CONCATENATED MODULE: ./src/loader/m3u8-parser.ts

/**
 * M3U8 parser
 * @module
 */
// https://regex101.com is your friend
var MASTER_PLAYLIST_REGEX = /(?:#EXT-X-STREAM-INF:([^\n\r]*)[\r\n]+([^\r\n


 'pink', 'orange'];
let rectangleCurrentColor:string = rectangleColors[0];

// DO NOT TOUCH THE CODE below THIS LINE
let startX:number = 50-(rectangleWidth/2);
let startY:number = 50-(rectangleHeight/2);

let increaseSide:number = 20;

for(let i:number=0;i<6;i++){

ctx.beginPath();
ctx.fillStyle = rectangleCurrentColor;
ctx.fillRect(startX, startY, rectangleWidth, rectangleHeight);

rectangleWidth = rectangleWidth + increaseSide;
rectangleHeight = rectangleHeight + increaseSide;
startX = startX + rectangleWidth - increaseSide;
startY = startY + rectangleHeight - increaseSide;
rectangleCurrentColor = rectangleColors[0+i+1];

}
import { atom, AtomMut } from '@reatom/core'
import { withReducers, WithReducers } from './withReducers'

// it would be better for semantic use additional `add` and `subtract`
// but is it really needed to take slow down creation and increase mem usage?
export type NumberAtomReducers = {
  increment(state: number, value?: number): number
  decrement(state: number, value?: number): number
  random(): number
  reset(): number
}

export type NumberAtom = WithReducers<AtomMut<number>, NumberAtomReducers>

export const reatomNumber = (initState = 0, name?: string): NumberAtom =>
  atom(initState, name).pipe(
    withReducers({
      increment: (state, value = 1) => state + value,
      decrement: (state, value = 1) => state - value,
      random: Math.random,
      reset: () => initState,
    }),
  )
import { createSlice } from '@reduxjs/toolkit';
import authApi from '../../../api/auth-api';

export interface IAuth {
    loading: boolean;
    isAuth: boolean;
    isLogout: boolean;
    user: any;
}

const authSlide = createSlice({
    name: 'auth',
    initialState: {
        loading: true,
        isAuth: false,
        isLogout: false,
        user: null,
    },
    reducers: {
        loadUserStart(state) {
            state.loading = true;
        },
        loadUserSuccess(state, action) {
            state.loading = false;
            state.user = action.payload;
            state.isAuth = true;
            state.isLogout = false;
        },
        loadUserFailed(state) {
            localStorage.removeItem('token');

            state.loading = false;
            state.user = null;
            state.isAuth = false;
            state.isLogout = true;
        },
        logout(state) {
            localStorage.removeItem('token');

            state.loading = false;
            state.user = null;
            state.isAuth = false;
            state.isLogout = true;
        },
    },
});

const { actions, reducer } = authSlide;

export const { loadUserStart, loadUserSuccess, loadUserFailed, logout } = actions;

export const loadUser = () => async (dispatch: any) => {
    try {
        dispatch(loadUserStart());
        const response = await authApi.getUser();

        if (response.permissions && (response.permissions as string[]).includes('administrator')) {
            return dispatch(loadUserSuccess(response));
        }

        return dispatch(loadUserFailed());
    } catch (err) {
        dispatch(loadUserFailed());
    }
};

export default reducer;
import bcrypt from 'bcrypt';

const hash = (plaintext: string): Promise<string> => {
  return bcrypt.hash(plaintext, 10);
};

const compare = (plaintext: string, e


n $method(&mut self, other: $scalar) {
                $imp::$method(&mut self.0, other)
            }
        }
    };
}

macro_rules! define_ops {
    ($f: ty, $($t: ty)*) => ($(
        define_op!(impl Add<$t> for $f, add);
        define_op!(impl Sub<$t> for $f, sub);
        define_op!(impl Mul<$t> for $f, mul);
        define_op!(impl Div<$t> for $f, div);
        define_op!(impl Rem<$t> for $f, rem);

        define_ord!($t, $f);

        define_op_assign!(impl AddAssign<$t> for $f, add_assign);
        define_op_assign!(impl SubAssign<$t> for $f, sub_assign);
        define_op_assign!(impl MulAssign<$t> for $f, mul_assign);
        define_op_assign!(impl DivAssign<$t> for $f, div_assign);
        define_op_assign!(impl RemAssign<$t> for $f, rem_assign);
    )*)
}

define_from!( Nat, usize u8 u16 u32 u64 u128 );
define_from!( Int, usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 );

define_eq!( Nat, usize u8 u16 u32 u64 u128 );
define_eq!( Int, usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 );

define_ops!( Nat, usize u8 u16 u32 u64 u128 );
define_ops!( Int, usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 );

// Need a separate macro to extract the Big[U]Int from the Nat/Int struct.
macro_rules! define_op_0 {
    (impl $imp: ident < $scalar: ty > for $res: ty, $method: ident) => {
        impl $imp<$scalar> for $res {
            type Output = $res;

            #[inline]
            fn $method(self, other: $scalar) -> $res {
                $imp::$method(self.0, &other.0).into()
            }
        }
    };
}

macro_rules! define_op_0_assign {
    (impl $imp: ident < $scalar: ty > for $res: ty, $method: ident) => {
        // Implement A * B
        impl $imp<$scalar> for $res {
            #[inline]
            fn $method(&mut self, other: $scalar) {
                $imp::$method(&mut self.0, other.0)
            }
        }
    };
}

define_op_0!(impl Add<Nat> for Nat, add);
define_op_0!(impl Sub<Nat> for Nat, sub);
define_op_0!(impl Mul<Nat> for Nat, mul);
define_op_0!(impl Div<Nat> for Nat, div);
define_op_0!(impl Rem<Nat> for Nat, rem);

define_op_0_assign!(impl AddAssign<Nat> for Nat, add_assign);
define_op_0_assign!(impl SubAssign<Nat> for Nat, sub_assign);
define_op_0_assign!(impl MulAssign<Nat> for Nat, mul_assign);
define_op_0_assign!(impl DivAssign<Nat> for Nat, div_assign);
define_op_0_assign!(impl RemAssign<Nat> for Nat, rem_assign);

define_op_0!(impl Add<Int> for Int, add);
define_op_0!(impl Sub<Int> for Int, sub);
define_op_0!(impl Mul<Int> for Int, mul);
define_op_0!(impl Div<Int> for Int, div);
define_op_0!(impl Rem<Int> for Int, rem);

define_op_0_assign!(impl AddAssign<Int> for Int, add_assign);
define_op_0_assign!(impl SubAssign<Int> for Int, sub_assign);
define_op_0_assign!(impl MulAssign<Int> for Int, mul_assign);
define_op_0_assign!(impl DivAssign<Int> for Int, div_assign);
define


ShouldBeNil)
			So(tt1, ShouldBeFalse)
		})

		//Empty db
		sqlite.DB.MustExec("delete from test_user where 1 = 1")
		sqlite.DB.MustExec("delete from test_acl where 1 = 1")

		sqlite.DB.Close()

		//Delete the db
		os.Remove("../test-files/sqlite_test.db")

		sqlite.Halt()

	})

}

func TestMemorySqlite(t *testing.T) {

	//Initialize Sqlite without mandatory values (fail).
	authOpts := make(map[string]string)

	Convey("If mandatory params are not set initialization should fail", t, func() {
		_, err := NewSqlite(authOpts, log.DebugLevel, hashing.NewHasher(authOpts, "sqlite"))
		So(err, ShouldBeError)
	})

	//Initialize Sqlite with some test values (omit tls).
	authOpts["sqlite_source"] = "memory"
	authOpts["sqlite_userquery"] = "SELECT password_hash FROM test_user WHERE username = ? limit 1"
	authOpts["sqlite_superquery"] = "select count(*) from test_user where username = ? and is_admin = 1"
	authOpts["sqlite_aclquery"] = "SELECT test_acl.topic FROM test_acl, test_user WHERE test_user.username = ? AND test_acl.test_user_id = test_user.id AND rw >= ?"

	Convey("Given valid params NewSqlite should return a Sqlite backend instance", t, func() {
		sqlite, err := NewSqlite(authOpts, log.DebugLevel, hashing.NewHasher(authOpts, "sqlite"))
		So(err, ShouldBeNil)

		//Create schemas
		sqlite.DB.MustExec(userSchema)
		sqlite.DB.MustExec(aclSchema)

		//Empty db
		sqlite.DB.MustExec("delete from test_user where 1 = 1")
		sqlite.DB.MustExec("delete from test_acl where 1 = 1")

		//Insert a user to test auth
		username := "test"
		userPass := "testpw"
		//Hash generated by the pw utility
		userPassHash := "PBKDF2$sha512$100000$os24lcPr9cJt2QDVWssblQ==$BK1BQ2wbwU1zNxv3Ml3wLuu5//hPop3/LvaPYjjCwdBvnpwusnukJPpcXQzyyjOlZdieXTx6sXAcX4WnZRZZnw=="

		insertQuery := "INSERT INTO test_user(username, password_hash, is_admin) values(?, ?, ?)"

		var userID int64

		res, err := sqlite.DB.Exec(insertQuery, username, userPassHash, MOSQ_ACL_READ)
		So(err, ShouldBeNil)

		userID, err = res.LastInsertId()

		So(err, ShouldBeNil)
		So(userID, ShouldBeGreaterThan, 0)

		Convey("Given a username and a correct password, it should correctly authenticate it", func() {

			authenticated, err := sqlite.GetUser(username, userPass, "")
			So(err, ShouldBeNil)
			So(authenticated, ShouldBeTrue)

		})

		Convey("Given a username and an incorrect password, it should not authenticate it", func() {

			authenticated, err := sqlite.GetUser(username, "wrong_password", "")
			So(err, ShouldBeNil)
			So(authenticated, ShouldBeFalse)

		})

		Convey("Given a username that is admin, super user should pass", func() {
			superuser, err := sqlite.GetSuperuser(username)
			So(err, ShouldBeNil)
			So(superuser, ShouldBeTrue)
		})

		//Now create some acls and test topics

		strictAcl := "test/topic/1"
		singleLevelAcl := "test/topic


 var response = new ShoppingCartVM()
            {
                ShoppingCart = _shoppingCart,
                ShoppingCartTotal = _shoppingCart.GetShoppingCartTotal()
            };

            return View(response);
        }

        public async Task<IActionResult> AddItemToShoppingCart(int id)
        {
            var item = await _moviesService.GetMovieByIdAsync(id);

            if (item != null)
            {
                _shoppingCart.AddItemToCart(item);
            }
            return RedirectToAction(nameof(ShoppingCart));
        }

        public async Task<IActionResult> RemoveItemFromShoppingCart(int id)
        {
            var item = await _moviesService.GetMovieByIdAsync(id);

            if (item != null)
            {
                _shoppingCart.RemoveItemFromCart(item);
            }
            return RedirectToAction(nameof(ShoppingCart));
        }

        public async Task<IActionResult> CompleteOrder()
        {
            var items = _shoppingCart.GetShoppingCartItems();
            string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            string userEmailAddress = User.FindFirstValue(ClaimTypes.Email);

            await _ordersService.StoreOrderAsync(items, userId, userEmailAddress);
            await _shoppingCart.ClearShoppingCartAsync();

            return View("OrderCompleted");
        }
    }
}


2[ok2a&peacekeepers&censored], delay[ok2a&peacekeepers&censored], col="black", pch=1, cex=1.1) # circle
mtext("With U.N. peacekeeping", line=1, cex=1.1)
ok2b <- ok&!peacekeepers
plot(badness2[ok2], delay[ok2], type="n", xlab="Pre-treatment measure of problems with the country", ylab="", bty="n", xaxt="n")
axis(1, quantile(badness2[ok2], c(.05, .95)), c("not so bad", "really bad"))
axis(1, range(badness2[ok2]), c("",""), tck=0)
points(badness2[ok2b&!peacekeepers&!censored], delay[ok2b&!peacekeepers&!censored], col="black", pch=20, cex=.6) # dot
points(badness2[ok2b&!peacekeepers&censored], delay[ok2b&!peacekeepers&censored], col="black", pch=1, cex=1.1) # circle
mtext("Without U.N. peacekeeping", line=1, cex=1.1)

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABUAAAAPACAMAAADDuCPrAAADAFBMVEUAAAABAQECAgIDAwMEBAQFBQUGBgYHBwcICAgJCQkKCgoLCwsMDAwNDQ0ODg4PDw8QEBARERESEhITExMUFBQVFRUWFhYXFxcYGBgZGRkaGhobGxscHBwdHR0eHh4fHx8gICAhISEiIiIjIyMkJCQlJSUmJiYnJycoKCgpKSkqKiorKyssLCwtLS0uLi4vLy8wMDAxMTEyMjIzMzM0NDQ1NTU2NjY3Nzc4ODg5OTk6Ojo7Ozs8PDw9PT0+Pj4/Pz9AQEBBQUFCQkJDQ0NERERFRUVGRkZHR0dISEhJSUlKSkpLS0tMTExNTU1OTk5PT09QUFBRUVFSUlJTU1NUVFRVVVVWVlZXV1dYWFhZWVlaWlpbW1tcXFxdXV1eXl5fX19gYGBhYWFiYmJjY2NkZGRlZWVmZmZnZ2doaGhpaWlqampra2tsbGxtbW1ubm5vb29wcHBxcXFycnJzc3N0dHR1dXV2dnZ3d3d4eHh5eXl6enp7e3t8fHx9fX1+fn5/f3+AgICBgYGCgoKDg4OEhISFhYWGhoaHh4eIiIiJiYm


local JUGGERNAUT_BOT_STATE_INTRO				= 0
local JUGGERNAUT_BOT_STATE_IDLE					= 1
local JUGGERNAUT_BOT_STATE_ATTACK				= 2
local JUGGERNAUT_BOT_STATE_OMNISLASH			= 3

-----------------------------------------------------------------------------------------------------

if CRoshanJuggernautBot == nil then
	CRoshanJuggernautBot = class({})
end

-----------------------------------------------------------------------------------------------------

function CRoshanJuggernautBot:constructor( me )
	self.me = me
	self.hAbilityOmnislash = self.me:FindAbilityByName( "juggernaut_omni_slash" )
	if self.hAbilityOmnislash == nil then
		print( 'JUGG BOT - failed to find omnislash!' )
	end
	self.nBotState = JUGGERNAUT_BOT_STATE_INTRO
	self.hAttackTarget = nil
end

-----------------------------------------------------------------------------------------------------

function CRoshanJuggernautBot:ChangeBotState( nNewState )
	self.nBotState = nNewState
end

-----------------------------------------------------------------------------------------------------

function CRoshanJuggernautBot:BotThink()

	if not IsServer() then
		return
	end
	if self.bWasKilled then
		return -1
	end
	if ( not self.me:IsAlive() ) then
		self.bWasKilled = true
		return -1
	end

	if GameRules:IsGamePaused() == true then
		return 0.5
	end

	if self.nBotState == JUGGERNAUT_BOT_STATE_INTRO then

		local hAttackPosition = Entities:FindByName( nil, "juggernaut_attack_pos" )
		if hAttackPosition ~= nil then

			ExecuteOrderFromTable( {
				UnitIndex = self.me:entindex(),
				OrderType = DOTA_UNIT_ORDER_ATTACK_MOVE,
				Position = hAttackPosition:GetAbsOrigin(),
				Queue = false,
			} )

			self:ChangeBotState( JUGGERNAUT_BOT_STATE_IDLE )
		end

	elseif self.nBotState == JUGGERNAUT_BOT_STATE_IDLE then
		local hHero = self:FindBestTarget()
		if hHero ~= nil then
			self.hAttackTarget = hHero
			self:ChangeBotState( JUGGERNAUT_BOT_STATE_ATTACK )
		end

	elseif self.nBotState == JUGGERNAUT_BOT_STATE_ATTACK then

		if self.hAttackTarget == nil or self.hAttackTarget:IsAlive() == false then
			self:ChangeBotState( JUGGERNAUT_BOT_STATE_IDLE )
		end

		print( 'JUGG BOT - ATTACKING TARGET! ' .. self.hAttackTarget:GetUnitName() )
		self:AttackTarget( self.hAttackTarget )

		local hHero = self:FindBestTarget()
		if hHero ~= nil then
			self.hAttackTarget = hHero

			print( 'JUGG BOT - Checking omnislash for castability - ' .. tostring( self.hAbilityOmnislash:IsFullyCastable() ) )
			if self.hAbilityOmnislash and self.hAbilityOmnislash:IsFullyCastable() then
				print('JUGG BOT - going for omni')
				self:ChangeBotState( JUGGERNAU


n this.scatteredFeatureSpawnList;
    }

    public static class Start extends StructureStart
    {
        public Start()
        {
        }

        public Start(World worldIn, Random p_i2060_2_, int p_i2060_3_, int p_i2060_4_)
        {
            super(p_i2060_3_, p_i2060_4_);
            BiomeGenBase biomegenbase = worldIn.getBiomeGenForCoords(new BlockPos(p_i2060_3_ * 16 + 8, 0, p_i2060_4_ * 16 + 8));

            if (biomegenbase != BiomeGenBase.jungle && biomegenbase != BiomeGenBase.jungleHills)
            {
                if (biomegenbase == BiomeGenBase.swampland)
                {
                    ComponentScatteredFeaturePieces.SwampHut componentscatteredfeaturepieces$swamphut = new ComponentScatteredFeaturePieces.SwampHut(p_i2060_2_, p_i2060_3_ * 16, p_i2060_4_ * 16);
                    this.components.add(componentscatteredfeaturepieces$swamphut);
                }
                else if (biomegenbase == BiomeGenBase.desert || biomegenbase == BiomeGenBase.desertHills)
                {
                    ComponentScatteredFeaturePieces.DesertPyramid componentscatteredfeaturepieces$desertpyramid = new ComponentScatteredFeaturePieces.DesertPyramid(p_i2060_2_, p_i2060_3_ * 16, p_i2060_4_ * 16);
                    this.components.add(componentscatteredfeaturepieces$desertpyramid);
                }
            }
            else
            {
                ComponentScatteredFeaturePieces.JunglePyramid componentscatteredfeaturepieces$junglepyramid = new ComponentScatteredFeaturePieces.JunglePyramid(p_i2060_2_, p_i2060_3_ * 16, p_i2060_4_ * 16);
                this.components.add(componentscatteredfeaturepieces$junglepyramid);
            }

            this.updateBoundingBox();
        }
    }
}
package net.minecraft.world.gen.layer;

import net.minecraft.crash.CrashReport;
import net.minecraft.crash.CrashReportCategory;
import net.minecraft.util.ReportedException;
import net.minecraft.world.WorldType;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.gen.ChunkProviderSettings;

public abstract class GenLayer
{
    private long worldGenSeed;
    protected GenLayer parent;
    private long chunkSeed;
    protected long baseSeed;

    public static GenLayer[] initializeAllBiomeGenerators(long seed, WorldType p_180781_2_, String p_180781_3_)
    {
        GenLayer genlayer = new GenLayerIsland(1L);
        genlayer = new GenLayerFuzzyZoom(2000L, genlayer);
        GenLayerAddIsland genlayeraddisland = new GenLayerAddIsland(1L, genlayer);
        GenLayerZoom genlayerzoom = new GenLayerZoom(2001L, genlayeraddisland);
        GenLayerAddIsland genlayeraddisland1 = new GenLayerAddIsland(2L, genlayerzoom);
        genlayeraddisland1 = new GenLayerAddIsland(50L, genlayeraddisland1);
        genlayeraddisland1 = new GenLayerAddIsland(70L, genlayeraddisland1);
        GenLayerRemoveTooMuchOcean genlayerremovetoomuchocean = new GenLayerRemoveTooMuchOcean(2L, genlayeraddisland1);
        GenLayerAddSnow genlayeraddsnow = new GenLayerAddSnow(2L, genlayerremovetoomuchocean);
        GenLayerAddIsland genlayeraddisland2 = new GenLayerAddIsland(3L, genlayeraddsnow);
        GenLayerEdge genlayeredge = new GenLayerEdge(2L, genlayeraddisland2, GenLayerEdge.Mode.COOL_WARM);
        genlayeredge = new GenLayerEdge(2L, genlayeredge, GenLayerEdge.Mode.HEAT_ICE);
        genlayeredge = new GenLayerEdge


)

        assert set([nodes[1], nodes[2]]) == set(g.bfs_nodes_to_run())

@pytest.mark.skip(reason="Run manually to re-generate doc images")
class TestDocsExample:
    @pytest.fixture
    def complex_dag(self, wf_node_generator):
        g = WorkflowDAG()
        nodes = [wf_node_generator() for i in range(10)]
        for n in nodes:
            g.add_node(n)

        g.add_edge(nodes[0], nodes[1], "failure_nodes")
        g.add_edge(nodes[0], nodes[2], "success_nodes")
        g.add_edge(nodes[0], nodes[3], "always_nodes")
        g.add_edge(nodes[1], nodes[4], "success_nodes")
        g.add_edge(nodes[1], nodes[5], "failure_nodes")

        g.add_edge(nodes[2], nodes[6], "failure_nodes")
        g.add_edge(nodes[3], nodes[6], "success_nodes")
        g.add_edge(nodes[4], nodes[6], "always_nodes")

        g.add_edge(nodes[6], nodes[7], "always_nodes")
        g.add_edge(nodes[6], nodes[8], "success_nodes")
        g.add_edge(nodes[6], nodes[9], "failure_nodes")

        return (g, nodes)

    def test_dnr_step(self, complex_dag):
        (g, nodes) = complex_dag
        base_dir = '/awx_devel'

        g.generate_graphviz_plot(file_name=os.path.join(base_dir, "workflow_step0.gv"))
        nodes[0].job = Job(status='successful')
        g.mark_dnr_nodes()
        g.generate_graphviz_plot(file_name=os.path.join(base_dir, "workflow_step1.gv"))
        nodes[2].job = Job(status='successful')
        nodes[3].job = Job(status='successful')
        g.mark_dnr_nodes()
        g.generate_graphviz_plot(file_name=os.path.join(base_dir, "workflow_step2.gv"))
        nodes[6].job = Job(status='failed')
        g.mark_dnr_nodes()
        g.generate_graphviz_plot(file_name=os.path.join(base_dir, "workflow_step3.gv"))
        nodes[7].job = Job(status='successful')
        nodes[9].job = Job(status='successful')
        g.mark_dnr_nodes()
        g.generate_graphviz_plot(file_name=os.path.join(base_dir, "workflow_step4.gv"))


un mail a [hello@spark.io](mailto:hello@spark.io).*

Se volete connettere più Cores, dovrete seguire questo processo per ognuno di essi. Saprete quale è quale dal segnale dell'arcobaleno.

Una volta finito di nominare i vostri Cores, potrete controllarli con l'applicazione Tinker! Provate *digitalWrite* sul pin D7 per accendere il LED sul Core.

## Smart Config con l'applicazione TI

Lo Smart Config con l'applicazione Texas Instruments CC3000 è simile al processo descritto prima, sebbene non sia necessario un account Spark e  TI ha anche un applet Java che può lavorare da un computer Mac, Windows, o Linux.

Seguite le istruzioni sul sito di Texas Instrument:

[CC3000 Smart Config @ Texas Instruments](http://processors.wiki.ti.com/index.php/CC3000_Smart_Config)

L'unica cosa che è differente è che dovrete attivare la chiave AES opzionale e immettere `sparkdevices2013`.

*NOTA: L'applicazione Android di TI non é disponibile su Google Play; dovrete scaricarla voi dalla loro pagina web e caricare l'apk voi stessi.*

## Connessione via USB

Potete anche connettere lo Spark Core alla vostra rete Wi-Fi via USB comunicando via Serial. *NOTA: Questo funziona solo se lo Spark Core è in modalità di ascolto (cioè il led RGB lampeggia blu)*.

Prima di tutto dovrete scaricare un'applicazione di terminale seriale.

Per utenti __Windows__ , raccomandiamo [PuTTY](http://www.chiark.greenend.org.uk/~sgtatham/putty/).
Dovrete pure installare il driver per Windows:

[< Driver Windows per lo Spark Core >](https://s3.amazonaws.com/spark-website/Spark.zip)

[CoolTerm](http://freeware.the-meiers.org/) fornisce una bella interfaccia GUI.
![CoolTerm settings]({{assets}}/images/coolterm-settings.png)
![CoolTerm setup]({{assets}}/images/coolterm-setup.png)

Per utenti __Mac__ , sia CoolTerm che screen vanno bene.

Per un utilizzo __Linux__ command line, [GNU Screen](https://www.gnu.org/software/screen/) funziona bene.
(Con OS X, il modo command line viene fatto partire con un comando simile a `screen /dev/cu.usbmodem1411 9600`.
Su Ubuntu, è qualcosa del genere `screen /dev/ttyACM0 9600`. Dove si trovano i Device può variare: cercate nella cartella `/dev` se non lo trovate subito)

__Come fare__

Connettete il vostro Spark Core al computer via USB. Mentre lo Spark Core è in modalità ascolto, aprire una porta seriale via USB usando i parametri standard che dovrebbero essere:

- Baudrate: 9600
- Data Bits: 8
- Parity: none
- Stop Bits: 1

Dopo aver aperto una connessione seriale, avete a disposizione due comandi premendo **w** o **i** sulla tastiera. Ecco cosa fanno:

- **w**: Definisce l'SSID e la password del vostro Wi-Fi
- **i**: ("i" come identifica) Legge l'ID dello Spark Core

**NOTA:** Se collegate


	d_hellinger_model_ptr->get_confidence_level(),
											d_hellinger_model_ptr->get_grid_iterations(),
											d_hellinger_model_ptr->get_grid_search(),
											d_hellinger_model_ptr->get_use_amoeba_tolerance(),
											d_hellinger_model_ptr->get_amoeba_tolerance(),
											d_hellinger_model_ptr->get_use_amoeba_iterations(),
											d_hellinger_model_ptr->get_amoeba_iterations(),
											d_output_path.toStdString(),
											d_results_filename_root.toStdString(),
											d_path_for_temporary_files.toStdString()));
}

void
GPlatesQtWidgets::HellingerThread::calculate_three_way_uncertainties()
{
	qDebug() << "calculate_three_way_uncertainties";
	QString pick_file = d_path_for_temporary_files + d_temp_pick_file;

	GPlatesApi::PythonInterpreterLocker interpreter_locker;

	// Retrieve the main module.
	boost::python::object main = boost::python::import("__main__");

	boost::python::object global(main.attr("__dict__"));
	boost::python::object ignored = boost::python::exec_file(d_python_file.toStdString().c_str(),global, global);
	boost::python::object pythonCode = global["calculate_uncertainty_3_way"];

	HellingerPoleEstimate estimate_12 = d_hellinger_model_ptr->get_initial_guess_12();
	HellingerPoleEstimate estimate_13 = d_hellinger_model_ptr->get_initial_guess_13();

	boost::python::extract<std::string>(pythonCode(
											pick_file.toStdString().c_str(),
											estimate_12.d_lat,
											estimate_12.d_lon,
											estimate_12.d_angle,
											estimate_13.d_lat,
											estimate_13.d_lon,
											estimate_13.d_angle,
											d_hellinger_model_ptr->get_search_radius(),
											d_hellinger_model_ptr->get_confidence_level(),
											d_hellinger_model_ptr->get_use_amoeba_tolerance(),
											d_hellinger_model_ptr->get_amoeba_tolerance(),
											d_hellinger_model_ptr->get_use_amoeba_iterations(),
											d_hellinger_model_ptr->get_amoeba_iterations(),
											d_output_path.toStdString(),
											d_results_filename_root.toStdString(),
											d_path_for_temporary_files.toStdString()));
}

void
GPlatesQtWidgets::HellingerThread::run()
{
	// FIXME: the output file names are hard-coded in the python script, so changing these
	// filenames here, or elsewhere in this class, will likely result in not being able to find/open
	// the result files....
	QString temp_file = d_path_for_temporary_files + d_temp_pick_file;
	QString temp_file_temp_result = d_path_for_temporary_files + d_temp_result_filename;
	QString temp_file_par = d_path_for_temporary_files + d_temp_par;
	QString temp_file_res = d_path_for_temporary_files + d_temp_res;

	// Remove any old temporary files arising from previous fits.
	QFile::remove(temp_file_temp_result);
	QFile::remove(temp_file_par);
	QFile::remove(temp_file_res);

#if 1
	qDebug() << "temp file: " << temp_file;
	qDebug() << "temp_file_temp_result: " << temp_file_temp_result;
	qDebug() << "temp file par: " << temp_


ort "),ue.push("import "),K.importKind&&K.importKind!=="value"&&ue.push(K.importKind," "),ue.push(W("id")," = ",W("moduleReference")),ce.semi&&ue.push(";"),l(ue);case"TSExternalModuleReference":return["require(",W("expression"),")"];case"TSModuleDeclaration":{let Fe=ee.getParentNode(),z=g(K.id),U=Fe.type==="TSModuleDeclaration",Z=K.body&&K.body.type==="TSModuleDeclaration";if(U)ue.push(".");else{K.declare&&ue.push("declare "),ue.push(I(ee,ce,W));let se=ce.originalText.slice(E(K),E(K.id));K.id.type==="Identifier"&&K.id.name==="global"&&!/namespace|module/.test(se)||ue.push(z||/(?:^|\s)module(?:\s|$)/.test(se)?"module ":"namespace ")}return ue.push(W("id")),Z?ue.push(W("body")):K.body?ue.push(" ",l(W("body"))):ue.push(de),ue}case"TSConditionalType":return P(ee,ce,W);case"TSInferType":return["infer"," ",W("typeParameter")];case"TSIntersectionType":return J(ee,ce,W);case"TSUnionType":return L(ee,ce,W);case"TSFunctionType":return Q(ee,ce,W);case"TSTupleType":return V(ee,ce,W);case"TSTypeReference":return[W("typeName"),S(ee,ce,W,"typeParameters")];case"TSTypeAnnotation":return W("typeAnnotation");case"TSEmptyBodyFunctionExpression":return k(ee,ce,W);case"TSJSDocAllType":return"*";case"TSJSDocUnknownType":return"?";case"TSJSDocNullableType":return Y(ee,W,"?");case"TSJSDocNonNullableType":return Y(ee,W,"!");case"TSInstantiationExpression":return[W("expression"),W("typeParameters")];default:throw new Error(`Unknown TypeScript node type: ${JSON.stringify(K.type)}.`)}}r.exports={printTypescript:ie}}}),hd=te({"src/language-js/print/comment.js"(e,r){ne();var{hasNewline:t}=Ue(),{builders:{join:s,hardline:a},utils:{replaceTextEndOfLine:n}}=qe(),{isLineComment:u}=Ke(),{locStart:i,locEnd:l}=ut(),p=Pt();function y(c,f){let F=c.getValue();if(u(F))return f.originalText.slice(i(F),l(F)).trimEnd();if(p(F)){if(h(F)){let E=g(F);return F.trailing&&!t(f.originalText,i(F),{backwards:!0})?[a,E]:E}let _=l(F),w=f.originalText.slice(_-3,_)==="*-/";return["/*",n(F.value),w?"*-/":"*/"]}throw new Error("Not a comment: "+JSON.stringify(F))}function h(c){let f=`*${c.value}*`.split(`
`);return f.length>1&&f.every(F=>F.trim()[0]==="*")}function g(c){let f=c.value.split(`
`);return["/*",s(a,f.map((F,_)=>_===0?F.trimEnd():" "+(_<f.length-1?F.trim():F.trimStart()))),"*/"]}r.exports={printComment:y}}}),vd=te({"src/language-js/print/literal.js"(e,r){ne();var{printString:t,printNumber:s}=Ue(),{replaceTextEndOfLine:a}=Yt(),{printDirective:n}=ct();function u(y,h){let g=y.getNode();switch(g.type){case"RegExpLiteral":return p(g);case


tss	68(%rbx), %ymm12
	vmulps			%ymm8, %ymm12, %ymm15
	vaddps			%ymm15, %ymm2, %ymm2
	vmulps			%ymm9, %ymm12, %ymm15
	vaddps			%ymm15, %ymm6, %ymm6

	subl		$ 1, %r10d // k-1
	addq		$ 32, %r11 // A+1*bs*sizeof(float)
	addl		$ 1, %r15d // offsetB+1

//	jmp			0f // end

	// end
0:

#if MACRO_LEVEL>=1
	.endm
#else
	ret

#if defined(OS_LINUX)
	.size	inner_edge_trmm_nn_rl_16x4_lib8, .-inner_edge_trmm_nn_rl_16x4_lib8
#endif
#endif

// common inner routine with file scope
//
// strsm
// right
// lower
// transposed
// not-unit
//
// input arguments:
// r10  <- D
// r11  <- inv_diag_D
// r12d <- kn
// ymm0 <- []
// ymm1 <- []
// ymm2 <- []
// ymm3 <- []
// ymm12 <- dirty
// ymm13 <- dirty
// ymm14 <- dirty
// ymm15 <- dirty
//
// output arguments:
// r10  <- D
// r11  <- inv_diag_D
// r12d <- kn
// ymm0 <- []
// ymm1 <- []
// ymm2 <- []
// ymm3 <- []
// ymm12 <- dirty
// ymm13 <- dirty
// ymm14 <- dirty
// ymm15 <- dirty

#if MACRO_LEVEL>=1
	.macro INNER_EDGE_TRSM_RLT_INV_16X4_VS_LIB8
#else
	.p2align 4,,15
#if defined(OS_LINUX)
	.type inner_edge_trsm_rlt_inv_16x4_vs_lib8, @function
inner_edge_trsm_rlt_inv_16x4_vs_lib8:
#elif defined(OS_MAC)
_inner_edge_trsm_rlt_inv_16x4_vs_lib8:
#elif defined(OS_WINDOWS)
	.def inner_edge_trsm_rlt_inv_16x4_vs_lib8; .scl 2; .type 32; .endef
inner_edge_trsm_rlt_inv_16x4_vs_lib8:
#endif
#endif

	vbroadcastss	0(%r11), %ymm13
	vmulps			%ymm0, %ymm13, %ymm0
	vmulps			%ymm4, %ymm13, %ymm4
	cmpl			$ 2, %r12d
	jl				0f // ret
	vbroadcastss	4(%r10), %ymm13
	vmulps			%ymm0, %ymm13, %ymm12
	vsubps			%ymm12, %ymm1, %ymm1
	vmulps			%ymm4, %ymm13, %ymm12
	vsubps			%ymm12, %ymm5, %ymm5
	vbroadcastss	8(%r10), %ymm13
	vmulps			%ymm0, %ymm13, %ymm12
	vsubps			%ymm12, %ymm2, %ymm2
	vmulps


const std::map<int, uint8_t> kOlympicV2WRRQueueToWeight() {
  const std::map<int, uint8_t> wrrQueueToWeight = {
      {getOlympicV2QueueId(OlympicV2QueueType::NCNF), kOlympicV2NCNFWeight},
      {getOlympicV2QueueId(OlympicV2QueueType::BRONZE), kOlympicV2BronzeWeight},
      {getOlympicV2QueueId(OlympicV2QueueType::SILVER), kOlympicV2SilverWeight},
      {getOlympicV2QueueId(OlympicV2QueueType::GOLD), kOlympicV2GoldWeight},
  };

  return wrrQueueToWeight;
}

const std::vector<int> kOlympicWRRQueueIds() {
  const std::vector<int> wrrQueueIds = {
      getOlympicQueueId(OlympicQueueType::SILVER),
      getOlympicQueueId(OlympicQueueType::GOLD),
      getOlympicQueueId(OlympicQueueType::ECN1),
      getOlympicQueueId(OlympicQueueType::BRONZE)};
  const std::vector<int> wrrQueueIds3Q2Q = {
      getOlympicQueueId(OlympicQueueType::ECN1),
      getOlympicQueueId(OlympicQueueType::ICP),
      getOlympicQueueId(OlympicQueueType::NC)};

  return isDualStage3Q2QQos() ? wrrQueueIds3Q2Q : wrrQueueIds;
}

const std::vector<int> kOlympicV2WRRQueueIds() {
  const std::vector<int> queueIds = {
      getOlympicV2QueueId(OlympicV2QueueType::NCNF),
      getOlympicV2QueueId(OlympicV2QueueType::BRONZE),
      getOlympicV2QueueId(OlympicV2QueueType::SILVER),
      getOlympicV2QueueId(OlympicV2QueueType::GOLD)};

  return queueIds;
}

const std::vector<int> kOlympicSPQueueIds() {
  const std::vector<int> spQueueIds = {
      getOlympicQueueId(OlympicQueueType::ICP),
      getOlympicQueueId(OlympicQueueType::NC)};

  return spQueueIds;
}

const std::vector<int> kOlympicWRRAndICPQueueIds() {
  const std::vector<int> wrrAndICPQueueIds = {
      getOlympicQueueId(OlympicQueueType::SILVER),
      getOlympicQueueId(OlympicQueueType::GOLD),
      getOlympicQueueId(OlympicQueueType::ECN1),
      getOlympicQueueId(OlympicQueueType::BRONZE),
      getOlympicQueueId(OlympicQueueType::ICP)};
  return wrrAndICPQueueIds;
}

const std::vector<int> kOlympicWRRAndNCQueueIds() {
  const std::vector<int> wrrAndNCQueueIds = {
      getOlympicQueueId(OlympicQueueType::SILVER),
      getOlympicQueueId(OlympicQueueType::GOLD),
      getOlympicQueueId(OlympicQueueType::ECN1),
      getOlympicQueueId(OlympicQueueType::BRONZE),
      getOlympicQueueId(OlympicQueueType::NC)};
  return wrrAndNCQueueIds;
}

const std::vector<int> kOlympicAllSPQueueIds() {
  const std::vector<int> queueIds = {
      getOlympicV2QueueId(OlympicV2QueueType::NCNF),
      getOlympicV2QueueId(OlympicV2QueueType::BRONZE),
      getOlympicV2QueueId(OlympicV2QueueType::SILVER),
      getOlympicV2QueueId(OlympicV2QueueType::GOLD),
      getOlympicV2QueueId(OlympicV2QueueType::ICP),
      getOlympicV2QueueId(OlympicV2QueueType::NC)};

  return queueIds;


String(dateString);
        while (true) {
            XmlPullParser.Event tag = parser.next();
            if (tag == XmlPullParser.Event.START_ELEMENT) {
                String name = parser.getName();
                switch (name) {
                    case PubkeyElement.PubkeyDataElement.ELEMENT:
                        String base64EncodedOpenPgpPubKey = parser.nextText();
                        PubkeyElement.PubkeyDataElement pubkeyDataElement = new PubkeyElement.PubkeyDataElement(base64EncodedOpenPgpPubKey);
                        return new PubkeyElement(pubkeyDataElement, date);
                }
            }
        }
    }
}
/*
 *
 * Copyright 2017-2024 Florian Schmaus, 2018 Paul Schaub.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jivesoftware.smackx.ox.element;

import java.util.Date;
import java.util.List;
import java.util.Set;

import org.jivesoftware.smack.packet.ExtensionElement;
import org.jivesoftware.smack.util.Objects;
import org.jivesoftware.smack.util.RandomUtil;
import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smack.util.XmlStringBuilder;

import org.jxmpp.jid.Jid;

/**
 * Abstract class that bundles functionality of encrypted OpenPGP content elements ({@link CryptElement},
 * {@link SigncryptElement}) together.
 */
public abstract class EncryptedOpenPgpContentElement extends OpenPgpContentElement {

    public static final String ELEM_RPAD = "rpad";

    private final String rpad;

    protected EncryptedOpenPgpContentElement(Set<? extends Jid> to, String rpad, Date timestamp, List<ExtensionElement> payload) {
        super(Objects.requireNonNullNorEmpty(
                to, "Encrypted OpenPGP content elements must have at least one 'to' attribute."),
                timestamp, payload);
        this.rpad = Objects.requireNonNull(rpad);
    }

    @SuppressWarnings("JavaUtilDate")
    protected EncryptedOpenPgpContentElement(Set<? extends Jid> to, List<ExtensionElement> payload) {
        super(Objects.requireNonNullNorEmpty(
                to, "Encrypted OpenPGP content elements must have at least one 'to' attribute."),
                new Date(), payload);
        this.rpad = createRandomPadding();
    }

    private static String createRandomPadding() {
        int len = RandomUtil.nextSecureRandomInt(256);
        return StringUtils.randomString(len);
    }

    @Override
    protected void addCommonXml(XmlStringBuilder xml) {
        super.addCommonXml(xml);

        xml.openElement("rpad").escape(rpad).closeElement("rpad");
    }
}
/*
 *
 * Copyright 2018 Paul Schaub.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
pa


fficient
  // b/c in rebuild_special_one() neighs of all 1-2s are added,
  //   then a dedup(), then neighs of all 1-3s are added, then final dedup()
  // this means intermediate size cannot exceed ms^2 + ms

  int maxspecial = atom->maxspecial;
  copy = new tagint[maxspecial*maxspecial + maxspecial];

  // zero out stats

  breakcount = 0;
  breakcounttotal = 0;
}

/* ---------------------------------------------------------------------- */

FixBondBreak::~FixBondBreak()
{
  delete random;

  // delete locally stored arrays

  memory->destroy(partner);
  memory->destroy(finalpartner);
  memory->destroy(distsq);
  memory->destroy(broken);
  delete [] copy;
}

/* ---------------------------------------------------------------------- */

int FixBondBreak::setmask()
{
  int mask = 0;
  mask |= POST_INTEGRATE;
  mask |= POST_INTEGRATE_RESPA;
  return mask;
}

/* ---------------------------------------------------------------------- */

void FixBondBreak::init()
{
  if (utils::strmatch(update->integrate_style,"^respa"))
    nlevels_respa = (dynamic_cast<Respa *>(update->integrate))->nlevels;

  // enable angle/dihedral/improper breaking if any defined

  if (atom->nangles) angleflag = 1;
  else angleflag = 0;
  if (atom->ndihedrals) dihedralflag = 1;
  else dihedralflag = 0;
  if (atom->nimpropers) improperflag = 1;
  else improperflag = 0;

  if (force->improper) {
    if (force->improper_match("^class2") || force->improper_match("^ring"))
      error->all(FLERR,"Cannot yet use fix bond/break with this improper style");
  }

  lastcheck = -1;
}

/* ---------------------------------------------------------------------- */

void FixBondBreak::post_integrate()
{
  int i,j,k,m,n,i1,i2,n1,n3,type;
  double delx,dely,delz,rsq;
  tagint *slist;

  if (update->ntimestep % nevery) return;

  // check that all procs have needed ghost atoms within ghost cutoff
  // only if neighbor list has changed since last check

  if (lastcheck < neighbor->lastcall) check_ghosts();

  // acquire updated ghost atom positions
  // necessary b/c are calling this after integrate, but before Verlet comm

  comm->forward_comm();

  // resize bond partner list and initialize it
  // probability array overlays distsq array
  // needs to be atom->nmax in length

  if (atom->nmax > nmax) {
    memory->destroy(partner);
    memory->destroy(finalpartner);
    memory->destroy(distsq);
    nmax = atom->nmax;
    memory->create(partner,nmax,"bond/break:partner");
    memory->create(finalpartner,nmax,"bond/break:finalpartner");
    memory->create(distsq,nmax,"bond/break:distsq");
    probability = distsq;
  }

  int nlocal = atom->nlocal;
  int nall = atom->nlocal + atom->nghost;

  for (i = 0; i < nall; i++) {
    partner[i] = 0;
    finalpartner[i] = 0;
    distsq[i] = 0.0;
  }

  // loop over bond list
  // setup possible partner list of bonds to break

  double **x = atom->x;
  tagint *tag = atom->tag;
  int *mask = atom->mask;
  int **bondlist = neighbor->bondlist;
  int nbondlist = neighbor->nbondlist;

  for (n = 0; n < nbondlist; n++) {
    i1 =


apiVersion && cur_dev.properties.deviceID == pd_props.deviceID &&
                    cur_dev.properties.deviceType == pd_props.deviceType &&
                    cur_dev.properties.driverVersion == pd_props.driverVersion &&
                    cur_dev.properties.vendorID == pd_props.vendorID) {
                    std::vector<VkDisplayPlanePropertiesKHR> props{};
                    uint32_t prop_count = 0;
                    ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayPlanePropertiesKHR(physical_devices[dev], &prop_count, nullptr));
                    if (icd == 1) {
                        // For this extension, if no support exists (like for ICD 1), the value of 0 should be returned by the
                        // loader.
                        ASSERT_EQ(0U, prop_count);
                    } else {
                        ASSERT_EQ(cur_dev.display_plane_properties.size(), prop_count);
                        props.resize(prop_count);
                        ASSERT_EQ(VK_SUCCESS,
                                  GetPhysicalDeviceDisplayPlanePropertiesKHR(physical_devices[dev], &prop_count, props.data()));
                        ASSERT_EQ(cur_dev.display_plane_properties.size(), prop_count);

                        ASSERT_EQ(props, cur_dev.display_plane_properties);
                    }
                    found = true;
                    break;
                }
            }
            if (found) {
                break;
            }
        }
    }
}

// Test vkGetDisplayPlaneSupportedDisplaysKHR where nothing supports it.
TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRNoSupport) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
    env.get_test_icd(0).physical_devices.push_back({});

    InstWrapper instance(env.vulkan_functions);
    instance.CheckCreate();

    PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR =
        instance.load("vkGetDisplayPlaneSupportedDisplaysKHR");
    ASSERT_EQ(GetDisplayPlaneSupportedDisplaysKHR, nullptr);
}

// Test vkGetDisplayPlaneSupportedDisplaysKHR where instance supports it, but nothing else.
TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRNoICDSupport) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
    env.get_test_icd(0).physical_devices.push_back({});

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(VK_KHR_DISPLAY_EXTENSION_NAME);
    instance.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);

    PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR =
        instance.load("vkGetDisplayPlaneSupportedDisplaysKHR");
    ASSERT_EQ(GetDisplayPlaneSupportedDisplaysKHR, nullptr);
}

// Fill in random but valid data into the display plane property data struct for the current physical device
void GenerateRandomDisplays(std::vector<VkDisplayKHR>& disps) {
    disps.resize((rand() % 5) + 1);
    for (uint32_t i = 0; i < disps.size(); ++i) {
        disps[i] = CreateRandomDisplay();
    }
}

// Test vGetDisplayPlaneSupportedDisplaysKHR where instance and ICD supports it, but device does not support it.
TEST(LoaderInstPhys


3, 3, 3],
        )
        await searcher.cancel('some error message')
      },
    )
    expect(true).toBe(false)
  } catch (result) {
    expect(result).toBe('2333')
  }
})

test('cancel with ctrl+c', async () => {
  try {
    await searchHistory(
      '',
      async (searcher) => {
        await keypress(
          searcher,
          [
            2, 3, 3, 3,
            [ctrlC.sequence, ctrlC],
          ],
        )
      },
    )

    expect(true).toBe(false)
  } catch (result) {
    expect(result).toBe('2333')
  }
})

test('cancel with esc', async () => {
  try {
    await searchHistory(
      '',
      async (searcher) => {
        await keypress(
          searcher,
          [
            2, 3, 3, 3,
            [esc.sequence, esc],
          ],
        )
      },
    )

    expect(true).toBe(false)
  } catch (result) {
    expect(result).toBe('2333')
  }
})

test('search not match and cancel', async () => {
  try {
    await searchHistory(
      '3jdfn2-9jgf',
      async (searcher) => {
        await searcher.cancel()
      },
    )

    expect(true).toBe(false)
  } catch (result) {
    expect(result).toBe('3jdfn2-9jgf')
  }
})

test('search not match, but confirm', async () => {
  const result = await searchHistory(
    '3jdfn2-9jgf',
    async (searcher) => {
      await searcher.up()
      await searcher.down()
      await searcher.pageDown()
      await searcher.up()
      await searcher.pageUp()
      await searcher.submit()
    },
  )

  expect(result).toBe('3jdfn2-9jgf')
})
/* ------------
   Shell.ts

   The OS Shell - The "command line interface" (CLI) for the console.

    Note: While fun and learning are the primary goals of all enrichment center activities,
          serious injuries may occur when trying to write your own Operating System.
   ------------ */

// TODO: Write a base class / prototype for system services and let Shell inherit from it.

module TSOS {
    export class Shell {
        // Properties
        public promptStr = ">";
        public commandList = [];
        public curses = "[fuvg],[cvff],[shpx],[phag],[pbpxfhpxre],[zbgureshpxre],[gvgf]";
        public apologies = "[sorry]";
        public pillConsumed = false; //Is this the right spot? Should it be in global.ts? Who knows? Not me.

        constructor() {
        }

        public init() {
            var sc: ShellCommand;
            //
            // Load the command list.

            // ver
            sc = new ShellCommand(this.shellVer,
                                  "ver",
                                  "- Displays the current version data.");
            this.commandList[this.commandList.length] = sc;

            // help
            sc = new ShellCommand(this.shellHelp,
                                  "help",
                                  "- This is the help command. Seek help.");
            this.commandList[this.commandList.length] = sc;

            // shutdown
            sc = new ShellCommand(this.shellShutdown,
                                  "shutdown",
                                  "- Shuts down the virtual OS but leaves the underlying host / hardware simulation running.");
            this.commandList[


, 9.4663f, 10.9187f, 9.5996f, 10.4587f)
            curveTo(9.7329f, 9.9987f, 9.9163f, 9.6187f, 10.1496f, 9.3187f)
            curveTo(10.3829f, 9.0154f, 10.6563f, 8.7904f, 10.9696f, 8.6437f)
            curveTo(11.2863f, 8.497f, 11.6279f, 8.4237f, 11.9946f, 8.4237f)
            curveTo(12.3579f, 8.4237f, 12.6979f, 8.497f, 13.0146f, 8.6437f)
            curveTo(13.3346f, 8.7904f, 13.6113f, 9.0154f, 13.8446f, 9.3187f)
            curveTo(14.0779f, 9.6187f, 14.2613f, 9.9987f, 14.3946f, 10.4587f)
            curveTo(14.5313f, 10.9187f, 14.5996f, 11.462f, 14.5996f, 12.0887f)
            close()
            moveTo(13.6746f, 12.0887f)
            curveTo(13.6746f, 11.542f, 13.6279f, 11.0837f, 13.5346f, 10.7137f)
            curveTo(13.4446f, 10.3404f, 13.3213f, 10.0404f, 13.1646f, 9.8137f)
            curveTo(13.0113f, 9.587f, 12.8329f, 9.4254f, 12.6296f, 9.3287f)
            curveTo(12.4263f, 9.2287f, 12.2146f, 9.1787f, 11.9946f, 9.1787f)
            curveTo(11.7746f, 9.1787f, 11.5629f, 9.2287f, 11.3596f, 9.3287f)
            curveTo(11.1563f, 9.4254f, 10.9779f, 9.587f, 10.8246f, 9.8137f)
            curveTo(10.6713f, 10.0404f, 10.5479f, 10.3404f, 10.4546f, 10.7137f)
            curveTo(10.3646f, 11.0837f, 10.3196f, 11.542f, 10.3196f, 12.0887f)
            curveTo(10.3196f, 12.6354f, 10.3646f, 13.0937f, 10.4546f, 13.4637f)
            curveTo(10.5479f, 13.8337f, 10.6713f, 14.132f, 10.8246f, 14.3587f)
            curveTo(10.9779f, 14.5854f, 11.1563f, 14.7487f, 11.3596f, 14.8487f)
            curveTo(11.5629f, 14.9454f, 11.7746f, 14.9937f, 11.9946f, 14.9937f)
            curveTo(12.2146f, 14.9937f, 12.4263f, 14.9454f, 12.6296f, 14.8487f)
            curveTo(12.8329f, 14.7487f, 13.0113f, 14.5854f, 13.1646f, 14.3587f)
            curveTo(13.3213f, 14.132f, 13.4446f, 13.8337f, 13.5346f, 13.4637f)
            curveTo(13.6279f, 13.0937f, 13.6746f, 12.6354f, 13.6746f, 12.0887f)
            close()
          }
        }
        .build()
    return _key0!!
  }

private var _key0: ImageVector? = null
package com.sadellie.unitto.core.designsystem.icons.symbols

import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.path
import androidx.compose.ui.unit.dp

val Symbols.Cached: ImageVector
  get() {
    if (_Cached != null) {
      return _Cached!!
    }
    _C


(dataBytes)

        // Write to Iceberg and enrichment table.
        val fut1 = s3AsyncClient.putObject({ it.bucket(s3Bucket).key(s3Key) }, dataBody)
        val fut2 = s3AsyncClient.putObject({ it.bucket(enrichmentTablesBucket).key(enrichmentTablesS3Key) }, dataBody)

        CompletableFuture.allOf(fut1, fut2).await()

        val metrics = ParquetUtil.footerMetrics(footer, Stream.empty(), MetricsConfig.forTable(icebergTable))
        val dataFile = DataFiles.builder(PartitionSpec.unpartitioned())
            .withPath(icebergS3Path)
            .withFileSizeInBytes(dataLength.toLong())
            .withFormat("PARQUET")
            .withMetrics(metrics)
            .build()
        return dataFile
    }

    private fun concatIcebergParquetFiles(inputFiles: Iterable<InputFile>, outputFile: org.apache.iceberg.io.OutputFile): ParquetMetadata {
        // Get the schema from the file instead of using the table schema to avoid incompatibilities.
        val schema = ParquetFileReader.open(inputFiles.first()).use { rdr -> rdr.footer.fileMetaData.schema }
        val rowGroupSize: Long = 128 * 1024 * 1024
        val writer = ParquetFileWriter(
            ParquetIcebergOutputFile(outputFile),
            schema,
            ParquetFileWriter.Mode.CREATE,
            rowGroupSize,
            0,
        )
        writer.start()
        for (inputFile in inputFiles) {
            writer.appendFile(inputFile)
        }
        writer.end(mapOf())
        return writer.footer
    }
}

const val MATANO_SYSTEM_DB = "matano_system"

/** Write Iceberg metadata for enrichment tables */
class EnrichmentMetadataWriter(
    val configs: Map<String, EnrichmentConfig>,
) {
    private val logger = LoggerFactory.getLogger(this::class.java)
    val athenaQueryRunner = AthenaQueryRunner("matano_system_v3")

    fun doMerge(table: Table, pkCol: String, tempTableAthenaId: String): CompletableFuture<Unit> {
        val (_, db, name) = table.name().split(".", limit = 3)
        val mainTableAthenaId = "$db.$name"

        val cols = table.schema().columns().map { it.name() }
        val colsPart = cols.joinToString(",")
        val updateColPart = cols.joinToString(",") { "$it = new.$it" }
        val insertColPart = cols.joinToString(",") { "new.$it" }

        val stmt = """
        MERGE INTO $mainTableAthenaId main USING $tempTableAthenaId new
            ON (main.$pkCol = new.$pkCol)
            WHEN MATCHED
                THEN UPDATE SET $updateColPart
            WHEN NOT MATCHED
                THEN INSERT ($colsPart) VALUES($insertColPart)
        """.trimIndent()

        return athenaQueryRunner.runAthenaQuery(stmt)
    }

    fun doMetadataWrite(
        icebergCatalog: Catalog,
        icebergTable: Table,
        dataFile: DataFile,
        appendFiles: () -> AppendFiles,
        overwriteFiles: () -> OverwriteFiles,
    ): CompletableFuture<Unit> {
        val icebergTableName = icebergTable.name().split(".").last() // remove catalog, db
        val enrichTableName = icebergTableName.removePrefix("enrich_")
        val conf = configs[enrichTableName] ?: throw RuntimeException("Invalid table name: $enrichTableName")
        if (conf.enrichment_type == "static" || conf.write_mode == "overwrite") {
            logger.info("Doing overwrite for enrichment table: $icebergTableName")
            return CompletableFuture.supplyAsync({
                icebergTable.newScan().planFiles().map { it.file() }
            }, executor).thenApplyAsync { files ->
                overwriteFile


($sp)
/* AD33FC 8005C25C 8CAE0018 */  lw    $t6, 0x18($a1)
/* AD3400 8005C260 8CB0001C */  lw    $s0, 0x1c($a1)
/* AD3404 8005C264 000E7980 */  sll   $t7, $t6, 6
/* AD3408 8005C268 020FC021 */  addu  $t8, $s0, $t7
/* AD340C 8005C26C 0218082B */  sltu  $at, $s0, $t8
/* AD3410 8005C270 1020000B */  beqz  $at, .L8005C2A0
/* AD3414 8005C274 02402025 */   move  $a0, $s2
.L8005C278:
/* AD3418 8005C278 0C016EF5 */  jal   func_8005BBD4
/* AD341C 8005C27C 02002825 */   move  $a1, $s0
/* AD3420 8005C280 8E280018 */  lw    $t0, 0x18($s1)
/* AD3424 8005C284 8E39001C */  lw    $t9, 0x1c($s1)
/* AD3428 8005C288 26100040 */  addiu $s0,


*c.a(), c.g()*c.a(), c.b()*c.a(), c.a());
        write(c, iter);
    });
    return true;
}

bool
ImageUtils::isCompressed(const osg::Image *image)
{
    //Later versions of OSG have an Image::isCompressed function but earlier versions like 2.8.3 do not.  This is a workaround so that
    //we can tell if an image is compressed on all versions of OSG.
    switch(image->getPixelFormat())
    {
        case(GL_COMPRESSED_ALPHA_ARB):
        case(GL_COMPRESSED_INTENSITY_ARB):
        case(GL_COMPRESSED_LUMINANCE_ALPHA_ARB):
        case(GL_COMPRESSED_LUMINANCE_ARB):
        case(GL_COMPRESSED_RGBA_ARB):
        case(GL_COMPRESSED_RGB_ARB):
        case(GL_COMPRESSED_RGB_S3TC_DXT1_EXT):
        case(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT):
        case(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT):
        case(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT):
        case(GL_COMPRESSED_SIGNED_RED_RGTC1_EXT):
        case(GL_COMPRESSED_RED_RGTC1_EXT):
        case(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT):
        case(GL_COMPRESSED_RED_GREEN_RGTC2_EXT):
        case(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG):
        case(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG):
        case(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG):
        case(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG):
            return true;
        default:
            return false;
    }
}

bool
ImageUtils::isFloatingPointInternalFormat(GLint i)
{
    return
        (i >= 0x8C10 && i <= 0x8C17) || // GL_TEXTURE_RED_TYPE_ARB, et al
        (i >= 0x8814 && i <= 0x881F);   // GL_RGBA32F_ARB, et al
}

std::string
ImageUtils::getInternalFormatString(GLint internalFormat)
{
    switch (internalFormat)
    {
        // Basic pixel formats
        case GL_ALPHA:          return "GL_ALPHA";
        case GL_LUMINANCE:      return "GL_LUMINANCE";
        case GL_LUMINANCE_ALPHA: return "GL_LUMINANCE_ALPHA";
        case GL_INTENSITY:      return "GL_INTENSITY";
        case GL_RED:            return "GL_RED";
        case GL_RG:             return "GL_RG";
        case GL_RGB:            return "GL_RGB";
        case GL_RGBA:           return "GL_RGBA";

        // Sized internal formats - Red/RG
        case GL_R8:             return "GL_R8";
        case GL_R16:            return "GL_R16";
        case GL_R16F:           return "GL_R16F";
        case GL_R32F:           return "GL_R32F";
        case GL_R8I:            return "GL_R8I";
        case GL_R8UI:           return "GL_R8UI";
        case GL_R16I:           return "GL_R16I";
        case GL_R16UI:          return "GL_R16UI";
        case GL_R32I:           return "GL_R32I";
        case GL_R32UI:          return "GL_R32UI";
        case GL_RG8:            return "GL_RG8";