/* Copyright (C) 2006 Charlie C
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
*    claim that you wrote the original software. If you use this software
*    in a product, an acknowledgment in the product documentation would be
*    appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
*    misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
// Auto generated from makesdna dna.c
#ifndef __BLENDER_RCTF__H__
#define __BLENDER_RCTF__H__

// -------------------------------------------------- //
#include "blender_Common.h"

namespace Blender {

    // ---------------------------------------------- //
    class rctf
    {
    public:
        float xmin;
        float xmax;
        float ymin;
        float ymax;
    };
}

#endif//__BLENDER_RCTF__H__


 n / 2; i++) {
    cosTable[i] = Math.cos((2 * Math.PI * i) / n);
    sinTable[i] = Math.sin((2 * Math.PI * i) / n);
  }

  // Bit-reversed addressing permutation
  for (let i = 0; i < n; i++) {
    const j = reverseBits(i, levels);
    if (j > i) {
      let temp = real[i];
      real[i] = real[j];
      real[j] = temp;
      temp = imag[i];
      imag[i] = imag[j];
      imag[j] = temp;
    }
  }

  // Cooley-Tukey decimation-in-time radix-2 FFT
  for (let size = 2; size <= n; size *= 2) {
    const halfsize = size / 2;
    const tablestep = n / size;
    for (let i = 0; i < n; i += size) {
      for (let j = i, k = 0; j < i + halfsize; j++, k += tablestep) {
        const tpre = real[j + halfsize] * cosTable[k] + imag[j + halfsize] * sinTable[k];
        const tpim = -real[j + halfsize] * sinTable[k] + imag[j + halfsize] * cosTable[k];
        real[j + halfsize] = real[j] - tpre;
        imag[j + halfsize] = imag[j] - tpim;
        real[j] += tpre;
        imag[j] += tpim;
      }
    }
  }
}

// Returns the integer whose value is the reverse of the lowest 'bits' bits of the integer 'x'.
function reverseBits(x: number, bits: number): number {
  let y = 0;
  for (let i = 0; i < bits; i++) {
    y = (y << 1) | (x & 1);
    x >>>= 1;
  }
  return y;
}

/*
 * Computes the discrete Fourier transform (DFT) of the given complex vector, storing the result back into the vector.
 * The vector can have any length. This requires the convolution function, which in turn requires the radix-2 FFT function.
 * Uses Bluestein's chirp z-transform algorithm.
 */
function transformBluestein(real: number[], imag: number[]) {
  // Find a power-of-2 convolution length m such that m >= n * 2 + 1
  if (real.length != imag.length) throw 'Mismatched lengths';
  const n = real.length;
  let m = 1;
  while (m < n * 2 + 1) m *= 2;

  // Trignometric tables
  const cosTable = new Array(n);
  const sinTable = new Array(n);
  for (let i = 0; i < n; i++) {
    const j = (i * i) % (n * 2); // This is more accurate than j = i * i
    cosTable[i] = Math.cos((Math.PI * j) / n);
    sinTable[i] = Math.sin((Math.PI * j) / n);
  }

  // Temporary vectors and preprocessing
  const areal = new Array(m);
  const aimag = new Array(m);
  for (let i = 0; i < n; i++) {
    areal[i] = real[i] * cosTable[i] + imag[i] * sinTable[i];
    aimag[i] = -real[i] * sinTable[i] + imag[i] * cosTable[i];
  }
  for (let i = n; i < m; i++) areal[i] = aimag[i] = 0;
  const breal = new Array(m);
  const bimag = new Array(m);
  breal[0] = cosTable[0];
  bimag[0] = sinTable[0];
  for (let i = 1; i < n; i++) {
    breal[i] = breal[m - i] = cosTable[i];
    bimag[i] = bimag[m - i] = sinTable[i];
  }
  for (let i = n; i <= m - n; i++) breal[


 ease,
			max-height 0.2s ease,
			visibility 0.2s ease,
			opacity 0.2s ease;
	}
	#nav-item-search,
	#nav-item-login {
		visibility: visible;
	}
	#primary-bar.engaged,
	#secondary-bar.engaged #nav-item-archive,
	#secondary-bar.engaged #nav-item-sequences,
	#secondary-bar.engaged #nav-item-about,
	.page-toolbar.engaged {
		visibility: visible;
		max-height: 1000px;
	}
	#primary-bar.engaged,
	#secondary-bar.engaged #nav-item-archive,
	#secondary-bar.engaged #nav-item-sequences,
	#secondary-bar.engaged #nav-item-about,
	.page-toolbar.engaged {
		opacity: 1.0;
	}
	#primary-bar.engaged {
		top: 0;
	}
	#secondary-bar.engaged #nav-item-archive {
		top: 196px;
	}
	#secondary-bar.engaged #nav-item-sequences {
		top: 230px;
	}
	#secondary-bar.engaged #nav-item-about {
		top: 264px;
	}
	.page-toolbar.engaged {
		top: 314px;
	}

	#post-nav-ui-toggle {
		bottom: 10px;
		right: -30px;
	}
	#content.comment-thread-page ~ #ui-elements-container #post-nav-ui-toggle {
		right: -54px;
	}
	#post-nav-ui-toggle button.engaged {
		transform: rotate(-90deg);
	}

	#quick-nav-ui,
	#new-comment-nav-ui,
	#hns-date-picker {
		bottom: 0;
		max-height: 0px;
		opacity: 0.0;
		transition:
			bottom 0.2s ease,
			max-height 0.2s ease,
			opacity 0.2s ease,
			visibility 0.2s ease;
	}
	#quick-nav-ui.engaged,
	#new-comment-nav-ui.engaged,
	#hns-date-picker.engaged {
		visibility: visible;
		max-height: 1000px;
		opacity: 1.0;
	}

	#quick-nav-ui {
		right: -24px;
	}
	#content.post-page ~ #ui-elements-container #quick-nav-ui {
		right: -48px;
	}
	#quick-nav-ui.engaged {
		bottom: 64px;
	}
	#quick-nav-ui a {
		font-weight: 400;
	}

	#new-comment-nav-ui {
		right: -49px;
	}
	#new-comment-nav-ui.engaged {
		bottom: 216px;
	}

	#hns-date-picker {
		right: -186px;
	}
	#hns-date-picker.engaged {
		bottom: 247px;
	}
	@media only screen and (max-width: 1440px) {
		#hns-date-picker {
			background-color: rgba(255,255,255,0.95);
			right: -18px;
		}
		#hns-date-picker::before {
			display: none;
		}
		#hns-date-picker input {
			background-color: #fff;
		}
		#hns-date-picker span {
			text-shadow:
				0 0 1px #fff,
				0 0 3px #fff,
				0 0 5px #fff,
				0 0 8px #fff,
				0 0 13px #fff,
				0 0 21px #fff;
		}
		#hns-date-picker.engaged {
			bottom: 238px;
		}
	}

	#appearance-adjust-ui-toggle {
		bottom: 10px;
		left: 10px;
	}
	#appearance-adjust-ui-toggle button.en


  ((x) == TPM0 ? (6) : \
    ((x) == TPM1 ? (2) : \
    ((x) == TPM2 ? (2) : (-1))))
/* @brief Has counter reset by the selected input capture event (register bits C0SC[ICRST], C1SC[ICRST], ...). */
#define FSL_FEATURE_TPM_HAS_COUNTER_RESET_BY_CAPTURE_EVENT (0)
/* @brief Has TPM_PARAM. */
#define FSL_FEATURE_TPM_HAS_PARAM (1)
/* @brief Has TPM_VERID. */
#define FSL_FEATURE_TPM_HAS_VERID (1)
/* @brief Has TPM_GLOBAL. */
#define FSL_FEATURE_TPM_HAS_GLOBAL (1)
/* @brief Has TPM_TRIG. */
#define FSL_FEATURE_TPM_HAS_TRIG (1)
/* @brief Has counter pause on trigger. */
#define FSL_FEATURE_TPM_HAS_PAUSE_COUNTER_ON_TRIGGER (1)
/* @brief Has external trigger selection. */
#define FSL_FEATURE_TPM_HAS_EXTERNAL_TRIGGER_SELECTION (1)
/* @brief Has TPM_COMBINE. */
#define FSL_FEATURE_TPM_HAS_COMBINE (1)
/* @brief Has TPM_POL. */
#define FSL_FEATURE_TPM_HAS_POL (1)
/* @brief Has TPM_FILTER. */
#define FSL_FEATURE_TPM_HAS_FILTER (1)
/* @brief Has TPM_QDCTRL. */
#define FSL_FEATURE_TPM_HAS_QDCTRL (1)

/* TSI module features */

/* @brief TSI module version. */
#define FSL_FEATURE_TSI_VERSION (4)
/* @brief Has end-of-scan DMA transfer request enable (register bit GENCS[EOSDMEO]). */
#define FSL_FEATURE_TSI_HAS_END_OF_SCAN_DMA_ENABLE (1)
/* @brief Number of TSI channels. */
#define FSL_FEATURE_TSI_CHANNEL_COUNT (16)

/* USB module features */

/* @brief HOST mode enabled */
#define FSL_FEATURE_USB_KHCI_HOST_ENABLED (1)
/* @brief OTG mode enabled */
#define FSL_FEATURE_USB_KHCI_OTG_ENABLED (1)
/* @brief Size of the USB dedicated RAM */
#define FSL_FEATURE_USB_KHCI_USB_RAM (2048)
/* @brief Base address of the USB dedicated RAM */
#define FSL_FEATURE_USB_KHCI_USB_RAM_BASE_ADDRESS (1074790400)
/* @brief Has KEEP_ALIVE_CTRL register */
#define FSL_FEATURE_USB_KHCI_KEEP_ALIVE_ENABLED (0)
/* @brief Has the Dynamic SOF threshold compare support */
#define FSL_FEATURE_USB_KHCI_DYNAMIC_SOF_THRESHOLD_COMPARE_ENABLED (1)
/* @brief Has the VBUS detect support */
#define FSL_FEATURE_USB_KHCI_VBUS_DETECT_ENABLED (1)
/* @brief Has the IRC48M module clock support */
#define FSL_FEATURE_USB_KHCI_IRC48M_MODULE_CLOCK_ENABLED (0)
/* @brief Number of endpoints supported */
#define FSL_FEATURE_USB_ENDPT_COUNT (16)

/* VREF module features */

/* @brief Has chop oscillator (bit TRM[CHOPEN]) */
#define FSL_FEATURE_VREF_HAS_CHOP_OSC (1)
/* @brief Has second order curvature compensation (bit SC[ICOMPEN]) */
#define FSL_FEATURE_VREF_HAS_COMPENSATION (1)
/* @brief If high/low buffer mode supported */
#define FSL_FEATURE_VREF_MODE_LV_TYPE (1)
/* @brief Module has also low reference (registers VREFL/VREFH) */
#define FSL_FEATURE_VREF_HAS_LOW_REFERENCE (0)
/* @brief Has VREF_TRM4. */
#define FSL_FEATURE_VREF_HAS_TRM4 (1)

/* WDOG module features */

/* @brief Watchdog is available. */
#define FSL_FEATURE_WDOG_HAS_WATCHDOG (1)
/* @brief WDOG_CNT can be 32-bit written. */
#define FSL_FEATURE_WDOG_HAS_32BIT_ACCESS (1)

#endif /* _MKL28Z7_FEATURES_H_ */


}",
                "package pc3; public class CC3 { }");

        javadoc("-d", base.resolve("out").toString(),
                "--frames",
                "--module-source-path", src.toString(),
                "-group", "abc < & > def", "ma",
                "--module", "ma,mb,mc");

        checkExit(Exit.OK);

        checkOutput("overview-summary.html", true,
                "abc < & > def",
                ",\"abc < & > def\"],");
    }
}

/*
 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug      8202947
 * @summary  test the at-version tag, and corresponding option
 * @library  /tools/lib ../lib
 * @modules jdk.javadoc/jdk.javadoc.internal.tool
 * @build    toolbox.ToolBox JavadocTester
 * @run main TestVersionTag
 */

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import toolbox.ToolBox;

public class TestVersionTag extends JavadocTester {

    public static void main(String... args) throws Exception {
        TestVersionTag tester = new TestVersionTag();
        tester.runTests();
    }

    ToolBox tb = new ToolBox();
    Path src;

    TestVersionTag() throws Exception {
        src = Files.createDirectories(Paths.get("src"));
        tb.writeJavaFiles(src,
                  "package pkg;\n"
                + "/** Introduction. \n"
                + " * @version 1.2.3\n"
                + " */\n"
                + "public class Test { }\n");
    }

    @Test
    void testVersion() {
        javadoc("-d", "out-version",
                "-sourcepath", src.toString(),
                "-version",
                "pkg");
        checkExit(Exit.OK);

        checkVersion(true);
    }

    @Test
    void testNoVersion() {
        javadoc("-d", "out-noversion",
                "-sourcepath", src.toString(),
                "pkg");
        checkExit(Exit.OK);

        checkVersion(false);
    }

