/*
 * Copyright 2018 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
#include "base.h"

#include <nvif/class.h>

int
nv50_base_new(struct nouveau_drm *drm, int head, struct nv50_wndw **pwndw)
{
	struct {
		s32 oclass;
		int version;
		int (*new)(struct nouveau_drm *, int, s32, struct nv50_wndw **);
	} bases[] = {
		{ GK110_DISP_BASE_CHANNEL_DMA, 0, base917c_new },
		{ GK104_DISP_BASE_CHANNEL_DMA, 0, base917c_new },
		{ GF110_DISP_BASE_CHANNEL_DMA, 0, base907c_new },
		{ GT214_DISP_BASE_CHANNEL_DMA, 0, base827c_new },
		{ GT200_DISP_BASE_CHANNEL_DMA, 0, base827c_new },
		{   G82_DISP_BASE_CHANNEL_DMA, 0, base827c_new },
		{  NV50_DISP_BASE_CHANNEL_DMA, 0, base507c_new },
		{}
	};
	struct nv50_disp *disp = nv50_disp(drm->dev);
	int cid;

	cid = nvif_mclass(&disp->disp->object, bases);
	if (cid < 0) {
		NV_ERROR(drm, "No supported base class\n");
		return cid;
	}

	return bases[cid].new(drm, head, bases[cid].oclass, pwndw);
}


ass_NSURLCredentialStorage1,
      _lib._sel_cancelPreviousPerformRequestsWithTarget_selector_object_1,
      aTarget._id,
      aSelector,
      anArgument?._id ?? ffi.nullptr,
    );
  }

  static void cancelPreviousPerformRequestsWithTarget_(
    PedometerBindings _lib,
    NSObject aTarget,
  ) {
    _lib._objc_msgSend_15(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_cancelPreviousPerformRequestsWithTarget_1,
      aTarget._id,
    );
  }

  static bool getAccessInstanceVariablesDirectly(PedometerBindings _lib) {
    return _lib._objc_msgSend_12(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_accessInstanceVariablesDirectly1,
    );
  }

  static bool useStoredAccessor(PedometerBindings _lib) {
    return _lib._objc_msgSend_12(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_useStoredAccessor1,
    );
  }

  static NSSet keyPathsForValuesAffectingValueForKey_(
    PedometerBindings _lib,
    NSString key,
  ) {
    final _ret = _lib._objc_msgSend_55(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_keyPathsForValuesAffectingValueForKey_1,
      key._id,
    );
    return NSSet._(_ret, _lib, retain: true, release: true);
  }

  static bool automaticallyNotifiesObserversForKey_(
    PedometerBindings _lib,
    NSString key,
  ) {
    return _lib._objc_msgSend_56(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_automaticallyNotifiesObserversForKey_1,
      key._id,
    );
  }

  static void setKeys_triggerChangeNotificationsForDependentKey_(
    PedometerBindings _lib,
    NSArray keys,
    NSString dependentKey,
  ) {
    _lib._objc_msgSend_80(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_setKeys_triggerChangeNotificationsForDependentKey_1,
      keys._id,
      dependentKey._id,
    );
  }

  static NSArray classFallbacksForKeyedArchiver(PedometerBindings _lib) {
    final _ret = _lib._objc_msgSend_77(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_classFallbacksForKeyedArchiver1,
    );
    return NSArray._(_ret, _lib, retain: true, release: true);
  }

  static NSObject classForKeyedUnarchiver(PedometerBindings _lib) {
    final _ret = _lib._objc_msgSend_2(
      _lib._class_NSURLCredentialStorage1,
      _lib._sel_classForKeyedUnarchiver1,
    );
    return NSObject._(_ret, _lib, retain: true, release: true);
  }
}

void _ObjCBlock_ffiVoid_NSDictionary_fnPtrTrampoline(
  ffi.Pointer<_ObjCBlock> block,
  ffi.Pointer<ObjCObject> arg0,
) => block.ref.target
    .cast<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ObjCObject> arg0)>>()
    .asFunction<void Function(ffi.Pointer<ObjCObject>)>()(arg0);
final _ObjCBlock_ffiVoid_NSDictionary_closureRegistry =
    <int, void Function(ffi.Pointer<ObjCObject>)>{};
int _ObjCBlock_ffiVoid_NSDictionary_closureRegistryIndex = 0;
ffi.Pointer<ffi.Void> _ObjCBlock_ffiVoid_NSDictionary_registerClosure(
  void Function(


32,
    pub OTG_FS_HCTSIZ4: u32,
    pub OTG_FS_HCCHAR5: u32,
    pub OTG_FS_HCINT5: u32,
    pub OTG_FS_HCINTMSK5: u32,
    pub OTG_FS_HCTSIZ5: u32,
    pub OTG_FS_HCCHAR6: u32,
    pub OTG_FS_HCINT6: u32,
    pub OTG_FS_HCINTMSK6: u32,
    pub OTG_FS_HCTSIZ6: u32,
    pub OTG_FS_HCCHAR7: u32,
    pub OTG_FS_HCINT7: u32,
    pub OTG_FS_HCINTMSK7: u32,
    pub OTG_FS_HCTSIZ7: u32,
    pub OTG_FS_HCCHAR8: u32,
    pub OTG_FS_HCINT8: u32,
    pub OTG_FS_HCINTMSK8: u32,
    pub OTG_FS_HCTSIZ8: u32,
    pub OTG_FS_HCCHAR9: u32,
    pub OTG_FS_HCINT9: u32,
    pub OTG_FS_HCINTMSK9: u32,
    pub OTG_FS_HCTSIZ9: u32,
    pub OTG_FS_HCCHAR10: u32,
    pub OTG_FS_HCINT10: u32,
    pub OTG_FS_HCINTMSK10: u32,
    pub OTG_FS_HCTSIZ10: u32,
    pub OTG_FS_HCCHAR11: u32,
    pub OTG_FS_HCINT11: u32,
    pub OTG_FS_HCINTMSK11: u32,
    pub OTG_FS_HCTSIZ11: u32,
}
#[cfg(not(feature = "nosync"))]
pub struct Instance {
    pub(crate) addr: u32,
    pub(crate) _marker: PhantomData<*const RegisterBlock>,
}
#[cfg(not(feature = "nosync"))]
impl ::core::ops::Deref for Instance {
    type Target = RegisterBlock;
    #[inline(always)]
    fn deref(&self) -> &RegisterBlock {
        unsafe { &*(self.addr as *const _) }
    }
}
#[cfg(feature = "rtic")]
unsafe impl Send for Instance {}
<reponame>atmaramnaik/corr
use crate::parser::{Parsable, ParseResult, ws};
use nom::combinator::map;
use crate::template::VariableReferenceName;
use nom::sequence::{preceded, terminated, tuple};
use nom::bytes::complete::tag;
use nom::character::complete::char;
use nom::multi::{separated_list0};
use crate::core::parser::string;
use crate::template::form::extractable::ExtractableForm;

impl Parsable for ExtractableForm{
    fn parser<'a>(input: &'a str) -> ParseResult<'a, Self> {
        preceded(ws(tag("form")),extractable_form_options)(input)
    }
}
fn extractable_form_options<'a>(input: &'a str) -> ParseResult<'a, ExtractableForm> {
    map(preceded(ws(char('{')),terminated(separated_list0(ws(char(',')),
        tuple((terminated(ws(string),ws(char(':'))),ws(VariableReferenceName::parser)))
    ),ws(char('}')))),|pairs|ExtractableForm::WithFields(pairs))(input)
    // map(preceded(ws(char('{')),terminated(separated_list0(ws(char(',')),tuple((ws(string),preceded(ws(tag(":")),ws(VariableReferenceName::parser))))) ,ws(char('}')))),|pairs|ExtractableForm::WithFields(pairs))(input)
}
#[cfg(test)]
mod tests{
    use crate::template::form::extractable::ExtractableForm;
    use crate::parser::Parsable;
    use crate::parser::util::assert_if;
    use crate::template::VariableReferenceName;

    #[test]
    fn should_parse_extractable_form(){
        let text=r#"form {"name":name }"#;
        let a= ExtractableFo


ps://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateSubDevices.html]
    /// (https://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clCreateSubDevices.html)
    ///
    #[repr(C)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub enum DevicePartitionProperty {
        Equally = ffi::CL_DEVICE_PARTITION_EQUALLY as isize,
        ByCounts = ffi::CL_DEVICE_PARTITION_BY_COUNTS as isize,
        ByCountsListEnd = ffi::CL_DEVICE_PARTITION_BY_COUNTS_LIST_END as isize,
        ByAffinityDomain = ffi::CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN as isize,
    }
}

enum_from_primitive! {
    /// cl_command_queue_info
    #[repr(C)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub enum CommandQueueInfo {
        Context = ffi::CL_QUEUE_CONTEXT as isize,
        Device = ffi::CL_QUEUE_DEVICE as isize,
        ReferenceCount = ffi::CL_QUEUE_REFERENCE_COUNT as isize,
        Properties = ffi::CL_QUEUE_PROPERTIES as isize,
    }
}

enum_from_primitive! {
    /// cl_channel_type
    #[repr(C)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub enum ChannelType {
        SnormInt8 = ffi::CL_SNORM_INT8 as isize,
        SnormInt16 = ffi::CL_SNORM_INT16 as isize,
        UnormInt8 = ffi::CL_UNORM_INT8 as isize,
        UnormInt16 = ffi::CL_UNORM_INT16 as isize,
        UnormShort565 = ffi::CL_UNORM_SHORT_565 as isize,
        UnormShort555 = ffi::CL_UNORM_SHORT_555 as isize,
        UnormInt101010 = ffi::CL_UNORM_INT_101010 as isize,
        SignedInt8 = ffi::CL_SIGNED_INT8 as isize,
        SignedInt16 = ffi::CL_SIGNED_INT16 as isize,
        SignedInt32 = ffi::CL_SIGNED_INT32 as isize,
        UnsignedInt8 = ffi::CL_UNSIGNED_INT8 as isize,
        UnsignedInt16 = ffi::CL_UNSIGNED_INT16 as isize,
        UnsignedInt32 = ffi::CL_UNSIGNED_INT32 as isize,
        HalfFloat = ffi::CL_HALF_FLOAT as isize,
        Float = ffi::CL_FLOAT as isize,
        UnormInt24 = ffi::CL_UNORM_INT24 as isize,
    }
}

enum_from_primitive! {
    /// cl_mem_object_type
    #[repr(C)]
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub enum MemObjectType {
        Buffer = ffi::CL_MEM_OBJECT_BUFFER as isize,
        Image2d = ffi::CL_MEM_OBJECT_IMAGE2D as isize,
        Image3d = ffi::CL_MEM_OBJECT_IMAGE3D as isize,
        Image2dArray = ffi::CL_MEM_OBJECT_IMAGE2D_ARRAY as isize,
        Image1d = ffi::CL_MEM_OBJECT_IMAGE1D as isize,
        Image1dArray = ffi::CL_MEM_OBJECT_IMAGE1D_ARRAY as isize,
        Image1dBuffer = ffi::CL_MEM_OBJECT_IMAGE1D_BUFFER as isize,
    }
}

enum_from_primitive! {
    /// cl_mem_info
    #[repr(C)]
    #[derive(Clone


gon></g>
<g id="flip-to-back"><path d="M9,7H7l0,2h2V7z M9,11H7v2h2V11z M9,3C7.9,3,7,3.9,7,5h2V3z M13,15h-2v2h2V15z M19,3v2h2C21,3.9,20.1,3,19,3z M13,3h-2v2h2V3z M9,17v-2H7C7,16.1,7.9,17,9,17z M19,13h2v-2h-2V13z M19,9h2V7h-2V9z M19,17c1.1,0,2-0.9,2-2h-2V17z M5,7H3v2h0l0,10c0,1.1,0.9,2,2,2h12v-2H5V7z M15,5h2V3h-2V5z M15,17h2v-2h-2V17z"></path></g>
<g id="flip-to-front"><path d="M3,13h2v-2H3L3,13z M3,17h2v-2H3V17z M5,21v-2H3C3,20.1,3.9,21,5,21z M3,9h2V7H3V9z M15,21h2v-2h-2V21z M19,3H9C7.9,3,7,3.9,7,5v2h0v2v6c0,1.1,0.9,2,2,2h5h4h1c1.1,0,2-0.9,2-2V5C21,3.9,20.1,3,19,3z M19,15H9V5h10V15z M11,21h2v-2h-2V21z M7,21h2v-2H7V21z"></path></g>
<g id="folder"><path d="M10,4H4C2.9,4,2,4.9,2,6l0,12c0,1.1,0.9,2,2,2h16c1.1,0,2-0.9,2-2V8c0-1.1-0.9-2-2-2h-8L10,4z"></path></g>
<g id="folder-shared"><path d="M20,6h-8l-2-2H4C2.9,4,2,4.9,2,6l0,12c0,1.1,0.9,2,2,2h16c1.1,0,2-0.9,2-2V8C22,6.9,21.1,6,20,6z M15,9c1.1,0,2,0.9,2,2c0,1.1-0.9,2-2,2c-1.1,0-2-0.9-2-2C13,9.9,13.9,9,15,9z M19,17h-8v-1c0-1.3,2.7-2,4-2c1.3,0,4,0.7,4,2V17z"></path></g>
<g id="forward"><polygon points="12,8 12,4 20,12 12,20 12,16 4,16 4,8 "></polygon></g>
<g id="fullscreen"><path d="M7,14H5v5h5v-2H7V14z M5,10h2V7h3V5H5V10z M17,17h-3v2h5v-5h-2V17z M14,5v2h3v3h2V5H14z"></path></g>
<g id="fullscreen-exit"><path d="M5,16h3v3h2v-5H5V16z M8,8H5v2h5V5H8V8z M14,19h2v


fauna.com/fauna/current/api/fql/functions/delete
 * delete_ with underscore suffix, becase it's reserved word.
 */