    void checkVersion(boolean on) {
        checkOutput("pkg/Test.html", on,
                "
\n"
                + "
Version:
\n"
                + "
1.2.3
\n"
                + "
");
    }
}
/*
 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR


si tout va vien
change_ddir
	movem.l	d0-a5,-(sp)	;
	addq.l	#4,a0		;saute le mot de commande
	bsr	kill_space		;=> chemin dans la commande
	lea	ddrive(a6),a4	;drive destination
	moveq	#";",d0		;recherche le commentaire
	bsr	str_chc		;(si y'en a un !)
	bmi.s	cdd_0		;alors ??
	clr.b	0(a0,d0.w)		;y'en a un,on l'expulse
cdd_0	bsr	str_len		;longueur sans commentaires
	movea.l	a0,a1		;
	adda.w	d0,a1		;a1=fin de commande
	movea.l	a0,a2		;
	cmpi.b	#":",1(a2)		;changement de lecteur ?
	bne.s	cdd_bcl1		;non
	addq.l	#3,a2		;si,on garde le premier '\'
cdd_bcl1	cmpi.b	#"\",(a2)+		;cherche tous les sparateurs
	bne.s	cdd_1		;c'en est pas un
	clr.b	-1(a2)		;ben si,on saucissone la chaine
cdd_1	cmpa.l	a1,a2		;fin de chaine atteinte ?
	ble.s	cdd_bcl1		;non
cdd_bcl2	bsr.s	in_chg_ddir	;va dans le 1er dossier
	bne.s	cdd_end		;erreur
	bsr	next_str		;partie suivante du chemin
	cmpa.l	a1,a0		;fin de chaine atteinte ?
	blt.s	cdd_bcl2		;non,on boucle
	moveq	#0,d0		;force Z=1
cdd_end	movem.l	(sp)+,d0-a5
	rts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
in_chg_ddir			;En sortie,Z=1 si ok
	bsr.s	change_dir		;changement de dir.
	beq.s	icdd_end		;ok
	move.l	a0,-(sp)		;inexistant,essaye de le crer
	move.w	#$39,-(sp)		;Create Dir
	trap	#1
	addq.l	#2,sp
	movea.l	(sp)+,a0		;reprend A0
	bsr.s	change_dir		;maintenant on ouvre le disque
	beq.s	icdd_end		;ok
	movea.l	a0,a1		;non,prpare le texte d'erreur
	lea	mes18(pc),a0	;le chemin n'existe pas,et on
	bsr	print		;peut pas le creer.
	movea.l	a1,a0
	bsr	print
	moveq	#-1,d0		;force Z=0
icdd_end	rts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
change_sdir			;En sortie,Z=1 si ok
	movem.l	d0-a5,-(sp)
	addq.l	#4,a0		;saute le mot de commande
	bsr	kill_space		;=> chemin dans la commande
	lea	sdrive(a6),a4	;drive source
	bsr.s	change_dir		;appel de la fonction
	beq.s	csd_end


late-content .vendor-about-text{padding:30px 0}.bravo_wrap .page-template-content .vendor-about-text img{max-width:100%}.bravo_wrap .page-template-content .vendor-about-text .title{font-size:36px;font-weight:600;margin-bottom:30px}@media(max-width: 768px){.bravo_wrap .page-template-content .vendor-about-text .title{margin-bottom:15px;font-size:24px}}.bravo_wrap .page-template-content .vendor-about-text .desc{font-size:18px;line-height:36px}@media(max-width: 768px){.bravo_wrap .page-template-content .vendor-about-text .desc{margin-bottom:15px}}.bravo_wrap .page-template-content .vendor-about-text .go_to_faqs{margin-top:15px;display:inline-block;background:#54a79f;color:#fff;padding:8px 25px;border-radius:10px;font-size:16px;cursor:pointer}@media(max-width: 766px){.bravo_wrap .page-template-content .bravo-form-search-tour .text-heading{padding-left:0px}.bravo_wrap .page-template-content .bravo-form-search-tour .sub-heading{padding-left:0px}}#bravo_custom_tour_book_app .select2-container{width:100% !important}.bravo_wrap .page-template-content .bravo_form .g-button-submit button{margin-left:1px}body .bravo_wrap .bravo_detail_tour .bravo_content .g-term .item img{width:auto}@media(max-width: 1023px){.bravo_wrap .bravo_form .smart-search .bravo-autocomplete{left:0}body .bravo_wrap .bravo_search_tour .bravo-list-item .list-item .item-tour .info .duration{width:100% !important;float:none;text-align:center;align-items:center;color:#5e6d77;position:relative;top:5px;font-size:18px}body .bravo_wrap .bravo_search_tour .bravo-list-item .list-item .item-tour .info .g-price{width:100% !important;float:none;text-align:center}body .bravo_wrap .bravo_search_tour .bravo-list-item .list-item .item-tour .info{padding:10px !important;margin-top:10px}}body .bravo_wrap .bravo-checkbox input[type=checkbox]:checked+.checkmark:after{border:solid #54a79f;border-width:0 2px 2px 0}.availability-key{background-color:#a8b1b6;border:2px solid transparent;cursor:pointer}.availability-key.active,.availability-key:hover{border:2px solid #000}.availability-key.available{background-color:#54b5bc}.availability-key.takeaseat{background-color:#cd6c7f}.availability-key.other{background-color:#cc932c}.months-calendar .datepicker.datepicker-inline{width:auto}.months-calendar .datepicker.datepicker-inline .table-condensed{width:100%}.months-calendar .datepicker.datepicker-inline td,.months-calendar .datepicker.datepicker-inline th{height:30px}body .dates-calendar .fc-time-grid-event .fc-time{display:none}body .dates-calendar .fc-event{padding:0px;height:auto}body .bravo_wrap .bravo_detail_tour .bravo_content .g-faq2 .item{margin:15px 0}body .bravo_wrap .bravo_detail_tour .bravo_content .g-faq2 .item .desc{border:solid 1px #ccc;padding:10px;margin-top:10px}/*# sourceMappingURL=app.custom.css.map


/*
 * Copyright (c) International Business Machines Corp., 2006
 * Copyright (c) Nokia Corporation, 2006
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Author: Artem Bityutskiy (Битюцкий Артём)
 *
 * Jan 2007: Alexander Schmidt, hacked per-volume update.
 */

/*
 * This file contains implementation of the volume update and atomic LEB change
 * functionality.
 *
 * The update operation is based on the per-volume update marker which is
 * stored in the volume table. The update marker is set before the update
 * starts, and removed after the update has been finished. So if the update was
 * interrupted by an unclean re-boot or due to some other reasons, the update
 * marker stays on the flash media and UBI finds it when it attaches the MTD
 * device next time. If the update marker is set for a volume, the volume is
 * treated as damaged and most I/O operations are prohibited. Only a new update
 * operation is allowed.
 *
 * Note, in general it is possible to implement the update operation as a
 * transaction with a roll-back capability.
 */

#include <linux/err.h>
#include <linux/uaccess.h>
#include <linux/math64.h>
#include "ubi.h"

/**
 * set_update_marker - set update marker.
 * @ubi: UBI device description object
 * @vol: volume description object
 *
 * This function sets the update marker flag for volume @vol. Returns zero
 * in case of success and a negative error code in case of failure.
 */
static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol)
{
	int err;
	struct ubi_vtbl_record vtbl_rec;

	dbg_gen("set update marker for volume %d", vol->vol_id);

	if (vol->upd_marker) {
		ubi_assert(ubi->vtbl[vol->vol_id].upd_marker);
		dbg_gen("already set");
		return 0;
	}

	memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
	       sizeof(struct ubi_vtbl_record));
	vtbl_rec.upd_marker = 1;

	mutex_lock(&ubi->device_mutex);
	err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
	vol->upd_marker = 1;
	mutex_unlock(&ubi->device_mutex);
	return err;
}

/**
 * clear_update_marker - clear update marker.
 * @ubi: UBI device description object
 * @vol: volume description object
 * @bytes: new data size in bytes
 *
 * This function clears the update marker for volume @vol, sets new volume
 * data size and clears the "corrupted" flag (static volumes only). Returns
 * zero in case of success and a negative error code in case of failure.
 */
static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,
			       long long bytes)
{
	int err;
	struct ubi_vtbl_record vtbl_rec;

	dbg_gen("clear update marker for volume %d", vol->vol_id);

	memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
	       sizeof(struct ubi_vtbl_record));
	ubi_assert(vol->upd_marker && vtbl_rec.upd_marker);
	vtbl_rec.upd_marker = 0;

	if (vol->vol_type == UBI_STATIC_VOLUME) {
		vol->corrupted = 0;
		vol->used_bytes = bytes;
		vol->used_ebs = div_u64_rem(bytes, vol->usable_leb_size,
					    &vol->last_eb_bytes);
		if (vol->last_eb_bytes)
			vol->used_ebs += 1;
		else
			vol->last_eb_bytes = vol->usable_leb_size;
	}

	mutex_lock(&ubi->device_mutex);
	err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
	vol->upd_marker = 0;
	mutex_unlock(&ubi->device_mutex);
	return err;
}

/**
 * ubi_start_update - start volume update.
 * @ubi: UBI device description object
 * @vol: volume description object
 * @bytes: update bytes
 *
 * This function starts volume update operation. If @bytes is zero, the volume
 * is just wiped out. Returns zero in case of success and a negative error code
 * in case of failure.
 */