export const delete_ = (ref: CollectionRef): Delete => ({
  delete: { collection: ref['@ref'].id },
});
import {AbstractTokenizer} from '../..';
import {InputStream} from '../..';

export class TestTokenizer extends AbstractTokenizer<string>
{

	protected doReadInput(input: InputStream): string
	{
		input.readWhile((ch: string) => {
			return ch === ' '
		});

		return input.readWhile((ch: string) => {
			return ch !== ' '
		});
	}

}
/**
 * 1.将数组划分为两个部分，前半部分已经排序，后半部分待排序
 * 2.每次取出后半部分的头一个元素，依次与已经排序的元素比较
 * 3.如果较小就往左移动，直到找到一个合适的位置，将元素放下
 * @param n 待排数组
 */
export default function insertSort(n: Array<number>): Array<number> {
  if (!n) return;
  // 以i为分界符号，左边已经有序 右边无序
  for (let i = 1; i < n.length; i++) {
    const curVal = n[i]; // 选出待插入元素
    let j = i - 1;
    for (; j >= 0; j--) {
      if (n[j] > curVal) {
        // 如果当前元素大于待插入元素，则将当前元素右移
        n[j + 1] = n[j];
      } else {
        // 否则跳出循环
        break;
      }
    }
    // 将当前元素放在 j+1 的位置
    n[j + 1] = curVal;
  }
  return n;
}
import { Injectable } from '@angular/core';
import { of } from 'rxjs';
import { Todo } from '../models/Todo';

@Injectable({
  providedIn: 'root'
})
export class TodoService {

  todos : Todo[];

  constructor() {
    this.todos = [
      {
        id:'111',
        title:'Learn C++',
        isComplete:true,
        date:new Date()
      },
      {
        id:'222',
        title:'Learn React',
        isComplete:true,
        date:new Date()
      },
      {
        id:'333',
        title:'Learn Angular',
        isComplete:false,
        date:new Date()
      }
    ];
  }

  getTodos(){
    return of(this.todos);
  }

  addTodo(todo : Todo){
    this.todos.push(todo)
  }

  changeStatus(todo : Todo){
    this.todos.forEach(singleTodo => {
      if(singleTodo.id == todo.id){
        singleTodo.isComplete = !singleTodo.isComplete;
      }
    })
  }

  deleteTodo(todo : Todo){
    let index;
    this.todos.forEach((sTodo,ind)=>{
      if(todo.id == sTodo.id){
        index = ind;
      }
    })
    this.todos.splice(index,1);
  }
}
package org.ofdrw.core.annotation.pageannot;

import org.dom4j.Element;
import org.ofdrw.core.basicStructure.pageObj.layer.PageBlockType;
import org.ofdrw.core.basicStructure.pageObj.layer.block.CT_PageBlock;
import org.ofdrw.core.basicType.ST_Box;

/**
 * 注释的金泰呈现效果
 *

 * 使用页面块定义来描述
 *

 * 15.2 图 81 表 61
 *
 * @author 泰山信息科技
 * @since 2019-11-19 05:48:28
 */
public class Appearance extends CT_PageBlock {

    public Appearance(Element proxy) {
        super(proxy);
    }

    publ


	ROCKETLUA_INPUTENUM(CAPITAL,tbl)
	ROCKETLUA_INPUTENUM(KANA,tbl)
	ROCKETLUA_INPUTENUM(HANGUL,tbl)
	ROCKETLUA_INPUTENUM(JUNJA,tbl)
	ROCKETLUA_INPUTENUM(FINAL,tbl)
	ROCKETLUA_INPUTENUM(HANJA,tbl)
	ROCKETLUA_INPUTENUM(KANJI,tbl)
	ROCKETLUA_INPUTENUM(ESCAPE,tbl)
	ROCKETLUA_INPUTENUM(CONVERT,tbl)
	ROCKETLUA_INPUTENUM(NONCONVERT,tbl)
	ROCKETLUA_INPUTENUM(ACCEPT,tbl)
	ROCKETLUA_INPUTENUM(MODECHANGE,tbl)
	ROCKETLUA_INPUTENUM(PRIOR,tbl)
	ROCKETLUA_INPUTENUM(NEXT,tbl)
	ROCKETLUA_INPUTENUM(END,tbl)
	ROCKETLUA_INPUTENUM(HOME,tbl)
	ROCKETLUA_INPUTENUM(LEFT,tbl)
	ROCKETLUA_INPUTENUM(UP,tbl)
	ROCKETLUA_INPUTENUM(RIGHT,tbl)
	ROCKETLUA_INPUTENUM(DOWN,tbl)
	ROCKETLUA_INPUTENUM(SELECT,tbl)
	ROCKETLUA_INPUTENUM(PRINT,tbl)
	ROCKETLUA_INPUTENUM(EXECUTE,tbl)
	ROCKETLUA_INPUTENUM(SNAPSHOT,tbl)
	ROCKETLUA_INPUTENUM(INSERT,tbl)
	ROCKETLUA_INPUTENUM(DELETE,tbl)
	ROCKETLUA_INPUTENUM(HELP,tbl)
	ROCKETLUA_INPUTENUM(LWIN,tbl)
	ROCKETLUA_INPUTENUM(RWIN,tbl)
	ROCKETLUA_INPUTENUM(APPS,tbl)
	ROCKETLUA_INPUTENUM(POWER,tbl)
	ROCKETLUA_INPUTENUM(SLEEP,tbl)
	ROCKETLUA_INPUTENUM(WAKE,tbl)
	ROCKETLUA_INPUTENUM(F1,tbl)
	ROCKETLUA_INPUTENUM(F2,tbl)
	ROCKETLUA_INPUTENUM(F3,tbl)
	ROCKETLUA_INPUTENUM(F4,tbl)
	ROCKETLUA_INPUTENUM(F5,tbl)
	ROCKETLUA_INPUTENUM(F6,tbl)
	ROCKETLUA_INPUTENUM(F7,tbl)
	ROCKETLUA_INPUTENUM(F8,tbl)
	ROCKETLUA_INPUTENUM(F9,tbl)
	ROCKETLUA_INPUTENUM(F10,tbl)
	ROCKETLUA_INPUTENUM(F11,tbl)
	ROCKETLUA_INPUTENUM(F12,tbl)
	ROCKETLUA_INPUTENUM(F13,tbl)
	ROCKETLUA_INPUTENUM(F14,tbl)
	ROCKETLUA_INPUTENUM(F15,tbl)
	ROCKETLUA_INPUTENUM(F16,tbl)
	ROCKETLUA_INPUTENUM(F17,tbl)
	ROCKETLUA_INPUTENUM(F18,tbl)
	ROCKETLUA_INPUTENUM(F19,tbl)
	ROCKETLUA_INPUTENUM(F20,tbl)
	ROCKETLUA_INPUTENUM(F21,tbl)
	ROCKETLUA_INPUTENUM(F22,tbl)
	ROCKETLUA_INPUTENUM(F23,tbl)
	ROCKETLUA_INPUTENUM(F24,tbl)
	ROCKETLUA_INPUTENUM(NUMLOCK,tbl)
	ROCKETLUA_INPUTENUM(SCROLL,tbl)
	ROCKETLUA_INPUTENUM(OEM_FJ_


>= startColumn && colNo <= endColumn) {
							if (!columns[colNo]) {
								columns[colNo] = [];
							}
							columns[colNo][rowNo - startRow] = item.innerHTML;

							colNo += 1;
						}
					});
				}
			});

			this.dataFound(); // continue
		}
	},

	/**
	 * TODO:
	 * - switchRowsAndColumns
	 * - startRow, endRow etc.
	 */
	parseGoogleSpreadsheet: function () {
		var self = this,
			options = this.options,
			googleSpreadsheetKey = options.googleSpreadsheetKey,
			columns = this.columns;

		if (googleSpreadsheetKey) {
			jQuery.getJSON('https://spreadsheets.google.com/feeds/cells/' +
				  googleSpreadsheetKey + '/' + (options.googleSpreadsheetWorksheet || 'od6') +
					  '/public/values?alt=json-in-script&callback=?',
					  function (json) {

				// Prepare the data from the spreadsheat
				var cells = json.feed.entry,
					cell,
					cellCount = cells.length,
					colCount = 0,
					rowCount = 0,
					i;

				// First, find the total number of columns and rows that
				// are actually filled with data
				for (i = 0; i < cellCount; i++) {
					cell = cells[i];
					colCount = Math.max(colCount, cell.gs$cell.col);
					rowCount = Math.max(rowCount, cell.gs$cell.row);
				}

				// Set up arrays containing the column data
				for (i = 0; i < colCount; i++) {
					columns[i] = new Array(rowCount);
				}

				// Loop over the cells and assign the value to the right
				// place in the column arrays
				for (i = 0; i < cellCount; i++) {
					cell = cells[i];
					columns[cell.gs$cell.col - 1][cell.gs$cell.row - 1] =
						cell.content.$t;
				}
				self.dataFound();
			});
		}
	},

	/**
	 * Find the header row. For now, we just check whether the first row contains
	 * numbers or strings. Later we could loop down and find the first row with
	 * numbers.
	 */
	findHeaderRow: function () {
		var headerRow = 0;
		each(this.columns, function (column) {
			if (typeof column[0] !== 'string') {
				headerRow = null;
			}
		});
		this.headerRow = 0;
	},

	/**
	 * Trim a string from whitespace
	 */
	trim: function (str) {
		//return typeof str === 'number' ? str : str.replace(/^\s+|\s+$/g, ''); // fails with spreadsheet
		return typeof str === 'string' ? str.replace(/^\s+|\s+$/g, '') : str;
	},

	/**
	 * Parse numeric cells in to number types and date types in to true dates.
	 * @param {Object} columns
	 */
	parseTypes: function () {
		var columns = this.columns,
			col = columns.length,
			row,
			val,
			floatVal,
			trimVal,
			dateVal;

		while (col--) {
			row = columns[col].length;
			while (row--) {
				val = columns[col][row];
				floatVal = parseFloat(val);
				trimVal = this.trim(val);
				/*jslint eqeq: true*/
				if (trimVal == floatVal) { // is numeric
				/*jslint eqeq: false*/
					columns[col][row] = floatVal;

					// If the number is greater than milliseconds in a year, assume datetime
					if (floatVal > 365 * 24 * 3600 * 1000) {
						columns[col].isDatetime = true;
					} else {
						columns[col].isNumeric = true;
					}

				} else { // string, continue to determine if it is a date string or really a string
					dateVal = this


-weight: 400;
  font-display: swap;
  src: url("https://static-rs-terwer.oss-cn-beijing.aliyuncs.com/lib/fonts/LXGWWenkai/lxgwwenkai-regular-subset-103.woff2") format("woff2");
  unicode-range: U+60, U+631, U+2606, U+3014-3015, U+309c, U+33a1, U+4e52, U+4ec6, U+4f86, U+4f8d, U+4fde, U+4fef, U+500b, U+502a, U+515c, U+518a, U+51a5, U+51f3, U+5243, U+52c9, U+52d5, U+53a2, U+53ee, U+54ce, U+54fa, U+54fc, U+5580, U+5587, U+563f, U+56da, U+5792, U+5815, U+5960, U+59d7, U+5a1f, U+5b78, U+5b9b, U+5be1, U+5c4e, U+5c51, U+5c6f, U+5c9a, U+5cfb, U+5d16, U+5ed6, U+5f27, U+5f6a, U+5f6c, U+603c, U+609a, U+6168, U+61c8, U+6236, U+62d0, U+62f1, U+62fd, U+631a, U+6328, U+632b, U+6346, U+638f, U+63a0, U+63c9, U+655e, U+6590, U+6615, U+6627, U+66ae, U+66e6, U+66f0, U+6703, U+67da, U+67ec, U+6816, U+6893, U+68ad, U+68f5, U+6977, U+6984, U+69db, U+6b72, U+6bb7, U+6ce3, U+6cfb, U+6d47, U+6da1, U+6dc4, U+6e43, U+6eaf, U+6eff, U+6f8e, U+7011, U+7063, U+7076, U+7096, U+70ba, U+70db, U+70ef, U+7119-711a, U+7172, U+718f, U+7194, U+727a, U+72d9, U+72ed, U+7325, U+73ae, U+73ba, U+73c0, U+7410, U+7426, U+7554, U+7576, U+75ae, U+75b9, U+762b, U+766b, U+7682, U+7750, U+7779, U+7784, U+77eb, U+77ee, U+78f7, U+79e9, U+7a79, U+7b1b, U+7b28, U+7bf7, U+7db2, U+7ec5, U+7eee, U+7f14, U+7f1a, U+7fe1, U+8087, U+809b, U+8231, U+830e, U+835f, U+83e9, U+849c, U+851a, U+868a, U+8718, U+874e, U+8822, U+8910, U+8944, U+8a3b, U+8bb6, U+8bbc, U+8d50, U+8e72, U+8f9c, U+900d, U+904b, U+9063, U+90a2, U+90b9, U+94f2, U+952f, U+9576-9577, U+9593, U+95f8, U+


 /// Start date of the sub-period
+     pub start_date: NaiveDate,
+     /// End date of the sub-period
+     pub end_date: NaiveDate,
+     /// Return value for the sub-period
+     pub return_value: Decimal,
+     /// Beginning market value
+     pub beginning_value: Decimal,
+     /// Ending market value
+     pub ending_value: Decimal,
+     /// Net cash flow during the period
+     pub net_cash_flow: Decimal,
+     /// Weighted cash flow for Modified Dietz
+     pub weighted_cash_flow: Option<Decimal>,
+ }
+
+ /// Cash flow for performance calculations
+ #[derive(Debug, Clone)]
+ pub struct CashFlow {
+     /// Date of the cash flow
+     pub date: NaiveDate,
+     /// Amount of the cash flow (positive for inflows, negative for outflows)
+     pub amount: Decimal,
+     /// Description of the cash flow
+     pub description: Option<String>,
+ }
+
+ /// Performance attribution analysis
+ #[derive(Debug, Serialize, Deserialize, Clone)]
+ pub struct PerformanceAttribution {
+     /// Total portfolio return
+     pub portfolio_return: Decimal,
+     /// Benchmark return
+     pub benchmark_return: Decimal,
+     /// Excess return (portfolio - benchmark)
+     pub excess_return: Decimal,
+     /// Allocation effect by asset class
+     pub allocation_effect: HashMap<String, Decimal>,
+     /// Selection effect by asset class
+     pub selection_effect: HashMap<String, Decimal>,
+     /// Interaction effect by asset class
+     pub interaction_effect: HashMap<String, Decimal>,
+     /// Currency effect by asset class (for international portfolios)
+     pub currency_effect: Option<HashMap<String, Decimal>>,
+ }
+
+ /// Calculate time-weighted return using the Modified Dietz method
+ pub fn calculate_modified_dietz(
+     beginning_value: Decimal,
+     ending_value: Decimal,
+     cash_flows: &[CashFlow],
+     start_date: NaiveDate,
+     end_date: NaiveDate
+ ) -> Result<TimeWeightedReturn> {
+     // Calculate total days in period
+     let period_days = (end_date.signed_duration_since(start_date).num_days() as f64).max(1.0);
+
+     // Calculate net cash flow and weighted cash flow
+     let mut net_cash_flow = Decimal::ZERO;
+     let mut weighted_cash_flow = Decimal::ZERO;
+
+     for cf in cash_flows {
+         if cf.date < start_date || cf.date > end_date {
+             continue;
+         }
+
+         net_cash_flow += cf.amount;
+
+         // Calculate weight based on days from start
+         let days_from_start = cf.date.signed_duration_since(start_date).num_days() as f64;
+         let weight = Decimal::from_f64((period_days - days_from_start) / period_days)
+             .unwrap_or(Decimal::ZERO);
+
+         weighted_cash_flow += cf.amount * weight;
+     }
+
+     // Calculate Modified Dietz return
+     let denominator = beginning_value + weighted_cash_flow;
+
+     if denominator == Decimal::ZERO {
+         return Err(anyhow!("Cannot calculate Modified Dietz return with zero denominator"));
+     }
+
+     let return_value = (ending_value - beginning_value - net_cash_flow) / denominator;
+
+     // Create sub-period return
+     let sub_period = SubPeriodReturn {
+         start_date,


 observation.Args{})

	q := sqlf.Sprintf(
		markUsedBatchSpecExecutionCacheEntriesQueryFmtstr,
		s.now(),
		pq.Array(ids),
	)
	return s.Exec(ctx, q)
}

// cleanBatchSpecExecutionEntriesQueryFmtstr collects cache entries to delete by
// collecting enough so that if we were to delete them we'd be under
// maxCacheSize again. Also, cache entries from older cache versions are always
// deleted.
const cleanBatchSpecExecutionEntriesQueryFmtstr = `
WITH total_size AS (
  SELECT sum(octet_length(value)) AS total FROM batch_spec_execution_cache_entries
),
candidates AS (
  SELECT
    id
  FROM (
    SELECT
      entries.id,
      entries.created_at,
      entries.last_used_at,
      SUM(octet_length(entries.value)) OVER (ORDER BY COALESCE(entries.last_used_at, entries.created_at) ASC, entries.id ASC) AS running_size
    FROM batch_spec_execution_cache_entries entries
  ) t
  WHERE
    ((SELECT total FROM total_size) - t.running_size) >= %s
),
outdated AS (
	SELECT
		id
	FROM batch_spec_execution_cache_entries
	WHERE
		version < %s
),
ids AS (
	SELECT id FROM outdated
	UNION ALL
	SELECT id FROM candidates
)
DELETE FROM batch_spec_execution_cache_entries WHERE id IN (SELECT id FROM ids)
`

func (s *Store) CleanBatchSpecExecutionCacheEntries(ctx context.Context, maxCacheSize int64) (err error) {
	ctx, _, endObservation := s.operations.cleanBatchSpecExecutionCacheEntries.With(ctx, &err, observation.Args{Attrs: []attribute.KeyValue{
		attribute.Int("MaxTableSize", int(maxCacheSize)),
	}})
	defer endObservation(1, observation.Args{})

	return s.Exec(ctx, sqlf.Sprintf(cleanBatchSpecExecutionEntriesQueryFmtstr, maxCacheSize, btypes.CurrentCacheVersion))
}

func scanBatchSpecExecutionCacheEntry(wj *btypes.BatchSpecExecutionCacheEntry, s dbutil.Scanner) error {
	return s.Scan(
		&wj.ID,
		&wj.UserID,
		&wj.Key,
		&wj.Value,
		&wj.Version,
		&dbutil.NullTime{Time: &wj.LastUsedAt},
		&wj.CreatedAt,
	)
}
package syncer

import (
	"container/heap"
	"time"
)

type scheduledSync struct {
	changesetID int64
	nextSync    time.Time
	priority    priority
}

// changesetPriorityQueue is a min heap that sorts syncs by priority
// and time of next sync. It is not safe for concurrent use.
type changesetPriorityQueue struct {
	items []scheduledSync
	index map[int64]int // changesetID -> index
}

// newChangesetPriorityQueue creates a new queue for holding changeset sync instructions in chronological order.
// items with a high priority will always appear at the front of the queue.
func newChangesetPriorityQueue() *changesetPriorityQueue {
	q := &changesetPriorityQueue{
		items: make([]scheduledSync, 0),
		index: make(map[int64]int),
	}
	heap.Init(q)
	return q
}

// The following methods implement heap.Interface based on the priority queue example:
// https://golang.org/pkg/container/heap/#example__priorityQueue

func (pq *changesetPriorityQueue) Len() int { return len(pq.items) }

func (pq *changesetPriorityQueue) Less(i, j int) bool {
	// We want items ordered by priority, then NextSync
	// Order by priority and then NextSync
	a := pq.items[i]
	b := pq.items[j]

	if a.priority != b.priority {
		// Greater than here since we want high priority items to be ranked before low priority


()));
        pollee.register_observer(counter.clone(), Events::IN);
        let expected_count = 10;
        (0..expected_count).for_each(|_| pollee.add_events(Events::IN));
        pollee.unregister_observer(&(counter.clone() as _));
        assert!(counter.count() == expected_count);
    }
}
<gh_stars>100-1000
//! Global board definitions for Sipeed Maix Go

/** Display width in pixels */
pub const DISP_WIDTH: u16 = 320;
/** Display height in pixels */
pub const DISP_HEIGHT: u16 = 240;
/** Number of pixels in display */
pub const DISP_PIXELS: usize = (DISP_WIDTH as usize) * (DISP_HEIGHT as usize);

/** I2C address of NS2009 (touch screen sensor) */
pub const NS2009_SLV_ADDR: u16 = 0x48;

/** I2C address bits for NS2009 */
pub const NS2009_ADDR_BITS: u32 = 7;

/** I2C clock speed for NS2009 */
pub const NS2009_CLK: u32 = 100000;

/** Calibration matrix for touch screen */
pub const NS2009_CAL: [i32; 7] = [65, 5853, -1083592, -4292, -15, 16450115, 65536];

/** I2C address of MSA300 (accelerometer) */
pub const MSA300_SLV_ADDR: u16 = 0x26;

/** I2C address bits for NS2009 */
pub const MSA300_ADDR_BITS: u32 = 7;

/** I2C clock speed for MSA300 */
pub const MSA300_CLK: u32 = 500000;

/** DVP SCCB address for OV2640 */
pub const OV2640_ADDR: u8 = 0x60;

/** I/O pins for FPIOA */
#[derive(Copy, Clone)]
pub enum io {
    /** JTAG TCK */
    JTAG_TCK = 0,
    /** JTAG TDI */
    JTAG_TDI = 1,
    /** JTAG TMS */
    JTAG_TMS = 2,
    /** JTAG TDO */
    JTAG_TDO = 3,
    /** Host RX (from STM32F103C8) */
    ISP_RX = 4,
    /** Host TX (to STM32F103C8) */
    ISP_TX = 5,
    /** WIFI serial TX (from perspective of ESP8285, so our RX) */
    WIFI_TX = 6,
    /** WIFI serial RX (from perspective of ESP8285, so our TX) */
    WIFI_RX = 7,
    /** WIFI enable (to ESP8285) */
    WIFI_EN = 8,
    /** Unused */
    BPSK_P = 9,
    /** Unused */
    BPSK_N = 10,
    /** General purpose I/O pin */
    IO11 = 11,
    /** Blue led (output) */
    LED_B = 12,
    /** Green led (output) */
    LED_G = 13,
    /** Red led (output) */
    LED_R = 14,
    /** Key direction 1 press (input) */
    KEY1 = 15,
    /** Key center press (input) */
    BOOT_KEY0 = 16,
    /** Key direction 2 press (input) */
    KEY2 = 17,
    /** Microphone I2S BCK */
    MIC_BCK = 18,
    /** Microphone I2S WS */
    MIC_WS = 19,
    /** Microphone I2S DAT3 */
    MIC_DAT3 = 20,
    /** Microphone I2S DAT2 */
    MIC_DAT2 = 21,
    /** Microphone I2S DAT1 */
    MIC_DAT1 = 22,
    /** Microphone I2S DAT0 */
    MIC_DAT0 = 23,
    /** Microphone LED DAT */
    MIC_LED_DAT = 24,
    /** Microphone LED CLK */
    MIC


/**
   * Get current text of input.
   *
   * @return {string}
   */
  getText: function getText() {
    if ('value' in this._root) {
      return this._root.value;
    }
    return this._root[getTextContentAccessor()];
  },

  /**
   * Determine the differing substring between the initially stored
   * text content and the current content.
   *
   * @return {string}
   */
  getData: function getData() {
    if (this._fallbackText) {
      return this._fallbackText;
    }

    var start;
    var startValue = this._startText;
    var startLength = startValue.length;
    var end;
    var endValue = this.getText();
    var endLength = endValue.length;

    for (start = 0; start < startLength; start++) {
      if (startValue[start] !== endValue[start]) {
        break;
      }
    }

    var minEnd = startLength - start;
    for (end = 1; end <= minEnd; end++) {
      if (startValue[startLength - end] !== endValue[endLength - end]) {
        break;
      }
    }

    var sliceTail = end > 1 ? 1 - end : undefined;
    this._fallbackText = endValue.slice(start, sliceTail);
    return this._fallbackText;
  }
});

PooledClass.addPoolingTo(FallbackCompositionState);

module.exports = FallbackCompositionState;

/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 */

var DOMProperty = __webpack_require__(24);

var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;

var HTMLDOMPropertyConfig = {
  isCustomAttribute: RegExp.prototype.test.bind(new RegExp('^(data|aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$')),
  Properties: {
    /**
     * Standard Properties
     */
    accept: 0,
    acceptCharset: 0,
    accessKey: 0,
    action: 0,
    allowFullScreen: HAS_BOOLEAN_VALUE,
    allowTransparency: 0,
    alt: 0,
    // specifies target context for links with `preload` type
    as: 0,
    async: HAS_BOOLEAN_VALUE,
    autoComplete: 0,
    // autoFocus is polyfilled/normalized by AutoFocusUtils
    // autoFocus: HAS_BOOLEAN_VALUE,
    autoPlay: HAS_BOOLEAN_VALUE,
    capture: HAS_BOOLEAN_VALUE,
    cellPadding: 0,
    cellSpacing: 0,
    charSet: 0,
    challenge: 0,
    checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VAL


rinter* printer) const override;
  void GenerateFieldInfo(io::Printer* printer,
                         std::vector<uint16_t>* output) const override;

};

class RepeatedImmutableMessageFieldLiteGenerator
    : public ImmutableFieldLiteGenerator {
 public:
  explicit RepeatedImmutableMessageFieldLiteGenerator(
      const FieldDescriptor* descriptor, int messageBitIndex, Context* context);
  RepeatedImmutableMessageFieldLiteGenerator(
      const RepeatedImmutableMessageFieldLiteGenerator&) = delete;
  RepeatedImmutableMessageFieldLiteGenerator& operator=(
      const RepeatedImmutableMessageFieldLiteGenerator&) = delete;
  ~RepeatedImmutableMessageFieldLiteGenerator() override;

  // implements ImmutableFieldLiteGenerator ------------------------------------
  int GetNumBitsForMessage() const override;
  void GenerateInterfaceMembers(io::Printer* printer) const override;
  void GenerateMembers(io::Printer* printer) const override;
  void GenerateBuilderMembers(io::Printer* printer) const override;
  void GenerateInitializationCode(io::Printer* printer) const override;
  void GenerateFieldInfo(io::Printer* printer,
                         std::vector<uint16_t>* output) const override;
  void GenerateKotlinDslMembers(io::Printer* printer) const override;

  std::string GetBoxedType() const override;

 protected:
  const FieldDescriptor* descriptor_;
  absl::flat_hash_map<absl::string_view, std::string> variables_;
  ClassNameResolver* name_resolver_;
  Context* context_;
};

}  // namespace java
}  // namespace compiler
}  // namespace protobuf
}  // namespace google

#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_MESSAGE_FIELD_LITE_H__


lized");
        }

        const isFinished = gameStat.isFinished;
        let projection = "first3HoursBestScore"
        if (isFinished) {
            projection = "bestScore";
        }

        const bestScore = await Team.find().select(`${projection} name`).sort([[`${projection}.totalBestScore`, -1]]);
        if (isFinished) {
            return res.json(bestScore.map(_ => ({ team: _.name, score: _.bestScore.totalBestScore })));
        }
        else {
            return res.json(bestScore.map(_ => ({ team: _.name, score: _.first3HoursBestScore.totalBestScore })));
        }
    }
}

export default DataController;
export class FormHelper {