int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
		     long long bytes)
{
	int i, err;

	dbg_gen("start update of volume %d, %llu bytes", vol->vol_id, bytes);
	ubi_assert(!vol->updating && !vol->changing_leb);
	vol->updating = 1;

	err = set_update_marker(


// Optional parameters for the method 'DeleteSipAuthCallsCredentialListMapping'
type DeleteSipAuthCallsCredentialListMappingParams struct {
	// The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the CredentialListMapping resources to delete.
	PathAccountSid *string `json:"PathAccountSid,omitempty"`
}

func (params *DeleteSipAuthCallsCredentialListMappingParams) SetPathAccountSid(PathAccountSid string) *DeleteSipAuthCallsCredentialListMappingParams {
	params.PathAccountSid = &PathAccountSid
	return params
}

// Delete a credential list mapping from the requested domain
func (c *ApiService) DeleteSipAuthCallsCredentialListMapping(DomainSid string, Sid string, params *DeleteSipAuthCallsCredentialListMappingParams) error {
	path := "/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings/{Sid}.json"
	if params != nil && params.PathAccountSid != nil {
		path = strings.Replace(path, "{"+"AccountSid"+"}", *params.PathAccountSid, -1)
	} else {
		path = strings.Replace(path, "{"+"AccountSid"+"}", c.requestHandler.Client.AccountSid(), -1)
	}
	path = strings.Replace(path, "{"+"DomainSid"+"}", DomainSid, -1)
	path = strings.Replace(path, "{"+"Sid"+"}", Sid, -1)

	data := url.Values{}
	headers := map[string]interface{}{
		"Content-Type": "application/x-www-form-urlencoded",
	}

	resp, err := c.requestHandler.Delete(c.baseURL+path, data, headers)
	if err != nil {
		return err
	}

	defer resp.Body.Close()

	return nil
}

// Optional parameters for the method 'FetchSipAuthCallsCredentialListMapping'
type FetchSipAuthCallsCredentialListMappingParams struct {
	// The SID of the [Account](https://www.twilio.com/docs/iam/api/account) that created the CredentialListMapping resource to fetch.
	PathAccountSid *string `json:"PathAccountSid,omitempty"`
}

func (params *FetchSipAuthCallsCredentialListMappingParams) SetPathAccountSid(PathAccountSid string) *FetchSipAuthCallsCredentialListMappingParams {
	params.PathAccountSid = &PathAccountSid
	return params
}

// Fetch a specific instance of a credential list mapping
func (c *ApiService) FetchSipAuthCallsCredentialListMapping(DomainSid string, Sid string, params *FetchSipAuthCallsCredentialListMappingParams) (*ApiV2010SipAuthCallsCredentialListMapping, error) {
	path := "/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings/{Sid}.json"
	if params != nil && params.PathAccountSid != nil {
		path = strings.Replace(path, "{"+"AccountSid"+"}", *params.PathAccountSid, -1)
	} else {
		path = strings.Replace(path, "{"+"AccountSid"+"}", c.requestHandler.Client.AccountSid(), -1)
	}
	path = strings.Replace(path, "{"+"DomainSid"+"}", DomainSid, -1)
	path = strings.Replace(path, "{"+"Sid"+"}", Sid, -1)

	data := url.Values{}
	headers := map[string]interface{}{
		"Content-Type": "application/x-www-form-urlencoded",
	}

	resp, err := c.requestHandler.Get(c.baseURL+path, data, headers)
	if err != nil {
		return nil, err
	}

	defer resp.Body.Close()

	ps := &ApiV2010SipAuthCallsCredentialListMapping{}
	if err := json.NewDecoder(resp.Body).Decode(p


，`this`有时候会指向全局对象，这甚至也可以归结为语言层面的bug之一。ES6的箭头函数优化了这一点，它的内部没有自己的`this`,这也就导致了`this`总是指向上一层的`this`，如果上一层还是箭头函数，则继续向上指，直到指向到有自己`this`的函数为止，并作为自己的`this`
- 箭头函数不能用作构造函数，因为它没有自己的`this`，无法实例化
- 也是因为箭头函数没有自己的this,所以箭头函数 内也不存在`arguments`对象。（可以用扩展运算符代替）
- 函数默认赋值。`ES6`之前，函数的形参是无法给默认值得，只能在函数内部通过变通方法实现。`ES6`以更简洁更明确的方式进行函数默认赋值

```js
function es6Fuc (x, y = 'default') {
    console.log(x, y);
}
es6Fuc(4) // 4, default
```

**升级部分**

> ES6新增了双冒号运算符，用来取代以往的`bind`，`call`,和`apply`。(浏览器暂不支持，`Babel`已经支持转码)

```js
foo::bar;
// 等同于
bar.bind(foo);

foo::bar(...arguments);
// 等同于
bar.apply(foo, arguments);
```

### 9、Symbol是什么，有什么作用？

> `Symbol`是`ES6`引入的第七种原始数据类型（说法不准确，应该是第七种数据类型，Object不是原始数据类型之一，已更正），所有Symbol()生成的值都是独一无二的，可以从根本上解决对象属性太多导致属性名冲突覆盖的问题。对象中`Symbol()`属性不能被`for...in`遍历，但是也不是私有属性

### 10、Set是什么，有什么作用？

> `Set`是`ES6`引入的一种类似`Array`的新的数据结构，`Set`实例的成员类似于数组`item`成员，区别是`Set`实例的成员都是唯一，不重复的。这个特性可以轻松地实现数组去重

### 11、Map是什么，有什么作用？

> `Map`是`ES6`引入的一种类似`Object`的新的数据结构，`Map`可以理解为是`Object`的超集，打破了以传统键值对形式定义对象，对象的`key`不再局限于字符串，也可以是`Object`。可以更加全面的描述对象的属性

### 12、Proxy是什么，有什么作用？

> `Proxy`是`ES6`新增的一个构造函数，可以理解为JS语言的一个代理，用来改变JS默认的一些语言行为，包括拦截默认的`get/set`等底层方法，使得JS的使用自由度更高，可以最大限度的满足开发者的需求。比如通过拦截对象的`get/set`方法，可以轻松地定制自己想要的`key`或者`value`。下面的例子可以看到，随便定义一个`myOwnObj`的`key`,都可以变成自己想要的函数`

```js
function createMyOwnObj() {
  //想把所有的key都变成函数，或者Promise,或者anything
  return new Proxy({


he [`models.py`](google_takeout_parser/models.py), to filter to a particular type you can provide that to skip parsing other files:

```python
from google_takeout_parser.models import Location
from google_takeout_parser.path_dispatch import TakeoutParser
# filter_type can be a list to filter multiple types
locations = list(TakeoutParser("path/to/Takeout").parse(filter_type=Location))
len(locations)
99913
```

I personally exclusively use this through the [HPI google takeout](https://github.com/karlicoss/HPI/blob/master/my/google/takeout/parser.py) file, as a configuration layer to locate where my takeouts are on disk, and since that 'automatically' unzips the takeouts (I store them as the zips), i.e., doesn't require me to maintain an unpacked view

#### Youtube Comment JSON

The CSV youtube comment files' content are stored as a JSON blob, which look like:

```json
{
  "takeoutSegments": [
    {
      "text": "I symlink /bin/sh to dash, its a very minimal/posix compliant implementation. see "
    },
    {
      "text": "https://wiki.archlinux.org/index.php/Dash",
      "link": {
        "linkUrl": "https://wiki.archlinux.org/index.php/Dash"
      }
    }
  ]
}
```

This exposes some functions to help parse those, into text, markdown, or just extract the links:

```python
from google_takeout_parser.path_dispatch import TakeoutParser
from google_takeout_parser.models import CSVYoutubeComment
from google_takeout_parser.parse_csv import extract_comment_links, reconstruct_comment_content

path = "./Takeout-1599315526"
comments = list(
    TakeoutParser(path, error_policy="raise").parse(
        cache=False, filter_type=CSVYoutubeComment
    )
)
for e in comments:
    print(extract_comment_links(e.contentJSON))
    print(reconstruct_comment_content(e.contentJSON, "text"))
    print(reconstruct_comment_content(e.contentJSON, "markdown"))
```

### Legacy HTML Parsing

I would _heavily recommend against_ using the HTML format for `My Activity`. It is not always possible to properly parse the metadata, is more prone to errors parsing dates due to local timezones, and takes much longer to parse than the JSON format.

On certain machines, the giant HTML files may even take so much memory that the process is eventually killed for using too much memory. For a workaround, see [split_html](./split_html).

### Contributing

Just to give a brief overview, to add new functionality (parsing some new folder that this doesn't currently support), you'd need to:

- Add a `model` for it in [`models.py`](google_takeout_parser/models.py) subclassing `BaseEvent` and adding it to the Union at the bottom of the file. That should have a [`key` property function](https://github.com/purarue/google_takeout_parser/blob/a8aefac76d8e1474ca2275b4a7c78bbb962c7a04/google_takeout_parser/models.py#L185-L187) which describes each event uniquely (this is used to remove duplicate items when merging takeouts)
- Write a function which takes the `Path` to the file you're trying to parse and converts it to the model you created (See examples in [`parse_json.py`](google_takeout_parser/parse_json.py)). Ideally extract a single raw item from the takeout file add a test for it so its obvious when/if the format changes.
- Add a regex match for the file path to the handler map in [`google_takeout_parser/locales/


// TODO: find something to do with this information
		}

		[ClientPacketHandler(RealmServerOpCode.MSG_MOVE_TELEPORT_ACK)]
		public static void HandlerTeleportAck(IRealmClient client, RealmPacketIn packet)
		{
			var teleporteeId = packet.ReadPackedEntityId();
			var flags = packet.ReadUInt32();
			var time = packet.ReadUInt32();

			var chr = client.ActiveCharacter;
			var teleportee = chr.Map.GetObject(teleporteeId) as Character;

			// TODO: find something to do with this information.
		}
		#endregion

		public static void SendEnterTransport(Unit unit)
		{
			var transport = unit.TransportInfo;
			SendMonsterMoveTransport(unit, transport.Position - unit.Position, unit.TransportPosition);
		}

		public static void SendLeaveTransport(Unit unit)
		{
			var transport = unit.TransportInfo;
			SendMonsterMoveTransport(unit, unit.TransportPosition, transport.Position);
		}

		/// <summary>
		/// Move from current position  to
		/// new position on the Transport (relative to transport)
		/// </summary>
		/// <param name="unit"></param>
		public static void SendMonsterMoveTransport(Unit unit, Vector3 from, Vector3 to)
		{
			if (!unit.IsAreaActive)
			{
				return;
			}
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_MONSTER_MOVE_TRANSPORT))
			{
				var transport = unit.TransportInfo;

				unit.EntityId.WritePacked(packet);
				transport.EntityId.WritePacked(packet);
				packet.Write((ushort)0);				// unknown flags
				packet.Write(from);
				packet.Write(Utility.GetSystemTime());
				if (unit is Character)
				{
					packet.Write((byte) MovementState.WalkOnLand);
					packet.Write(unit.TransportOrientation);
					packet.Write((uint) MonsterMoveFlags.Flag_0x800000);
				}
				else
				{
					packet.Write((byte)0);
					packet.Write((uint) MonsterMoveFlags.Walk);
				}
				packet.Write(0);
				packet.Write(1);
				packet.Write(to);

				unit.SendPacketToArea(packet);
			}
		}

		/// <summary>
		/// Jumping while not moving when mounted
		/// </summary>
		[ClientPacketHandler(RealmServerOpCode.CMSG_MOUNTSPECIAL_ANIM)]
		public static void HandleMountSpecialAnim(IRealmClient client, RealmPacketIn packet)
		{
			var chr = client.ActiveCharacter;
			if (chr.MoveControl.Mover is Unit && ((Unit)chr.MoveControl.Mover).IsMounted)
			{
				SendMountSpecialAnim(client);
			}
		}

		public static void SendMountSpecialAnim(IRealmClient client)
		{
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_MOUNTSPECIAL_ANIM, 8))
			{
				client.ActiveCharacter.EntityId.WritePacked(packet);
				client.ActiveCharacter.SendPacketToArea(packet, false);
			}
		}

		#region SEND
		public static void SendMoveToPacket(Unit movingUnit, ref Vector3 pos, float orientation, uint moveTime, MonsterMoveFlags moveFlags)
		{
			if (!movingUnit.IsAreaActive && movingUnit.CharacterMaster == null)
			{
				return;
			}
			//log.Debug("Monster Move: O={0}, Time={1}, Flags={2}, Pos={3}", orientation, moveTime, moveFlags, pos);
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_MONSTER_MOVE, 53))
			{
				movingUnit.EntityId.WritePacked(packet);			// 8
				packet.Write((byte)0);
				packet.Write(m


device_pixel_ratio),u_units_to_pixels:new t.aO(ze,L.u_units_to_pixels),u_image:new t.aH(ze,L.u_image),u_image_height:new t.aI(ze,L.u_image_height)}),linePattern:(ze,L)=>({u_matrix:new t.aJ(ze,L.u_matrix),u_texsize:new t.aO(ze,L.u_texsize),u_ratio:new t.aI(ze,L.u_ratio),u_device_pixel_ratio:new t.aI(ze,L.u_device_pixel_ratio),u_image:new t.aH(ze,L.u_image),u_units_to_pixels:new t.aO(ze,L.u_units_to_pixels),u_scale:new t.aN(ze,L.u_scale),u_fade:new t.aI(ze,L.u_fade)}),lineSDF:(ze,L)=>({u_matrix:new t.aJ(ze,L.u_matrix),u_ratio:new t.aI(ze,L.u_ratio),u_device_pixel_ratio:new t.aI(ze,L.u_device_pixel_ratio),u_units_to_pixels:new t.aO(ze,L.u_units_to_pixels),u_patternscale_a:new t.aO(ze,L.u_patternscale_a),u_patternscale_b:new t.aO(ze,L.u_patternscale_b),u_sdfgamma:new t.aI(ze,L.u_sdfgamma),u_image:new t.aH(ze,L.u_image),u_tex_y_a:new t.aI(ze,L.u_tex_y_a),u_tex_y_b:new t.aI(ze,L.u_tex_y_b),u_mix:new t.aI(ze,L.u_mix)}),raster:(ze,L)=>({u_matrix:new t.aJ(ze,L.u_matrix),u_tl_parent:new t.aO(ze,L.u_tl_parent),u_scale_parent:new t.aI(ze,L.u_scale_parent),u_buffer_scale:new t.aI(ze,L.u_buffer_scale),u_fade_t:new t.aI(ze,L.u_fade_t),u_opacity:new t.aI(ze,L.u_opacity),u_image0:new t.aH(ze,L.u_image0),u_image1:new t.aH(ze,L.u_image1),u_brightness_low:new t.aI(ze,L.u_brightness_low),u_brightness_high:new t.aI(ze,L.u_brightness_high),u_saturation_factor:new t.aI(ze,L.u_saturation_factor),u_contrast_factor:new t.aI(ze,L.u_contrast_factor),u_spin_weights:new t.aN(ze,L.u_spin_weights)}),symbolIcon:(ze,L)=>({u_is_size_zoom_constant:new t.aH(ze,L.u_is_size_zoom_constant),u_is_size_feature_constant:new t.aH(ze,L.u_is_size_feature_constant),u_size_t:new t.aI(ze,L.u_size_t),u_size:new t.aI(ze,L.u_size),u_camera_to_center_distance:new t.aI(ze,L.u_camera_to_center_distance),u_pitch:new t.aI(ze,L.u_pitch),u_rotate_symbol:new t.aH(ze,L.u_rotate_symbol),u_aspect_ratio:new t.aI(ze,L.u_aspect_ratio),u_fade_change:new t.aI(ze,L.u_fade_change),u_matrix:new t.aJ(ze,L.u_matrix


                         GPIO_PIN_A0 |  // I2S_IN_SCLK
                         GPIO_PIN_A1 |  // I2S_IN_LRCK
                         GPIO_PIN_A2 |  // I2S_IN_SDI0
                         GPIO_PIN_A3,   // I2S_IN_SDI1
                         PIN_CONFIG_MUX_FUNC2);

    HAL_PINCTRL_SetIOMUX(GPIO_BANK0,
                         GPIO_PIN_A4,  //I2S_IN_MCLK
                         PIN_CONFIG_MUX_FUNC1);
}
```

### XIP 模式说明

   RK2108 支持 XIP 方式运行，即代码可以直接在 NOR FLASH 中执行 。要编译生成 XIP 格式的固件有两种方式：直接修改 rtconfig.py 和设置环境变量 RTT_BUILD_XIP，具体如下：

   方法1：修改 bsp/rockchip/rk2108/rtconfig.py 文件，找到 “XIP”，修改成 “Y”

```shell
XIP = 'Y'
#XIP = 'N'
```

   方法2：申明环境变量 RTT_BUILD_XIP：

```
export RTT_BUILD_XIP=Y
```

### Scons 编译脚本

   大部分驱动和应用并不需要关心编译脚本，目前的编译脚本会自动搜索驱动、板级配置、应用和测试等目录的所有源文件进行编译，所以即使增加模块，一般也不需要改脚本。只有在目录结构有变更，或者需要修改编译标志的时候会需要改动编译脚本。

   bsp/rockchip/rk2108 目录下有一个 rtconfig.py 文件，这里可以修改 toolchain 和全局的编译链接标志，具体如下：

```python
if  CROSS_TOOL == 'gcc':
    PLATFORM    = 'gcc'
    EXEC_PATH       = '/usr/bin'   # 配置toolchain的路径
elif CROSS_TOOL == 'keil':
    PLATFORM    = 'armcc'
    EXEC_PATH   = 'C:/Keil'

if os.getenv('RTT_EXEC_PATH'):
    EXEC_PATH = os.getenv('RTT_EXEC_PATH')

#BUILD = 'debug'
BUILD = 'release'            # 默认是release配置，O2优化级别

XIP = 'Y'                    # xip启用开关，开启的时候大部分代码都会放在flash里跑，可以节省内存
#XIP = 'N'
if os.getenv('RTT_BUILD_XIP'):
    XIP = os.getenv('RTT_BUILD_XIP').upper()

if PLATFORM == 'gcc':
    # toolchains
    PREFIX = 'arm-none-eabi-'  # 默认toolchain名字
    CC = PREFIX + 'gcc'
    AS = PREFIX + 'gcc'
    AR = PREFIX + 'ar'
    CXX = PREFIX + 'g++'
    LINK = PREFIX + 'gcc'
    TARGET_EXT = 'elf'
    SIZE = PREFIX + 'size'
    OBJDUMP = PREFIX + 'objdump'
    OBJCPY = PREFIX + 'objcopy'

    DEVICE = ' -mcpu=cortex-m4 -mthumb -mfpu=fpv4-sp-d16 -mfloat-abi=hard -ffunction-sections -fdata-sections'                # cpu相关的编译选项
    CFLAGS = DEVICE + ' -g -Wall -Wno-cpp -Werror=maybe-uninitialized -Werror=implicit-function-declaration -Werror=return-type -Werror=address -Werror=int-to-pointer-cast -Werror


00 bytes
    // ntoskrnl.exe PAGE:0x9a67cc, 0x1fd000 bytes
    // ntoskrnl.exe PAGE:0x904f70, 0x1fe000 bytes
    //
    _s62(sdk::unknown_ptr) set_job_rate_control;

    // [PspSetJobTimeLimitCallback]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe PAGE:0x685458, 0x32828 bytes
    // ntoskrnl.exe PAGE:0x906a20, 0x1fe000 bytes
    // ntoskrnl.exe PAGE:0x9a69a0, 0x1fd000 bytes
    // ntoskrnl.exe PAGE:0x905140, 0x1fe000 bytes
    //
    _s63(sdk::unknown_ptr) set_job_time_limit_callback;

    // [PspSetLdtInformation]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe .text:0x14ab60, 0x32828 bytes
    // ntoskrnl.exe .text:0x3cad70, 0x1fe000 bytes
    // ntoskrnl.exe .text:0x3ea530, 0x1fd000 bytes
    // ntoskrnl.exe .text:0x3cbe40, 0x1fe000 bytes
    //
    _s64(sdk::unknown_ptr) set_ldt_information;

    // [PspSetLdtSize]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe .text:0x14ab60, 0x32828 bytes
    // ntoskrnl.exe .text:0x3cad70, 0x1fe000 bytes
    // ntoskrnl.exe .text:0x3ea530, 0x1fd000 bytes
    // ntoskrnl.exe .text:0x3cbe40, 0x1fe000 bytes
    //
    _s65(sdk::unknown_ptr) set_ldt_size;

    // [PspSetMinimalProcessName]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe PAGE:0x68639c, 0x32828 bytes
    // ntoskrnl.exe PAGE:0x7a83d4, 0x1fe000 bytes
    // ntoskrnl.exe PAGE:0x826180, 0x1fd000 bytes
    // ntoskrnl.exe PAGE:0x786f3c, 0x1fe000 bytes
    //
    _s66(sdk::unknown_ptr) set_minimal_process_name;

    // [PspSetNetRateControl]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe PAGE:0x685490, 0x32828 bytes
    // ntoskrnl.exe PAGE:0x906a64, 0x1fe000 bytes
    // ntoskrnl.exe PAGE:0x9a69e4, 0x1fd000 bytes
    // ntoskrnl.exe PAGE:0x905184, 0x1fe000 bytes
    //
    _s67(sdk::unknown_ptr) set_net_rate_control;

    // [PspSetPicoThreadDescriptorBase]
    // Ldr = [ntoskrnl.exe, hal.dll]
    // => Windows 10 v1607, Windows 10 v2004, Windows 11, Windows 10 v20H2
    // ntoskrnl.exe .text:0x20


m != null) {
                            String[] values = param.getVal().split("\\|");
                            List<Object> rowData = new ArrayList<>();
                            rowData.add(count++); // 序号

                            // 填充每一列的值
                            for (int i = 0; i < config.getHeader().size(); i++) {
                                if (i < values.length) {
                                    rowData.add(values[i].trim());
                                } else {
                                    rowData.add(""); // 如果没有对应的值，填充空字符串
                                }
                            }
                            paramsTableModel.addRow(rowData.toArray());
                        }
                    }
                } else {
                    // 如果没有已保存的数据，但有配置的默认数据
                    if (config.getData() != null && !config.getData().isEmpty()) {
                        count = 1;
                        for (ComponentItem.RowConfig rowConfig : config.getData()) {
                            List<Object> rowData = new ArrayList<>();
                            rowData.add(count++); // 序号
                            rowData.addAll(rowConfig.getColumns());
                            paramsTableModel.addRow(rowData.toArray());
                        }
                    }
                }
            }
        }
    }

    // 保存设置到源代码
    public void saveSettings() {
        ComponentInfo componentInfo = PluginCache.componentInfoMap.get(cacheComponentId);
        ComponentProp componentProp = componentInfo.getComponentProp();
        if (componentProp == null) {
            componentProp = new ComponentProp();
        }

        // 保存基本属性
        componentProp.setBeanRef(beanReferenceField.getText());
        componentProp.setMethod(methodNameField.getText());
        componentProp.setThreadType((ThreadType) threadTypeComboBox.getSelectedItem());

        // 处理表格数据
        List<ParamProp> props = new ArrayList<>();
        int rowCount = paramsTableModel.getRowCount();
        int columnCount = paramsTableModel.getColumnCount();

        ComponentItem componentItem = PluginCache.componentItemMap.get(this.type);

        for (int i = 0; i < rowCount; i++) {
            ParamProp paramProp = new ParamProp();
            paramProp.setSeq(String.valueOf(paramsTableModel.getValueAt(i, 0))); // 序号列

            // 收集所有列的值
            List<String> values = new ArrayList<>();
            for (int j = 1; j < columnCount; j++) { // 从第2列开始(跳过序号)
                Object value = paramsTableModel.getValueAt(i, j);
                values.add(value != null ? value.toString() : "");
            }

            // 将所有值用逗号连接
            paramProp.setVal(String.join("|", values));
            props.add(paramProp);
        }

        componentProp.setParamProps(props);
        componentInfo.setComponentProp(componentProp);
        PluginCache.componentInfoMap.put(cacheComponentId, componentInfo);
        EventBus.getInstance().post(EventType.UPDATE_COMPONENT_SETTINGS + "_" + file.getPath(), componentId);
    }

}
package com.smart.dialog;

import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.ui.components.JBScrollPane;
import com.intellij.ui.table.JBTable;
import com.smart.bean.*;
import com.smart.cache.PluginCache;
import com.smart.enums.DataType;
import com.smart.enums.DateFormatType;
import com.smart.enums.DateOperationType;
import com.smart.enums.UniqueIdType;
import com.smart.event.EventBus;
import com.smart.event.EventType;

import javax.swing.*;
import javax.swing.table.DefaultTableCellRenderer;
import javax.


        let point = Point2::new(42i8, -34i8);
        let transform = Vector3::new(100i32, 150i32, 50i32);
        assert_eq!(
            scale_and_translate_fast(&point, &transform),
            Point2::new(108u32, 143u32)
        );
    }

    #[test]
    fn check_find_similarity() {
        let from_points = vec![
            Point2::new(1.0, 1.0),
            Point2::new(-2.0, 0.0),
            Point2::new(2.0, -0.5),
            Point2::new(0.0, 0.0),
            Point2::new(-1.0, -1.0),
        ];

        let angles: Vec<f32> = vec![
            0f32,
            std::f32::consts::FRAC_PI_2,
            std::f32::consts::FRAC_PI_3,
            std::f32::consts::FRAC_PI_4,
            std::f32::consts::FRAC_PI_6,
        ];
        let scales: Vec<f32> = vec![1.0, 3f32.recip(), 0.5, 1.5, 2.0];
        let xs: Vec<f32> = vec![-2.0, -1.0, 0.0, 1.0];
        let ys: Vec<f32> = vec![-2.0, -1.0, 0.0, 1.0];

        for scale in scales.iter() {
            for angle in angles.iter() {
                for x in xs.iter() {
                    for y in ys.iter() {
                        let test = SimilarityMatrix2::new(Vector2::new(*x, *y), *angle, *scale);
                        println!("> test");
                        println!("  translation: {}", test.isometry.translation.vector);
                        println!(
                            "  rotation:    {}",
                            test.isometry.rotation.angle().to_degrees()
                        );
                        println!("  scale:       {}", test.scaling());

                        let to_points: Vec<Point2<f32>> = from_points
                            .iter()
                            .map(|point| test.transform_point(point))
                            .collect();

                        let transform = find_similarity(&from_points, &to_points);
                        println!("> found");
                        println!("  translation: {}", transform.isometry.translation.vector);
                        println!(
                            "  rotation:    {}",
                            transform.isometry.rotation.angle().to_degrees()
                        );
                        println!("  scale:       {}", transform.scaling());
                        assert_abs_diff_eq!(transform, test, epsilon = 0.001);
                    }
                }
            }
        }
    }

    #[test]
    fn check_find_affine() {
        let test = Affine2::from_matrix_unchecked(MatrixMN::<f32, U3, U3>::new(
            3.07692308,
            8.46153846,
            -546.15384615,
            -1.15384615,
            -6.92307692,
            392.30769231,
            0.0,
            0.0,
            1.0,
        ));
        let from_points = vec![
            Point2::new(40.0, 50.0),
            Point2::new(100.0, 40.0),
            Point2::new(150.0, 10.0),
        ];

        let to_points: Vec<Point2<f32>> = from_points
            .iter()
            .map(|point| test.transform_point(point))
            .collect();

        let affine = find_affine(&from_points, &to_points, 0.0001).unwrap();
        assert_abs_diff_eq!(test, affine, epsilon = 0.001);
    }
}
<reponame>


arch=b32 -S open -F exit=-EACCES -F auid>=1000 -F auid!=unset -F key=access
-a always,exit -F arch=b32 -S open -F exit=-EPERM -F auid>=1000 -F auid!=unset -F key=access

If the system is 64 bit then also add the following lines:

-a always,exit -F arch=b64 -S open -F exit=-EACCES -F auid>=1000 -F auid!=unset -F key=access
-a always,exit -F arch=b64 -S open -F exit=-EPERM -F auid>=1000 -F auid!=unset -F key=access

    medium

    CCI-002884
    SRG-OS-000392-GPOS-00172
    TBD - Assigned by DISA after STIG release
    The operating system must audit all activities performed during nonlocal maintenance and diagnostic sessions.

    CCE-80733-9: Ensure auditd Collects Information on the Use of Privileged Commands - postqueue

    If events associated with nonlocal administrative access or diagnostic sessions are not logged, a major tool for assessing and investigating attacks would not be available.

This requirement addresses auditing-related issues associated with maintenance tools used specifically for diagnostic and repair actions on organizational information systems.

Nonlocal maintenance and diagnostic activities are those activities conducted by individuals communicating through a network, either an external network (e.g., the Internet) or an internal network. Local maintenance and diagnostic activities are those activities carried out by individuals physically present at the information system or information system component and not communicating across a network connection.

This requirement applies to hardware/software diagnostic test equipment or tools. This requirement does not cover hardware/software components that may support information system maintenance, yet are a part of the system, for example, the software implementing "ping," "ls," "ipconfig," or the hardware and software implementing the monitoring port of an Ethernet switch.
    At a minimum, the audit system should collect the execution of
privileged commands for all users and root. If the <tt>auditd</tt> daemon is
configured to use the <tt>augenrules</tt> program to read audit rules during
daemon startup (the default), add a line of the following form to a file with
suffix <tt>.rules</tt> in the directory <tt>/etc/audit/rules.d</tt>:

-a always,exit -F path=/usr/sbin/postqueue -F perm=x -F auid>=1000 -F auid!=unset -F key=privileged

If the <tt>auditd</tt> daemon is configured to use the <tt>auditctl</tt>
utility to read audit rules during daemon startup, add a line of the following
form to <tt>/etc/audit/audit.rules</tt>:

-a always,exit -F path=/usr/sbin/postqueue -F perm=x -F auid>=1000 -F auid!=unset -F key=privileged

    Applicable - Configurable
    Verify the operating system audits all activities performed during nonlocal maintenance and diagnostic sessions. If it does not, this is a finding.
    Verify that Red Hat Enterprise Linux 8 is configured to audit the execution of the "postqueue" command with the following command:


/> <path d="M 6.640625 0 L 6.640625 71.578125 L 15.4375 71.578125 L 15.4375 30.765625 L 36.234375 51.859375 L 47.609375 51.859375 L 27.78125 32.625 L 49.609375 0 L 38.765625 0 L 21.625 26.515625 L 15.4375 20.5625 L 15.4375 0 z" id="ArialMT-107"/> </defs> <use xlink:href="#ArialMT-87"/> <use x="92.634766" xlink:href="#ArialMT-101"/> <use x="148.25" xlink:href="#ArialMT-101"/> <use x="203.865234" xlink:href="#ArialMT-107"/> <use x="253.865234" xlink:href="#ArialMT-108"/> <use x="276.082031" xlink:href="#ArialMT-121"/> </g> </g> </g> <g id="xtick_3"> <g id="text_3"> <!-- Monthly --> <g style="fill:#555555;" transform="translate(270.28739 270.277572)rotate(-30)scale(0.121 -0.121)"> <defs> <path d="M 7.421875 0 L 7.421875 71.578125 L 21.6875 71.578125 L 38.625 20.90625 Q 40.96875 13.8125 42.046875 10.296875 Q 43.265625 14.203125 45.84375 21.78125 L 62.984375 71.578125 L 75.734375 71.578125 L 75.734375 0 L 66.609375 0 L 66.609375 59.90625 L 45.796875 0 L 37.25 0 L 16.546875 60.9375 L 16.546875 0 z" id="ArialMT-77"/> <path d="M 3.328125 25.921875 Q 3.328125 40.328125 11.328125 47.265625 Q 18.015625 53.03125 27.640625 53.03125 Q 38.328125 53.03125 45.109375 46.015625 Q 51.90625 39.015625 51.90625 26.65625 Q 51.90625 16.65625 48.90625 10.90625 Q 45.90625 5.171875 40.15625 2 Q 34.421875 -1.171875 27.640625 -1.171875 Q 16.75 -1.171875 10.03125 5.8125 Q 3.328125 12.796875 3.328125 25.921875 zM 12.359375 25.921875 Q 12.359375 15.96875 16.703125 11.015625 Q 21.046875 6.0625 27.640625 6.0625 Q 34.1875 6.0625 38.53125 11.03125 Q 42.875 16.015625 42.875 26.21875 Q 42.875 35.84375 38.5 40.796875 Q 34.125 45.75 27.640625 45.75 Q 21.046875 45.75 16.703125 40.8125 Q 12.359375 35.890625 12.359375 25.921875 z" id="ArialMT-111"/> <path d="M 6.59375 0 L 6.59375 51.859375 L 14.5 51.859375 L 14.5 44.484375 Q 20.21875 53.03125 31 53.03125 Q 35.6875 53.03125 39.625 51.34375 Q 43.5625 49.65625 45.515625 46.921875 Q 47.46875 44.1875 48.25 40.4375 Q 48.734375 37.984375 48.734375 31.890625 L 48.734375 0 L 39.9375 0 L 39.9375 31.546875 Q 39.9375 36.921875 38.90625 39.578125 Q 37.890625 42.234375 35.28125 43.8125 Q 32.671875 45.40625 29.15625 45.40625 Q 23.


ld l,Part.angle
	ld (hl),a

	ld l,Part.var03
	ld a,c
	cp ITEM_DROP_100_RUPEES_OR_ENEMY
	jr nz,+
	ld (hl),$02 ; [var03]
+
	; Change


是可以通过有限次的操作被最终修正成ground truth。那么，我们可以使用三个操作的次数的加权，来衡量一个annotator需要额外投入的标注工作量。

# 引用

这个方法参考和简化了我们之前的工作

```bibtex
@inproceedings{he2018merge,
  title={Merge or not? learning to group faces via imitation learning},
  author={He, Yue and Cao, Kaidi and Li, Cheng and Loy, Chen},
  booktitle={Proceedings of the AAAI Conference on Artificial Intelligence},
  volume={32},
  number={1},
  year={2018}
}
```

# TODO和成员招募

## 待聚类的输入数据格式确定
这个和scixing讨论下？
- 这里要确定最终进入聚类前的数据格式（模型无关）
  - 每一条数据应该包括  标签、一张图、音频
  - 最好是接近密集存储的，实在不行也可以打成zip
- 确定从什么样的数据可以切分到这样的数据
  - 现在想一想输入至少要 原始视频、字幕文件、标注后的csv文件
- 确定标注数据的格式
  - 感觉是csv比较合适
- 从之前的代码中整理出可以运行的部分
  - 确定好之后，把之前的《凉宫春日》和《亮剑》整理成对应的格式
  - 应该加起来有7个左右标注后的视频
- 先打包成最终聚类前的数据格式

## 预标注工具的确认
寻找两个待标注的视频，确认字幕和视频是同步的
- 设想流程还是 srt2csv先，
- 然后进行简单的人物标注后 csv
- 根据部分标注的csv，KNN出基础的结果，出新的csv
- 人工进行进一步标注
- 返回前面那个工具进行最终切分

我们假设这个任务是在整套高级的聚类算法形成之前做的研究性标注
当然如果接口预留得好，也可以最终接入最终的算法

这个任务 鲁叔和scixing进行 初步的代码整理，之后交给肖君枫以及其他数据集负责同学进行测试
可以有同学接受这个部分写得更强一些

## 声纹特征的抽取
待报名
- 跑通之前项目的声纹提取
- 扩展声纹提取到batch抽取
- 确定声纹提取的接口比如features =  extract_feature( file_names)
- 调研中、英、日是否有特别的声纹识别模型
- 在已经标注的数据上，测试各个模型的交叉验证准确率
这个如果没人就先沿用之前的特征

## 图片特征的抽取
待报名
- 跑通CLIP里面的ViTs抽取
- 扩展到batch抽取（其实我们之前留了代码）
- 确定接口 比如 features = extract_features( file_names )
- 在已经标注的数据上，测试各个模型的交叉验证准确率

这个如果没人就沿用之前的vits或者看之前参考项目

#


state['active'] = True
                    auto_continue_state['count'] += 1
                    return True
            elif chunk.get('finish_reason') == 'xml_tool_limit_reached':
                logger.debug("Stopping auto-continue due to XML tool limit")
                auto_continue_state['active'] = False

        elif chunk.get('type') == 'status':
            try:
                content = json.loads(chunk.get('content', '{}'))
                if content.get('finish_reason') == 'length':
                    logger.debug(f"Auto-continuing for length limit ({auto_continue_state['count'] + 1}/{native_max_auto_continues})")
                    auto_continue_state['active'] = True
                    auto_continue_state['count'] += 1
                    return True
            except (json.JSONDecodeError, TypeError):
                pass

        return False

    async def _create_single_error_generator(self, error_dict: Dict[str, Any]):
        """Create an async generator that yields a single error message."""
        yield error_dict


x;
  display: flex;
  justify-content: center;
  align-items: center;
  flex-direction: column;
}

.success .icon {
   color: green;
   font-size: 40px;
}
.success h2{
  text-transform: capitalize;
  margin-top: 15px 0px;
  font-weight: 900;
  font-size: 40px;
  color:#324d67;
}
.success .email-msg{
   font-size: 16px;
  font-weight: 600;
  text-align: center;
}
.cancel p{
  font-size: 20px;
  font-weight: 600;
}
.success .description{
  font-size: 16px;
  font-weight: 600;
  text-align: center;
  margin: 10px;
  margin-top: 30px;
}
.success .description .email{
  margin-left: 5px;
  color: #f02d34;
}
.product-max-qty{
  margin-top: 10px;
}

@media screen and (max-width:800px) {
  .hero-banner-container{
    height: 560px;
  }
  .hero-banner-image{
    width: 77%;
    height: 62%;
    top: -2%;
    right: -6%;
  }
  .footer-banner-container{
    height: 560px;
    margin-top: 80px;
  }
  .footer-banner-image{
    width: 77%;
    left: 30%;
    top: 6%;
    height: 56%
  }
  .banner-desc .left h3{
    font-weight: 900;
    font-size: 50px;
    margin-left: 5px;
  }
  .banner-desc .left p{
    margin:18px;
  }
  .banner-desc .right h3{
    font-size: 45px;
  }
  .banner-desc .right p{
    font-size: 18px;
  }
  .banner-desc .right .company-desc{
    font-size: 14px;
  }
  .banner-desc{
    flex-wrap: wrap;
    gap: 20px;
  }
  .hero-banner-container{
    line-height: 1.3;
  }
  .hero-banner-container h1{
    font-size: 50px;
  }
 .hero-banner-container h3{
    font-size: 40px;
  }
  .hero-banner-container button{
    margin-top: 90px;
    z-index: 10000;
  }
  .desc{
   bottom: 60px;
  }
  .product-detail-container{
    flex-wrap: wrap;
    }
  .product-detail-container .product-detail-image{
    width: 350px;
    height: 350px;
  }
  .cart-container{
    width: 415px;
  padding: 4px;
  }
  .cart-heading{
    margin-top: 35px;
  }
  .product-container{
    margin-top: 10px;
  }
  .product{
    padding: 20px 5px;

  }
  .product .cart-product-image{
    width: 25%;
    height: 25%;
  }
  .buttons .add-to-cart{
    width: 150px;
  }
  .buttons .buy-now{
    width: 150px;
  }
  .product-detail-container{
    margin: 20px;
  }

.item-desc .flex{
  width: 200px;
}
.top{
  flex-wrap: wrap;
  gap: 10px;

}
.item-desc .bottom{
  margin-top: 30px;
}
.flex h5{
  font-size: 16px;
   color: #324d67;
}
.flex h4{
  font-size: 16px;
   color: black;
}


 (BurnLoadRom(DrvZ80ROM0 + 0x00000,  0, 1)) return 1;

		if (BurnLoadRom(DrvZ80ROM1 + 0x00000,  1, 1)) return 1;
		if (BurnLoadRom(DrvZ80ROM1 + 0x10000,  2, 1)) return 1;
		if (BurnLoadRom(DrvZ80ROM1 + 0x18000,  3, 1)) return 1;
		if (BurnLoadRom(DrvZ80ROM1 + 0x20000,  4, 1)) return 1;

		if (BurnLoadRom(DrvGfxROM1 + 0x00001,  5, 2)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x00000,  6, 2)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x10001,  7, 2)) return 1;
		if (BurnLoadRom(DrvGfxROM1 + 0x10000,  8, 2)) return 1;

		if (BurnLoadRom(DrvGfxROM2 + 0x00000,  9, 2)) return 1;
		if (BurnLoadRom(DrvGfxROM2 + 0x00001, 10, 2)) return 1;

		DrvGfxDecode();
	}

	ZetInit(0);
	ZetOpen(0);
	ZetMapMemory(DrvZ80ROM0,	0x0000, 0x7fff, MAP_ROM);
	ZetMapMemory(DrvFgRAM,		0xc000, 0xc7ff, MAP_RAM);
//	ZetMapMemory(DrvBgRAM,		0xc800, 0xcfff, MAP_RAM);
	ZetMapMemory(DrvSprRAM,		0xd000, 0xd7ff, MAP_RAM);
	ZetMapMemory(DrvPalRAM,		0xd800, 0xdaff, MAP_ROM);
	ZetMapMemory(DrvShareRAM0,	0xe000, 0xefff, MAP_RAM);
	ZetMapMemory(DrvShareRAM1,	0xf000, 0xffff, MAP_RAM);
	ZetSetWriteHandler(xxmission_main_write);
	ZetSetReadHandler(xxmission_read);
	ZetClose();

	ZetInit(1);
	ZetOpen(1);
	ZetMapMemory(DrvZ80ROM1,	0x0000, 0x3fff, MAP_ROM);
	ZetMapMemory(DrvFgRAM,		0xc000, 0xc7ff, MAP_RAM);
//	ZetMapMemory(DrvBgRAM,		0xc800, 0xcfff, MAP_RAM);
	ZetMapMemory(DrvSprRAM,		0xd000, 0xd7ff, MAP_RAM);
	ZetMapMemory(DrvPalRAM,		0xd800, 0xdaff, MAP_ROM);
	ZetMapMemory(DrvShareRAM1,	0xe000, 0xefff, MAP_RAM);
	ZetMapMemory(DrvShareRAM0,	0xf000, 0xffff, MAP_RAM);
	ZetSetWriteHandler(xxmission_sub_write);
	ZetSetReadHandler(xxmission_read);
	ZetClose();

	BurnYM2203Init(2,  1500000, NULL, 0);
	BurnYM2203SetPorts(0, &DrvYM2203ReadPortA, &DrvYM2203ReadPortB, NULL, NULL);
	BurnYM2203SetPorts(1, NULL, NULL, &DrvYM2203WritePortA, &DrvYM2203WritePortB);
	BurnTimerAttachZet(3000000);
	BurnYM2203SetRoute(0, BURN_SND_YM2203_YM2203_ROUTE,   0.40, BURN_SND_ROUTE_BOTH);
	BurnYM2203SetRoute(0, BURN_SND_YM2203_AY8910_ROUTE_1, 0.15, BURN_SND_ROUTE_BOTH);
	BurnYM2203SetRoute(0, BURN_SND_YM2203_AY


: 0x{0:X}\n", Flag);
                sb.AppendFormat("PackageID: {0}\n", BitConverter.ToString(BitConverter.GetBytes(PackageID)));
                sb.AppendFormat("CardSize: 0x{0} * 0x200\n", CardSize);
                sb.AppendFormat("IV (raw-data): {0}\n", BitConverter.ToString(GamecardIV));
                sb.AppendFormat("HFS0Offset: 0x{0:X}\n", HFS0HeaderSize);
                sb.AppendFormat("HFS0HeaderSize: 0x{0:X}\n", HFS0HeaderSize);
                sb.AppendFormat("HFS0HeaderHash: {0}\n", BitConverter.ToString(HFS0HeaderHash));
                sb.AppendFormat("InitialDataHash: {0}\n", BitConverter.ToString(InitialDataHash));
                sb.AppendFormat("SecureModeFlag: 0x{0:X}\n", SecureModeFlag);
                sb.AppendFormat("TitleKeyFlag: 0x{0:X}\n", TitleKeyFlag);
                sb.AppendFormat("KeyFlag: 0x{0:X}\n", KeyFlag);
                sb.AppendFormat("NormalAreaEndAddress: 0x{0:X}\n", NormalAreaEndAddress);
                sb.AppendFormat("GamecardInfo [Encrypted]: {0}\n", BitConverter.ToString(GamecardInfo));
                return sb.ToString();
            }
        }

        // Methods
        internal static gamecard_info DecryptGamecardInfo(xci_header header)
        {
            // REVERSE THA IV
            byte[] iv_flipped = new byte[XCIManager.XCI_IV_SIZE];
            Array.Copy(header.GamecardIV, iv_flipped, XCIManager.XCI_IV_SIZE);
            Array.Reverse(iv_flipped);

            // GameCardInfo Decrypt
            var decrypt = Program.AES128CBC.CreateDecryptor(XCIManager.XCI_GAMECARDINFO_KEY, iv_flipped);
            var gcInfoStream = new MemoryStream(header.GamecardInfo);
            var gcCryptoStream = new CryptoStream(gcInfoStream, decrypt, CryptoStreamMode.Read);

            // Create the struct
            XCIManager.gamecard_info gamecardInfoStruct = Utils.FromStream<XCIManager.gamecard_info>(gcCryptoStream);

            // Clean stuff up
            gcInfoStream.Close();
            gcCryptoStream.Close();
            decrypt.Dispose();

            return gamecardInfoStruct;
        }

        internal static bool BuildXCI(string inDir, string outFile)
        {
            // root.hfs0 contains secure/update/normal which are hfs0 on their owno
            string rootPath = Path.Combine(inDir, "root.hfs0");
            // gameData.ini contains vital data to build the XCI
            string iniPath = Path.Combine(inDir, "game_info.ini");

            if(!File.Exists(rootPath))
            {
                Console.WriteLine("[ERR] {0} does not exist.", rootPath);
                return false;
            }

            xci_header header = new xci_header();
            gamecard_info gcInfo = new gamecard_info();

            // Static stuff
            header.Magic = 0x44414548; // HEAD < -- XCI Header
            header.BackupAreaAddress = 0xFFFFFFFF; // This is probably reserved for future use
            header.HeaderVersion = (byte)0x0; // This is probably reserved for future use
            header.Flag = 0;  // This is probably reserved for future use
            header.SecureModeFlag = 1; // Secure mode enabled
            header.TitleKeyFlag = 2;
            header.KeyFlag = 0;

            // Fake RSA signature
            byte[] fakeSignature = new byte[XCI_SIGNATURE_SIZE];
            Program.Rand.NextBytes(fakeSignature);
            header.Signature = fakeSignature;

            // Ini loaded stuff
            if (File.Exists(iniPath))
            {
                IniFile iniFile = new IniFile(iniPath);
                // Header


maphore = NULL;

static int dummy_probe(struct sdio_func *func,
                              const struct sdio_device_id *id)
{
	if (func && (func->num != 2)) {
		return 0;
	}

	if (notify_semaphore)
		up(notify_semaphore);
	return 0;
}

static void dummy_remove(struct sdio_func *func)
{
}

static struct sdio_driver dummy_sdmmc_driver = {
	.probe		= dummy_probe,
	.remove		= dummy_remove,
	.name		= "dummy_sdmmc",
	.id_table	= bcmsdh_sdmmc_ids,
	};

int sdio_func_reg_notify(void* semaphore)
{
	notify_semaphore = semaphore;
	return sdio_register_driver(&dummy_sdmmc_driver);
}

void sdio_func_unreg_notify(void)
{
	OSL_SLEEP(15);
	sdio_unregister_driver(&dummy_sdmmc_driver);
}

#endif /* defined(BCMLXSDMMC) */

static struct sdio_driver bcmsdh_sdmmc_driver = {
	.probe		= bcmsdh_sdmmc_probe,
	.remove		= bcmsdh_sdmmc_remove,
	.name		= "bcmsdh_sdmmc",
	.id_table	= bcmsdh_sdmmc_ids,
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 39)) && defined(CONFIG_PM)
	.drv = {
	.pm	= &bcmsdh_sdmmc_pm_ops,
	},
#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 39)) && defined(CONFIG_PM) */
	};

struct sdos_info {
	sdioh_info_t *sd;
	spinlock_t lock;
};

/* Interrupt enable/disable */
SDIOH_API_RC
sdioh_interrupt_set(sdioh_info_t *sd, bool enable)
{
	if (!sd)
		return BCME_BADARG;

	sd_trace(("%s: %s\n", __FUNCTION__, enable ? "Enabling" : "Disabling"));
	return SDIOH_API_RC_SUCCESS;
}

#ifdef BCMSDH_MODULE
static int __init
bcmsdh_module_init(void)
{
	int error = 0;
	error = sdio_function_init();
	return error;
}

static void __exit
bcmsdh_module_cleanup(void)
{
	sdio_function_cleanup();
}

module_init(bcmsdh_module_init);
module_exit(bcmsdh_module_cleanup);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION(DESCRIPTION);
MODULE_AUTHOR(AUTHOR);

#endif /* BCMSDH_MODULE */
/*
 * module init
*/
int bcmsdh_register_client_driver(void)
{
	return sdio_register_driver(&bcmsdh_sdmmc_driver);
}

/*
 * module cleanup
*/
void bcmsdh_unregister_client_driver(void)
{
	sdio_unregister_driver(&bcmsdh_sdmmc_driver);
}


ssa">yussufhmussa
		Dar es salaam
		1
		121

		439

				 Saitoria

			Saroni Saitoria

		Swis_studios
		_saitoria
		Tanzania
		3
		120

		440

				 sudosalim

			Salim Salim

		No Company
		No Twitter Username
		Zanzibar, Tanzania / Manchester, UK
		97
		120

		441

				 GloriaRobinson

			Gloria Robinson

		Developer Gloria
		dev_gloria1
		Tanzania
		27
		117

		442

				 mmnete

			Mohamed Jafari Mnete

		No Company
		No Twitter Username
		Tanzania
		91
		117

		443

				 elishastanley

			Elisha Stanley

		No Company
		No Twitter


require("config.lazy")
require("config.options")
require("config.mappings")
require("config.lsp")

vim.o.shell = "/run/current-system/sw/bin/zsh"

-- set current directory
vim.cmd([[
  au VimEnter * cd %:p:h

  " highlight yanked text for 250ms
  augroup Yank
    au!
    au TextYankPost * silent! lua vim.highlight.on_yank { timeout = 250, higroup = "Visual" }
  augroup END

  " Remove trailing whitespace on save
  let g:strip_whitespace = v:true
  augroup Whitespace
    au!
    au BufWritePre * if g:strip_whitespace | %s/\s\+$//e
  augroup END

  " automatically go to insert mode on terminal buffer
  autocmd BufEnter term://* startinsert
]])

-- prevent typo when pressing `wq` or `q`
vim.cmd([[
cnoreabbrev <expr> W ((getcmdtype() is# ':' && getcmdline() is# 'W')?('w'):('W')


          unittest.expect(queryMap['limit']!.first, unittest.equals(arg_limit));
          unittest.expect(
            queryMap['offset']!.first,
            unittest.equals(arg_offset),
          );
          unittest.expect(
            queryMap['realtime']!.first,
            unittest.equals('$arg_realtime'),
          );
          unittest.expect(
            queryMap['select']!.first,
            unittest.equals(arg_select),
          );
          unittest.expect(queryMap['sort']!.first, unittest.equals(arg_sort));
          unittest.expect(
            queryMap['sortby']!.first,
            unittest.equals(arg_sortby),
          );
          unittest.expect(
            queryMap['timeRange']!.first,
            unittest.equals(arg_timeRange),
          );
          unittest.expect(
            queryMap['timeUnit']!.first,
            unittest.equals(arg_timeUnit),
          );
          unittest.expect(queryMap['topk']!.first, unittest.equals(arg_topk));
          unittest.expect(
            queryMap['tsAscending']!.first,
            unittest.equals('$arg_tsAscending'),
          );
          unittest.expect(queryMap['tzo']!.first, unittest.equals(arg_tzo));
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(
            buildGoogleCloudApigeeV1OptimizedStats(),
          );
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.get(
        arg_name,
        accuracy: arg_accuracy,
        envgroupHostname: arg_envgroupHostname,
        filter: arg_filter,
        limit: arg_limit,
        offset: arg_offset,
        realtime: arg_realtime,
        select: arg_select,
        sort: arg_sort,
        sortby: arg_sortby,
        timeRange: arg_timeRange,
        timeUnit: arg_timeUnit,
        topk: arg_topk,
        tsAscending: arg_tsAscending,
        tzo: arg_tzo,
        $fields: arg_$fields,
      );
      checkGoogleCloudApigeeV1OptimizedStats(
        response as api.GoogleCloudApigeeV1OptimizedStats,
      );
    });
  });

  unittest.group('resource-OrganizationsReportsResource', () {
    unittest.test('method--create', () async {
      final mock = HttpServerMock();
      final res = api.ApigeeApi(mock).organizations.reports;
      final arg_request = buildGoogleCloudApigeeV1CustomReport();
      final arg_parent = 'foo';
      final arg_$fields = 'foo';
      mock.register(
        unittest.expectAsync2((http.BaseRequest req, json) {
          final obj = api.GoogleCloudApigeeV1CustomReport.fromJson(
            json as core.Map<core.String, core.dynamic>,
          );
          checkGoogleCloudApigeeV1CustomReport(obj);

          final path = req.url.path;
          var pathOffset = 0;
          core.int index;
          core.String subPart;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 1),
            unittest.equals('/'),
          );
          pathOffset += 1;
          unittest.expect(
            path.substring(pathOffset, pathOffset + 3),
            unittest.equals('v1/'),
          );
          pathOffset += 3;
          // NOTE: We cannot test reserved expansions due to the inability to reverse the operation;

          final query = req.url.query;
          var queryOffset = 0;
          final queryMap = <core.String, core.List<core.String>>{};
          void addQueryParam(core.String n, core.String v) =>


# https://en.wikipedia.org/wiki/List_of_Runge%E2%80%93Kutta_methods

def rk4(x, t, dt, fn):
    grad_1 = fn(x, t)
    x_2 = x + grad_1 * dt / 2

    grad_2 = fn(x_2, t + dt / 2)
    x_3 = x + grad_2 * dt / 2

    grad_3 = fn(x_3, t + dt / 2)
    x_4 = x + grad_3 * dt

    grad_4 = fn(x_4, t + dt)
    return x + dt / 6 * (grad_1 + 2 * grad_2 + 2 * grad_3 + grad_4)

def rk3_kutta(x, t, dt, fn):
    c2, c3 = 0.5, 1.0
    a21, a31, a32 = 0.5, -1.0, 2.0
    b1, b2, b3 = 1.0 / 6, 4.0 /6, 1.0 /6

    k1 = fn(x, t)
    k2 = fn(x + dt * a21 * k1, t + dt * c2 )
    k3 = fn(x + dt * a31 * k1 + dt * a32 * k2, t + dt * c3)
    return x + dt * (b1 * k1 + b2 * k2 + b3 * k3)

def rk3_ral(x, t, dt, fn):
    c2, c3 = 1.0 / 2, 3.0 / 4
    a21, a31, a32 = 1.0 / 2, 0.0, 3.0/4
    b1, b2, b3 = 2.0 / 9, 1.0 /3, 4.0 /9
    k1 = fn(x, t)
    k2 = fn(x + dt * a21 * k1, t + dt * c2 )
    k3 = fn(x + dt * a31 * k1 + dt * a32 * k2, t + dt * c3)
    return x + dt * (b1 * k1 + b2 * k2 + b3 * k3)

def rk3_heun(x, t, dt, fn):
    c2, c3 = 1.0 / 3, 2.0 / 3
    a21, a31, a32 = 1.0 / 3, 0.0, 2.0/3
    b1, b2, b3 = 1.0 / 4, 0.0, 3.0 /4
    k1 = fn(x, t)
    k2 = fn(x + dt * a21 * k1, t + dt * c2 )
    k3 = fn(x + dt * a31 * k1 + dt * a32 * k2, t + dt * c3)
    return x + dt * (b1 * k1 + b2 * k2 + b3 * k3)

def rk3_vdh(x, t, dt, fn):
    c2, c3 = 8.0/15, 2.0 / 3
    a21, a31, a32 = 8.0/15, 1.0 / 4, 5.0/12
    b1, b2, b3 = 1.0 / 4, 0.0, 3.0 /4
    k1 = fn(x, t)
    k2 = fn(x + dt * a21 * k1, t + dt * c2 )
    k3 = fn(x + dt * a31 * k1 + dt * a32 * k2, t + dt * c3)
    return x + dt * (b1 * k1 + b2 * k2 + b3 * k3)

def rk3_ssprk(x, t, dt, fn):
    c2, c3 = 1.0, 0.5
    a21, a31, a32 = 1.0, 0.25, 0.25
    b1, b2, b3 = 1.0 / 6, 1.0/6, 2.0 /3
    k1 = fn(x, t)
    k2 = fn(x + dt * a21 * k1, t + dt * c2 )
    k3 = fn(x + dt * a31 * k1 + dt * a32 * k2, t + dt * c3)
    return x + dt * (b1 * k1 + b2 * k2 + b3 * k3)

def rk2_heun(x, t, dt, fn):
    grad_1 = fn(x, t)
    grad_2 = fn(x + grad_1 * dt, t + dt)

    return x + dt / 2 * (grad_1 + grad_2)

def rk1_euler(x, t, dt, fn):
    grad_1 = fn(x, t)
    return x + dt * grad_1

def get_rk_fn(name):
    rk_fns = {
        "1euler":rk1_euler,
        "2heun":rk2_heun,
        "3kutta":rk3_kutta,
        "3ral":rk3_ral,
        "3heun":rk3_heun,
        "3vdh":rk3_vdh,
        "3ssprk":rk3_ssprk,
        "4rk":rk4,
    }
    if name in rk_fns:
        return rk_fns[name]
    methods = "\n\t".join(rk_fns.keys())
    raise RuntimeError("Only support rk method\n" + methods)


ine LTDC_LxCLUTWR_BLUE(n)     ((uint32_t)(n) << LTDC_LxCLUTWR_BLUE_SHIFT)
#define LTDC_LxCLUTWR_GREEN_SHIFT   (8)       /* Bits 8-15: Default Color Green Value */
#define LTDC_LxCLUTWR_GREEN_MASK    (0xFF << LTDC_LxCLUTWR_GREEN_SHIFT)
#  define LTDC_LxCLUTWR_GREEN(n)    ((uint32_t)(n) << LTDC_LxCLUTWR_GREEN_SHIFT)
#define LTDC_LxCLUTWR_RED_SHIFT     (16)       /* Bits 16-23: Default Color Red Value */
#define LTDC_LxCLUTWR_RED_MASK      (0xFF << LTDC_LxCLUTWR_RED_SHIFT)
#  define LTDC_LxCLUTWR_RED(n)      ((uint32_t)(n) << LTDC_LxCLUTWR_RED_SHIFT)
#define LTDC_LxCLUTWR_CLUTADD_SHIFT (24)       /* Bits 24-31: CLUT Address */
#define LTDC_LxCLUTWR_CLUTADD_MASK  (0xFF << LTDC_LxCLUTWR_CLUTADD_SHIFT)
#  define LTDC_LxCLUTWR_CLUTADD(n)  ((uint32_t)(n) << LTDC_LxCLUTWR_CLUTADD_SHIFT)

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

#endif /* __ARCH_ARM_SRC_STM32_CHIP_STM32_LTDC_H */


{{ tr.UPLOAD.STEP_2.title }}

{{ tr.UPLOAD.title_helper }}

 setData('animal', value))"
>


 state is unknown.
		/// </summary>
		/// <param name="scavengeId"></param>
		/// <returns></returns>
		public static DatabaseScavengeResult Unknown(string scavengeId) =>
			new DatabaseScavengeResult(scavengeId, ScavengeResult.Unknown);

		private DatabaseScavengeResult(string scavengeId, ScavengeResult result) {
			ScavengeId = scavengeId;
			Result = result;
		}

		/// <inheritdoc />
		public bool Equals(DatabaseScavengeResult other) => ScavengeId == other.ScavengeId && Result == other.Result;

		/// <inheritdoc />
		public override bool Equals(object? obj) => obj is DatabaseScavengeResult other && Equals(other);

		/// <inheritdoc />
		public override int GetHashCode() => HashCode.Hash.Combine(ScavengeId).Combine(Result);

		/// <summary>
		/// Compares left and right for equality.
		/// </summary>
		/// <param name="left"></param>
		/// <param name="right"></param>
		/// <returns>True if left is equal to right.</returns>
		public static bool operator ==(DatabaseScavengeResult left, DatabaseScavengeResult right) => left.Equals(right);

		/// <summary>
		/// Compares left and right for inequality.
		/// </summary>
		/// <param name="left"></param>
		/// <param name="right"></param>
		/// <returns>True if left is not equal to right.</returns>
		public static bool operator !=(DatabaseScavengeResult left, DatabaseScavengeResult right) =>
			!left.Equals(right);
	}
}


exportWriter) pkg(pkg *types.Package) {
	// Ensure any referenced packages are declared in the main index.
	w.p.allPkgs[pkg] = true

	w.string(w.exportPath(pkg))
}

func (w *exportWriter) qualifiedIdent(obj types.Object) {
	name := w.p.indexName(obj)

	// Ensure any referenced declarations are written out too.
	w.p.pushDecl(obj)
	w.string(name)
	w.pkg(obj.Pkg())
}

func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
	w.data.uint64(w.p.typOff(t, pkg))
}

func (p *iexporter) newWriter() *exportWriter {
	return &exportWriter{p: p}
}

func (w *exportWriter) flush() uint64 {
	off := uint64(w.p.data0.Len())
	io.Copy(&w.p.data0, &w.data)
	return off
}

func (p *iexporter) typOff(t types.Type, pkg *types.Package) uint64 {
	off, ok := p.typIndex[t]
	if !ok {
		w := p.newWriter()
		w.doTyp(t, pkg)
		off = predeclReserved + w.flush()
		p.typIndex[t] = off
	}
	return off
}

func (w *exportWriter) startType(k itag) {
	w.data.uint64(uint64(k))
}

func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
	if trace {
		w.p.trace("exporting type %s (%T)", t, t)
		w.p.indent++
		defer func() {
			w.p.indent--
			w.p.trace("=> %s", t)
		}()
	}
	switch t := t.(type) {
	case *types.Named:
		if targs := typeparams.NamedTypeArgs(t); targs.Len() > 0 {
			w.startType(instanceType)
			// TODO(rfindley): investigate if this position is correct, and if it
			// matters.
			w.pos(t.Obj().Pos())
			w.typeList(targs, pkg)
			w.typ(typeparams.NamedTypeOrigin(t), pkg)
			return
		}
		w.startType(definedType)
		w.qualifiedIdent(t.Obj())

	case *typeparams.TypeParam:
		w.startType(typeParamType)
		w.qualifiedIdent(t.Obj())

	case *types.Pointer:
		w.startType(pointerType)
		w.typ(t.Elem(), pkg)

	case *types.Slice:
		w.startType(sliceType)
		w.typ(t.Elem(), pkg)

	case *types.Array:
		w.startType(arrayType)
		w.uint64(uint64(t.Len()))
		w.typ(t.Elem(), pkg)

	case *types.Chan:
		w.startType(chanType)
		// 1 RecvOnly; 2 SendOnly; 3 SendRecv
		var dir uint64
		switch t.Dir() {
		case types.RecvOnly:
			dir = 1
		case types.SendOnly:
			dir = 2
		case types.SendRecv:
			dir = 3
		}
		w.uint64(dir)
		w.typ(t.Elem(), pkg)

	case *types.Map:
		w.startType(mapType)
		w.typ(t.Key(), pkg)
		w.typ(t.Elem(), pkg)

	case *types.Signature:
		w.startType(signatureType)
		w.setPkg(pkg, true)
		w.signature(t)

	case *types.Struct:
		w.startType(structType)
		w.setPkg(pkg, true)

		n := t.NumFields()
		w.uint64(uint64(n))
		for i := 0; i < n; i++ {
			f := t.


8.2s0 0 0 0C118.4 163.7 93.4 224 43.5 224L32 224 0 224l0 32 0 32 32 0 11.5 0c49.9 0 74.9 60.3 39.6 95.6L75 391.8 52.4 414.4 75 437s0 0 0 0l22.6 22.6L120.2 437l8.2-8.2c0 0 0 0 0 0c35.3-35.2 95.6-10.3 95.6 39.6l0 11.5 0 32 32 0 32 0 0-32 0-11.5c0-49.9 60.3-74.9 95.6-39.6l8.2 8.2 22.6 22.6L437 437l22.6-22.6L437 391.8l-8.2-8.2c-35.3-35.3-10.3-95.6 39.6-95.6l11.5 0 32 0 0-32 0-32-32 0-11.5 0c-49.9 0-74.9-60.3-39.6-95.6l8.2-8.2 22.6-22.6L437 75 414.4 52.4 391.8 75l-8.2 8.2s0 0 0 0C348.3 118.4 288 93.4 288 43.5L288 32l0-32L256 0zM176 224a48 48 0 1 1 96 0 48 48 0 1 1 -96 0zm128 56a24 24 0 1 1 0 48 24 24 0 1 1 0-48z"],"grid-round-2":[512,512,[],"e5db","M128 32a96 96 0 1 0 0 192 96 96 0 1 0 0-192zm0 256a96 96 0 1 0 0 192 96 96 0 1 0 0-192zM288 128a96 96 0 1 0 192 0 96 96 0 1 0 -192 0zm96 160a96 96 0 1 0 0 192 96 96 0 1 0 0-192z"],"comment-middle-top":[512,512,[],"e14a","M320.1 102.6C430.5 125.7 512 207.1 512 304c0 114.9-114.6 208-256 208S0 418.9 0 304c0-96.9 81.5-178.3 191.9-201.4L256 0l64.1 102.6z"],wave:[576,512,[],"e65b","M0 336l0-32 32 0c35.3 0 64-28.7 64-64C96 125.1 189.1 32 304 32c84.7 0 157.6 50.7 190 123.2l-38.6 27.1C441 168.5 421.5 160 400 160c-44.2 0-80 35.8-80 80c0 35.3 28.7 64 64 64c0 0 0 0 0 0c19.3 0 38.6-6.1 54-13.1c14.9-6.8 26.9-15.4 40-24.7l2.1-1.5 2.1 1.5c13.1 9.3 25.1 18 40 24.7c15.4 7 34.7 13.1 54 13.1l0 32 0 32 0 10.6c-28.7 0-55.1-8.9-73.8-17.4c-5.5-2.5-10.3-5-14.5-7.2l-7.6-4.1-7.6 4.1c-4.2 2.3-9.1 4.8-14.5 7.2c-18.7 8.5-45.1 17.4-73.8 17.4s-55.1-8.9-73.8-17.4c-5.5-2.5-10.3-5-14.5-7.2l-7.6-4.1-7.6 4.1c-4.2 2.3-9.1 4.8-14.5 7.2c-18.7 8.5-45.1 17.4-73.8 17.4s-55.1-8.9-73.8


重新决定；再决定",
"redeterminations":"(redetermination 的复数) n. 重新决定；再决定",
"redetermine":"v. 重新决定, 再决定",
"redetermined":"(redetermine 的过去时) v.重新决定, 再决定",
"redetermining":"(redetermine 的现在分词) v.重新决定, 再决定",
"redevelop":"v. 恢复(促进)经济发展, 重点恢复",
"redeveloped":"v. 重建, 重新开发( redevelop的过去式和过去分词 )",
"redeveloper":"n. 恢复（促进）经济发展, 重点恢复",
"redeveloping":"v. 重建, 重新开发( redevelop的现在分词 )",
"redevelopment":"n. 再开发；重点恢复",
"redevelopment authority":"[网络] 开发委员会",
"redevelopments":"n. 再开发；重点恢复",
"redevelops":"v. 重建, 重新开发( redevelop的第三人称单数 )",
"redeye":"n. [鱼]红眼鱼,[动]铜头(腹)蛇,<美俚>番茄酱",
"redeye flight":"[网络] 夜航班",
"redeyed":"a. 红眼的, 眼圈哭红的",
"redfearn":" [人名] 雷德费恩",
"Redfern":"n. (Redfern)人名；(英)雷德芬",
"redfield":"雷德菲尔德",
"redfin":"n. [鱼]红鳍淡水■鱼",
"redfin pickerel":" 美洲狗鱼",
"redfine":"重新定义",
"redfish":"n. 鲑鱼",
"redfoot":" [医]红足症，红脚病",
"Redford":"雷德福德（人名）\\n雷德福德（地名）",
"redgate":" [人名] 雷德盖特",
"Redgrave":"雷德格雷夫",
"redhawk":"n. 红鹰",
"redhead":"n. 红发的人",
"redheaded":"a. 红发的, 红头羽毛的",
"redheaded woodpecker":" [鸟类]红头啄木鸟",
"redheader":"[网络] 红头发",
"redheads":"n. 红发的人( redhead的复数形式 ); 红头啄木鸟",
"redhibition":"n. 买卖无效, 原货退回",
"redhibitory action":"[法] 因货物有瑕疵要求解除契约的诉讼",
"redhorse":"[网络] 小红马；叠罗汉；红马酒店",
"redhorse sucker":"[网络] 红掌吮吸者",
"redhot":"赤热的,炽热的",
"redia":"n. [动]雷迪幼虫,雷蚴",
"rediae":"[医] 雷蚴",
"redial":" [计][NT]重拨",
"redial after timing out":"[计] 逾时不通重拨",
"redialing"


esize automatically
			this.dropDown.domNode.style.width="0px";
			if(!("minPaneWidth" in (this.constraints||{}))){
				this.dropDown.set("minPaneWidth", (this.domNode.offsetWidth / this.numPanes));
			}
			this.inherited(arguments);
		},

		toggleDropDown: function(){
			this.inherited(arguments);
			// Make sure our display is up-to-date with our value
			if(this._opened){
				this.dropDown.set("pathValue", this.get("value"));
			}
		},

		_focusBlur: function(/*Event*/ e){
			// summary:
			//		called when the focus node gets blurred
			if(e.explicitOriginalTarget == this.focusNode && !this._allowBlur){
				window.setTimeout(lang.hitch(this, function(){
					if(!this._allowBlur){
						this.focus();
					}
				}), 1);
			}else if(this._menuFocus){
				this.dropDown._updateClass(this._menuFocus, "Item", {"Hover": false});
				delete this._menuFocus;
			}
		},

		_focusFocus: function(/*Event*/ e){
			// summary:
			//		called when the focus node gets focus
			if(this._menuFocus){
				this.dropDown._updateClass(this._menuFocus, "Item", {"Hover": false});
			}
			delete this._menuFocus;
			var focusNode = focus.curNode;
			if(focusNode){
				focusNode = registry.byNode(focusNode);
				if(focusNode){
					this._menuFocus = focusNode.domNode;
				}
			}
			if(this._menuFocus){
				this.dropDown._updateClass(this._menuFocus, "Item", {"Hover": true});
			}
			delete this._allowBlur;
		},

		_onBlur: function(){
			// summary:
			//		called when focus is shifted away from this widget
			this._allowBlur = true;
			delete this.dropDown._savedFocus;
			this.inherited(arguments);
		},

		_setBlurValue: function(){
			// summary:
			//		sets the value of the widget once focus has left
			if(this.dropDown && !this._settingBlurValue){
				this._settingBlurValue = true;
				this.set("value", this.focusNode.value);
			}else{
				delete this._settingBlurValue;
				this.inherited(arguments);
			}
		},

		parse: function(/*String*/ value, /*Object*/ constraints){
			// summary:
			//		Function to convert a formatted string to a value - we use
			//		it to verify that it *really* is a valid value
			if(this._hasValidPath || this._hasSelection){
				return value;
			}
			var dd = this.dropDown, topDir = dd.topDir, sep = dd.pathSeparator;
			var ddVal = dd.get("pathValue");
			var norm = function(v){
				if(topDir.length && v.indexOf(topDir) === 0){
					v = v.substring(topDir.length);
				}
				if(sep && v[v.length - 1] == sep){
					v = v.substring(0, v.length - 1);
				}
				return v;
			};
			ddVal = norm(ddVal);
			var val = norm(value);
			if(val == ddVal){
				return value;
			}
			return undefined;
		},

		_startSearchFromInput: function(){
			// summary:
			//		kicks off a search based off the current text value of the widget
			var dd = this.dropDown, fn = this.focusNode;
			var val = fn.value, oVal = val, topDir = dd.topDir;
			if(this._hasSelection){
				_TextBoxMixin.selectInputText(fn, oVal.length);
			}
			this._hasSelection = false;
			if(topDir.length && val.indexOf(


? progress; // 0.0 - 1.0, null表示不确定进度
  final VoidCallback? onCancel;
  final bool showCancelButton;

  const FluentVideoLoading({
    super.key,
    this.message,
    this.progress,
    this.onCancel,
    this.showCancelButton = false,
  });

  @override
  State<FluentVideoLoading> createState() => _FluentVideoLoadingState();
}

class _FluentVideoLoadingState extends State<FluentVideoLoading>
    with TickerProviderStateMixin {
  late AnimationController _animationController;
  late Animation<double> _fadeAnimation;

  @override
  void initState() {
    super.initState();
    _animationController = AnimationController(
      duration: const Duration(milliseconds: 800),
      vsync: this,
    );
    _fadeAnimation = Tween<double>(
      begin: 0.0,
      end: 1.0,
    ).animate(CurvedAnimation(
      parent: _animationController,
      curve: Curves.easeInOut,
    ));
    _animationController.forward();
  }

  @override
  void dispose() {
    _animationController.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final theme = FluentTheme.of(context);

    return FadeTransition(
      opacity: _fadeAnimation,
      child: Container(
        color: material.Colors.black.withOpacity(0.8),
        child: Center(
          child: Card(
            padding: const EdgeInsets.all(32),
            borderRadius: BorderRadius.circular(12),
            backgroundColor: theme.cardColor,
            child: ConstrainedBox(
              constraints: const BoxConstraints(
                maxWidth: 400,
                minWidth: 300,
              ),
              child: Column(
                mainAxisSize: MainAxisSize.min,
                children: [
                  // 图标
                  Container(
                    width: 80,
                    height: 80,
                    decoration: BoxDecoration(
                      color: theme.accentColor.withOpacity(0.1),
                      shape: BoxShape.circle,
                    ),
                    child: Icon(
                      FluentIcons.video,
                      size: 40,
                      color: theme.accentColor,
                    ),
                  ),

                  const SizedBox(height: 24),

                  // 标题
                  Text(
                    '正在加载视频',
                    style: theme.typography.subtitle?.copyWith(
                      fontWeight: FontWeight.w600,
                    ),
                  ),

                  const SizedBox(height: 16),

                  // 进度条
                  if (widget.progress != null)
                    Column(
                      children: [
                        ProgressBar(
                          value: widget.progress! * 100,
                        ),
                        const SizedBox(height: 8),
                        Text(
                          '${(widget.progress! * 100).toInt()}%',
                          style: theme.typography.caption?.copyWith(
                            color: theme.inactiveColor,
                          ),
                        ),
                      ],
                    )
                  else
                    const ProgressRing(),

                  const SizedBox(height: 16),

                  // 消息文本
                  if (widget.message != null)
                    Text(
                      widget.message!,
                      style: theme.typography.caption?.copyWith(
                        color: theme.inactiveColor


	'',	'',	'4032001',	'',	'',	'2',	'',	'泡沫',	'Bubble',	'',	'',	'1',	'',	'',	'',	'',	'',	'',	'',	'',	'2001728',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'2001728',	'',	'不知是风雨欲来的天色还是众人的面色更加沉重，即使是一脸茫然的绯猁也不敢胡乱吭声。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'',	'',	'',	'',	'',	'2001729',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'2001729',	'',	'希瓦驱使着武装和随行的后勤造物，困难地将巨石挪开些许。一道贯穿整个掩体的裂缝出现在众人面前。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'[{"id":3012001,"pos":2,"enter":2}]',	'',	'10',	'',	'',	'',	'',	'',	'',	'',	'',	'2001730',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'2001730',	'',	'在裂缝底下，是连光线都无法存在的纯粹黑色，幽深得好像地狱的尽头，没有声音，没有人迹，没有时间的概念。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'',	'',	'10',	'',	'',	'',	'',	'',	'',	'',	'',	'2001731',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'2001731',	'',	'希瓦震惊地后退了一步。',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'1',	'',	'',	'',	'',	'',	'10',	'',	'',	'',	'',	'',	'',	'',	'',	'2001732',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	'',	''},
{'2001732',	'',	'妈呀，这是什么？！',	'',	'',	'',	'',	'',	'',	'',	'',	'3012001',	'',	'',	'2',	'',	'希瓦',


", "At most one of $fieldNames may be non-null")
          endControlFlow()
        }
    }
  }

  private fun generateNewBuilderMethod(type: MessageType, builderClassName: ClassName): FunSpec {
    val funBuilder = FunSpec.builder("newBuilder")
      .addModifiers(OVERRIDE)

    if (mutableTypes || !javaInterOp) {
      val codeBlock = buildCodeBlock {
        if (mutableTypes) {
          addStatement(
            "throw %T(%S)",
            ClassName("kotlin", "UnsupportedOperationException"),
            "newBuilder() is unsupported for mutable message types",
          )
        } else {
          addStatement(
            "throw %T(%S)",
            ClassName("kotlin", "AssertionError"),
            "Builders are deprecated and only available in a javaInterop build; see https://square.github.io/wire/wire_compiler/#kotlin",
          )
        }
      }

      return funBuilder
        .addAnnotation(
          AnnotationSpec.builder(Deprecated::class)
            .addMember("message = %S", "Shouldn't be used in Kotlin")
            .addMember("level = %T.%L", DeprecationLevel::class, DeprecationLevel.HIDDEN)
            .build(),
        )
        .returns(NOTHING)
        .addCode(codeBlock)
        .build()
    }

    funBuilder.returns(builderClassName)

    val nameAllocator = nameAllocator(type)

    funBuilder.addStatement("val builder = Builder()")

    for (fieldOrOneOf in type.fieldsAndFlatOneOfFieldsAndBoxedOneOfs()) {
      when (fieldOrOneOf) {
        is Field -> {
          val fieldName = nameAllocator[fieldOrOneOf]
          funBuilder.addStatement("builder.%1N·= %1N", fieldName)
        }
        is OneOf -> {
          val fieldName = nameAllocator[fieldOrOneOf]
          funBuilder.addStatement("builder.%1N·= %1N", fieldName)
        }
        else -> throw IllegalArgumentException("Unexpected element: $fieldOrOneOf")
      }
    }

    return funBuilder
      .addStatement("builder.addUnknownFields(unknownFields)")
      .addStatement("return builder")
      .build()
  }

  // Example:
  //
  // override fun equals(other: Any?): Boolean {
  //   if (other === this) return true
  //   if (other !is SimpleMessage) return false
  //   if (unknownFields != other.unknownFields) return false
  //   if (optional_int32 != other.optional_int32) return false
  //   return true
  // }
  private fun generateEqualsMethod(type: MessageType, nameAllocator: NameAllocator): FunSpec {
    val localNameAllocator = nameAllocator.copy()
    val otherName = localNameAllocator.newName("other")
    val kotlinType = type.typeName
    val result = FunSpec.builder("equals")
      .addModifiers(OVERRIDE)
      .addParameter(otherName, ANY.copy(nullable = true))
      .returns(BOOLEAN)

    val body = buildCodeBlock {
      addStatement("if (%N === this) return·true", otherName)
      addStatement("if (%N !is %T) return·false", otherName, kotlinType)
      addStatement("if (unknownFields != %N.unknownFields) return·false", otherName)

      for (fieldOrOneOf in type.fieldsAndFlatOneOfFieldsAndBoxedOneOfs()) {
        when (fieldOrOneOf) {
          is Field -> {
            val fieldName = localNameAllocator[fieldOrOneOf]
            if (fieldOrOneOf.useArray) {
              addStatement("if (!%1N.contentEquals(%2N.%1N)) return·false", fieldName, otherName)
            } else {
              addStatement("if (%1N != %2N.%1N) return·false", fieldName, otherName)


: Array<string|number>, refData: {
		refs: Refs,
		paths: Array<Array<string|number>>,
		originalValues: Array<any>
	}) => {
		refs: Refs;
		data: Array<any>;
		rootType: 'array';
	}|{
		refs: Refs;
		data: {
			[key: string]: any;
		};
		rootType: 'object';
	}|{
		refs: Refs;
		data: string;
		rootType: 'normal';
	};
	_replaceRefs: (data: ArrOrObj, refs: ParsingRefs) => ArrOrObj;

	toJSON: (data: any, refs: Refs) => string;
	fromJSON: (str: string) => any;
}import {
    IBulletData,
    IBulletManager, IBulletTask,
    IBulletUpdateResult,
    IIndicatorParams,
    IMoveTracingHandle,
    IMoveTracingIndicator,
    IPointTracingHandle,
    IPointTracingIndicator
} from "./Interface";
import {EBallisticType, EIndicatorType, EDevKeywords, IBallisticIndicator, IIndicator} from "../../define/GameDefine";
import {GameInstance, IExecuteData} from "../Interface";
import {PointTracingHandle} from "./PointTracingHandle";
import {MoveTracingHandle} from "./MoveTracingHandle";

export class BulletManager implements IBulletManager {

    //当前帧戳
    currentFrame:number;

    //类型指定
    readonly type:EIndicatorType.BALLISTIC;

    //~handles
    private _pointHandle:IPointTracingHandle;
    private _moveHandle:IMoveTracingHandle;

    private readonly _frameSchedule:{[frameStamp:number]:IBulletData[]};
    private readonly _beatingDataVec:IBulletData[];

    constructor() {
        this.type = EIndicatorType.BALLISTIC;
        this._pointHandle = new PointTracingHandle();
        this._moveHandle = new MoveTracingHandle();
        this._frameSchedule = {};
        this._beatingDataVec = [];
    }

    //更新框架
    updateFrame(frameStamp:number):void {
        this.currentFrame = frameStamp;
        this._pointHandle.currentFrame = frameStamp;
        this._moveHandle.currentFrame = frameStamp;
        this._beatingDataVec.forEach(bullet => {
            bullet.handle.updateExecute(bullet);
        });
        let currentSchedule = this._frameSchedule[frameStamp];
        if (currentSchedule) {
            let totalSchedules = currentSchedule.length;
            for(let i = totalSchedules - 1;i >= 0; i--) {
                let bullet = currentSchedule[i];
                let result = <IBulletUpdateResult>bullet.handle.updateExecute(bullet);
                if (result.isReached) {
                    this.triggerBullet(bullet);
                }
                else if (result.isDying) {
                    this.removeBullet(bullet);
                }
            }
        }
    }

    //执行指标
    execute(task:IBulletTask):boolean {
        let indicator = task.currentIndicator;
        let type = indicator.ballisticType;
        let param = task.paramBoard;
        let bullet:IBulletData;
        switch (type) {
            case EBallisticType.FIXED_DELAY:
                if (param[EDevKeywords.EXECUTOR_POINT] && param[EDevKeywords.TARGET_POINT]) {
                    bullet = this._pointHandle.create(<IPointTracingIndicator>indicator,param[EDevKeywords.EXECUTOR_POINT], param[EDevKeywords.TARGET_POINT]);
                }
                break;
            case EBallisticType.MOVE_TRACKING:
                if (param[EDevKeywords.EXECUTOR_POINT] && param[EDevKeywords.TARGET_ENTITY]) {
                    bullet = this._moveHandle.create(<IMov


   string systemTextFontName = "Arial",
        Brush? foreground = null,
        Brush? background = null)
    {
        var mathFont = new DefaultTexFont(WpfMathFontProvider.Instance, scale);
        var textFont = GetSystemFont(systemTextFontName, scale);

        return new TexEnvironment(
            style,
            mathFont,
            textFont,
            background.ToPlatform(),
            foreground.ToPlatform());
    }

    private static WpfSystemFont GetSystemFont(string fontName, double size)
    {
        var fontFamily = System.Windows.Media.Fonts.SystemFontFamilies.First(
            ff => ff.ToString() == fontName || ff.FamilyNames.Values?.Contains(fontName) == true);
        return new WpfSystemFont(size, fontFamily);
    }
}


 view, you'll find everything you need: your timetable, your tasks, your assignments and your unread messages, all in one place.",
          "welcome_title_2":
              "You can see your deteriorating tendency in ten different ways",
          "welcome_text_2":
              "You will see so many statistics that 8 years of elementary maths will not be enough to comprehend it.",
          "welcome_title_3":
              "Follow your goals and turn maths one into maths five.",
          "welcome_text_3":
              "Set your target and we'll tell you how many grades you should get. You even get confetti when you reach your goal.",
          "welcome_title_4": "Take as many notes as you want.",
          "welcome_text_4":
              "You can also organise your notes by lesson in the built-in notebook, so you can find everything in one app.",
          "login_w_kreta_acc": "Mit e-KRÉTA-Konto anmelden",
        },
      };

  String get i18n => localize(this, _t);
  String fill(List<Object> params) => localizeFill(this, params);
  String plural(int value) => localizePlural(value, this, _t);
  String version(Object modifier) => localizeVersion(modifier, this, _t);
}
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'timetable_cache_model.dart';

// **************************************************************************
// IsarCollectionGenerator
// **************************************************************************

// coverage:ignore-file
// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types

extension GetTimetableCacheModelCollection on Isar {
  IsarCollection<TimetableCacheModel> get timetableCacheModels =>
      this.collection();
}

const TimetableCacheModelSchema = CollectionSchema(
  name: r'TimetableCacheModel',
  id: -8626340955125680275,
  properties: {
    r'values': PropertySchema(
      id: 0,
      name: r'values',
      type: IsarType.stringList,
    )
  },
  estimateSize: _timetableCacheModelEstimateSize,
  serialize: _timetableCacheModelSerialize,
  deserialize: _timetableCacheModelDeserialize,
  deserializeProp: _timetableCacheModelDeserializeProp,
  idName: r'cacheKey',
  indexes: {},
  links: {},
  embeddedSchemas: {},
  getId: _timetableCacheModelGetId,
  getLinks: _timetableCacheModelGetLinks,
  attach: _timetableCacheModelAttach,
  version: '3.1.0+1',
);

int _timetableCacheModelEstimateSize(
  TimetableCacheModel object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final list = object.values;
    if (list != null) {
      bytesCount += 3 + list.length * 3;
      {
        for (var i = 0; i < list.length; i++) {
          final value = list[i];
          bytesCount += value.length * 3;
        }
      }
    }
  }
  return bytesCount;
}

void _timetableCacheModelSerialize(
  TimetableCacheModel object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeStringList(offsets[0], object.values);
}

TimetableCa


.text
main:
la $a0, prompt
li $v0, 4           # print
syscall

li $v0, 5           # read int
syscall

move $t4, $v0       # $t4 <- n
addi $t4, $t4, 1

li $t2, 1           # $t2 is an index i

loop:
move $a0, $t2
move $v0, $t2
jal fib             # call fib (n)
move $t3, $v0       # result is in $t3

# Output message and n
la $a0, result      # Print F_
li $v0, 4
syscall

move $a0, $t2       # Print n
li $v0, 1
syscall

la $a0, result2     # Print =
li $v0, 4
syscall

move $a0, $t3       # Print the answer
li $v0, 1
syscall

la $a0, endl        # Print '\n'
li $v0, 4
syscall

addi $t2, $t2, 1    # i++
bne $t2, $t4, loop

# End program
li $v0, 10
syscall

fib:
# Compute and return fibonacci number
beqz $a0, zero      # if n == 0 return 0
beq $a0, 1, one     # if n == 1 return 1

# Calling fib(n-1)
sub $sp, $sp, 4     # storing return address
sw $ra, 0($sp)

sub $a0, $a0, 1     # n-1
jal