  reset(form: HTMLFormElement) {
    const elements = Array.from(form.querySelectorAll('[name]'));
    elements.forEach((element) => {
      const type = element.getAttribute('type');
      switch (type) {
        case 'password':
        case 'email':
        case 'text':
          (element as HTMLInputElement).value = '';
          break;
        case 'number':
          (element as HTMLInputElement).value = '';
          break;
        case 'checkbox':
          (element as HTMLInputElement).checked = false;
          break;
        case 'json':
          (element as HTMLInputElement).dataset.value = '{}';
      }
    });
  }

  getJson(event: Event) {
    const form = event.target as HTMLFormElement;
    const elements = Array.from(form.querySelectorAll('[name]'));

    return elements.map(this.getValue)
      .reduce(this.reduceArrayToObject);
  }

  getJsonFromElement(form: HTMLFormElement) {
    const elements = Array.from(form.elements);

    return elements.map(this.getValue)
      .reduce(this.reduceArrayToObject);
  }

  isValid(event: Event) {
    const form = event.target as HTMLFormElement;

    const elements = Array.from(form.querySelectorAll('[name]')) as HTMLElement[];

    return elements.map(this.getValidity).filter((i) => {
      return i !== null;
    }).every((i) => {
      return i;
    });
  }

  isValidFromElement(form: HTMLFormElement) {
    const elements = Array.from(form.elements) as HTMLElement[];

    return elements
      .filter( (i: any) => i.type !== 'datetime-local')
      .map(this.getValidity).filter((i) => {
        return i !== null;
      }).every((i) => {
        return i;
      });
  }

  reduceArrayToObject(prev: any, current: any) {
    return Object.assign(current, prev);
  }

  submitFormListener(event: KeyboardEvent) {
    const submitKeys = ['Enter'];
    if (submitKeys.some((i) => i === event.code)) {
      // todo find a way to do a js submit safely.
      // this will not be caught by a submit event listener
      // (event.currentTarget as HTMLFormElement).submit();
    }
  }

  public getValidity(element: HTMLElement): boolean {
    const type = element.getAttribute('type');
    const dataType = element.dataset.type;
    const compare = dataType ? dataType : type;

    switch (compare) {
      case 'password':
      case 'text':
      case 'email':
      case 'number':
        return (element as HTMLInputElement).reportValidity();
      case 'checkbox':
      case 'switch':
        return true;
      case 'json':
        return !!element.dataset.value;
    }

    return false;
  }

  publ


dxlab.lincheck.paramgen.IntGen
import com.devexperts.dxlab.lincheck.strategy.stress.StressCTest
import com.devexperts.dxlab.lincheck.verifier.quantitative.CostWithNextCostCounter
import com.devexperts.dxlab.lincheck.verifier.quantitative.PathCostFunction.MAX
import com.devexperts.dxlab.lincheck.verifier.quantitative.QuantitativeRelaxationVerifier
import com.devexperts.dxlab.lincheck.verifier.quantitative.QuantitativeRelaxationVerifierConf
import com.devexperts.dxlab.lincheck.verifier.quantitative.QuantitativeRelaxed
import org.junit.Test
import java.lang.AssertionError

private const val K = 2

@StressCTest(verifier = QuantitativeRelaxationVerifier::class)
@QuantitativeRelaxationVerifierConf(factor = K, pathCostFunc = MAX, costCounter = KStackRelaxedPushTest.CostCounter::class)
class KStackRelaxedPushTest {
    private val s = KStackSimulation<Int>(k = K)

    @QuantitativeRelaxed
    @Operation
    fun put(@Param(gen = IntGen::class) value: Int) = s.pushRelaxed(value)

    @Operation
    fun popOrNull() = s.popOrNull()

    @Test
    fun test() = LinChecker.check(KStackRelaxedPushTest::class.java)

    // Should have '(k: Int)' constructor
    data class CostCounter @JvmOverloads constructor(private val k: Int, private val s: List<Int> = emptyList()) {
        fun put(value: Int, result: Result): List<CostWithNextCostCounter<CostCounter>> {
            return (0..(k - 1).coerceAtMost(s.size)).map { i ->
                val sNew = ArrayList(s)
                sNew.add(i, value)
                CostWithNextCostCounter(CostCounter(k, sNew), i, i != 0)
            }
        }

        fun popOrNull(result: Result): CostCounter? {
            if (s.isEmpty()) {
                return if (result.value == null) CostCounter(k) else null
            }
            if (s[0] != result.value) return null
            val sNew = ArrayList(s)
            sNew.removeAt(0)
            return CostCounter(k, sNew)
        }
    }
}

@StressCTest(actorsPerThread = 10, verifier = QuantitativeRelaxationVerifier::class)
@QuantitativeRelaxationVerifierConf(factor = K, pathCostFunc = MAX, costCounter = KStackRelaxedPopIncorrectTest.CostCounter::class)
class KStackRelaxedPopIncorrectTest {
    private val s = KStackSimulation<Int>(k = K + 1)

    @Operation
    fun put(@Param(gen = IntGen::class) value: Int) = s.push(value)

    @QuantitativeRelaxed
    @Operation
    fun popOrNull() = s.popOrNullRelaxed()

    @Test(expected = AssertionError::class)
    fun test() = LinChecker.check(KStackRelaxedPopIncorrectTest::class.java)

    // Should have '(k: Int)' constructor
    data class CostCounter @JvmOverloads constructor(private val k: Int, private val s: List<Int> = emptyList()) {
        fun put(value: Int, result: Result): CostCounter {
            check(result.type == VOID)
            val sNew = ArrayList(s)
            sNew.add(0, value)
            return CostCounter(k, sNew)
        }

        fun popOrNull(result: Result): List<CostWithNextCostCounter<CostCounter>> {
            if (result.value == null) {
                return if (s.isEmpty())
                    listOf(CostWithNextCostCounter(this, 0, false))
                else emptyList()
            }
            return (0..(k - 1).coerceAtMost(s.size - 1


 fa-content($fa-var-wpexplorer); }
.#{$fa-css-prefix}-wpforms:before { content: fa-content($fa-var-wpforms); }
.#{$fa-css-prefix}-wpressr:before { content: fa-content($fa-var-wpressr); }
.#{$fa-css-prefix}-wrench:before { content: fa-content($fa-var-wrench); }
.#{$fa-css-prefix}-x-ray:before { content: fa-content($fa-var-x-ray); }
.#{$fa-css-prefix}-xbox:before { content: fa-content($fa-var-xbox); }
.#{$fa-css-prefix}-xing:before { content: fa-content($fa-var-xing); }
.#{$fa-css-prefix}-xing-square:before { content: fa-content($fa-var-xing-square); }
.#{$fa-css-prefix}-y-combinator:before { content: fa-content($fa-var-y-combinator); }
.#{$fa-css-prefix}-yahoo:before { content: fa-content($fa-var-yahoo); }
.#{$fa-css-prefix}-yammer:before { content: fa-content($fa-var-yammer); }
.#{$fa-css-prefix}-yandex:before { content: fa-content($fa-var-yandex); }
.#{$fa-css-prefix}-yandex-international:before { content: fa-content($fa-var-yandex-international); }
.#{$fa-css-prefix}-yarn:before { content: fa-content($fa-var-yarn); }
.#{$fa-css-prefix}-yelp:before { content: fa-content($fa-var-yelp); }
.#{$fa-css-prefix}-yen-sign:before { content: fa-content($fa-var-yen-sign); }
.#{$fa-css-prefix}-yin-yang:before { content: fa-content($fa-var-yin-yang); }
.#{$fa-css-prefix}-yoast:before { content: fa-content($fa-var-yoast); }
.#{$fa-css-prefix}-youtube:before { content: fa-content($fa-var-youtube); }
.#{$fa-css-prefix}-youtube-square:before { content: fa-content($fa-var-youtube-square); }
.#{$fa-css-prefix}-zhihu:before { content: fa-content($fa-var-zhihu); }
/*
Stylesheet for use with Docutils/rst2html.

See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
customize this style sheet.

Modified from Chad Skeeters' rst2html-style
https://bitbucket.org/cskeeters/rst2html-style/

Modified by Boyd Greenfield and narimiran
*/

:root {
  --primary-background: #fff;
  --secondary-background: ghostwhite;
  --third-background: #e8e8e8;
  --border: #dde;
  --text: #222;
  --anchor: #07b;
  --anchor-focus: #607c9f;
  --input-focus: #1fa0eb;
  --strong: #3c3c3c;
  --hint: #9A9A9A;
  --nim-sprite-base64: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAN4AAAA9CAYAAADCt9ebAAAACXBIWXMAAAsTAAALEwEAmpwYAAAFFmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS42LWMxNDggNzkuMTY0MDM2LCAyMDE5LzA4LzEzLTAxOjA2OjU3ICAgICAgICAiPiA8cmRmOlJERiB


on Register*/
       Ifx_UReg_8Bit                       reserved_1C[4];         /**< \brief 1C, \internal Reserved */
       Ifx_QSPI_ECON                       ECON[8];                /**< \brief 20, Configuration Extension ${z}*/
       Ifx_QSPI_STATUS                     STATUS;                 /**< \brief 40, Status Register*/
       Ifx_QSPI_STATUS1                    STATUS1;                /**< \brief 44, Status Register 1*/
       Ifx_QSPI_SSOC                       SSOC;                   /**< \brief 48, Slave Select Output Control Register*/
       Ifx_UReg_8Bit                       reserved_4C[8];         /**< \brief 4C, \internal Reserved */
       Ifx_QSPI_FLAGSCLEAR                 FLAGSCLEAR;             /**< \brief 54, Flags Clear Register*/
       Ifx_QSPI_XXLCON                     XXLCON;                 /**< \brief 58, Extra Large Data Configuration Register*/
       Ifx_QSPI_MIXENTRY                   MIXENTRY;               /**< \brief 5C, MIX_ENTRY Register*/
       Ifx_QSPI_BACONENTRY                 BACONENTRY;             /**< \brief 60, BACON_ENTRY Register*/
       Ifx_QSPI_DATAENTRY                  DATAENTRY[8];           /**< \brief 64, DATA_ENTRY Register ${x}*/
       Ifx_UReg_8Bit                       reserved_84[12];        /**< \brief 84, \internal Reserved */
       Ifx_QSPI_RXEXIT                     RXEXIT;                 /**< \brief 90, RX_EXIT Register*/
       Ifx_QSPI_RXEXITD                    RXEXITD;                /**< \brief 94, RX_EXIT Debug Register*/
       Ifx_UReg_8Bit                       reserved_98[8];         /**< \brief 98, \internal Reserved */
       Ifx_QSPI_CAPCON                     CAPCON;                 /**< \brief A0, Capture Control Register*/
       Ifx_QSPI_MC                         MC;                     /**< \brief A4, Move Counter Register*/
       Ifx_QSPI_MCCON                      MCCON;                  /**< \brief A8, Move Counter control Register*/
       Ifx_UReg_8Bit                       reserved_AC[60];        /**< \brief AC, \internal Reserved */
       Ifx_QSPI_OCS                        OCS;                    /**< \brief E8, OCDS Control and Status*/
       Ifx_QSPI_KRSTCLR                    KRSTCLR;                /**< \brief EC, Kernel Reset Status Clear Register*/
       Ifx_QSPI_KRST1                      KRST1;                  /**< \brief F0, Kernel Reset Register 1*/
       Ifx_QSPI_KRST0                      KRST0;                  /**< \brief F4, Kernel Reset Register 0*/
       Ifx_QSPI_ACCEN1                     ACCEN1;                 /**< \brief F8, Access Enable Register 1*/
       Ifx_QSPI_ACCEN0                     ACCEN0;                 /**< \brief FC, Access Enable Register 0*/
} Ifx_QSPI;

/** \}  */
/******************************************************************************/
/** \}  */

/******************************************************************************/

/******************************************************************************/

#endif /* IFXQSPI_REGDEF_H */


��
	0x203bc: "\t\r\U000203bc", // 𠎼
	0x203bd: "\t\r\U000203bd", // 𠎽
	0x203be: "\t\r\U000203be", // 𠎾
	0x203bf: "\t\r\U000203bf", // 𠎿
	0x203c0: "\t\r\U000203c0", // 𠏀
	0x203c1: "\t\r\U000203c1", // 𠏁
	0x203c2: "\t\r\U000203c2", // 𠏂
	0x203c3: "\t\r\U000203c3", // 𠏃
	0x203c4: "\t\r\U000203c4", // 𠏄
	0x203c5: "\t\r\U000203c5", // 𠏅
	0x203c6: "\t\r\U000203c6", // 𠏆
	0x203c7: "\t\r\U000203c7", // 𠏇
	0x203c8: "\t\r\U000203c8", // 𠏈
	0x203c9: "\t\r\U000203c9", // 𠏉
	0x203ca: "\t\r\U000203ca", // 𠏊
	0x203cb: "\t\r\U000203cb", // 𠏋
	0x203cc: "\t\r\U000203cc", // 𠏌
	0x203cd: "\t\r\U000203cd", // 𠏍
	0x203ce: "\t\r\U000203ce", // 𠏎
	0x203cf: "\t\r\U000203cf", // 𠏏
	0x203d0: "\t\f\U000203d0", // 𠏐
	0x203d1: "\t\r\U000203d1", // 𠏑
	0x203d2: "\t\x0e\U000203d2", // 𠏒
	0x203d3: "\x1e\f\U000203d3", // 𠏓
	0x203d4: "\t\r\U000203d4", // 𠏔
	0x203d5: "\t\r\U000203d5", // 𠏕
	0x203d6: "\t\r\U000203d6", // 𠏖
	0x203d7: "\t\r\U000203d7", // 𠏗
	0x203d8: "\t\r\U000203d8", // 𠏘
	0x203d9: "\t\r\U000203d9", // 𠏙
	0x203da: "\t\r\U000203da", // 𠏚
	0x203db: "\t\r\U000203db", // 𠏛
	0x203dc: "\t\r\U000203dc", // 𠏜
	0x203dd: "\t\r\U000203dd", // 𠏝
	0x203de: "\t\r\U000203de", // 𠏞
	0x203df: "\t\r\U000203df", // 𠏟
	0x203e0: "\t\r\U000203e0", // 𠏠
	0x203e1: "\t\r\U000203e1", // 𠏡
	0x203e2: "\t\r\U000203e2", // 𠏢
	0x203e3: "\t\r\U000203e3", // 𠏣
	0x203e4: "\t\r\U000203e4", // 𠏤


2)
- 2.x feature -> 2.x develop | Update: controller's methods with try catch [`#131`](https://github.com/webreinvent/vaahcms/pull/131)
- 2.x feature/nitin fixes [`#127`](https://github.com/webreinvent/vaahcms/pull/127)
- 2.x feature -> 2.x develop | abinash fixes [`#125`](https://github.com/webreinvent/vaahcms/pull/125)
- 2.x feature -> 2.x develop | bugs fixing [`#126`](https://github.com/webreinvent/vaahcms/pull/126)
- 2.x feature -> 2.x develop | bugs fixing [`#122`](https://github.com/webreinvent/vaahcms/pull/122)
- feature -> develop | User Delete Fixed [`#119`](https://github.com/webreinvent/vaahcms/pull/119)
- feature -> develop | bugs fixing [`#118`](https://github.com/webreinvent/vaahcms/pull/118)
- 2.x feature -> 2.x develop | profile development [`#117`](https://github.com/webreinvent/vaahcms/pull/117)
- 2.x feature -> 2.x develop | user and registration settings  [`#116`](https://github.com/webreinvent/vaahcms/pull/116)
- 2.x feature -> 2.x develop | fixed dashboard links [`#115`](https://github.com/webreinvent/vaahcms/pull/115)
- 2.x feature -> 2.x develop | dashboard right side accordion menu [`#114`](https://github.com/webreinvent/vaahcms/pull/114)
- 2.x feature -> 2.x-develop | failed-job development [`#93`](https://github.com/webreinvent/vaahcms/pull/93)
- 2.x feature -> 2.x-develop | localization devlopment [`#99`](https://github.com/webreinvent/vaahcms/pull/99)
-  2.x feature -> 2.x-develop | env variables development [`#97`](https://github.com/webreinvent/vaahcms/pull/97)
- 2.x feature -> 2.x-develop |  job CRUD [`#92`](https://github.com/webreinvent/vaahcms/pull/92)
- feature -> develop  | user crud development [`#88`](https://github.com/webreinvent/vaahcms/pull/88)
- feature -> develop | roles development crud [`#87`](https://github.com/webreinvent/vaahcms/pull/87)
- feature -> develop | permission crud development [`#86`](https://github.com/webreinvent/vaahcms/pull/86)
- 2.x feature -> 2.x-develop | Added Public pages [`#85`](https://github.com/webreinvent/vaahcms/pull/85)
- feature -> feature | Updated: Forgot password page or reset password page [`#84`](https://github.com/webreinvent/vaahcms/pull/84)
### Commits

- [`3c2e7dd`](https://github.com/webreinvent/vaahcms/commit/3c2e7ddafdae5bf75a16724586adbceb1fc57344) Removed: vaahone file
- [`be3cb3c`](https://github.com/webreinvent/vaahcms/commit/be3cb3c597c9df4bcdba3eb2976a77b4dc18c433) added: new assets
- [`7d1ca07`](https://github.com/webreinvent/vaah


rt(string objectName, string role)
        {
            Grant("INSERT", objectName, role);
        }

        public void GrantUpdate(string objectName, string role)
        {
            Grant("UPDATE", objectName, role);
        }

        public void GrantDelete(string objectName, string role)
        {
            Grant("DELETE", objectName, role);
        }

        public void Grant(string permission, string objectName, string role)
        {
            ExecuteSqlWithNoReturn("GRANT {0} ON [{1}] TO [{2}]".FormatWith(permission, objectName, role));
        }

        public bool DoesRoleExist(string role)
        {
            var sql = @"SELECT '1' from sys.database_principals where name = N'{0}' AND type = 'R'";
            var o = ExecuteSqlWithOneReturn<bool>(sql);
            return o;
        }
        public bool DoesUserExist(string user)
        {
            var sql = @"SELECT '1' from sys.database_principals where name = N'{0}' AND type = 'U'";
            var o = ExecuteSqlWithOneReturn<bool>(sql);
            return o;
        }
    }
}


",
                request.getIds(), false);
        Mockito.doReturn(request.getIds()).when(modelService).convertSegmentIdWithName(
                "89af4ee2-2cdb-4b07-b39e-4c29856309aa", request.getProject(), request.getIds(), null);
        mockMvc.perform(
                MockMvcRequestBuilders.delete("/api/models/{model}/segments", "89af4ee2-2cdb-4b07-b39e-4c29856309aa")
                        .param("project", "default").param("purge", "false")
                        .param("ids", "ef5e0663-feba-4ed2-b71c-21958122bbff")
                        .accept(MediaType.parseMediaType(HTTP_VND_APACHE_KYLIN_JSON)))
                .andExpect(MockMvcResultMatchers.status().isOk());
        Mockito.verify(segmentController).deleteSegments("89af4ee2-2cdb-4b07-b39e-4c29856309aa", "default", false,
                false, request.getIds(), null);
    }

    @Test
    public void testRefreshSegmentsById() throws Exception {
        List<JobInfoResponse.JobInfo> jobInfos = new ArrayList<>();
        jobInfos.add(new JobInfoResponse.JobInfo("78847556-2cdb-4b07-b39e-4c29856309aa",
                "89af4ee2-2cdb-4b07-b39e-4c29856309aa"));
        SegmentsRequest request = mockSegmentRequest();
        Mockito.doAnswer(x -> jobInfos).when(modelBuildService).refreshSegmentById(Mockito.any());
        Mockito.doReturn(request.getIds()).when(modelService).convertSegmentIdWithName(
                "89af4ee2-2cdb-4b07-b39e-4c29856309aa", request.getProject(), request.getIds(), null);
        String mvcResult = mockMvc
                .perform(MockMvcRequestBuilders
                        .put("/api/models/{model}/segments", "89af4ee2-2cdb-4b07-b39e-4c29856309aa")
                        .contentType(MediaType.APPLICATION_JSON).content(JsonUtil.writeValueAsString(request))
                        .accept(MediaType.parseMediaType(HTTP_VND_APACHE_KYLIN_JSON)))
                .andExpect(MockMvcResultMatchers.status().isOk()).andReturn().getResponse().getContentAsString();
        Assert.assertTrue(mvcResult.contains("89af4ee2-2cdb-4b07-b39e-4c29856309aa"));
        Mockito.verify(segmentController).refreshOrMergeSegments(eq("89af4ee2-2cdb-4b07-b39e-4c29856309aa"),
                Mockito.any(SegmentsRequest.class));
    }

    @Test
    public void testMergeSegments() throws Exception {
        SegmentsRequest request = mockSegmentRequest();
        request.setType(SegmentsRequest.SegmentsRequestType.MERGE);
        request.setIds(new String[] { "0", "1" });
        Mockito.doAnswer(x -> new JobInfoResponse.JobInfo("0312bcc1-092e-42b1-ab0e-27807cf54f16",
                "79c27a68-343c-4b73-b406-dd5af0add951")).when(modelBuildService).mergeSegmentsManually(Mockito.any());
        Mockito.doReturn(request.getIds()).when(modelService).convertSegmentIdWithName(
                "89af4ee2-2cdb-4b07-b39e-4c29856309aa", request.getProject(), request.getIds(), null);
        val mvcResult = mockMvc
                .perform(MockMvcRequestBuilders
                        .put("/api/models/{model}/segments", "89af4ee2-2cdb-4b07-b39e-4c29856309aa")
                        .contentType(MediaType.APPLICATION_JSON).content(JsonUtil.writeValueAsString(request))


e@example.com",
				},
				UserMesaurements: UserMesaurements{
					HeightMeter:    180,
					WeightKilogram: 80,
					MaxHeartRate:   175,
				},
				SleepCollection: SleepCollection{
					SleepCollectionRecords: []SleepCollectionRecords{
						{
							ID:             "550e8400-e29b-41d4-a716-446655440000",
							UserID:         111111111,
							CreatedAt:      time.Date(2024, time.August, 15, 0, 0, 0, 0, time.UTC),
							UpdatedAt:      time.Date(2024, time.August, 15, 1, 0, 0, 0, time.UTC),
							Start:          time.Date(2024, time.August, 15, 0, 0, 0, 0, time.UTC),
							End:            time.Date(2024, time.August, 15, 8, 0, 0, 0, time.UTC),
							TimezoneOffset: "+02:00",
							Nap:            false,
							ScoreState:     "good",
							Score: Score{
								StageSummary: StageSummary{
									TotalInBedTimeMilli:         28800000,
									TotalAwakeTimeMilli:         3600000,
									TotalNoDataTimeMilli:        0,
									TotalLightSleepTimeMilli:    14400000,
									TotalSlowWaveSleepTimeMilli: 7200000,
									TotalRemSleepTimeMilli:      4320000,
									SleepCycleCount:             4,
									DisturbanceCount:            2,
								},
								SleepNeeded: SleepNeeded{
									BaselineMilli:             28800000,
									NeedFromSleepDebtMilli:    0,
									NeedFromRecentStrainMilli: 0,
									NeedFromRecentNapMilli:    0,
								},
								RespiratoryRate:            15,
								SleepPerformancePercentage: 85.5,
								SleepConsistencyPercentage: 80.2,
								SleepEfficiencyPercentage:  90.0,
							},
						},
					},
				},
				RecoveryCollection: RecoveryCollection{
					RecoveryRecords: []RecoveryRecords{
						{
							CycleID:    78942566,
							SleepID:    "550e8400-e29b-41d4-a716-446655440000",
							UserID:     111111111,
							CreatedAt:  time.Date(2024, time.August, 15, 0, 0, 0, 0, time.UTC),
							UpdatedAt:  time.Date(2024, time.August, 15, 1, 0, 0, 0, time.UTC),
							ScoreState: "SCORED",
							Score: RecoveryScore{
								UserCalibrating:  false,
								RecoveryScore:    85,
								RestingHeartRate: 60,
								HrvRmssdMilli:    50,
								Spo2Percentage:   98.0,
								SkinTempCelsius:  36.5,
							},
						},
					},
				},
				WorkoutCollection: WorkoutCollection{
					Records: []WorkoutRecords{
						{
							ID:             "7bfc6a15-5521-612f-b9a4-e274dd7afae9",
							UserID:         111111111,
							CreatedAt:      time.Date(2024, time.August, 15, 0, 6, 25, 0, time.UTC),
							UpdatedAt:      time.Date(2024, time.August, 15, 0, 7, 0, 0, time.UTC),
							Start:          time.Date(2024, time.August, 15, 0, 6, 25, 0, time.UTC),
							End:            time.Date(2024, time.August, 15, 0, 6, 42, 0, time.UTC),
							TimezoneOffset: "-07:00",
							SportID:        44,
							ScoreState:     "SCORED",
							Score: WorkoutScore{
								Strain:              7,
								AverageHeartRate:    150,
								MaxHeartRate:        180,
								Kilojoule:


ils.assertIsNodeKind<Ast.TConstant>(xorNode, Ast.NodeKind.Constant);

    if (XorNodeUtils.isContext(xorNode)) {
        return Type.UnknownInstance;
    }

    const constant: Ast.TConstant = xorNode.node;

    switch (constant.constantKind) {
        case Constant.PrimitiveTypeConstant.Action:
            return Type.ActionInstance;

        case Constant.PrimitiveTypeConstant.Any:
            return Type.AnyInstance;

        case Constant.PrimitiveTypeConstant.AnyNonNull:
            return Type.AnyNonNullInstance;

        case Constant.PrimitiveTypeConstant.Binary:
            return Type.BinaryInstance;

        case Constant.PrimitiveTypeConstant.Date:
            return Type.DateInstance;

        case Constant.PrimitiveTypeConstant.DateTime:
            return Type.DateTimeInstance;

        case Constant.PrimitiveTypeConstant.DateTimeZone:
            return Type.DateTimeZoneInstance;

        case Constant.PrimitiveTypeConstant.Duration:
            return Type.DurationInstance;

        case Constant.PrimitiveTypeConstant.Function:
            return Type.FunctionInstance;

        case Constant.PrimitiveTypeConstant.List:
            return Type.ListInstance;

        case Constant.PrimitiveTypeConstant.Logical:
            return Type.LogicalInstance;

        case Constant.PrimitiveTypeConstant.None:
            return Type.NoneInstance;

        case Constant.PrimitiveTypeConstant.Null:
            return Type.NoneInstance;

        case Constant.PrimitiveTypeConstant.Number:
            return Type.NumberInstance;

        case Constant.PrimitiveTypeConstant.Record:
            return Type.RecordInstance;

        case Constant.PrimitiveTypeConstant.Table:
            return Type.TableInstance;

        case Constant.PrimitiveTypeConstant.Text:
            return Type.TextInstance;

        case Constant.PrimitiveTypeConstant.Time:
            return Type.TimeInstance;

        case Constant.PrimitiveTypeConstant.Type:
            return Type.TypePrimitiveInstance;

        default:
            return Type.UnknownInstance;
    }
}
type CarouselItemDataType = {
  title: string;
  description: string;
  image: any;
}

export type CarouselProps = {
  data: CarouselItemDataType[];
};

export enum CarouselButton {
  Prev = 0,
  Next = 1,
};
import { Pipe, PipeTransform} from '@angular/core';
@Pipe({
name: 'elipsis'
})
export class ElipsisPipe implements PipeTransform {
  transform(value: any, maxlen: number): any {
return (!maxlen || !value || value.length < maxlen
  || value.length < 4) ? value : (value.substr(0, maxlen - 3) + '...');
  }
}

// para hacer muchos export de golpe y no tener que hacerlos uno a uno
// se puede declarar un array
export const PIPES_CADENAS = [ElipsisPipe];

/**
 * @category Generate
 * @description Number.range & BigInt.range
 * @param {number | bigint} from - Number to generate from
 * @param {number | bigint =} to - Number to generate until
 * @param {number | bigint | undefined = } step - Generation step
 * @param {"number" | "bigint" = } type - Number type
 * @returns {bigint|number|undefined}
 */
function* CreateRangeIterator(from, to, step, type) {
  if (typeof from !== type) {
    throw new TypeError();
  }
  if (type !== "number" && type !== "bigint") {
    throw new TypeError();
  }
  const zero = type === "number" ? 0 : BigInt(0);
  const one = type === "number" ? 1 : BigInt(1);
  if (typeof to === "undefined") {
    to = from;
    from = zero;
  }
  if (typeof step === "undefined") {
    step = one;
  }
  if (typeof from !== type || typeof to !== type || typeof step !== type) {
    throw new TypeError();
  }
  if ((typeof from === "number" && !Number.isFinite(from)) ||


if ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec


#ifndef COMMONS_H
#define COMMONS_H

#define NSMAX 6827
#define NTMAX 120
#define RX_SAMPLE_RATE 12000

#ifdef __cplusplus
#include <cstdbool>
//extern "C" {
#else
#include <stdbool.h>
#endif

  /*
   * This structure is shared with Fortran code, it MUST be kept in
   * sync with lib/jt9com.f90
   * int nutc;                   //UTC as integer, HHMM
   * int ntrperiod;              //TR period (seconds)
   * int nfqso;                  //User-selected QSO freq (kHz)
   * int npts8;                  //npts for c0() array
   * int nfa;                    //Low decode limit (Hz)
   * int nfSplit;                //JT65 | JT9 split frequency
   * int nfb;                    //High decode limit (Hz)
   * int ntol;                   //+/- decoding range around fQSO (Hz)
   * bool ndiskdat;              //true ==> data read from *.wav file
   * bool newdat;                //true ==> new data, must do long FFT
   */
typedef struct dec_data {
  float ss[184*NSMAX];
  float savg[NSMAX];
  short int d2[NTMAX*RX_SAMPLE_RATE];
  float dd2[NTMAX*RX_SAMPLE_RATE];
  struct
  {
//    char datetime[20];
    char mycall[12];
    char mybcall[12];
    char hiscall[12];
    char hisbcall[12];
//    char mygrid[6];
    char hisgrid[6];
    int listutc[10];
    int napwid;
    int nQSOProgress;
    int nftx;
    int nutc;
    int ntrperiod;
    int nfqso;
    int npts8;
    int nfa;
    int nfSplit;
    int nfb;
    int ntol;
    int kin;
    int nzhsym;
    int ndepth;
    int ncandthin;
    int ndtcenter;
    int nft8cycles;
    int nft8swlcycles;
    int ntxmode;
    int nmode;
    int nlist;
    int nranera;
    int ntrials10;
    int ntrialsrxf10;
    int naggressive;
    int nharmonicsdepth;
    int ntopfreq65;
    int nprepass;
    int nsdecatt;
    int nlasttx;
    int ndelay;
    int nmt;
    int nft8rxfsens;
    int nft4depth;
    int nsecbandchanged;
    bool ndiskdat;
    bool newdat;
    bool nagain;
    bool nagainfil;
    bool nswl;
    bool nfilter;
    bool nstophint;
    bool nagcc;
    bool nhint;
    bool fmaskact;
    bool showharmonics;
    bool lft8lowth;
    bool lft8subpass;
    bool ltxing;
    bool lhidetest;
    bool lhidetelemetry;
    bool lhideft8dupes;
    bool lhound;
    bool lhidehash;
    bool lcommonft8b;
    bool lmycallstd;
    bool lhiscallstd;
    bool lapmyc;
    bool lmodechanged;
    bool lbandchanged;
    bool lenabledxcsearch;
    bool lwidedxcsearch;
    bool lmultinst;
    bool lskiptx1;
    bool lforcesync;
    bool learlystart;
    } params;
} dec_data_t;

// for unknown reason values of the variables at beginning of dec_data list are being
// not updated while Decode button is pushed manually, for decoding again keep variables at end
// of the list

#ifdef __cplusplus
extern "C" {
#endif

extern struct {
  float wave[606720];
} foxcom_;

#define NUM_JT65_SYMBOLS 126               //63 data + 63 sync
#define NUM_JT9_SYMBOLS 85                 //69 data + 16 sync
#define NUM_T10_SYMBOLS 85                 //69 data + 16 sync
#define NUM_WSPR_SYMBOLS 162               //(50+31)*2, embedded sync
#define NUM_FT8_SYMBOLS 79
#define NUM_FT4_SYMBOLS 105

#define NUM_CW_SYMBOLS 250
#define TX_SAMPLE_RATE 48000

extern int volatile itone[NUM_WSPR_SYMBOLS];   //Audio tones for all Tx symbols
extern int volatile icw[NUM_CW_SYMBOLS];	    //Dits for CW ID

#ifdef __cplusplus
}
#endif

#endif // COMMONS_H


king_getgameinstancesforall" },
    { 0x928415DA2C6F33CB, "vehicle_tracking_getownerinstances" },
    { 0x17C0A6E02FD17259, "vehicle_tracking_getteaminstances" },
    { 0x23715A577F0F417C, "vehicle_tracking_init" },
    { 0xED7703226F8E7BA2, "vehicle_tracking_instancesarelimited" },
    { 0xFA0607E84C948C45, "vehicle_tracking_limitgameinstances" },
    { 0x8E77FCBB0EF7F554, "vehicle_tracking_limitownerinstances" },
    { 0xA64259D183C03A4C, "vehicle_tracking_limitteaminstances" },
    { 0x287B84C4B253388C, "vehicle_tracking_registerinstance" },
    { 0xBAD88FC2E5F17D9A, "vehicle_trackturretprojectile" },
    { 0x6CBA209CB7986926, "vehicle_travel_array" },
    { 0x8239D942B8DE295C, "vehicle_travel_player_connect_monitor" },
    { 0x4AD3571224041C5A, "vehicle_travel_player_disconnect_monitor" },
    { 0x7391E4DC04208935, "vehicle_treads" },
    { 0x0BA0B6E827595C6C, "vehicle_triggerkillspawner" },
    { 0xE6D9D70B8A0ECE0A, "vehicle_turnengineoff" },
    { 0x9FA495583BCFC210, "vehicle_turnengineon" },
    { 0xDAA918B914C3DC75, "vehicle_turret_cleanup" },
    { 0xD200196C9B95CF82, "vehicle_turret_difficulty" },
    { 0x60597776EC1D78DD, "vehicle_turret_init" },
    { 0x1E35C8060C6A0C14, "vehicle_turret_scan_off" },
    { 0x9EED8822B716CE4F, "vehicle_unload" },
    { 0x9E40DF8258FE2245, "vehicle_update" },
    { 0xFD09D2138EBAA712, "vehicle_vindiabodydamagelogic" },
    { 0x264EDFF22A41CF22, "vehicle_vindiadamagelogic" },
    { 0xE196C7823226ACD0, "vehicle_vindialaunchsmokegrenades" },
    { 0x929976D9F657E265, "vehicle_vindiameshanimdrivecleanuplogic" },
    { 0x38598829514DC2B3, "vehicle_vindiameshanimdrivelogic" },
    { 0xCC665D19A0701B29, "vehicle_vindiameshanimlogic" },
    { 0x4F1E604CE3F99828, "vehicle_vindiameshanimunloadlogic" },
    { 0x1EB160453CD1310E, "vehicle_vindiasmokegrenadelogic" },
    { 0xE7A8A8E800666722, "vehicle_vindiasmokelaunchsfxlogic" },
    { 0x864BDD7F7ACE4C9D, "vehicle_vindiaspawnsmokegrenade" },
    { 0xA3A9F6C9FE49513D, "vehicle_vindiaspeeduplogic" },
    { 0x1A708EDADE33D232, "vehicle_vindiaspeeduptimeoutlogic" },
    { 0x3E38EB6CF4E77433, "vehicle_vindiatirelogic" },
    { 0x045834BF18791934, "vehicle_vindiaunloadlogic" },
    { 0x2F5D56932896BDA8, "vehicle_wa


otstrap.com)
 * Copyright 2011-2016 Twitter,
 Inc.
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 *//*!
 * Generated using the Bootstrap Customizer (http://getbootstrap.com/customize/?id=35378cd201a131f69c68a64bc4438544)
 * Config saved to config.json and https://gist.github.com/35378cd201a131f69c68a64bc4438544
 */.pBslTbKdJwFXMpCQuc7v{color:#fff;margin:0 0 16px}.bCoyoXohuLs0f6urF2PD{margin-top:16px}.nav-ylx .bCoyoXohuLs0f6urF2PD{margin-top:32px}.nav-ylx .EF2m35WFubo6yUwP04MQ{margin-top:24px}
/*!
 * Bootstrap v3.3.7 (http://getbootstrap.com)
 * Copyright 2011-2016 Twitter,
 Inc.
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 *//*!
 * Generated using the Bootstrap Customizer (http://getbootstrap.com/customize/?id=35378cd201a131f69c68a64bc4438544)
 * Config saved to config.json and https://gist.github.com/35378cd201a131f69c68a64bc4438544
 */.hciep85bysUuJqNoK7uw{margin-top:32px}.nav-ylx .hciep85bysUuJqNoK7uw{margin-top:16px}.hciep85bysUuJqNoK7uw .Xa3KEcm2U_GOL2KMSoHw{margin:0 -12px}.nav-ylx .hciep85bysUuJqNoK7uw.KjXzXFYQr6Wp2QlxPUAY{margin-top:32px}.main-topBar-searchBar{-webkit-box-flex:0;-ms-flex:0 1 364px;flex:0 1 364px;position:relative}.nav-ylx .main-topBar-searchBar:hover .x-searchInput-searchInputSearchIcon{color:#fff}.nav-ylx .main-topBar-searchBar:focus-within .x-searchInput-searchInputSearchIcon{color:#fff}.x-searchInput-searchInputInput{border:0;border-radius:500px;color:#000;height:40px;padding:6px 48px;text-overflow:ellipsis;width:100%}.nav-ylx .x-searchInput-searchInputInput{background-color:#242424;color:#fff!important;height:48px;padding:6px 36px}.nav-ylx .x-searchInput-searchInputInput:hover{background-color:#2a2a2a;-webkit-box-shadow:0 0 0 1px hsla(0,0%,100%,.2);box-shadow:0 0 0 1px hsla(0,0%,100%,.2);outline:none}.nav-ylx .x-searchInput-searchInputInput:focus{-webkit-box-shadow:0 0 0 2px #fff;box-shadow:0 0 0 2px #fff;outline:none}.x-searchInput-searchInputInput::-ms-clear{display:none}.x-searchInput-searchInputOnSearch .x-searchInput-searchInputInput{background-color:rgba(0,0,0,.5)}.x-searchInput-searchInputOnSearch ::-webkit-input-placeholder{color:#fff}.x-searchInput-searchInputOnSearch ::-moz-placeholder{color:#fff}.x-searchInput-searchInputOnSearch :-ms-input-placeholder{color:#fff}.x-searchInput-searchInputOnSearch ::-ms-input-placeholder{color:#fff}.x-searchInput-searchInputOnSearch .x-searchInput-searchInputSearchIcon,.x-searchInput-searchInputOnSearch .x-searchInput-search


  AABB interpAabb;
  glm::vec3 pt1 = glm::mix(firstAabb.getMinPos(), secondAabb.getMinPos(), instSettings.isAnimBlendFactor);
  glm::vec3 pt2 = glm::mix(firstAabb.getMaxPos(), secondAabb.getMaxPos(), instSettings.isAnimBlendFactor);

  interpAabb.create(pt1);
  interpAabb.addPoint(glm::vec3(pt2.x, pt1.y, pt1.z));
  interpAabb.addPoint(glm::vec3(pt1.x, pt2.y, pt1.z));
  interpAabb.addPoint(glm::vec3(pt2.x, pt2.y, pt1.z));

  interpAabb.addPoint(glm::vec3(pt1.x, pt1.y, pt2.z));
  interpAabb.addPoint(glm::vec3(pt2.x, pt1.y, pt2.z));
  interpAabb.addPoint(glm::vec3(pt1.x, pt2.y, pt2.z));
  interpAabb.addPoint(pt2);

  /* scale AABB */
  interpAabb.setMinPos(interpAabb.getMinPos() * instSettings.isScale);
  interpAabb.setMaxPos(interpAabb.getMaxPos() * instSettings.isScale);

  /* honour swap axis */
  glm::quat swapAxisQuat = glm::identity<glm::quat>();
  if (instSettings.isSwapYZAxis) {
    glm::mat4 flipMatrix = glm::rotate(glm::mat4(1.0f), glm::radians(-90.0f), glm::vec3(0.0f, 0.0f, 1.0f));
    swapAxisQuat = glm::quat_cast(glm::rotate(flipMatrix, glm::radians(-90.0f), glm::vec3(0.0f, 1.0f, 0.0f)));
  }

  /* rotate and re-create AABB from min and max positions */
  AABB rotatedAabb;
  glm::vec3 interpMinPos = interpAabb.getMinPos();
  glm::vec3 interpMaxPos = interpAabb.getMaxPos();
  glm::vec3 p1 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat * interpMinPos;
  glm::vec3 p2 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMaxPos.x, interpMinPos.y, interpMinPos.z);
  glm::vec3 p3 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMinPos.x, interpMaxPos.y, interpMinPos.z);
  glm::vec3 p4 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMaxPos.x, interpMaxPos.y, interpMinPos.z);

  glm::vec3 p5 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMinPos.x, interpMinPos.y, interpMaxPos.z);
  glm::vec3 p6 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMaxPos.x, interpMinPos.y, interpMaxPos.z);
  glm::vec3 p7 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat *
  glm::vec3(interpMinPos.x, interpMaxPos.y, interpMaxPos.z);
  glm::vec3 p8 = glm::quat(glm::radians(instSettings.isWorldRotation)) * swapAxisQuat * interpMaxPos;

  rotatedAabb.create(p1);
  rotatedAabb.addPoint(p2);
  rotatedAabb.addPoint(p3);
  rotatedAabb.addPoint(p4);
  rotatedAabb.addPoint(p5);
  r


d6
				lea			$8.w,a5				; Startvektor
				lea			$1000.w,a1			; Endvektor
				jsr			GetFirstValue
				bgt			NumberError
				bne.s		.no_first			; [FirstVector] ?
				st			d6
				st			d7					; mit Parameter
				movea.l		d3,a5				; a5 = [Firstvector]
.no_first:		jsr			GetNextValue
				bgt			NumberError
				bne.s		.no_last
				sf			d6
				st			d7					; mit Parameter
				movea.l		d3,a1				; a1 = [,LastVector]
.no_last:		move.l		#_XBRA,d5			; wenn d5 = #_XBRA ---> keine ID
				jsr			GetNextValue
				bgt			NumberError
				bne.s		.no_id
				sf			d6
				st			d7					; mit Parameter
				move.l		d3,d5				; d5 = ID
.no_id:			tst.b		d6					; wenn nur FirstVector, dann gilt
				beq.s		.morethan_first		; LastVector=FirstVector
				movea.l		a5,a1				; a1 = [,LastVector]
.morethan_first:tst.b		d7
				bne			.WITH_PARAMETER

*---------------
*-------------- Vektoren nach ID's durchsuchen

				bsr			Umlenkung
				cmpi.w		#12,BILD_BREITE		; Screen zu schmal?
				bhs.s		.breite_io
				rts

.breite_io:		moveq		#100,d0				; d0 = 100-Anzahl Kennungen
				move.w		#($1000-8)/2-1,d1	; Schleifenzhler
				link		a0,#-4*100			; Platz fr 100 Kennungen
				lea			8.w,a1				; Anfangsadresse
				pea			.vector_fail(pc)
				bsr			TestBusOn
.xbra_loop_2:	movea.l		(a1),a2				; erste Routine holen

* Vektor testen
				moveq		#99,d3				; hchstens 100 Links
.xbra_loop_1:	cmpi.l		#'XBRA',-12(a2)		; Routinen testen
				bne.s		.cont

* ID schon vorhanden?
				move.l		-8(a2),d4
				movea.l		a0,a3				; gefundene Kennungen
				moveq		#99,d5
				sub.w		d0,d5				; Schleifenzhler
				bmi.s		.new_id
.xbra_loop_0:	cmp.l		(a3)+,d4			; ID's testen
				beq.s		.no_new_id
				dbra		d5,.xbra_loop_0

.new_id:		move.l		d4,-(a0)			; neue Kennung eintragen
				subq.w		#1,d0				; Zhler-1
				beq.s		.no_more_ids		; schon 100 ID's?
.no_new_id:		movea.l		-(a2),a2			; neuer XBRA Link
				dbra		d3,.xbra_loop_1
				bra.s		.cont

.vector_f


il.
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T1962809521"] = "Please provide some text as input. For example, an email."

-- Analyze text
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T2268303626"] = "Analyze text"

-- Target language
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T237828418"] = "Target language"

-- My Tasks
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T3011450657"] = "My Tasks"

-- You received a cryptic email that was sent to many recipients and you are now wondering if you need to do something? Copy the email into the input field. You also need to select a personal profile. In this profile, you should describe your role in the organization. The AI will then try to give you hints on what your tasks might be.
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T3646084045"] = "You received a cryptic email that was sent to many recipients and you are now wondering if you need to do something? Copy the email into the input field. You also need to select a personal profile. In this profile, you should describe your role in the organization. The AI will then try to give you hints on what your tasks might be."

-- Custom target language
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T3848935911"] = "Custom target language"

-- Please select one of your profiles.
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T465395981"] = "Please select one of your profiles."

-- Text or email
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T534887559"] = "Text or email"

-- Please provide a custom language.
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::MYTASKS::ASSISTANTMYTASKS::T656744944"] = "Please provide a custom language."

-- Please provide a text as input. You might copy the desired text from a document or a website.
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T137304886"] = "Please provide a text as input. You might copy the desired text from a document or a website."

-- Sentence structure
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T1714063121"] = "Sentence structure"

-- Rewrite & Improve Text
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T1994150308"] = "Rewrite & Improve Text"

-- Improve your text
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T2163831433"] = "Improve your text"

-- Language
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T2591284123"] = "Language"

-- Custom language
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T3032662264"] = "Custom language"

-- Your input to improve
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSISTANTREWRITEIMPROVE::T3037449423"] = "Your input to improve"

-- Writing style
UI_TEXT_CONTENT["AISTUDIO::ASSISTANTS::REWRITEIMPROVE::ASSIST


save },
    { "historyload", l_historyload },
    { "historyget", l_historyget },
    { "clearscreen", l_clearscreen },
    { "setcompletion", l_setcompletion},
    { "addcompletion", l_addcompletion },

    /* Aliases for more consistent function names */
    { "addhistory", l_historyadd },
    { "sethistorymaxlen", l_historysetmaxlen },
    { "savehistory", l_historysave },
    { "loadhistory", l_historyload },

    { "line", l_linenoise },
    { "lines", l_lines },

    { NULL, NULL }
};

int luaopen_linenoise(lua_State *L)
{
    lua_newtable(L);

    luaL_newmetatable(L, LN_COMPLETION_TYPE);
    lua_pushboolean(L, 0);
    lua_setfield(L, -2, "__metatable");
    lua_pop(L, 1);
#if LUA_VERSION_NUM > 501
    luaL_setfuncs(L,linenoise_funcs,0);
#else
    luaL_register(L, NULL, linenoise_funcs);
#endif
    return 1;
}


IT"] = 471,
      ["E.DODG"] = 30,
      ["E.HEAL"] = 0,
      ["E.HIT"] = 0,
      ["E.HP"] = 660,
      ["E.HPS"] = 90,
      ["E.INT"] = 315,
      ["E.LFS"] = 50,
      ["E.MCRIT"] = 30,
      ["E.MIMU"] = 0,
      ["E.MP"] = 0,
      ["E.MPS"] = 92,
      ["E.MR"] = 20,
      ["E.MRI"] = 0,
      ["E.PIMU"] = 0,
      ["E.SILR"] = 0,
      ["E.SKL"] = 0,
      ["E.STR"] = 367,
      ["GS"] = 2553.95,
      ["HEAL"] = 0,
      ["HIT"] = 0,
      ["HP"] = 500,
      ["HPS"] = 90,
      ["ID"] = 10,
      ["INT"] = 299,
      ["LFS"] = 50,
      ["MCRIT"] = 30,
      ["MIMU"] = 0,
      ["MP"] = 0,
      ["MPS"] = 92,
      ["MR"] = 20,
      ["MRI"] = 0,
      ["Name"] = "Sniper",
      ["NameRank"] = "Sniper11",
      ["PIMU"] = 0,
      ["Rank"] = 11,
      ["serial number"] = 118,
      ["SILR"] = 0,
      ["SKL"] = 0,
      ["STR"] = 351,
      ["Type"] = "AGI"
    },
    [12] = {
      ["+AGI"] = 22,
      ["+INT"] = 22,
      ["+STR"] = 22,
      ["AD"] = 1155,
      ["AGI"] = 659,
      ["AP"] = 55,
      ["ARM"] = 38,
      ["ARMP"] = 53,
      ["CDR"] = 0,
      ["CRIT"] = 437,
      ["DODG"] = 55,
      ["E.AD"] = 1247.4,
      ["E.AGI"] = 729.4,
      ["E.AP"] = 55,
      ["E.ARM"] = 38,
      ["E.ARMP"] = 57.4,
      ["E.CDR"] = 0,
      ["E.CRIT"] = 448,
      ["E.DODG"] = 66,
      ["E.HEAL"] = 0,
      ["E.HIT"] = 20.8,
      ["E.HP"] = 1241,
      ["E.HPS"] = 90,
      ["E.INT"] = 392.8,
      ["E.LFS"] = 50,
      ["E.MCRIT"] = 30,
      ["E.MIMU"] = 0,
      ["E.MP"] = 0,
      ["E.MPS"] = 92,
      ["E.MR"] = 20,
      ["E.MRI"] = 0,
      ["E.PIMU"] = 0,
      ["E.SILR"] = 0,
      ["E.SKL"] = 1,
      ["E.STR"] = 448.2,
      ["GS"] = 3110.35,
      ["HEAL"] = 0,
      ["HIT"] = 12,
      ["HP"] = 1010,
      ["HPS"] = 90,
      ["ID"] = 10,
      ["INT"] = 362,
      ["LFS"] = 50,
      ["MCRIT"] = 30,
      ["MIMU"] = 0,
      ["MP"] = 0,
      ["MPS"] = 92,
      ["MR"] = 20,
      ["MRI"] = 0,
      ["Name"] = "Sniper",
      ["NameRank"] = "Sniper12",
      ["PIMU"] = 0,
      ["Rank"] = 12,
      ["serial number"] = 119,
      ["SILR"] = 0,
      ["SKL"] = 1,
      ["STR"] = 424,
      ["Type"] = "AGI"
    }
  },


th: 100%;
    overflow: auto;
}

.cvat-empty-invitations-list {
    .ant-empty {
        top: 50%;
        left: 50%;
        position: absolute;
        transform: translate(-50%, -50%);
    }
}

.cvat-invitations-pagination {
    display: flex;
    justify-content: center;
}

.cvat-invitations-list-content {
    padding-bottom: $grid-unit-size;
    height: 95%;
}

.cvat-invitation-item {
    margin-bottom: $grid-unit-size;

    &:hover {
        border: 1px solid $border-color-hover;
    }

    .cvat-invitation-description {
        display: flex;
        align-items: center;
    }

    .cvat-invitation-actions {
        button {
            margin-left: $grid-unit-size;
        }
    }

    .ant-card-body {
        padding: $grid-unit-size * 2;
    }
}

.cvat-invitation-item-declined {
    opacity: 0.5;
    pointer-events: none;
}

.cvat-invitation-item-ribbon {
    top: $grid-unit-size * 0.5;
}
// Copyright (C) 2020-2022 Intel Corporation
//
// SPDX-License-Identifier: MIT

@import '../../base';

.cvat-header.ant-layout-header {
    display: flex;
    padding-left: 0;
    padding-right: 0;
    line-height: 0;
    height: $header-height;
    background: $header-color;
}

.ant-btn.cvat-header-button {
    color: $text-color;
    padding: 0 $grid-unit-size;
    margin-right: $grid-unit-size;
}

.cvat-left-header {
    .ant-btn.cvat-header-button {
        opacity: 0.7;

        &.cvat-active-header-button {
            font-weight: bold;
            opacity: 1;
        }
    }

    .anticon.cvat-logo-icon {
        margin: 0 $grid-unit-size * 2;
    }

    width: 50%;
    display: flex;
    justify-content: flex-start;
    align-items: center;
}

.cvat-right-header {
    width: 50%;
    display: flex;
    justify-content: flex-end;
    align-items: center;

    > a.ant-btn {
        span[role='img'] {
            font-size: 24px;
            line-height: 24px;
        }
    }
}

.cvat-header-menu-user-dropdown {
    display: flex;
    align-items: center;
    border-left: 1px solid $border-color-1;

    .anticon.cvat-header-dropdown-icon {
        &.anticon-caret-down {
            font-size: 12px;
        }

        font-size: 20px;
        padding: $grid-unit-size;
    }

    > div:nth-child(2) {
        > div:nth-child(2) { /* org slug */
            font-size: 10px;
        }

        max-width: $grid-unit-size * 15;
        height: $grid-unit-size * 5;
        overflow: hidden;
        white-space: nowrap;
        text-overflow: ellipsis;
        align-items: center;
    }
}

.cvat-header-menu {
    width: $grid-unit-size * 20;
}

.cvat-header-menu-active-organization-item {
    ::after {
        content: ' \2713';
        float: right;
        margin-left: $grid-unit-size;
    }

    font-weight: bold;
}

.cvat-modal-organization-selector {
    width: 100%;
}

.cvat-shortcuts-modal-window-table {
    .ant-table {


);
  return header;
}

Future<bool> applySettings(RhasspyApi rhasspy, RhasspyProfile profile) async {
  if (!profile.isDialogueRhasspy) {
    log.w("rhasspy Dialogue Management is not enable.");
    profile.setDialogueSystem("rhasspy");
  }
  log.d("sending new profile config", "APP");
  try {
    if (await rhasspy.setProfile(ProfileLayers.defaults, profile)) {
      log.i("Restarting rhasspy...", "RHASSPY");
      if (await rhasspy.restart()) {
        log.i("restarted", "RHASSPY");
        return true;
      } else {
        log.e("failed to restarted rhasspy", "RHASSPY");
        return false;
      }
    } else {
      log.e("failed to send new profile", "RHASSPY");
      return false;
    }
  } catch (e) {
    log.e("failed to send new profile ${e.toString()}");
    return false;
  }
}

Future<RhasspyApi> getRhasspyInstance(SharedPreferences prefs,
    [BuildContext context]) async {
  SecurityContext securityContext = SecurityContext.defaultContext;
  Directory appDocDirectory = await getApplicationDocumentsDirectory();
  String certificatePath = appDocDirectory.path + "/SslCertificate.pem";
  try {
    if (File(certificatePath).existsSync())
      securityContext.setTrustedCertificates(certificatePath);
  } on TlsException {}
  String value = prefs.getString("Rhasspyip");
  if (value == null) {
    if (context != null)
      FlushbarHelper.createError(
              message: "please insert rhasspy server ip first")
          .show(context);
    log.e("please insert rhasspy server ip first", "RHASSPY");
    return null;
  }
  String ip = value.split(":").first;
  int port = int.parse(value.split(":").last);
  return RhasspyApi(ip, port, prefs.getBool("SSL") ?? false,
      securityContext: securityContext);
}

MaterialColor createMaterialColor(Color color) {
  List strengths = <double>[.05];
  final swatch = <int, Color>{};
  final int r = color.red, g = color.green, b = color.blue;

  for (int i = 1; i < 10; i++) {
    strengths.add(0.1 * i);
  }
  strengths.forEach((strength) {
    final double ds = 0.5 - strength;
    swatch[(strength * 1000).round()] = Color.fromRGBO(
      r + ((ds < 0 ? r : (255 - r)) * ds).round(),
      g + ((ds < 0 ? g : (255 - g)) * ds).round(),
      b + ((ds < 0 ? b : (255 - b)) * ds).round(),
      1,
    );
  });
  return MaterialColor(color.value, swatch);
}
import 'logger.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:intl/intl.dart';

void openLogPage(BuildContext context, Logger logger) {
  Navigator.push(
    context,
    MaterialPageRoute(
      builder: (context) => LogPage(
        logger: logger,
      ),
    ),
  );
}

class LogPage extends StatefulWidget {
  final Logger logger;
  final double textSize;
  LogPage({Key key, this.logger, this.textSize = 20}) : super(key: key);

  @override
  _LogPageState createState() => _LogPageState();
}

class _Log


-webkit- -moz- -o- -ms- ".split(" "),E="Webkit Moz O ms",S=E.split(" "),k=E.toLowerCase().split(" "),T={svg:"http://www.w3.org/2000/svg"},M={},A={},D={},I=[],R=I.slice,O=function(e,n,r,i){var o,a,s,u,c=t.createElement("div"),l=t.body,p=l||t.createElement("body");if(parseInt(r,10))for(;r--;)s=t.createElement("div"),s.id=i?i[r]:v+(r+1),c.appendChild(s);return o=["",'<style id="s',v,'">',e,"</style>"].join(""),c.id=v,(l?c:p).innerHTML+=o,p.appendChild(c),l||(p.style.background="",p.style.overflow="hidden",u=m.style.overflow,m.style.overflow="hidden",m.appendChild(p)),a=n(c,e),l?c.parentNode.removeChild(c):(p.parentNode.removeChild(p),m.style.overflow=u),!!a},N=function(){function e(e,i){i=i||t.createElement(r[e]||"div"),e="on"+e;var a=e in i;return a||(i.setAttribute||(i=t.createElement("div")),i.setAttribute&&i.removeAttribute&&(i.setAttribute(e,""),a=o(i[e],"function"),o(i[e],"undefined")||(i[e]=n),i.removeAttribute(e))),i=null,a}var r={select:"input",change:"input",submit:"form",reset:"form",error:"img",load:"img",abort:"img"};return e}(),P={}.hasOwnProperty;f=o(P,"undefined")||o(P.call,"undefined")?function(e,t){return t in e&&o(e.constructor.prototype[t],"undefined")}:function(e,t){return P.call(e,t)},Function.prototype.bind||(Function.prototype.bind=function(e){var t=this;if("function"!=typeof t)throw new TypeError;var n=R.call(arguments,1),r=function(){if(this instanceof r){var i=function(){};i.prototype=t.prototype;var o=new i,a=t.apply(o,n.concat(R.call(arguments)));return Object(a)===a?a:o}return t.apply(e,n.concat(R.call(arguments)))};return r}),M.flexbox=function(){return c("flexWrap")},M.flexboxlegacy=function(){return c("boxDirection")},M.canvas=function(){var e=t.createElement("canvas");return!!e.getContext&&!!e.getContext("2d")},M.canvastext=function(){return!!d.canvas&&!!o(t.createElement("canvas").getContext("2d").fillText,"function")},M.webgl=function(){return!!e.WebGLRenderingContext},M.touch=function(){var n;return"ontouchstart"in e||e.DocumentTouch&&t instanceof DocumentTouch?n=!0:O(["@media (",_.join("touch-enabled),("),v,")","{#modernizr{top:9px;position:absolute}}"].join(""),function(e){n=9===e.offsetTop}),n},M.geolocation=function(){return"geolocation"in navigator},M.postmessage=function(){return!!e.postMessage},M.websqldatabase=function(){return!!e.openDatabase},M.indexedDB=function(){return!!c("indexedDB",e)},M.hashchange=function(){return N("hashchange",e)&&(t.documentMode===n||t.documentMode>7)},M.history=function(){return!!e.history&&!!history.pushState},M.draganddrop=function(){var e=t.createElement("div");return"draggable"in e||"ondragstart"in e&&"ondrop"


进而完全控制Zabbix实例，导致敏感监控数据和连接系统的泄露。

Qualys公司对于该漏洞进行分析，指出利用这个漏洞可能允许攻击者提升权限并获得对易受攻击的Zabbix服务器的完全控制，且目前已经发现，有超过83000个暴露在互联网上的Zabbix服务器。

漏洞具体信息如下：
### 漏洞等级

**高危**
### 受影响版本

**目前受影响的Zabbix版本：**

**6.0.0 <= Zabbix < 6.0.32rc1**

**6.4.0 <= Zabbix < 6.4.17rc1**

**Zabbix 7.0.0**
### 修复方案

目前官方已发布新版本修复该漏洞，建议受影响用户升级到Zabbix 6.0.32rc1、Zabbix 6.4.17rc1、Zabbix 7.0.1rc1或更高版本。官网地址：https://www.zabbix.com/download

尽管关于CVE-2024-42327的咨询仅在上周发布，但包含该问题补丁的版本6.0.32rc1、6.4.17rc1和7.0.1rc1已于7月发布。这些修补版本还解决了另外一个漏洞，编号为CVE-2024-36466（CVSS评分为8.8）。该漏洞存在认证绕过问题，可能允许攻击者签署伪造的zbx_session cookie并以管理员权限登录。

Zabbix版本7.0.1rc1还修复了CVE-2024-36462，这是一个不受控制的资源消耗漏洞，可能允许攻击者造成拒绝服务（DoS）状态。目前没有发现该漏洞被公开利用的情况，强烈建议用户尽快安全最新版本，以修复上述漏洞。

参考来源：https://www.securityweek.com/critical-vulnerability-found-in-zabbix-network-monitoring-tool/

![](https://mmbiz.qpic.cn/sz_mmbiz_png/PZibWfCgzicQNbU68NXCNH8sw9R1wBYiaT6icvH7moZbnkDB7UPWcP57YnEr5sDNDh6pssbCmuxvzQERZeMhN6Dknw/640?wx_fmt=png "")

天唯科技专注于大型组织信息安全领域及IT基础设施解决方案的规划、建设与持续运维服务。帮助客户提高IT基础设施及信息安全管控水平和安全运营能力，使客户在激烈的市场环境中保持竞争力。

我们一直秉承“精兵强将，专业专注”的发展理念。
先后在江门、深圳成立分公司，在武汉、长沙成立办事处以及成立广州的服务支撑中心。公司已


delete(Wrap_UIListBoxSerializeHandler* obj)
{
    LNRB_SAFE_UNREGISTER_WRAPPER_OBJECT(obj->handle);
    delete obj;
}

static void LNUIListBoxSerializeHandler_mark(Wrap_UIListBoxSerializeHandler* obj)
{

rb_gc_mark(obj->m_proc);

}

static VALUE LNUIListBoxSerializeHandler_allocate(VALUE klass)
{
    VALUE obj;
    Wrap_UIListBoxSerializeHandler* internalObj;

    internalObj = new Wrap_UIListBoxSerializeHandler();
    if (internalObj == NULL) rb_raise(LuminoRubyRuntimeManager::instance->luminoModule(), "Faild alloc - LNUIListBoxSerializeHandler_allocate");
    obj = Data_Wrap_Struct(klass, LNUIListBoxSerializeHandler_mark, LNUIListBoxSerializeHandler_delete, internalObj);

    return obj;
}

static VALUE LNUIListBoxSerializeHandler_allocateForGetObject(VALUE klass, LNHandle handle)
{
    VALUE obj;
    Wrap_UIListBoxSerializeHandler* internalObj;

    internalObj = new Wrap_UIListBoxSerializeHandler();
    if (internalObj == NULL) rb_raise(LuminoRubyRuntimeManager::instance->luminoModule(), "Faild alloc - LNUIListBoxSerializeHandler_allocate");
    obj = Data_Wrap_Struct(klass, LNUIListBoxSerializeHandler_mark, LNUIListBoxSerializeHandler_delete, internalObj);

    internalObj->handle = handle;
    return obj;
}

static LNResult Wrap_LNUIListBoxSerializeHandler_OnSerialize_ProcCaller(LNHandle uilistboxserializehandler, LNHandle self, LNHandle ar)
{
    Wrap_UIListBoxSerializeHandler* selfObj;
    Data_Get_Struct(LNRB_HANDLE_WRAP_TO_VALUE(uilistboxserializehandler), Wrap_UIListBoxSerializeHandler, selfObj);
    VALUE retval = rb_funcall(selfObj->m_proc, rb_intern("call"), 2, LNRB_HANDLE_WRAP_TO_VALUE(self), LNRB_HANDLE_WRAP_TO_VALUE(ar));
    return LN_OK;	// TODO: error handling.
}

static VALUE Wrap_LNUIListBoxSerializeHandler_Create(int argc, VALUE* argv, VALUE self)
{
    Wrap_UIListBoxSerializeHandler* selfObj;
    Data_Get_Struct(self, Wrap_UIListBoxSerializeHandler, selfObj);
    if (0 <= argc && argc <= 1) {
        VALUE proc, block;
        rb_scan_args(argc, argv, "01&", &proc, &block); // (handler=nil, &block)
        if (proc != Qnil) selfObj->m_proc = proc;
        if (block != Qnil) selfObj->m_proc = block;
        LNResult result = LNUIListBoxSerializeHandler_Create(Wrap_LNUIListBoxSerializeHandler_OnSerialize_ProcCaller, &selfObj->handle);
        if (result < 0) rb_raise(rb_eRuntimeError, "Lumino runtime error. (%d)\n%s", result, LNRuntime_GetLastErrorMessage());
        LuminoRubyRuntimeManager::instance->registerWrapperObject(self, false);
        return Qnil;
    }
    rb_raise(rb_eArgError, "UIListBoxSerializeHandler::init - wrong argument type.");
    return Qnil;
}

//==============================================================================
// UIListItemSerializeHandler

struct Wrap_UIListItemSerializeHandler
    : public Wrap_RubyObject
{

    VALUE m_proc = Qnil;
    Wrap_UIListItemSerializeHandler()
    {}
};

static void LNUIListItemSerializeHandler_delete(Wrap_UIListItemSerializeHandler* obj)
{
    LNRB_SAFE_UNREGISTER_WRAPPER_OBJECT(obj->handle);
    delete obj;
}

static void LNUIListItemSerializeHandler_mark(Wrap_UIListItemSerializeHan


tly_rounded_divide_sqrt
  };
}

HIPSYCL_SPECIALIZE_GET_INFO(device, name)
{
  return get_rt_device()->get_device_name();
}

HIPSYCL_SPECIALIZE_GET_INFO(device, global_mem_cache_type)
{
  if (!get_rt_device()->has(rt::device_support_aspect::global_mem_cache))
    return info::global_mem_cache_type::none;
  if (get_rt_device()->has(
          rt::device_support_aspect::global_mem_cache_read_only))
    return info::global_mem_cache_type::read_only;
  else if (get_rt_device()->has(
          rt::device_support_aspect::global_mem_cache_read_write))
    return info::global_mem_cache_type::read_write;

  return info::global_mem_cache_type::none;
}

HIPSYCL_SPECIALIZE_GET_INFO(device, global_mem_cache_line_size) {
  return get_rt_device()->get_property(
      rt::device_uint_property::global_mem_cache_line_size);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, global_mem_cache_size)
{
  return get_rt_device()->get_property(
      rt::device_uint_property::global_mem_cache_size);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, global_mem_size)
{
  return get_rt_device()->get_property(
      rt::device_uint_property::global_mem_size);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, max_constant_buffer_size)
{
  return get_rt_device()->get_property(
      rt::device_uint_property::max_constant_buffer_size);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, max_constant_args) {
  return get_rt_device()->get_property(
      rt::device_uint_property::max_constant_args);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, local_mem_type) {
  if (get_rt_device()->has(rt::device_support_aspect::emulated_local_memory)) {
    return info::local_mem_type::global;
  } else {
    return info::local_mem_type::local;
  }
}

HIPSYCL_SPECIALIZE_GET_INFO(device, local_mem_size)
{
  return get_rt_device()->get_property(
      rt::device_uint_property::local_mem_size);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, error_correction_support) {
  return get_rt_device()->has(rt::device_support_aspect::error_correction);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, host_unified_memory) {
  return get_rt_device()->has(rt::device_support_aspect::host_unified_memory);
}

HIPSYCL_SPECIALIZE_GET_INFO(device, profiling_timer_resolution)
{ return 1; }

HIPSYCL_SPECIALIZE_GET_INFO(device, is_endian_little)
{ return get_rt_device()->has(rt::device_support_aspect::little_endian); }

HIPSYCL_SPECIALIZE_GET_INFO(device, is_available)
{ return true; }

HIPSYCL_SPECIALIZE_GET_INFO(device, is_compiler_available)
{ return true; }

HIPSYCL_SPECIALIZE_GET_INFO(device, is_linker_available)
{ return true; }

HIPSYCL_SPECIALIZE_GET_INFO(device, execution_capabilities)
{
  return std::vector<info::execution_capability