T2YoTywgcHJvdG8pXG52YXIgJGV4cG9ydCA9IHJlcXVpcmUoJy4vX2V4cG9ydCcpO1xuJGV4cG9ydCgkZXhwb3J0LlMsICdPYmplY3QnLCB7IHNldFByb3RvdHlwZU9mOiByZXF1aXJlKCcuL19zZXQtcHJvdG8nKS5zZXQgfSk7XG5cblxuXG4vLy8vLy8vLy8vLy8vLy8vLy9cbi8vIFdFQlBBQ0sgRk9PVEVSXG4vLyAuL25vZGVfbW9kdWxlcy9jb3JlLWpzL2xpYnJhcnkvbW9kdWxlcy9lczYub2JqZWN0LnNldC1wcm90b3R5cGUtb2YuanNcbi8vIG1vZHVsZSBpZCA9IDQ4MFxuLy8gbW9kdWxlIGNodW5rcyA9IDkiXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7QUFDQTsiLCJzb3VyY2VSb290IjoiIn0=\n//# sourceURL=webpack-internal:///480\n");

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

eval("// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = __webpack_require__(49);\nvar anObject = __webpack_require__(39);\nvar check = function (O, proto) {\n  anObject(O);\n  if (!isObject(proto) && proto !== null) throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function (test, buggy, set) {\n      try {\n        set = __webpack_require__(71)(Function.call, __webpack_require__(209).f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch (e) { buggy = true; }\n      return function setPrototypeOf(O, proto) {\n        check(O, proto);\n        if (buggy) O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNDgxLmpzIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vLy4vbm9kZV9tb2R1bGVzL2NvcmUtanMvbGlicmFyeS9tb2R1bGVzL19zZXQtcHJvdG8uanM/NjVhNCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBXb3JrcyB3aXRoIF9fcHJvdG9fXyBvbmx5LiBPbGQgdjggY2FuJ3Qgd29yayB3aXRoIG51bGwgcHJvdG8gb


nd	#$003c,d0
	add.b	d0,Voice_Tremolo_Position(a6)
	bra		Simplet_Period_Nop
;
Simplet_Sample_Offset:
	move.l	Voice_Sample_Offset(a6),d1
	clr.l	d0
	move.b	Voice_Parameters(a6),d0
	beq.s	Simplet_Sample_Offset_No_New
;
	lsl.w	#8,d0
	move.l	d0,d1
Simplet_Sample_Offset_No_New:
;
	move.l	Voice_Sample_Offset(a6),d0
	add.l	d1,d0
	cmp.l	Voice_Length(a6),d0
	ble.s	Simplet_Sample_Offset_Ok
	move.l	Voice_Length(a6),d0
Simplet_Sample_Offset_Ok:
	move.l	d0,Voice_Sample_Offset(a6)
	move.l	d0,Voice_Sample_Position(a6)
	rts
;
Volume_Slide:
	clr.l	d0
	move.b	Voice_Parameters(a6),d0
	lsr	#4,d0
	beq.s	Volume_Slide_Down
	mulu	#5,d0
Volume_Slide_Up_d0:
	add	d0,Voice_Volume(a6)
	cmp	#$40,Voice_Volume(a6)
	ble.s	Volume_Slide_Up_Ok
	move	#$40,Voice_Volume(a6)
;
Volume_Slide_Up_Ok:
	move	Voice_Volume(a6),Voice_Sample_Volume(a6)
	bra	Simplet_Period_Nop
;
Volume_Slide_Down:
	move.b	Voice_Parameters(a6),d0
	and	#$0f,d0
	mulu	#5,d0
Volume_Slide_Down_d0:
	sub.w	d0,Voice_Volume(a6)
	bpl.s	Volume_Slide_Down_Ok
	clr	Voice_Volume(a6)
;
Volume_Slide_Down_Ok:
	move	Voice_Volume(a6),Voice_Sample_Volume(a6)
	bra	Simplet_Period_Nop
;
Simplet_Position_Jump:
	clr.l	d0
	move.b	Voice_Parameters(a6),d0
;
	move	d0,Simplet_Position_Jump_Pos
	st	Simplet_Position_Jump_Flag
	rts
;
Volume_Change:
	clr.l	d0
	move.b	Voice_Parameters(a6),d0
	cmp.b	#$40,d0
	ble.s	Volume_Change_Ok
	moveq.l	#$40,d0
;
Volume_Change_Ok:
	move	d0,Voice_Volume(a6)
	move	d0,Voice_Sample_Volume(a6)
	rts
;
Simplet_Pattern_Break:
	clr.l	d0
;
	tst.b	Simplet_Old_Module(pc)
	bne.s	Simplet_Pattern_Break_Ok
;
	move.b	Voice_Parameters(a6),d0
;
	move	d0,d2			; Codage en BCD
	lsr	#4,d0			; premier chiffre
	mulu.w	#10,d0			; les dizaines
	and	#$0f,d2			; deuxime chiffre
	add


bgzfp->ff = nullptr;
        *reterrp = kPglRetWriteFail;
        return 1;
      }
    }
    bgzfp->ff = nullptr;
  }
  return 0;
}

#ifdef __cplusplus
}
#endif
// This library is part of PLINK 2, copyright (C) 2005-2024 Shaun Purcell,
// Christopher Chang.
//
// This library is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation; either version 3 of the License, or (at your
// option) any later version.
//
// This library 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 Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library.  If not, see <http://www.gnu.org/licenses/>.

#include "plink2_bits.h"

#ifdef __cplusplus
namespace plink2 {
#endif

#if defined(USE_SSE2) && !defined(USE_AVX2)
void Pack32bTo16bMask(const void* words_vec, uintptr_t ct_32b, void* dest) {
  // This is also competitive in the AVX2 case, but never quite beats the
  // simple loop.  (We'd want to enable a similar function for Ryzen,
  // processing one 32-byte vector instead of two 16-byte vectors at a time in
  // the main loop since _mm256_packus_epi16() doesn't do what we want.)
  const VecW m1 = VCONST_W(kMask5555);
#  ifdef USE_SHUFFLE8
  const VecW swap12 = vecw_setr8(
      0, 1, 4, 5, 2, 3, 6, 7,
      8, 9, 12, 13, 10, 11, 14, 15);
#  else
  const VecW m2 = VCONST_W(kMask3333);
#  endif
  const VecW m4 = VCONST_W(kMask0F0F);
  const VecW m8 = VCONST_W(kMask00FF);
  const VecW* words_valias = S_CAST(const VecW*, words_vec);
  unsigned char* dest_uc = S_CAST(unsigned char*, dest);
  for (uintptr_t vidx = 0; vidx != ct_32b; ++vidx) {
    VecW vec_lo = vecw_loadu(&(words_valias[2 * vidx])) & m1;
    VecW vec_hi = vecw_loadu(&(words_valias[2 * vidx + 1])) & m1;
#  ifdef USE_SHUFFLE8
    // this right-shift-3 + shuffle shortcut saves two operations.
    vec_lo = (vec_lo | vecw_srli(vec_lo, 3)) & m4;
    vec_hi = (vec_hi | vecw_srli(vec_hi, 3)) & m4;
    vec_lo = vecw_shuffle8(swap12, vec_lo);
    vec_hi = vecw_shuffle8(swap12, vec_hi);
#  else
    vec_lo = (vec_lo | vecw_srli(vec_lo, 1)) & m2;
    vec_hi = (vec_hi | vecw_srli(vec_hi, 1)) & m2;
    vec_lo = (vec_lo | vecw_srli(vec_lo, 2)) & m4;
    vec_hi = (vec_hi | vecw_srli(vec_hi, 2)) & m4;
#  endif
    vec_lo = vec_lo | vecw_srli(vec_lo, 4);
    vec_hi = vec_hi | vecw_srli(vec_hi, 4);
    const VecW vec_packed = vecw_gather_even(vec_lo, vec_hi, m8);
    vecw_storeu(&(dest_uc[vidx * 16]), vec_packed);
  }
}


port androidx.core.view.doOnLayout
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.recyclerview.widget.RecyclerView.OnScrollListener
import androidx.recyclerview.widget.RecyclerViewUtils
import androidx.recyclerview.widget.StaggeredGridLayoutManager
import kohii.v1.core.Bucket
import kohii.v1.core.Manager
import kohii.v1.core.Playback
import kohii.v1.core.Selector
import kohii.v1.core.Strategy

internal class RecyclerViewBucket(
  manager: Manager,
  override val root: RecyclerView,
  strategy: Strategy,
  selector: Selector,
) : Bucket(manager, root, strategy, selector), RecyclerView.OnChildAttachStateChangeListener {
  companion object {
    internal fun RecyclerView.fetchOrientation(): Int {
      val layout = this.layoutManager ?: return NONE_AXIS
      return when (layout) {
        is LinearLayoutManager -> layout.orientation
        is StaggeredGridLayoutManager -> layout.orientation
        else -> {
          return if (layout.canScrollVertically()) {
            if (layout.canScrollHorizontally()) {
              BOTH_AXIS
            } else {
              VERTICAL
            }
          } else {
            if (layout.canScrollHorizontally()) {
              HORIZONTAL
            } else {
              NONE_AXIS
            }
          }
        }
      }
    }
  }

  private val scrollListener =
    object : OnScrollListener() {
      override fun onScrolled(
        recyclerView: RecyclerView,
        dx: Int,
        dy: Int,
      ) {
        manager.refresh()
      }
    }

  override fun onAdded() {
    super.onAdded()
    root.addOnScrollListener(scrollListener)
    root.addOnChildAttachStateChangeListener(this)
  }

  override fun onAttached() {
    super.onAttached()
    root.doOnLayout { view ->
      if (view.isAttachedToWindow &&
        view is RecyclerView &&
        view.scrollState == RecyclerView.SCROLL_STATE_IDLE
      ) {
        manager.refresh()
      }
    }
  }

  override fun onRemoved() {
    super.onRemoved()
    root.removeOnScrollListener(scrollListener)
    root.removeOnChildAttachStateChangeListener(this)
  }

  override fun accepts(container: ViewGroup): Boolean {
    if (!container.isAttachedToWindow) return false
    val params = RecyclerViewUtils.fetchItemViewParams(container)
    return RecyclerViewUtils.accepts(root, params)
  }

  override fun allowToPlay(playback: Playback): Boolean {
    val container = playback.container
    return root.findContainingViewHolder(container) != null && super.allowToPlay(playback)
  }

  override fun selectToPlay(candidates: Collection<Playback>): Collection<Playback> {
    return selectByOrientation(candidates, orientation = root.fetchOrientation())
  }

  override fun onChildViewAttachedToWindow(view: View) {
    val holder = root.findContainingViewHolder(view)
    manager.master.requests.filter {
      RecyclerViewUtils.fetchViewHolder(it.key) === holder
    }
      .forEach {
        it.value.bucket = this
      }
  }

  override fun onChildViewDetachedFromWindow(view: View) {
    // do nothing
  }
}
/*
 * Copyright (c) 2019 Nam Nguyen, nam@ene.im
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE


     """Print simulation results to console."""
        print(f"\nSimulation Results - {results.scenario.upper()}")
        print("=" * 50)

        print(f"Duration: {results.duration:.2f} seconds")
        print(f"Total Events: {len(results.events)}")
        print(f"Nodes Simulated: {results.statistics.get('nodes_simulated', 0)}")

        # Event summary
        event_types = results.statistics.get('event_types', {})
        if event_types:
            print(f"\nEvent Summary:")
            for event_type, count in event_types.items():
                print(f"  {event_type.replace('_', ' ').title()}: {count}")

        # Node states
        node_states = results.node_states
        operational_nodes = sum(1 for state in node_states.values() if state.get('operational', False))
        print(f"\nFinal State:")
        print(f"  Operational Nodes: {operational_nodes}/{len(node_states)}")

        # Recent events
        recent_events = results.events[-5:] if len(results.events) > 5 else results.events
        if recent_events:
            print(f"\nRecent Events:")
            for event in recent_events:
                device_info = f" [{event['device']}]" if event.get('device') else ""
                print(f"  • {event['message']}{device_info}")

        print("=" * 50)


Value.getObject(rt));
      w2c_rapier__wasm3d__bg_rawshapecasthit_witness2(&nativeState->rootCtx, args[0].asNumber());

      return jsi::Value::undefined();
    }));

    /* export: '__wbindgen_add_to_stack_pointer' */
    exports.setProperty(rt, "__wbindgen_add_to_stack_pointer", HOSTFN("__wbindgen_add_to_stack_pointer", 1) {
      auto nativeState = tryGetContext(rt, thisValue.getObject(rt));
      w2c_rapier__wasm3d__bg_0x5F_wbindgen_add_to_stack_pointer(&nativeState->rootCtx, args[0].asNumber());

      return jsi::Value::undefined();
    }));

    /* export: '__wbindgen_free' */
    exports.setProperty(rt, "__wbindgen_free", HOSTFN("__wbindgen_free", 3) {
      auto nativeState = tryGetContext(rt, thisValue.getObject(rt));
      w2c_rapier__wasm3d__bg_0x5F_wbindgen_free(&nativeState->rootCtx, args[0].asNumber(), args[1].asNumber(), args[2].asNumber());

      return jsi::Value::undefined();
    }));

    /* export: '__wbindgen_malloc' */
    exports.setProperty(rt, "__wbindgen_malloc", HOSTFN("__wbindgen_malloc", 2) {
      auto nativeState = tryGetContext(rt, thisValue.getObject(rt));
      w2c_rapier__wasm3d__bg_0x5F_wbindgen_malloc(&nativeState->rootCtx, args[0].asNumber(), args[1].asNumber());

      return jsi::Value::undefined();
    }));

    /* export: '__wbindgen_exn_store' */
    exports.setProperty(rt, "__wbindgen_exn_store", HOSTFN("__wbindgen_exn_store", 1) {
      auto nativeState = tryGetContext(rt, thisValue.getObject(rt));
      w2c_rapier__wasm3d__bg_0x5F_wbindgen_exn_store(&nativeState->rootCtx, args[0].asNumber());

      return jsi::Value::undefined();
    }));

  exports.setNativeState(rt, inst);
  mod.setProperty(rt, "exports", std::move(exports));

  // end full exports
  return mod;
}

}
//
//  tagfile.cpp
//  boe_test
//
//  Created by Celtic Minstrel on 2022-07-12.
//

#include "fileio/tagfile.hpp"
#include <sstream>
#include <array>

#include "catch.hpp"

TEST_CASE("Simple tag file") {
	static const std::string file_contents =
	"A 12\n"
	"B 22\n"
	"C 45\n"
	"\f"
	"X 'Hello World'\n"
	"Y foo\n"
	"Z Blah!\n"
	;
	cTagFile content;
	SECTION("output") {
		std::ostringstream file;
		auto& p1 = content.add();
		p1["A"] << 12;
		p1["B"] << 22;
		p1["C"] << 45;
		auto& p2 = content.add();
		p2["X"] << "Hello World";
		p2["Y"] << "foo";
		p2["Z"] << "Blah!";
		content.writeTo(file);
		CHECK(file.str() == file_contents);
	}
	SECTION("input") {
		std::istringstream file(file_contents);
		content.readFrom(file);
		CHECK(content[0]["A"][0] == 12);
		CHECK(content[0]["B"][0] == 22);
		CHECK(content[0]["C"][0] == 45);
		CHECK(content[1]["X"][0] == std::string("Hello World"));
		CHECK(content[1]["Y"][0] == std::string("foo"));
		CHECK(content[1][


ries[Name].Name, "VSize"))
						if (Height == -1)
							Height = Val;
				}

			} while (!ieof());

			if (Format == -1)
				Format = UTX_P8;
			if (Width == -1 || Height == -1 || (PalEntry == NumPal && Format != UTX_DXT1) || (Format != UTX_P8 && Format != UTX_DXT1))
				return IL_FALSE;
			if (BaseCreated == IL_FALSE) {
				BaseCreated = IL_TRUE;
				ilTexImage(Width, Height, 1, UtxFormatToBpp(Format), UtxFormatToDevIL(Format), IL_UNSIGNED_BYTE, NULL);
				Image = iCurImage;
			}
			else {
				Image->Next = ilNewImageFull(Width, Height, 1, UtxFormatToBpp(Format), UtxFormatToDevIL(Format), IL_UNSIGNED_BYTE, NULL);
				if (Image->Next == NULL)
					return IL_FALSE;
				Image = Image->Next;
			}

			iseek(5, IL_SEEK_CUR);
			UtxReadCompactInteger();

			switch (Format)
			{
				case UTX_P8:
					Image->Pal.PalSize = Palettes[PalEntry].Count * 4;
					Image->Pal.Palette = (ILubyte*)ialloc(Image->Pal.PalSize);
					if (Image->Pal.Palette == NULL)
						//@TODO: Do all the deallocations needed here!
						return IL_FALSE;
					memcpy(Image->Pal.Palette, Palettes[PalEntry].Pal, Image->Pal.PalSize);
					Image->Pal.PalType = IL_PAL_RGBA32;

					if (iread(Image->Data, Image->SizeOfData, 1) != 1)
						return IL_FALSE;  //@TODO: Deallocations...
					break;

				case UTX_DXT1:
//
//
// HACK!!!
//
//
//igetc();
//ExtraData[0] = igetc();
//if (ExtraData[0] == 0x0C)
	//iseek(8, IL_SEEK_CUR);
//	iread(ExtraData+1, 8, 1);
//else
	//iseek(7, IL_SEEK_CUR);
//	iread(ExtraData+1, 7, 1);
//if (igetc() == 0x80)
//	igetc();
					Image->DxtcSize = IL_MAX(Image->Width * Image->Height / 2, 8);
					CompData = (ILubyte*)ialloc(Image->DxtcSize);
					if (CompData == NULL)
						//@TODO: Do all the deallocations needed here!
						return IL_FALSE;

					if (iread(CompData, Image->DxtcSize, 1) != 1) {
						ifree(CompData);
						return IL_FALSE;  //@TODO: Deallocations...
					}
					// Keep a copy of the DXTC data if the user wants it.
					if (ilGetInteger(IL_KEEP_DXTC_DATA) == IL_TRUE) {
						Image->DxtcData = CompData;
						Image->DxtcFormat = IL_DXT1;
						CompData = NULL;
					}
					if (DecompressDXT1(Image, CompData) == IL_FALSE) {
						ifree(CompData);
						return IL_FALSE;
					}
					ifree(CompData);
					break;
			}
			Image->Origin = IL_ORIGIN_UPPER_LEFT;
		}
	}

	UtxDestroyNameEntries(NameEntries, &Header);
	UtxDestroyExportTable(ExportTable, &Header);
	UtxDestroyImportTable(ImportTable, &Header);
	UtxDestroyPalettes(Palettes, NumPal);

	//return IL_FALSE;
	return ilFixImage();
}

#endif//IL_NO_UTX


ndencies = relationalDependencies;

    /// <summary>
    ///     Relational provider-specific dependencies for this service.
    /// </summary>
    protected virtual RelationalEvaluatableExpressionFilterDependencies RelationalDependencies { get; }

    /// <inheritdoc />
    public override bool IsEvaluatableExpression(Expression expression, IModel model)
    {
        if (expression is MethodCallExpression methodCallExpression)
        {
            var method = methodCallExpression.Method;

            if (model.FindDbFunction(method) != null)
            {
                // Never evaluate DbFunction
                // If it is inside lambda then we will have whole method call
                // If it is outside of lambda then it will be evaluated for table valued function already.
                return false;
            }

            if (method.DeclaringType == typeof(RelationalDbFunctionsExtensions))
            {
                return false;
            }
        }

        return base.IsEvaluatableExpression(expression, model);
    }
}


14]
	br .L4
.L27:
	cmp4.ne p6, p7 = 13, r40
	(p6) br.cond.dptk .L29
	adds r15 = 208, r12
	;;
	adds r14 = -152, r15
	;;
	ldfd f8 = [r14]
	br .L4
.L29:
	cmp4.ne p6, p7 = 14, r40
	(p6) br.cond.dptk .L31
.L70:
	adds r16 = 208, r12
	;;
	adds r14 = -152, r16
	;;
	ld8 r8 = [r14]
	br .L4
.L31:
	cmp4.ne p6, p7 = 15, r40
	(p6) br.cond.dptk .L4
	ld4 r15 = [r41]
	;;
	and r14 = 1, r15
	;;
	cmp4.eq p6, p7 = 0, r14
	(p6) br.cond.dptk .L34
	ld8 r8 = [r42]
	br .L4
.L34:
	addl r14 = 1024, r0
	;;
	and r14 = r14, r15
	;;
	cmp4.eq p6, p7 = 0, r14
	(p6) br.cond.dptk .L4
	adds r17 = 208, r12
	;;
	adds r14 = -160, r17
	;;
	ld8 r17 = [r14]
	;;
	adds r15 = -1, r17
	;;
	cmp.ltu p6, p7 = 31, r15
	(p6) br.cond.dptk .L4
	ld8 r16 = [r42]
	;;
	cmp.geu p6, p7 = 1, r17
	ld1 r8 = [r16]
	(p6) br.cond.dptk .L38
	adds r15 = 1, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 8
	;;
	or r8 = r14, r8
.L38:
	cmp.geu p6, p7 = 2, r17
	(p6) br.cond.dptk .L39
	adds r15 = 2, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 16
	;;
	or r8 = r14, r8
.L39:
	cmp.geu p6, p7 = 3, r17
	(p6) br.cond.dptk .L40
	adds r15 = 3, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 24
	;;
	or r8 = r14, r8
.L40:
	cmp.geu p6, p7 = 4, r17
	(p6) br.cond.dptk .L41
	adds r15 = 4, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 32
	;;
	or r8 = r14, r8
.L41:
	cmp.geu p6, p7 = 5, r17
	(p6) br.cond.dptk .L42
	adds r15 = 5, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 40
	;;
	or r8 = r14, r8
.L42:
	cmp.geu p6, p7 = 6, r17
	(p6) br.cond.dptk .L43
	adds r15 = 6, r16
	;;
	ld1 r14 = [r15]
	;;
	shl r14 = r14, 48
	;;
	or r8 =


( (resp: any) => {  // Pasar por el map la respuesta devuelta y obtener solo el hospital
              return resp.hospital;
          }));
  }

  borrarHospital( id: string ){

        let url = URL_SERVICIOS + '/hospital/' + id + '?token=' + this.token;  // url = 'http://localhost:3000/hospital/6064ad5465fe8126cc832c9b?token=xxxxxxxxxxx'

        this.cargarStorage();  // Recarga los valores de las propiedades token y usuario almacenados en el LocalStorage para actualizarlos

        return this.http.delete(url)
          .pipe(map((resp: any) => {
            console.log(resp.hospital);
            Swal.fire('Hospital Eliminado', 'Hospital ' + resp.hospital.nombre + ' eliminado correctamente', 'success');  //SweetAlert2
            return true
          }));
  }

  crearHospital( nombre: Hospital ){

        let url = URL_SERVICIOS + '/hospital?token=' + this.token;   // url = 'http://localhost:3000/hospital?token=token_usuario_que_crea_hospital'

        return this.http.post(url, nombre);
  }

  buscarHospitales( termino: string ){

        let url = URL_SERVICIOS + '/busqueda/coleccion/hospitales/' + termino;  // url = 'http://localhost:3000/busqueda/coleccion/hospitales/termino_de_busqueda'

        return this.http.get(url)  // Devuelve la busqueda realizada con los hospitales que coincidan con el término de búsqueda en la colección de hospitales de mongoDB
          .pipe(map( (resp: any) => resp.hospitales));  // Pasa la respuesta con el resultado de la búsqueda por el operador map y devuelve solo el array de hospitales

  }

  actualizarHospital( hospital: Hospital ){

        let url = `${URL_SERVICIOS}/hospital/${hospital._id}?token=${this.token}`;  //url 'http://localhost:3000/hospital/:id?token=xxxxxxxxxxxx' a la cual haremos la petición

        this.cargarStorage();  // Recarga los valores de las propiedades token y usuario almacenados en el LocalStorage para actualizarlos

        return this.http.put(url, hospital)  //La respueta a esta petición será entregada (retornada) a quien esté suscrito (esto es un observable)
                .pipe(map( (resp: any) => {  // Pasa por el operador map la respuesta

                  Swal.fire('Hospital Actualizado', resp.hospital.nombre, 'success');  //Alerta de SweetAlert2 para hospital actualizado
                  return true;  // Retorna un true si todo OK, si retornara false sabríamos que hubo problemas y no actualizó
                }));

  }

}
///<reference path="../reference.ts" />

module Plottable {
export module Animator {

  /**
   * A child class of RectAnimator that will move the rectangle
   * as well as animate its growth.
   */
  export class MovingRect extends Rect {

    /**
     * The pixel value to move from
     */
    public startPixelValue: number;

    /**
     * Constructs a MovingRectAnimator
     *
     * @param {number} basePixel The pixel value to start moving from
     * @param {boolean} isVertical If the movement/animation is vertical
     */
    constructor(startPixelValue: number, isVertical = true) {
      super(isVertical);
      this.startPixelValue = startPixelValue;
    }

    public _startMovingProjector(attrToProjector: AttributeToProjector) {
      return d3.functor(this.startPixelValue);
    }


        DC32     Mode_Sense10_data
        CFI EndBlock cfiBlock4
//  145 }
//  146
//  147 /*******************************************************************************
//  148 * Function Name  : SCSI_RequestSense_Cmd
//  149 * Description    : SCSI RequestSense Command routine.
//  150 * Input          : None.
//  151 * Output         : None.
//  152 * Return         : None.
//  153 *******************************************************************************/

        SECTION `.text`:CODE:NOROOT(2)
        CFI Block cfiBlock5 Using cfiCommon0
        CFI Function SCSI_RequestSense_Cmd
        THUMB
//  154 void SCSI_RequestSense_Cmd (void)
//  155 {
SCSI_RequestSense_Cmd:
        LDR.N    R0,??DataTable16  ;; CBW
        LDRB     R1,[R0, #+19]
        CMP      R1,#+19
        IT       CS
//  156   u8 Request_Sense_data_Length;
//  157
//  158   if (CBW.CB[4] <= REQUEST_SENSE_DATA_LEN)
//  159   {
//  160     Request_Sense_data_Length = CBW.CB[4];
//  161   }
//  162   else
//  163   {
//  164     Request_Sense_data_Length = REQUEST_SENSE_DATA_LEN;
        MOVCS    R1,#+18
//  165   }
//  166   Transfer_Data_Request(Scsi_Sense_Data, Request_Sense_data_Length);
        LDR.N    R0,??DataTable7  ;; Scsi_Sense_Data
        B.W      Transfer_Data_Request
        CFI EndBlock cfiBlock5
//  167 }
//  168
//  169 /*******************************************************************************
//  170 * Function Name  : Set_Scsi_Sense_Data
//  171 * Description    : Set Scsi Sense Data routine.
//  172 * Input          : u8 Sens_Key
//  173                    u8 Asc.
//  174 * Output         : None.
//  175 * Return         : None.
//  176 *******************************************************************************/

        SECTION `.text`:CODE:NOROOT(2)
        CFI Block cfiBlock6 Using cfiCommon0
        CFI Function Set_Scsi_Sense_Data
        THUMB
//  177 void Set_Scsi_Sense_Data(u8 Sens_Key, u8 Asc)
//  178 {
//  179   Scsi_Sense_Data[2] = Sens_Key;
Set_Scsi_Sense_Data:
        LDR.N    R2,??DataTable7  ;; Scsi_Sense_Data
        STRB     R0,[R2, #+2]
//  180   Scsi_Sense_Data[12] = Asc;
        STRB     R1,[R2, #+12]
//  181 }
        BX       LR               ;; return
        CFI EndBlock cfiBlock6

        SECTION `.text`:CODE:NOROOT(2)
        DATA
??DataTable7:
        DC32     Scsi_Sense_Data
//  182
//  183 /*******************************************************************************
//  184 * Function Name  : SCSI_Start_Stop_Unit_Cmd
//  185 * Description    : SCSI Start_Stop_Unit Command routine.
//  186 * Input          : None.
//  187 * Output         : None.
//  188 * Return         : None.
//  189 *******************************************************************************/

        SECTION `.text`:CODE:NOROOT(2)
        CFI Block cfiBlock7 Using cfiCommon0
        CFI Function SCSI_Start_Stop_Unit_Cmd
        THUMB
//  190 void SCSI_Start_Stop_Unit_Cmd(void)
//  191 {


',GradientType=0 );
}
.vjs-styled-skin .vjs-play-control:before {
  content: "\e001";
}
.vjs-styled-skin.vjs-playing .vjs-play-control:before {
  content: "\e002";
}
/* Volume/Mute
-------------------------------------------------------------------------------- */
.vjs-styled-skin .vjs-mute-control,
.vjs-styled-skin .vjs-volume-menu-button {
  cursor: pointer;
  float: right;
}
.vjs-styled-skin .vjs-mute-control:before,
.vjs-styled-skin .vjs-volume-menu-button:before {
  content: "\e006";
}
.vjs-styled-skin .vjs-mute-control.vjs-vol-0:before,
.vjs-styled-skin .vjs-volume-menu-button.vjs-vol-0:before {
  content: "\e003";
}
.vjs-styled-skin .vjs-mute-control.vjs-vol-1:before,
.vjs-styled-skin .vjs-volume-menu-button.vjs-vol-1:before {
  content: "\e004";
}
.vjs-styled-skin .vjs-mute-control.vjs-vol-2:before,
.vjs-styled-skin .vjs-volume-menu-button.vjs-vol-2:before {
  content: "\e005";
}
.vjs-styled-skin .vjs-volume-control {display: none;}

/* Progress
--------------------------------------------------------------------------------
*/

.vjs-styled-skin .vjs-progress-control {
  position: absolute;
  left: 6em;
  right: 8.6em;
  width: auto;
  height: 11px;
  top: 10px;
  border-radius: 6px;
  padding: 0 2px;
  background: #7a9922;
  -webkit-box-shadow: 0 1px 0 rgba(255,255,255,0.26), inset 0 1px 2px rgba(0,0,0,0.33);
  box-shadow: 0 1px 0 rgba(255,255,255,0.26), inset 0 1px 2px rgba(0,0,0,0.33);
}

.vjs-styled-skin .vjs-slider {
  outline: 0;
  position: relative;
  cursor: pointer;
  padding: 0;
  border-radius: 6px;
  height: 100%;
}
.vjs-styled-skin .vjs-slider:focus {
  -webkit-box-shadow: 0 0 2em #ffffff;
  box-shadow: 0 0 2em #ffffff;
}
.vjs-styled-skin .vjs-slider-handle {
  position: absolute;
  left: 0;
  top: -3px;
  width: 16px;
  height: 16px;
  background: #f7f7f7;
  border: 1px solid #969696;
  border-radius: 50%;
  -webkit-box-shadow: 0 1px 4px rgba(62,77,18,0.5);
  box-shadow: 0 1px 4px rgba(62,77,18,0.5);
}
.vjs-styled-skin .vjs-slider-handle:before {
  content: "";
  position: absolute;
  left: 4px;
  top: 4px;
  width: 6px;
  height: 6px;
  background: #F0EAEA;
  border: 1px solid #969696;
  border-radius: 50%;
  -webkit-box-shadow: inset 0 1px 4px rgba(62,77,18,0.5);


有效执行枪支、弹药管理制度，造成枪支、弹药被盗、被抢或者丢失的；

(五)枪支、弹药被盗、被抢或者丢失，未及时报告公安机关的；

(六)不按照规定审验枪支的；

(七)不上缴报废枪支的；

(八)发生其他涉枪违法违纪案件的。

第十六条 专职守护、押运人员依照本条例的规定使用枪支，造成无辜人员伤亡或者财产损失的，由其所在单位依法补偿受害人的损失。

专职守护、押运人员违反本条例的规定使用枪支，造成人员伤亡或者财产损失的，除依法受到刑事处罚或者行政处罚外，还应当依法承担赔偿责任。

第十七条 公安机关有下列行为之一，造成严重后果的，对直接负责的主管人员和其他直接责任人员依照刑法关于滥用职权罪、玩忽职守罪的规定，依法追究刑事责任；尚不够刑事处罚的，依法给予记大过、降级或者撤职的行政处分：

(一)超出法定范围批准有关单位配备守护、押运公务用枪的；

(二)为不符合法定条件的人员发放守护、押运公务用枪持枪证件的；

(三)不履行本条例规定的监督管理职责，造成后果的。

第十八条 本条例自公布之日起施行。# 储蓄管理条例

1992年12月11日 中华人民共和国国务院令第107号发布

<!-- INFO END -->

## 第一章 总则

第一条 为了发展储蓄事业，保护储户的合法权益，加强储蓄管理，制定本条例。

第二条 凡在中国境内办理储蓄业务的储蓄机构和参加储蓄的个人，必须遵守本条例的规定。

第三条 本条例所称储蓄是指个人将属于其所有的人民币或者外币存入储蓄机构，储蓄机构开具存折或者存单作为凭证，个人凭存折或者存单可以支取存款本金和利息，储蓄机构依照规定支付存款本金和利息的活动。

任何单位和个人不得将公款以个人名义转为储


{
            archiveClassifier.set("javadoc")
            archiveAppendix.set(this@withType.name)
        })

        // Provide artifacts information required by Maven Central
        pom {
            name.set("Ksoup")
            description.set("A lightweight Kotlin Multiplatform library to parse HTML/XML data.")
            url.set("https://github.com/MohamedRejeb/Ksoup")

            licenses {
                license {
                    name.set("Apache-2.0")
                    url.set("https://opensource.org/licenses/Apache-2.0")
                }
            }
            issueManagement {
                system.set("Github")
                url.set("https://github.com/MohamedRejeb/Ksoup/issues")
            }
            scm {
                connection.set("https://github.com/MohamedRejeb/Ksoup.git")
                url.set("https://github.com/MohamedRejeb/Ksoup")
            }
            developers {
                developer {
                    id.set("MohamedRejeb")
                    name.set("Mohamed Rejeb")
                    email.set("mohamedrejeb445@gmail.com")
                }
            }
        }
    }
}

signing {
    useInMemoryPgpKeys(
        System.getenv("OSSRH_GPG_SECRET_KEY_ID"),
        System.getenv("OSSRH_GPG_SECRET_KEY"),
        System.getenv("OSSRH_GPG_SECRET_KEY_PASSWORD"),
    )
    sign(publishing.publications)
}

// TODO: remove after https://youtrack.jetbrains.com/issue/KT-46466 is fixed
project.tasks.withType(AbstractPublishToMaven::class.java).configureEach {
    dependsOn(project.tasks.withType(Sign::class.java))
}package com.mohamedrejeb.ksoup

import com.mohamedrejeb.ksoup.entities.KsoupEntities
import kotlin.test.Test
import kotlin.test.assertEquals

class KsoupEntitiesTest {

    fun testDecodeHtml5(input: String, expectedOutput: String) {
        val decoded = KsoupEntities.decodeHtml5(input)
        assertEquals(
            expectedOutput,
            decoded
        )
    }

    fun testEncodeHtml5(input: String, expectedOutput: String) {
        val encoded = KsoupEntities.encodeHtml5(input)
        assertEquals(
            expectedOutput,
            encoded
        )
    }

    // Decode Test
    @Test
    fun testDecodeHtml5_1() {
        testDecodeHtml5("
asdf & ÿ ü '
", "
asdf & ÿ ü '
")
    }

    @Test
    fun testDecodeHtml5_2() {
        testDecodeHtml5("Hello <World>!", "Hello <World>!")
    }

    @Test
    fun testDecodeHtml5_3() {
        testDecodeHtml5("The price is $10.", "The price is $10.")
    }

    @Test
    fun testDecodeHtml5_4() {
        testDecodeHtml5("<img src="image.jpg">", "")
    }

    @Test
    fun testDecodeHtml5_5() {
        testDecodeHtml5("   ", "   ")
    }

    @Test
    fun testDecodeHtml5_6() {
        testDecodeHtml5("Å", "Å")
    }

    @Test
    fun pruneBasicLatin() {
        testDecodeHtml5("*", "*")
    }

    @Test
    fun pruneLatin1Supplement() {
        testDecodeHtml5("®", "®")
    }

    @Test
    fun pruneLatinExtendedA() {
        testDecodeHtml5("Ġ", "Ġ")
    }

    @Test
    fun pruneLatinExtendedB() {
        testDecodeHtml5("ȭ", "ȭ")
    }

    @Test
    fun pruneIPAExtensions() {
        testDecodeHtml5("ɠ", "ɠ")
    }

    @Test
    fun pruneSpacingModifierLetters() {
        testDecodeHtml5("˧", "˧")
    }

    @Test
    fun pruneCombiningDiacriticalMarks() {
        assertEquals(expected = """͠""", actual = KsoupEntities.decodeHtml("͠"))


lf, solver: &Solver<U, E>, state: State<U, E>) -> Stream<U, E> {
        if let Some(bfs) = self.as_any().downcast_ref::<Conde<U, E, Goal<U, E>>>() {
            let mut stream = Stream::empty();

            // Process first element separately to avoid one extra clone of `state`.
            if bfs.conjunctions.len() > 1 {
                for conjunction in bfs
                    .conjunctions
                    .iter()
                    .rev()
                    .take(bfs.conjunctions.len() - 1)
                {
                    let new_stream = conjunction.solve(solver, state.clone());
                    stream = Stream::mplus(new_stream, LazyStream::delay(stream));
                }
            }

            if self.conjunctions.len() > 0 {
                let new_stream = bfs.conjunctions[0].solve(solver, state);
                stream = Stream::mplus(new_stream, LazyStream::delay(stream));
            }

            stream
        } else if let Some(dfs) = self.as_any().downcast_ref::<Conde<U, E, DFSGoal<U, E>>>() {
            let mut stream = Stream::empty();

            // Process first element separately to avoid one extra clone of `state`.
            if dfs.conjunctions.len() > 1 {
                for conjunction in dfs
                    .conjunctions
                    .iter()
                    .rev()
                    .take(dfs.conjunctions.len() - 1)
                {
                    let new_stream = conjunction.solve(solver, state.clone());
                    stream = Stream::mplus_dfs(new_stream, LazyStream::delay(stream));
                }
            }

            if self.conjunctions.len() > 0 {
                let new_stream = dfs.conjunctions[0].solve(solver, state);
                stream = Stream::mplus_dfs(new_stream, LazyStream::delay(stream));
            }

            stream
        } else {
            unreachable!()
        }
    }
}

/// Disjunction operator.
///
/// The conde operator is a disjunction of conjunctions where the body expression is of the
/// following form where commas are replaced with ANDs and ORs to show the logical relations:
/// ```text
/// conde {
///     [g11 AND g12 AND g13 AND ...] OR
///     [g21 AND g22 AND g23 AND ...] OR
///     [g31 AND g32 AND g33 AND ...] OR
///     ...
/// }
/// ```
///
/// If there is only one goal within the conjunction as: `[foo()]`, then the brackets are not
/// necessary, and we can write just `foo()`.
///
/// # Example
/// Conde is one of the core miniKanren operators, and it executes an interleaved search of the
/// streams of solutions from the conjunctions. This example shows how the solutions from the
/// `member`-relations, are interleaved by the `conde`-operator:
/// ```rust
/// extern crate proto_vulcan;
/// use proto_vulcan::prelude::*;
/// use proto_vulcan::relation::member;
/// fn main() {
///     let query = proto_vulcan_query!(|q| {
///         conde {
///             member(q, [1, 2, 3]),
///             member(q, [4, 5, 6]),
///             member(q, [7, 8,


d the span map for all pages in the arena. heapArena objects are
// themselves allocated off-heap.
//
// Since arenas are aligned, the address space can be viewed as a
// series of arena frames. The arena map (mheap_.arenas) maps from
// arena frame number to *heapArena, or nil for parts of the address
// space not backed by the Go heap. The arena map is structured as a
// two-level array consisting of a "L1" arena map and many "L2" arena
// maps; however, since arenas are large, on many architectures, the
// arena map consists of a single, large L2 map.
//
// The arena map covers the entire possible address space, allowing
// the Go heap to use any part of the address space. The allocator
// attempts to keep arenas contiguous so that large spans (and hence
// large objects) can cross arenas.
namespace go;

using goarch = @internal.goarch_package;
using goos = @internal.goos_package;
using atomic = @internal.runtime.atomic_package;
using math = runtime.@internal.math_package;
using sys = runtime.@internal.sys_package;
using @unsafe = unsafe_package;
using @internal;
using @internal.runtime;
using runtime.@internal;

partial class runtime_package {

internal static readonly UntypedInt maxTinySize = /* _TinySize */ 16;
internal const int8 tinySizeClass = /* _TinySizeClass */ 2;
internal static readonly UntypedInt maxSmallSize = /* _MaxSmallSize */ 32768;
internal static readonly UntypedInt pageShift = /* _PageShift */ 13;
internal static readonly UntypedInt pageSize = /* _PageSize */ 8192;
internal static readonly UntypedInt _PageSize = /* 1 << _PageShift */ 8192;
internal static readonly UntypedInt _PageMask = /* _PageSize - 1 */ 8191;
internal static readonly UntypedInt _64bit = /* 1 << (^uintptr(0) >> 63) / 2 */ 1;
internal static readonly UntypedInt _TinySize = 16;
internal const int8 _TinySizeClass = /* int8(2) */ 2;
internal static readonly UntypedInt _FixAllocChunk = /* 16 << 10 */ 16384; // Chunk size for FixAlloc
internal static readonly UntypedInt _StackCacheSize = /* 32 * 1024 */ 32768;
internal static readonly UntypedInt _NumStackOrders = /* 4 - goarch.PtrSize/4*goos.IsWindows - 1*goos.IsPlan9 */ 2;
internal static readonly UntypedInt heapAddrBits = /* (_64bit*(1-goarch.IsWasm)*(1-goos.IsIos*goarch.IsArm64))*48 + (1-_64bit+goarch.IsWasm)*(32-(goarch.IsMips+goarch.IsMipsle)) + 40*goos.IsIos*goarch.IsArm64 */ 48;
internal static readonly UntypedInt maxAlloc = /* (1 << heapAddrBits) - (1-_64bit)*1 */ 281474976710656;
// The number of bits in a heap address, the size of heap
// arenas, and the L1 and L2 arena map sizes are related by
//
//   (1 << addr bits) = arena size * L1 entries * L2 entries
//
// Currently, we balance these as follows:
//
//       Platform  Addr bits  Arena size  L1 entries   L2 entries
// --------------  ---------  ----------  ----------  -----------
//       */64-bit         48        64MB           1    4M (32MB)
// windows/64-bit         48         4MB          64    1M  (8MB)
//      ios/arm64         33         4MB           1  2048  (8KB)
//       */32-bit         32         4MB           1  1024  (4KB)
//     */mips(le)         31         4MB           1   512  (2KB)
internal static readonly UntypedInt heapArenaBytes = /* 1 << logHeapArenaBytes */ 4194304;
internal static readonly UntypedInt heapArenaWords = /* heapArenaBytes / goarch.PtrSize */ 524288;
internal static readonly UntypedInt logHeapArenaBytes = /* (6+20)*(_


考虑合并多个变量，将多个变量封装成一个对象，通过AtomicReference来保证原子性。

## JUC 并发包用过哪些线程安全的类？

答案：

- ConcurrentHashMap
- CountDownLatch、CyclicBarrier
- Semaphore
- BlockingQueue
- ThreadPoolExecutor
- ReentrantLock、ReentrantReadWriteLock
- CompletableFuture

## ThreadLocal 是什么？

答案：
ThreadLocal，也就是线程本地变量。如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地拷贝，多个线程操作这个变量的时候，实际是操作自己本地内存里面的变量，从而起到线程隔离的作用，避免了线程安全问题。

## ThreadLocal 实现原理？

答案：

- Thread类有一个类型为 ThreadLocal.ThreadLocalMap 的实例变量 threadLocals，即每个线程都有一个属于自己的ThreadLocalMap。
- ThreadLocalMap内部维护着Entry数组，每个Entry代表一个完整的对象，key是ThreadLocal本 身，value是ThreadLocal的泛型值。
- 每个线程在往ThreadLocal里设置值的时候，都是往自己的ThreadLocalMap里存，读也是以某个 ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

**ThreadLocal 内存结构图：**

由结构图是可以看出：

- Thread对象中持有一个ThreadLocal.ThreadLocalMap的成员变量。
- ThreadLocalMap内部维护了Entry数组，每个Entry代表一个完整的对象，key是ThreadLocal本身，value是ThreadLocal的泛型值。

## Java 有哪些原子性的方法？

答案：
1、循环原子类，例如 AtomicInteger，实现i++原子操作
2、JUC 包下的锁，如 ReentrantLock ，对i++操作加锁 lock.lock() 来实现原子性
3、使用 synchronized，对 i++ 操作加锁

## 原子操作类有哪些？

答案：

当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量i=1，A线程更新i+1，B线程也更新i+1，经过两个线程操作之后可能i不等于3，而是等于2。因为A和B线程在更新变量i的时候拿到的i都是1，这就是线程不安全的更新操作，**一般我们会使用synchronized来解决这个问题，synchronized会保证多线程不会同时更新变量i。**

其实除此之外，还有更轻量级的选择，Java从JDK 1.5开始提供了`java.util.concurrent.atomic`包，这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。

因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式


s", msg);
    printf("col %d: pivrow %d, supno %d, xprune %d\n",
	   jcol, pivrow, supno[jcol], xprune[jcol]);

    printf("\tU-col:\n");
    for (i = xusub[jcol]; i < xusub[jcol+1]; i++)
	printf("\t%d%10.4f\n", usub[i], ucol[i]);
    printf("\tL-col in rectangular snode:\n");
    fsupc = xsup[supno[jcol]];	/* first col of the snode */
    i = xlsub[fsupc];
    k = xlusup[jcol];
    while ( i < xlsub[fsupc+1] && k < xlusup[jcol+1] ) {
	printf("\t%d\t%10.4f\n", lsub[i], lusup[k]);
	i++; k++;
    }
    fflush(stdout);
}

/*
 * Check whether tempv[] == 0. This should be true before and after
 * calling any numeric routines, i.e., "panel_bmod" and "column_bmod".
 */
void scheck_tempv(int n, double *tempv)
{
    int i;

    for (i = 0; i < n; i++) {
	if (tempv[i] != 0.0)
	{
	    fprintf(stderr,"tempv[%d] = %f\n", i,tempv[i]);
	    ABORT("scheck_tempv");
	}
    }
}

void
sGenXtrue(int n, int nrhs, double *x, int ldx)
{
    int  i, j;
    for (j = 0; j < nrhs; ++j)
	for (i = 0; i < n; ++i) {
	    x[i + j*ldx] = 1.0;/* + (double)(i+1.)/n;*/
	}
}

/*
 * Let rhs[i] = sum of i-th row of A, so the solution vector is all 1's
 */
void
sFillRHS(trans_t trans, int nrhs, double *x, int ldx,
         SuperMatrix *A, SuperMatrix *B)
{
    DNformat *Bstore;
    double   *rhs;
    double one = 1.0;
    double zero = 0.0;
    int      ldc;
    char transc[1];

    Bstore = B->Store;
    rhs    = Bstore->nzval;
    ldc    = Bstore->lda;

    if ( trans == NOTRANS ) *(unsigned char *)transc = 'N';
    else *(unsigned char *)transc = 'T';

    sp_sgemm(transc, nrhs, one, A,
	     x, ldx, zero, rhs, ldc);

}

/*
 * Fills a double precision array with a given value.
 */
void
sfill(double *a, int alen, double dval)
{
    register int i;
    for (i = 0; i < alen; i++) a[i] = dval;
}

/*
 * Check the inf-norm of the error vector
 */
void sinf_norm_error(int nrhs, SuperMatrix *X, double *xtrue)
{
    DNformat *Xstore;
    double err, xnorm;
    double *Xmat, *soln_work;
    int i, j;

    Xstore = X->Store;
    Xmat = Xstore->nzval;

    for (j = 0; j < nrhs; j++) {
      soln_work = &Xmat[j*Xstore->lda];
      err = xnorm = 0.0;
      for (i = 0; i < X->nrow; i++) {
	err = SUPERLU_MAX(err, fabs(soln_work[i] - xtrue[i]));
	xnorm = SUPERLU_MAX(xnorm, fabs(soln_work[i]));
      }
      err = err / xnorm;
      printf("||X - Xtrue||/||X|| = %e\n", err);
    }
}

/* Print performance of the code. */
void
sPrintPerf(SuperMatrix *L, SuperMatrix *U, mem_usage_t *mem_usage,
           double rpg, double rcond, double *ferr,
           double *berr, char *equed, SuperLUStat_t *stat)
{
    SCformat *Lstore;
    NCformat *Ustore;
    double   *utime;
    flops_t  *ops;

    utime = stat->utime;
    ops   = stat->ops;

    if ( utime[FACT] != 0. )
	printf("Factor flops = %e\tMflops = %8.2f\n", ops[FACT],
	       ops[FACT]*1e-6/utime[FACT]);
    printf("Identify relaxed snodes	= %8.2f\n", utime[RELAX]);
    if ( utime[SOLVE] != 0. )
	printf("Solve flops = %.0f, Mflops = %8.2f\n", ops[SOLVE],
	       ops[SOLVE]*1e-6/utime[SOLVE]);

    Lstore = (SCformat *) L->Store;
    Ustore = (NCformat *) U->Store;
    printf("\tNo of nonzeros in factor L = %d\n", Lstore->nnz);
    printf("\tNo of nonzeros in factor U = %d\n", Ustore->nnz);
    printf("\tNo of nonzeros in L+U = %d\n", Lstore->nnz + Ustore->nnz);

    printf("L\\U MB %.3f\ttotal MB needed %.3f\texpansions %d\n",
	   mem_usage->for_lu/1e6, mem_usage->total_needed/1e6,
	   mem_usage->expansions);

    printf("\tFactor\tMflops\tSolve\tMflops\tEtree\tEquil\tRcond\tRefine\n");
    printf("PERF:%8.2f%8.2f%8.2f%8.2f%8.2f%8.2f%8.2f%8.2f\n",
	   utime[FACT], ops[FACT]*1e-6/utime[FACT],
	   utime[SOLVE], ops[SOLVE]*1e-6/utime[SOLVE],
	   utime[ETREE], utime[EQUIL], utime[RCOND], utime[REFINE]);

    printf("\tRpg\t\tRcond\t\tFerr\t\tBerr\t\tEquil?\n");
    printf("NUM:\t%e\t%e\t%e\t%e\t%s\n",
	   rpg, rcond, ferr[0], berr[0], equed);

}

int print_double_vec(char *what, int n, double *vec)
{
    int i;
    printf("%s: n %d\n", what, n);
    for (i = 0; i < n; ++i) printf("%d\t%f\n", i, vec[i]);
    return 0;
}


nner(new BanSync(plugin), new MuteSync(plugin), new IpSync(plugin), new IpRangeSync(plugin), new ExpiresSync(plugin),
          new WarningSync(plugin), new RollbackSync(plugin), new NameSync(plugin));
    } else {
      syncRunner = new Runner(new BanSync(plugin), new MuteSync(plugin), new IpSync(plugin), new IpRangeSync(plugin), new ExpiresSync(plugin),
          new WarningSync(plugin), new RollbackSync(plugin), new NameSync(plugin),
          new GlobalBanSync(plugin), new GlobalMuteSync(plugin), new GlobalIpSync(plugin), new GlobalNoteSync(plugin));
    }

    plugin.setSyncRunner(syncRunner);

    setupAsyncRunnable(10L, syncRunner);

    /*
     * This task should be ran last with a 1L offset as it gets modified
     * above.
     */
    setupAsyncRunnable((plugin.getSchedulesConfig()
        .getSchedule("saveLastChecked") * 20L) + 1L, new SaveLastChecked(plugin));

    // Purge
    plugin.getScheduler().runAsync(new Purge(plugin));

    if (!plugin.getConfig().isCheckForUpdates()) return;

    // @TODO Update checker logic here
  }

  private void setupAsyncRunnable(long length, Runnable runnable) {
    if (length <= 0) return;

    Sponge.getGame().getScheduler().createTaskBuilder().async().execute(runnable).intervalTicks(length).submit(this);
  }
}
package com.genersoft.iot.vmp.media.zlm;

import com.alibaba.fastjson.JSONObject;
import com.genersoft.iot.vmp.conf.MediaServerConfig;
import com.genersoft.iot.vmp.storager.IRedisCatchStorage;
import com.genersoft.iot.vmp.storager.IVideoManagerStorager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;

@RestController
@RequestMapping("/zlm")
public class ZLMHTTPProxyController {

    private final static Logger logger = LoggerFactory.getLogger(ZLMHTTPProxyController.class);

    @Autowired
    private IVideoManagerStorager storager;

    @Autowired
    private IRedisCatchStorage redisCatchStorage;

    @Value("${media.port}")
    private int mediaHttpPort;

    @ResponseBody
    @RequestMapping(value = "/**/**/**", produces = "application/json;charset=UTF-8")
    public Object proxy(HttpServletRequest request, HttpServletResponse response){

        if (redisCatchStorage.getMediaInfo() == null) {
            return "未接入流媒体";
        }
        MediaServerConfig mediaInfo = redisCatchStorage.getMediaInfo();
        String requestURI = String.format("http://%s:%s%s?%s&%s",
                mediaInfo.getLocalIP(),
                mediaHttpPort,
                request.getRequestURI().replace("/zlm",""),
                mediaInfo.getHookAdminParams(),
                request.getQueryString()
        );
        // 发送请求
        RestTemplate restTemplate = new RestTemplate();
        //将指定的url返回的参数自动封装到自定义好的对应类对象中
        Object result = null;
        try {
            result = restTemplate.getForObject(requestURI,Object.class);

        }catch (HttpClientErrorException httpClientErrorException) {
            response.setStatus(httpClientErrorException.getStatusCode().value());
        }
        return result;
    }
}
package me.


btn-secondary:hover {
    background-color: #484848;
    text-color: #fff
}

.page-body.skin-white .btn.btn-secondary:active,
.page-body.skin-white .btn.btn-secondary:focus {
    background-color: #484848;
    border-color: #434343
}

.page-body.skin-white .settings-pane {
    background: #eee;
    color: #666
}

.page-body.skin-white .settings-pane>a[data-toggle=settings-pane] {
    color: #666
}

.page-body.skin-white .settings-pane>a[data-toggle=settings-pane]:hover {
    color: #FFF
}

.page-body.skin-white .settings-pane .user-info .user-details h3 a {
    color: #95cd62
}

.page-body.skin-white .settings-pane .user-info .user-details .user-title {
    color: rgba(149, 205, 98, .65)
}

.page-body.skin-white .settings-pane .links-block.left-sep {
    border-left: 1px solid #fff
}

.page-body.skin-white .settings-pane .links-block h4 {
    color: #95cd62
}

.page-body.skin-white .settings-pane .links-block h4 span {
    display: inline-block;
    border-bottom: 1px solid #eee
}

.page-body.skin-white .settings-pane .links-block h4 a {
    color: #95cd62
}

.page-body.skin-white .settings-pane .links-block h4 a:hover {
    color: #666
}

.page-body.skin-white .settings-pane .links-block ul li a {
    color: #666
}

.page-body.skin-white .settings-pane .links-block ul li a:hover {
    color: #95cd62
}

.page-body.skin-white .sidebar-menu {
    background: #fff
}

.page-body.skin-white .sidebar-menu .logo-env {
    border-bottom: 1px solid #eee
}

.page-body.skin-white .sidebar-menu .logo-env .settings-icon a {
    color: #666
}

.page-body.skin-white .sidebar-menu .logo-env .settings-icon a:hover {
    color: #95cd62
}

.page-body.skin-white .sidebar-menu .main-menu a {
    color: #666;
    border-bottom: 1px solid #eee
}

.page-body.skin-white .sidebar-menu .main-menu a:hover {
    color: #5095d5;
}

.page-body.skin-white .sidebar-menu .main-menu li.active>a {
    color: #5095d5
}

.page-body.skin-white .sidebar-menu .main-menu li.has-sub>a:before {
    color: #666
}

.page-body.skin-white .sidebar-menu .ps-scrollbar-x-rail .ps-scrollbar-x,
.page-body.skin-white .sidebar-menu .ps-scrollbar-y-rail .ps-scrollbar-y {
    background-color: #eee
}

@media screen and (min-width:768px) {
    .page-body.skin-white .sidebar-menu.collapsed+.main-content .user-info-navbar .user-info-menu a[data-toggle=sidebar] {
        color: #606161
    }
    .page-body.skin-white .sidebar-menu.collapsed .main-menu>li.active,
    .page-body.skin-white .sidebar-menu.collapsed .main-menu>li li.active {
        background-color: #f7f7f7


ationship.

We count how many mothers nodes can have (it turns to be 0 or 1). We walk
through all nodes (`for c in N()`) and per node we retrieve the mother nodes
(`E.mother.v(c)`), and we store the lengths (if non-zero) in a dictionary
(`mother_len`):

```python
mother_len = {}
for c in N():
    lms = E.mother.f(c) or []
    nms = len(lms)
    if nms: mother_len[c] = nms
```

##### See also #####

*   [`code`](code.md)
---
title: `vs`
---

**verbal stem**

Stem of the verb that indicates an aspect or constellation of the act expressed by the verb.

This feature is present on objects of type
[`word`](otype.md).

The Hebrew verb has multiple stems, and each of these stems can be marked with tense/mood.
For the tenses/moods, see [`vt`](vt.md).
Not all words have verbal stem (e.g. nouns) and these are marked as `NA`.

Here is the list of possible values. Some values are specific for Aramaic.

Hebrew stems:

code|description
---|---
`hif`  | `hif‘il`
`hit`  | `hitpa“el`
`htpo` | `hitpo“el`
`hof`  | `hof‘al`
`nif`  | `nif‘al`
`piel` | `pi“el`
`poal` | `po“al`
`poel` | `po“el`
`pual` | `pu“al`
`qal`  | `qal`

Aramaic stems:

code|description
---|---
`afel` | `af‘el`
`etpa` | `etpa“al`
`etpe` | `etpe‘el`
`haf`  | `haf‘el`
`hotp` | `hotpa“al`
`hsht` | `hishtaf‘al`
`htpa` | `hitpa“al`
`htpe` | `hitpe‘el`
`nit`  | `nitpa“el`
`pael` | `pa“el`
`peal` | `pe‘al`
`peil` | `pe‘il`
`shaf` | `shaf‘el`
`tif`  | `tif‘al`
`pasq` | `passiveqal`

##### Note
> The division in Hebrew and Aramaic stems should be checked.

The meanings/functions of these stems should be clarified.

Check my definition of stem above.
---
title: `label`
---

**(half-)verse label**

This feature occurs on objects of type
[`verse` and `half-verse`](otype.md).

# Half-verse

Many verses consist of two parts.
Those parts are called half-verses, and the first one is indicated with *A*, and the second one with *B*.
There are only a few verses with three parts, and the third part is indicated, unsurprisingly, by *C*.

##### Note
> The half-verse object has no features that specify the verse it occurs in.

When working in Text-Fabric, you can go from verses `v` to half-verses `h` and vice versa by means of

```python
L.d(v, 'half_verse')
```

and

```python
L.u(h, 'verse')
```

respectively.

# Verse

A small string of fixed with with an abbreviation of the book name, the chapter number and the verse number
of the verse in question.

##### Hint
> This feature is a bit tricky to use for searches,
because there are sometimes leading spaces and sometimes not;
sometimes there is a space between book and chapter, and sometimes not.
the abbreviation of the name of the book is not the abbreviation of the latin name of the book.
We recommend to use the *book*, *chapter*, and *verse* features.

If you are in Text-Fabric, use the
[`T.sectionFromNode`](https://annotation.github.io/text-fabric/tf/core/text.html#tf.core.text.Text.sectionFromNode)
function.

The main use of this function is in cases where you want to combine data in this set with other files
from the ETCBC.
These files often refer to data by means of these verse labels.
# Wise Favorites Worker

一个提供网络收藏、AI 标签分类、跨平台分享的方案，部署在 Cloudflare workers 上。

## 功能


, width="800", height="311" %}

{% Img src="image/admin/e0O2woQjZJ92aYlPOJzT.png", alt="google.com의 최대 콘텐츠풀 페인트 타임라인", width="800", height="311" %}

첫 번째 예에서는 Instagram 로고가 비교적 일찍 로드되어 다른 콘텐츠가 점진적으로 표시된 후에도 최대 요소로 남아 있습니다. Google 검색 결과 페이지 예에서 최대 요소는 이미지 또는 로고 로드가 완료되기 전에 표시되는 텍스트 단락입니다. 개별 이미지가 모두 이 단락보다 작기 때문에 텍스트 단락이 로드 프로세스 전체에서 최대 요소로 유지됩니다.

{% Aside %} Instagram 타임라인의 첫 번째 프레임에서 카메라 로고 주위에 녹색 상자가 없음을 알 수 있습니다. 이는 `<svg>` 요소이고 `<svg>` 요소는 현재 LCP 후보로 간주되지 않기 때문입니다. 첫 번째 LCP 후보는 두 번째 프레임의 텍스트입니다. {% endAside %}

## LCP 측정 방법

LCP는 [실험실](/user-centric-performance-metrics/#in-the-lab)이나 [현장](/user-centric-performance-metrics/#in-the-field)에서 측정할 수 있으며 다음 도구에서 사용할 수 있습니다.

### 현장 도구

- [Chrome User Experience Report](https://developer.chrome.com/docs/crux/)
- [PageSpeed Insights](https://pagespeed.web.dev/)
- [Search Console(Core Web Vitals Report)](https://support.google.com/webmasters/answer/9205520)
- [`web-vitals` JavaScript 라이브러리](https://github.com/GoogleChrome/web-vitals)

### 실험실 �


ger literal after '('");
      if (getUnsigned(Weight))
        return true;
      lex();
      if (expectAndConsume(MIToken::rparen))
        return true;
    }
    MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
  } while (consumeIfPresent(MIToken::comma));
  MBB.normalizeSuccProbs();
  return false;
}

bool MIParser::parseBasicBlock(MachineBasicBlock &MBB,
                               MachineBasicBlock *&AddFalthroughFrom) {
  // Skip the definition.
  assert(Token.is(MIToken::MachineBasicBlockLabel));
  lex();
  if (consumeIfPresent(MIToken::lparen)) {
    while (Token.isNot(MIToken::rparen) && !Token.isErrorOrEOF())
      lex();
    consumeIfPresent(MIToken::rparen);
  }
  consumeIfPresent(MIToken::colon);

  // Parse the liveins and successors.
  // N.B: Multiple lists of successors and liveins are allowed and they're
  // merged into one.
  // Example:
  //   liveins: %edi
  //   liveins: %esi
  //
  // is equivalent to
  //   liveins: %edi, %esi
  bool ExplicitSuccessors = false;
  while (true) {
    if (Token.is(MIToken::kw_successors)) {
      if (parseBasicBlockSuccessors(MBB))
        return true;
      ExplicitSuccessors = true;
    } else if (Token.is(MIToken::kw_liveins)) {
      if (parseBasicBlockLiveins(MBB))
        return true;
    } else if (consumeIfPresent(MIToken::Newline)) {
      continue;
    } else
      break;
    if (!Token.isNewlineOrEOF())
      return error("expected line break at the end of a list");
    lex();
  }

  // Parse the instructions.
  bool IsInBundle = false;
  MachineInstr *PrevMI = nullptr;
  while (!Token.is(MIToken::MachineBasicBlockLabel) &&
         !Token.is(MIToken::Eof)) {
    if (consumeIfPresent(MIToken::Newline))
      continue;
    if (consumeIfPresent(MIToken::rbrace)) {
      // The first parsing pass should verify that all closing '}' have an
      // opening '{'.
      assert(IsInBundle);
      IsInBundle = false;
      continue;
    }
    MachineInstr *MI = nullptr;
    if (parse(MI))
      return true;
    MBB.insert(MBB.end(), MI);
    if (IsInBundle) {
      PrevMI->setFlag(MachineInstr::BundledSucc);
      MI->setFlag(MachineInstr::BundledPred);
    }
    PrevMI = MI;
    if (Token.is(MIToken::lbrace)) {
      if (IsInBundle)
        return error("nested instruction bundles are not allowed");
      lex();
      // This instruction is the start of the bundle.
      MI->setFlag(MachineInstr::BundledSucc);
      IsInBundle = true;
      if (!Token.is(MIToken::Newline))
        // The next instruction can be on the same line.
        continue;
    }
    assert(Token.isNewlineOrEOF() && "MI is not fully parsed");
    lex();
  }

  // Construct successor list by searching for basic block machine operands.
  if (!ExplicitSuccessors) {
    SmallVector<MachineBasicBlock*,4> Successors;
    bool IsFallthrough;
    guessSuccessors(MBB, Successors, IsFallthrough);
    for (MachineBasicBlock *Succ : Successors)
      MBB.addSuccessor(Succ);

    if (IsFallthrough) {
      AddFalthroughFrom = &MBB;
    } else {
      MBB.normalizeSuccProbs();
    }
  }

  return false;
}

bool MIParser::parseBasicBlocks() {
  lex();
  // Skip until the first machine basic block.
  while (Token.is(MIToken::Newline))


2, U+6e3e, U+6e58, U+6eef, U+6ef2, U+6fe4, U+708a, U+7130, U+7165, U+7172, U+71c9, U+7232, U+7239, U+7261, U+7280, U+72a7, U+72f8, U+73c8, U+7464, U+753b, U+754f, U+755c, U+75d8, U+76ea, U+776b, U+7779, U+777f, U+7784, U+778e, U+77db, U+77ee, U+79e4, U+7a46, U+7a57, U+7aba, U+7aed, U+7b4d, U+7c7b, U+7c7d, U+7d13, U+7d33, U+7dbb, U+7dec, U+7df9, U+7e46, U+7ea7, U+7edf, U+8085, U+8165, U+81fb, U+82b8, U+82d3, U+8343, U+839e, U+83e9, U+840d, U+851a, U+853d, U+8543, U+859b, U+85fb, U+87fb, U+888d, U+8adc, U+8b0a, U+8bb0, U+8bbe, U+8bc4, U+8bf4, U+8c5a, U+8cc3, U+8ce4, U+8d44, U+8e81, U+8f66, U+8fdb, U+900d, U+9063, U+914c, U+9223, U+9226, U+923a, U+925b, U+9264, U+929c, U+92b9, U+9320, U+934d, U+935b, U+9444, U+957f, U+96a7, U+9756, U+97ad, U+97cc, U+9898, U+98ea, U+9921, U+9952, U+9a55, U+9b0d, U+9b91, U+9bca, U+9ebd, U+9f4b, U+ff1c-ff1d, U+ff21, U+ff38, U+ff9f;
}
/* [G_105] */
@font-face {
  font-family: 'Chiron Hei HK WS';
  font-style: normal;
  font-weight: 250 900;
  font-display: swap;
  src: url('../woff2/chironheihkvf.G_105.woff2') format('woff2-variations'), url('../woff2/chironheihkvf.G_105.woff2') format('woff2 supports variations');
  unicode-range: U+2103, U+3014-3015, U+4e1a, U+4e50, U+4f10, U+4f3d, U+4f6c, U+4f70, U+4fcf, U+5006, U+50d1, U+5170, U+518c, U+51f0, U+51f6, U+51f9, U+5219, U+5256, U+525d, U+52c9, U+5349, U+5351, U+5356, U+5375, U+53db, U+53ee, U+53f7, U+5492, U+5497, U+54fa, U+5538, U+55bb, U+55e8, U+56b7, U+5757, U+58be, U+5937, U+59dc, U+59e8, U+5a49, U+5a9a-5a9b, U+5ab3, U+5b9b, U+5b9e, U+5be8, U+5c37, U+


lay:inline-block;width:300px;margin-bottom:14px;-webkit-box-flex:50%;-ms-flex:50%;flex:50%}.order-bottom .amount-info .amount-list .all-amount[data-v-7afbbb1e],.order-bottom .amount-info .amount-list .pay-time[data-v-7afbbb1e],.order-bottom .amount-info .amount-list .send-amount[data-v-7afbbb1e]{display:inline-block;-webkit-box-flex:50%;-ms-flex:50%;flex:50%;padding-left:10%}.order-bottom .amount-info .amount-list .package-amount .amount-name[data-v-7afbbb1e]{margin-right:14px}.order-bottom .amount-info .amount-list .all-amount .amount-name[data-v-7afbbb1e]{margin-right:24px}.order-bottom .amount-info .amount-list .all-amount .amount-price[data-v-7afbbb1e]{color:#f56c6c}.order-bottom .amount-info .amount-list .send-amount .amount-name[data-v-7afbbb1e]{margin-right:10px}.avatar-uploader .el-upload{border-radius:4px!important;background:#fcfcfc}.avatar-uploader .avatar-uploader-icon{background:#fcfcfc}.avatar-uploader .el-icon-plus:before{content:"\4E0A\4F20\56FE\7247"!important;font-size:12px;color:#000}.el-dialog{border-radius:8px}.el-dialog__header{background:#fbfbfa;border-radius:8px 8px 0 0;border:none}.dashboard-container .cancelTime,.dashboard-container .orderTime{padding-left:30px}.dashboard-container td.operate .cell .after,.dashboard-container td.operate .cell .before,.dashboard-container td.operate .cell .middle{height:39px;width:48px}.dashboard-container td.operate .cell,.dashboard-container td.otherOperate .cell{display:-webkit-box;display:-ms-flexbox;display:flex;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-webkit-box-pack:center;-ms-flex-pack:center;justify-content:center}[data-v-6793a8ec]:export{menuBg:#343744;menuText:#bfcbd9;menuActiveText:#ffc200}.avatar-uploader .el-upload[data-v-6793a8ec]{border-radius:4px!important;background:#fcfcfc}.avatar-uploader .avatar-uploader-icon[data-v-6793a8ec]{background:#fcfcfc}.avatar-uploader .el-icon-plus[data-v-6793a8ec]:before{content:"\4E0A\4F20\56FE\7247"!important;font-size:12px;color:#000}.el-dialog[data-v-6793a8ec]{border-radius:8px}.el-dialog__header[data-v-6793a8ec]{background:#fbfbfa;border-radius:8px 8px 0 0;border:none}.HeadLable[data-v-6793a8ec]{background:#fff;color:#333;height:64px;font-size:16px;padding-left:22px;line-height:64px;font-weight:700;margin-bottom:15px;top:0;left:0;opacity:0;-webkit-animation:opacity-data-v-6793a8ec .5s ease-out .8s forwards;animation:opacity-data-v-6793a8ec .5s ease-out .8s forwards}.HeadLable .goBack[data-v-6793a8ec]{border-right:1px solid #d8dde3;padding-right:14px


0.0F, 0.0F, 0.0F, -0.4363F, -2.3562F, 0.0F));
		PartDefinition bowl_r3 = bowl.addOrReplaceChild("bowl_r3", CubeListBuilder.create()
				.texOffs(0, 0).addBox(-2.0F, -7.0F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, -0.7854F, 0.0F));
		PartDefinition bowl_r4 = bowl.addOrReplaceChild("bowl_r4", CubeListBuilder.create()
				.texOffs(0, 0).addBox(-2.0F, -7.0F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, 0.7854F, 0.0F));
		PartDefinition bowl_r5 = bowl.addOrReplaceChild("bowl_r5", CubeListBuilder.create()
				.texOffs(22, 0).addBox(-2.0F, -6.5F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, 1.5708F, 0.0F));
		PartDefinition bowl_r6 = bowl.addOrReplaceChild("bowl_r6", CubeListBuilder.create()
				.texOffs(22, 0).addBox(-2.0F, -6.5F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, 3.1416F, 0.0F));
		PartDefinition bowl_r7 = bowl.addOrReplaceChild("bowl_r7", CubeListBuilder.create()
				.texOffs(22, 0).addBox(-2.0F, -6.5F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, -1.5708F, 0.0F));
		PartDefinition bowl_r8 = bowl.addOrReplaceChild("bowl_r8", CubeListBuilder.create()
				.texOffs(22, 0).addBox(-2.0F, -6.5F, 1.5F, 4.0F, 4.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -0.4363F, 0.0F, 0.0F));

		PartDefinition meal = partdefinition.addOrReplaceChild("meal", CubeListBuilder.create()
				.texOffs(0, 22).addBox(-2.0F, -5.5F, -2.0F, 4.0F, 4.0F, 4.0F, new CubeDeformation(0.0F)), PartPose.ZERO);
		PartDefinition meal_r9 = meal.addOrReplaceChild("meal_r9", CubeListBuilder.create()
				.texOffs(26, 11).addBox(2.0F, -3.0F, -5.0F, 1.0F, 3.0F, 1.0F, new CubeDeformation(0.0F)), PartPose.offsetAndRotation(0.0F, 0.0F, 0.0F, -1.2217F, -1.9199F, 0.0F));


from typing import List, Optional

from pydantic import BaseModel, Field

from .plugin import config

class ImageReference(BaseModel):
    """图片参考信息"""

    image_path: str = Field(description="图片文件路径")
    description: str = Field(description="图片描述信息，用于指导AI理解图片内容和用途")
    weight: float = Field(default=1.0, description="图片参考权重，范围0.1-2.0，默认1.0")

    def __str__(self) -> str:
        return f"Image: {self.image_path} (Weight: {self.weight}) - {self.description}"

class MultiImageDrawRequest(BaseModel):
    """多图绘制请求"""

    reference_images: List[ImageReference] = Field(description="参考图片列表，最多支持5张")
    target_prompt: str = Field(description="目标图片生成提示词，描述期望生成的图片")
    size: str = Field(default="1024x1024", description="图片尺寸")
    guidance_scale: float = Field(default=7.5, description="引导强度")
    send_to_chat: str = Field(default="", description="是否发送到聊天")

    def validate_images(self) -> None:
        """验证图片数量"""
        if len(self.reference_images) > config.MAX_IMAGE_NUM:
            raise ValueError(f"最多支持{config.MAX_IMAGE_NUM}张参考图片")
        if len(self.reference_images) == 0:
            raise ValueError("至少需要1张参考图片")

    def construct_prompt(self) -> str:
        """构建综合提示词"""
        image_descriptions = []
        for i, img_ref in enumerate(self.reference_images, 1):
            weight_desc = f"(重要程度: {img_ref.weight})" if img_ref.weight != 1.0 else ""
            image_descriptions.append(f"参考图片{i}: {img_ref.description} {weight_desc}")

        return f"""基于以下参考图片生成新图片:

{chr(10).join(image_descriptions)}

目标描述: {self.target_prompt}

请综合分析所有参考图片的特征，并根据目标描述生成一张新的图片。注意保持参考图片的关键特征，同时融入目标描述的要求。"""


om '.';

// 暂时不考虑负数，a - b 相当于 a 减去 1 的次数为 b 减去 1 一直减到 0 的次数。
export const sub = (a: number, b: number) => b === 0 ? a : sub1(sub(a, sub1(b)));import { CanvasElementModel } from "../../models-canvas/CanvasElementModel";
import { Rectangle } from "../../geometry/Rectangle";
import { DeserializeEvent } from "../../base-models/BaseModel";
import { RectangleElementFactory } from "./RectangleElementFactory";

export class RectangleElementModel extends CanvasElementModel {
	border: number;
	borderColor: string;
	background: string;
	dimensions: Rectangle;

	constructor() {
		super(RectangleElementFactory.NAME);
		this.border = 2;
		this.borderColor = "black";
		this.background = "rgb(0,192,255)";
		this.dimensions = new Rectangle(0, 0, 100, 100);
		this.selected = false;
	}

	serialize() {
		return {
			...super.serialize(),
			dimensions: this.dimensions.serialize()
		};
	}

	deSerialize(event: DeserializeEvent): void {
		super.deSerialize(event);
		this.dimensions.deserialize(event.data["dimensions"]);
	}

	getDimensions(): Rectangle {
		return this.dimensions;
	}

	setDimensions(dimensions: Rectangle) {
		this.dimensions = dimensions;
	}
}
import { split } from '../../src/generic';
import { expect } from 'chai';
import * as tf from '@tensorflow/tfjs-core';
import '@tensorflow/tfjs-backend-cpu';
import 'mocha';

describe('Generic Split test',
  () => {
    it('should split data into train & test', () => {
      /**
       * [
       *   [0, 1],
       *   [2, 3],
       *   [4, 5],
       *   [6, 7],
       *   [8, 9]
       * ]
       */
      const X = tf.range(0, 10).reshape([5, 2]);

      const y = tf.range(0, 5);

      const [X_train, X_test, y_train, y_test] = split([X, y]);

      const actX_test = tf.range(6, 10).reshape([2, 2]);
      const actX_train = tf.range(0, 6).reshape([3, 2]);

      const acty_train = tf.range(0, 3).reshape([3]);
      const acty_test = tf.range(3, 5).reshape([2]);

      expect(actX_test.dataSync()).to.eql(X_test.dataSync());
      expect(actX_train.dataSync()).to.eql(X_train.dataSync());

      expect(acty_train.dataSync()).to.eql(y_train.dataSync());
      expect(acty_test.dataSync()).to.eql(y_test.dataSync());
  });

  it('should throws if tensors length equals zero ', () => {
    expect(() => split([])).to.throw('inputs should not have length of zero');
  });

  it('should throws if inputs have different first dimension', () => {
    const t1 = tf.ones([10, 28, 28, 3]);
    const t2 = tf.ones([8]);
    expect(() => split([t1, t2])).to.throw('inputs should have the same length');
  });
});
import { TestBed, inject } from '@angular/core/testing';

import { PagerService } from './pager.service';

describe('PagerService', () => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [PagerService]
    });
  });

  it('should be created', inject([PagerService], (service: PagerService) => {
    expect(service).toBeTruthy();
  }));
  it( 'should have 1 page when 3 items at a default size of 10', inject([PagerService], (service: PagerService) => {
    service.items =  [1, 2, 3];
    expect(service.pages).toBe(1);
  }));
  it( 'should change size to 1 and have 3 pages


lled_activity_timeout(
    activity_id: &str,
    signal_id: &str,
) -> TestHistoryBuilder {
    let mut t = TestHistoryBuilder::default();
    t.add_by_type(EventType::WorkflowExecutionStarted);
    t.add_full_wf_task();
    let scheduled_event_id = t.add_activity_task_scheduled(activity_id);
    t.add_we_signaled(
        signal_id,
        vec![Payload {
            metadata: Default::default(),
            data: b"hello ".to_vec(),
        }],
    );
    t.add_full_wf_task();
    t.add(
        EventType::ActivityTaskCancelRequested,
        history_event::Attributes::ActivityTaskCancelRequestedEventAttributes(
            ActivityTaskCancelRequestedEventAttributes {
                scheduled_event_id,
                ..Default::default()
            },
        ),
    );
    t.add(
        EventType::ActivityTaskTimedOut,
        history_event::Attributes::ActivityTaskTimedOutEventAttributes(
            ActivityTaskTimedOutEventAttributes {
                scheduled_event_id,
                ..Default::default()
            },
        ),
    );
    t.add_full_wf_task();
    t.add_workflow_execution_completed();
    t
}

/// 1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
/// 2: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
/// 3: EVENT_TYPE_WORKFLOW_TASK_STARTED
/// 4: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
/// 5: EVENT_TYPE_ACTIVITY_TASK_SCHEDULED
/// 6: EVENT_TYPE_ACTIVITY_TASK_STARTED
/// 7: EVENT_TYPE_ACTIVITY_TASK_TIMED_OUT
/// 8: EVENT_TYPE_WORKFLOW_TASK_SCHEDULED
/// 9: EVENT_TYPE_WORKFLOW_TASK_STARTED
/// 10: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
/// 11: EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED
pub fn started_activity_timeout(activity_id: &str) -> TestHistoryBuilder {
    let mut t = TestHistoryBuilder::default();
    t.add_by_type(EventType::WorkflowExecutionStarted);
    t.add_full_wf_task();
    let scheduled_event_id = t.add_get_event_id(
        EventType::ActivityTaskScheduled,
        Some(
            history_event::Attributes::ActivityTaskScheduledEventAttributes(
                ActivityTaskScheduledEventAttributes {
                    activity_id: activity_id.to_string(),
                    ..Default::default()
                },
            ),
        ),
    );
    let started_event_id = t.add_get_event_id(
        EventType::ActivityTaskStarted,
        Some(
            history_event::Attributes::ActivityTaskStartedEventAttributes(
                ActivityTaskStartedEventAttributes {
                    scheduled_event_id,
                    ..Default::default()
                },
            ),
        ),
    );
    t.add(
        EventType::ActivityTaskTimedOut,
        history_event::Attributes::ActivityTaskTimedOutEventAttributes(
            ActivityTaskTimedOutEventAttributes {
                scheduled_event_id,
                started_event_id,
                ..Default::default()
            },
        ),
    );
    t.add_full_wf_task();
    t.add_workflow_execution_completed();
    t
}

/// 1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
/// 2: EVENT_TYPE_WORKFLOW_T


        "O9.2"
            ],
            "description": "For the purposes of the Unicode bidirectional algorithm, the base directionality of each bidi paragraph for which the element forms the containing block is determined not by the element's computed 'direction'."
          }
        ],
        "syntax": "normal | embed | isolate | bidi-override | isolate-override | plaintext",
        "relevance": 56,
        "references": [
          {
            "name": "MDN Reference",
            "url": "https://developer.mozilla.org/docs/Web/CSS/unicode-bidi"
          }
        ],
        "description": "The level of embedding with respect to the bidirectional algorithm.",
        "restrictions": [
          "enum"
        ]
      },
      {
        "name": "unicode-range",
        "values": [
          {
            "name": "U+26",
            "description": "Ampersand."
          },
          {
            "name": "U+20-24F, U+2B0-2FF, U+370-4FF, U+1E00-1EFF, U+2000-20CF, U+2100-23FF, U+2500-26FF, U+E000-F8FF, U+FB00-FB4F",
            "description": "WGL4 character set (Pan-European)."
          },
          {
            "name": "U+20-17F, U+2B0-2FF, U+2000-206F, U+20A0-20CF, U+2100-21FF, U+2600-26FF",
            "description": "The Multilingual European Subset No. 1. Latin. Covers ~44 languages."
          },
          {
            "name": "U+20-2FF, U+370-4FF, U+1E00-20CF, U+2100-23FF, U+2500-26FF, U+FB00-FB4F, U+FFF0-FFFD",
            "description": "The Multilingual European Subset No. 2. Latin, Greek, and Cyrillic. Covers ~128 language."
          },
          {
            "name": "U+20-4FF, U+530-58F, U+10D0-10FF, U+1E00-23FF, U+2440-245F, U+2500-26FF, U+FB00-FB4F, U+FE20-FE2F, U+FFF0-FFFD",
            "description": "The Multilingual European Subset No. 3. Covers all characters belonging to European scripts."
          },
          {
            "name": "U+00-7F",
            "description": "Basic Latin (ASCII)."
          },
          {
            "name": "U+80-FF",
            "description": "Latin-1 Supplement. Accented characters for Western European languages, common punctuation characters, multiplication and division signs."
          },
          {
            "name": "U+100-17F",
            "description": "Latin Extended-A. Accented characters for for Czech, Dutch, Polish, and Turkish."
          },
          {
            "name": "U+180-24F",
            "description": "Latin Extended-B. Croatian, Slovenian, Romanian, Non-European and historic latin, Khoisan, Pinyin, Livonian, Sinology."
          },
          {
            "name": "U+1E00-1EFF",
            "description": "Latin Extended Additional. Vietnamese, German captial sharp s, Medievalist, Latin general use."
          },
          {
            "name": "U+250-2AF",
            "description": "International Phonetic Alphabet Extensions."
          },
          {
            "name": "U+370-3FF",
            "description": "Greek and Coptic."
          },
          {
            "name": "U+1F00-1FFF",
            "description": "Greek Extended. Accented characters for polytonic Greek."
          },
          {
            "name": "U+400-4FF",
            "description": "Cyrillic."
          },
          {
            "name": "U+500-52F",
            "description": "Cyrillic Supplement. Extra letters for Komi, Khanty, Chukchi, Mordvin, Kurdish, Aleut, Chuvash, Abkhaz, Azerbaijani, and Orok."
          },
          {
            "name": "U+00-52F, U+1E00


<param name="p6" />
    [DllImport(Dll)]
    public static extern CLong __gmpn_gcdext(IntPtr p0, IntPtr p1, IntPtr p2, IntPtr p3, CLong p4, IntPtr p5, CLong p6);

    /// <param name="p0">(C type: byte*) </param>
    /// <param name="p1" />
    /// <param name="p2">(C type: mp_ptr) </param>
    /// <param name="p3" />
    [DllImport(Dll)]
    public static extern nint __gmpn_get_str(IntPtr p0, int p1, IntPtr p2, CLong p3);

    /// <param name="p0">(C type: mp_srcptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2" />
    [DllImport(Dll)]
    public static extern CULong __gmpn_hamdist(IntPtr p0, IntPtr p1, CLong p2);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2" />
    /// <param name="p3" />
    [DllImport(Dll)]
    public static extern CLong __gmpn_lshift(IntPtr p0, IntPtr p1, CLong p2, uint p3);

    /// <param name="p0">(C type: mp_srcptr) </param>
    /// <param name="p1" />
    /// <param name="mp_limb_t" />
    [DllImport(Dll)]
    public static extern CLong __gmpn_mod_1(IntPtr p0, CLong p1, int mp_limb_t);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2" />
    /// <param name="p3">(C type: mp_srcptr) </param>
    /// <param name="p4" />
    [DllImport(Dll)]
    public static extern CLong __gmpn_mul(IntPtr p0, IntPtr p1, CLong p2, IntPtr p3, CLong p4);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2" />
    /// <param name="mp_limb_t" />
    [DllImport(Dll)]
    public static extern CLong __gmpn_mul_1(IntPtr p0, IntPtr p1, CLong p2, int mp_limb_t);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2">(C type: mp_srcptr) </param>
    /// <param name="p3" />
    [DllImport(Dll)]
    public static extern void __gmpn_mul_n(IntPtr p0, IntPtr p1, IntPtr p2, CLong p3);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="p2" />
    [DllImport(Dll)]
    public static extern void __gmpn_sqr(IntPtr p0, IntPtr p1, CLong p2);

    /// <param name="p0">(C type: mp_ptr) </param>
    /// <param name="p1">(C type: mp_srcptr) </param>
    /// <param name="


r.Component);Go.defaultProps={view:"hex"};const $o=Go;const Yo=function(){var e=(0,i.ZP)({default:{picker:{width:"12px",height:"12px",borderRadius:"6px",transform:"translate(-6px, -1px)",backgroundColor:"rgb(248, 248, 248)",boxShadow:"0 1px 4px 0 rgba(0, 0, 0, 0.37)"}}});return r.createElement("div",{style:e.picker})};const Ko=function(){var e=(0,i.ZP)({default:{picker:{width:"12px",height:"12px",borderRadius:"6px",boxShadow:"inset 0 0 0 1px #fff",transform:"translate(-6px, -6px)"}}});return r.createElement("div",{style:e.picker})};var Zo=function(e){var t=e.width,n=e.onChange,o=e.disableAlpha,a=e.rgb,s=e.hsl,l=e.hsv,c=e.hex,p=e.renderers,d=e.styles,b=void 0===d?{}:d,h=e.className,m=void 0===h?"":h,M=e.defaultView,O=(0,i.ZP)(on({default:{picker:{width:t,background:"#fff",borderRadius:"2px",boxShadow:"0 0 2px rgba(0,0,0,.3), 0 4px 8px rgba(0,0,0,.3)",boxSizing:"initial",fontFamily:"Menlo"},saturation:{width:"100%",paddingBottom:"55%",position:"relative",borderRadius:"2px 2px 0 0",overflow:"hidden"},Saturation:{radius:"2px 2px 0 0"},body:{padding:"16px 16px 12px"},controls:{display:"flex"},color:{width:"32px"},swatch:{marginTop:"6px",width:"16px",height:"16px",borderRadius:"8px",position:"relative",overflow:"hidden"},active:{absolute:"0px 0px 0px 0px",borderRadius:"8px",boxShadow:"inset 0 0 0 1px rgba(0,0,0,.1)",background:"rgba("+a.r+", "+a.g+", "+a.b+", "+a.a+")",zIndex:"2"},toggles:{flex:"1"},hue:{height:"10px",position:"relative",marginBottom:"8px"},Hue:{radius:"2px"},alpha:{height:"10px",position:"relative"},Alpha:{radius:"2px"}},disableAlpha:{color:{width:"22px"},alpha:{display:"none"},hue:{marginBottom:"0px"},swatch:{width:"10px",height:"10px",marginTop:"0px"}}},b),{disableAlpha:o});return r.createElement("div",{style:O.picker,className:"chrome-picker "+m},r.createElement("div",{style:O.saturation},r.createElement(Sn,{style:O.Saturation,hsl:s,hsv:l,pointer:Ko,onChange:n})),r.createElement("div",{style:O.body},r.createElement("div",{style:O.controls,className:"flexbox-fix"},r.createElement("div",{style:O.color},r.createElement("div",{style:O.swatch},r.createElement("div",{style:O.active}),r.createElement(u,{renderers:p}))),r.createElement("div",{style:O.toggles},r.createElement("div",{style:O.hue},r.createElement(y,{style:O.Hue,hsl:s,pointer:Yo,onChange:n})),r.createElement("div",{style:O.alpha},r.createElement(f,{style:O.Alpha,rgb:a,hsl:s,pointer:Yo,renderers:p,onChange:n})))),r.createElement($o,{rgb:a,hsl:s,hex:c,view:M,onChange:n,disableAlpha:o})))};Zo.propTypes={width:v().oneOfType([v().string,v().number]),disableAlpha:v().bool,styles:v().object,defaul


			klog.Errorf("Failed to stop services: %v", err)
		}
	}
	if e.kubelet != nil {
		if err := e.kubelet.kill(); err != nil {
			klog.Errorf("Failed to stop kubelet: %v", err)
		}
	}
	if e.rmDirs != nil {
		for _, d := range e.rmDirs {
			err := os.RemoveAll(d)
			if err != nil {
				klog.Errorf("Failed to delete directory %s: %v", d, err)
			}
		}
	}
}

// RunE2EServices actually start the e2e services. This function is used to
// start e2e services in current process. This is only used in run-services-mode.
func RunE2EServices(t *testing.T) {
	// Populate global DefaultFeatureGate with value from TestContext.FeatureGates.
	// This way, statically-linked components see the same feature gate config as the test context.
	if err := utilfeature.DefaultMutableFeatureGate.SetFromMap(framework.TestContext.FeatureGates); err != nil {
		t.Fatal(err)
	}
	e := newE2EServices()
	if err := e.run(t); err != nil {
		klog.Fatalf("Failed to run e2e services: %v", err)
	}
}

const (
	// services.log is the combined log of all services
	servicesLogFile = "services.log"
	// LogVerbosityLevel is consistent with the level used in a cluster e2e test.
	LogVerbosityLevel = "4"
)

// startInternalServices starts the internal services in a separate process.
func (e *E2EServices) startInternalServices() (*server, error) {
	testBin, err := os.Executable()
	if err != nil {
		return nil, fmt.Errorf("can't get current binary: %v", err)
	}
	// Pass all flags into the child process, so that it will see the same flag set.
	startCmd := exec.Command(testBin, append([]string{"--run-services-mode"}, os.Args[1:]...)...)
	server := newServer("services", startCmd, nil, nil, getServicesHealthCheckURLs(), servicesLogFile, e.monitorParent, false)
	return server, server.start()
}

// collectLogFiles collects logs of interest either via journalctl or by creating sym
// links. Since we scp files from the remote directory, symlinks will be
// treated as normal files and file contents will be copied over.
func (e *E2EServices) collectLogFiles() {
	// Nothing to do if report dir is not specified.
	if framework.TestContext.ReportDir == "" {
		return
	}
	klog.Info("Fetching log files...")
	journaldFound := isJournaldAvailable()
	for targetFileName, log := range e.logs {
		targetLink := path.Join(framework.TestContext.ReportDir, targetFileName)
		if journaldFound {
			// Skip log files that do not have an equivalent in journald-based machines.
			if len(log.JournalctlCommand) == 0 {
				continue
			}
			klog.Infof("Get log file %q with journalctl command %v.", targetFileName, log.JournalctlCommand)
			out, err := exec.Command("journalctl", log.JournalctlCommand...).CombinedOutput()
			if err != nil {
				klog.Errorf("failed to get %q from journald: %v, %v", targetFileName, string(out), err)
			} else {
				if err = ioutil.WriteFile(targetLink, out, 0644); err != nil {
					klog.Errorf("failed to write logs to %q: %v", targetLink, err)
				}
			}
			continue
		}
		for _, file := range log.Files {
			if _, err := os.Stat(file); err != nil {
				// Expected file not found on this distro.
				continue
			}
			if err := copyLogFile(file, targetLink); err != nil {
				klog.Erro


CHINESE_S = {}

--Translates

CHINESE_S["UPDATER_AVAILABLE"] =           			"当前可用."
CHINESE_S["UPDATER_UPDATE"] =               			"您是否要更新本程序?"
CHINESE_S["CHINESE_FONT_DOWNLOAD"] =					"正在下载字体"
CHINESE_S["MENU_TRANSLATE"] =							"翻译 Autoplugin"
CHINESE_S["TRANSLATE_ENGLISH_TITLE"] =					"英文方案: "
CHINESE_S["TRANSLATE_CURRENT_TITLE"] =					"当前方案: "
CHINESE_S["TRANSLATE_YOUR_TITLE"] =					"您的方案: "
CHINESE_S["MENU_TRANSLATE_DESC"] =						"通过翻译为您的语言来帮助改进 Autoplugin!"
CHINESE_S["SAVE_TRANSLATIONS"] =						"保存翻译"
CHINESE_S["EXIT_SAVE_TRANSLATIONS"] =      			"翻译尚未保存. 是否在退出前保存?"
CHINESE_S["TRANSLATION_SAVED_1"] =						"您的翻译已保存到:"
CHINESE_S["TRANSLATION_SAVED_2"] =						"在 Autoplugin GitHub 上传此文件以使其被收录."
CHINESE_S["NOTHING_TO_TRANSLATE"] =					"感谢您的关注, 但现在没有需要翻译的内容!"
CHINESE_S["STRING_UNSAFE_MODE"] =						"本程序需要启用不安全自制软件模式!"
CHINESE_S["STRING_PSVITA_RESTART"] =					"您的 PSVita 即将重启"
CHINESE_S["STRING_BACKUP_CONFIGS"] =					"正在创建 Config_backups.txt"
CHINESE_S["STRING_MISSING_CONFIG"] =					"找不到 config.txt"
CHINESE_S["STRING_BACK"] =								"返回主菜单"
CHINESE_S["STRING_CLOSE"] =							"退出 Autoplugin"
CHINESE_S["STRING_INSTALLED"] =						"已完成安装"
CHINESE_S["STRING_PLEASE_WAIT"] =						"请稍候..."
CHINESE_S["RESTART_QUESTION"] =						"是否重启?"

--Options Menus
CHINESE_S["MENU_TITLE"] =								"Autoplugin"
CHINESE_S["MENU_PSVITA"] =								"Vita 模式插件"
CHINESE_S["MENU_PSP"] =								"PSP(Adrenaline) 模式插件"
CHINESE_S["MENU_EXTRAS"] =								"附加功能"
CHINESE_S["MENU_EXIT"] =								"退出"

--Desc Options PSVITA
CHINESE_S["INSTALL_PLUGINS_DESC"] =					"安装为 PSVita 环境开发的实用插件"
CHINESE_S["UNINSTALL_PLUGINS_DESC"] =					"轻松简单地卸载插件"
CHINESE_S["INSTALL_SD2VITA_DESC"] =					"安装 SD2VITA 插件 (StorageMgr,由 CelesteBlue 开发)"
CHINESE_S["CONFIG_SD2VITA_DESC"] =						"配置 SD2


 License, or 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, see <https://www.gnu.org/licenses/>.
 */

package com.cleansweep.ui.theme

import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.ReadOnlyComposable
import androidx.compose.runtime.SideEffect
import androidx.compose.runtime.staticCompositionLocalOf
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.unit.dp
import androidx.core.view.WindowCompat

enum class AppTheme {
    SYSTEM,
    LIGHT,
    DARK,
    DARKER,
    AMOLED
}

private val LightColorScheme = lightColorScheme(
    primary = Color(0xFF0066CC),
    onPrimary = Color.White,
    primaryContainer = Color(0xFFD1E4FF),
    onPrimaryContainer = Color(0xFF001D36),
    secondary = Color(0xFF535F70),
    onSecondary = Color.White,
    secondaryContainer = Color(0xFFD7E3F7),
    onSecondaryContainer = Color(0xFF101C2B),
    tertiary = Color(0xFF6B5778),
    onTertiary = Color.White,
    tertiaryContainer = Color(0xFFF2DAFF),
    onTertiaryContainer = Color(0xFF251431),
    error = Color(0xFFBA1A1A),
    onError = Color.White,
    errorContainer = Color(0xFFFFDAD6),
    onErrorContainer = Color(0xFF410002),
    background = Color(0xFFFDFCFF),
    onBackground = Color(0xFF1A1C1E),
    surface = Color(0xFFFDFCFF),
    onSurface = Color(0xFF1A1C1E),
    surfaceVariant = Color(0xFFDFE2EB),
    onSurfaceVariant = Color(0xFF43474E),
    outline = Color(0xFF73777F)
)

private val DarkColorScheme = darkColorScheme(
    primary = Color(0xFF9FCAFF),
    onPrimary = Color(0xFF003258),
    primaryContainer = Color(0xFF004881),
    onPrimaryContainer = Color(0xFFD1E4FF),
    secondary = Color(0xFFBBC7DB),
    onSecondary = Color(0xFF253140),
    secondaryContainer = Color(0xFF3B4858),
    onSecondaryContainer = Color(0xFFD7E3F7),
    tertiary = Color(0xFFD7BDE4),
    onTertiary = Color(0xFF3B2948),
    tertiaryContainer = Color(0xFF523F5F),
    onTertiaryContainer = Color(0xFFF2DAFF),
    error = Color(0xFFFFB4AB),
    onError = Color(0xFF690005),
    errorContainer = Color(0xFF93000A),
    onErrorContainer = Color(0xFFFFDAD6),
    background = Color(0xFF1A1C1E),
    onBackground = Color(0xFFE2E2E6),
    surface = Color(0xFF1A1C1E),
    onSurface = Color(0xFFE2E2E6),
    surfaceVariant = Color(0xFF43474E),
    onSurfaceVaria


//Original:/testcases/core/c_ldst_ld_d_p_b/c_ldst_ld_d_p_b.dsp
// Spec Reference: c_ldst ld d [p] b
# mach: bfin

.include "testutils.inc"
	start

	INIT_R_REGS 0;

	loadsym p1, DATA_ADDR_1;
	loadsym p2, DATA_ADDR_2;
.ifndef BFIN_HOST
	loadsym p3, DATA_ADDR_3;
.endif
	loadsym p4, DATA_ADDR_4;
	loadsym p5, DATA_ADDR_5;
	loadsym fp, DATA_ADDR_6;

// load 8 bits from memory, and zero extend into 32-bit reg
	R0 = B [ P1 ] (Z);
	R1 = B [ P2 ] (Z);
.ifndef BFIN_HOST
	R2 = B [ P3 ] (Z);
.else
	R2 = 0x43 (Z);
.endif
	R3 = B [ P4 ] (Z);
	R4 = B [ P5 ] (Z);
	R5 = B [ P5 ] (Z);
	R6 = B [ FP ] (Z);
	CHECKREG r0, 0x00000003;
	CHECKREG r1, 0x00000023;
	CHECKREG r2, 0x00000043;
	CHECKREG r3, 0x00000063;
	CHECKREG r4, 0x00000083;
	CHECKREG r5, 0x00000083;
	CHECKREG r6, 0x00000003;
	R1 = B [ P2 ] (Z);
.ifndef BFIN_HOST
	R2 = B [ P3 ] (Z);
.else
	R2 = 0x43 (Z);
.endif
	R3 = B [ P4 ] (Z);
	R4 = B [ P5 ] (Z);
	R5 = B [ FP ] (Z);
	R7 = B [ P1 ] (Z);
	CHECKREG r0, 0x00000003;
	CHECKREG r1, 0x00000023;
	CHECKREG r2, 0x00000043;
	CHECKREG r3, 0x00000063;
	CHECKREG r4, 0x00000083;
	CHECKREG r5, 0x00000003;
	CHECKREG r7, 0x00000003;
.ifndef BFIN_HOST
	R2 = B [ P3 ] (Z);
.else
	R2 = 0x43 (Z);
.endif
	R3 = B [ P4 ] (Z);
	R4 = B [ P5 ] (Z);
	R5 = B [ FP ] (Z);
	R7 = B [ P1 ] (Z);
	R0 = B [ P2 ] (Z);
	CHECKREG r0, 0x00000023;
	CHECKREG r1, 0x00000023;
	CHECKREG r2, 0x00000043;
	CHECKREG r3, 0x00000063;
	CHECKREG r4, 0x00000083;
	CHECKREG r5, 0x00000003;
	CHECKREG r7, 0x00000003;

	R3 = B [ P4 ] (Z);
	R4 = B [ P5 ] (Z);
	R5 = B [ FP ] (Z);
	R7 = B [ P1 ] (Z);
	R0 = B [ P2 ] (Z);
.ifndef BFIN_HOST
	R1 = B [ P3 ] (Z);
.else
	R1 = 0x43;
.endif
	CHECKREG r0, 0x00000023;
	CHECKREG r1, 0x00000043;
	CHECKREG r2, 0x00000043;
	CHECKREG r3, 0x00000063;
	CHECKREG r


Comparable<E>
interface java.io.Serializable
Base: class java.lang.Object
Methods:
[compareTo, equals, getClass, getDeclaringClass,
hashCode, name, notify, notifyAll, ordinal, toString,
valueOf, wait]
Explore.containsAll(Enum)? true
Explore.removeAll(Enum): [values]
Compiled from "Reflection.java"
final class Explore extends java.lang.Enum<Explore> {
  public static final Explore HERE;
  public static final Explore THERE;
  public static Explore[] values();
  public static Explore valueOf(java.lang.String);
  static {};
}
```

答案是，values() 是由编译器添加的 static 方法。可以看出，在创建 Explore 的过程中，编译器还为其添加了 valueOf() 方法。这可能有点令人迷惑，Enum 类不是已经有 valueOf() 方法了吗。

不过 Enum 中的 valueOf() 方法需要两个参数，而这个新增的方法只需一个参数。由于这里使用的 Set 只存储方法的名字，而不考虑方法的签名，所以在调用 Explore.removeAll(Enum) 之后，就只剩下[values] 了。

从最后的输出中可以看到，编译器将 Explore 标记为 final 类，所以无法继承自 enum，其中还有一个 static 的初始化子句，稍后我们将学习如何重定义该句。

由于擦除效应（在[泛型 ]() 章节中介绍过），反编译无法得到 Enum 的完整信息，所以它展示的 Explore 的父类只是一个原始的 Enum，而非事实上的 Enum\<Explore\>。

由于 values() 方法是由编译器插入到 enum 定义中的 static 方法，所以，如果你将 enum 实例向上转型为 Enum，那么 values() 方法就不可访问了。不过，在 Class 中有一个 getEnumConstants0 方法，所以即便 Enum 接口中没有 values0 方法，我们仍然可以通过 Class 对象取得所有 enum 实例。

```java
// enums/UpcastEnum.java
// No values() method if you upcast an enum
enum Search { HITHER, YON }
public class UpcastEnum {
    public static void main(String[] args) {
        Search[] vals = Search.values();
        Enum e = Search.HITHER; // Upcast
// e.values(); // No values() in Enum
        for(Enum en : e.getClass().getEnumConstants())
            System.out.println(en);
    }
}

```

输出为：

```
HITHER
YON

```

因为 getEnumConstants() 是 Class 上的方法，所以你甚至可以对不是枚举的类调用此方法：

```java
// enums/NonEnum.java
public class NonEnum {
    public static void main(String[] args) {
        Class<Integer> intClass = Integer.class;
        try {
            for(Object en : intClass.getEnumConstants())
                System.out.println(en);
        } catch(Exception e) {
            System.out.println("Expected: " + e);
        }
    }
}
```

输出为：

```java
Expected: java.lang.NullPointerException
```

只不过，此时该方法返回 null，所以当你试图使用其返回的结果时会发生异常。

<!-- Implements, not Inherits -->

## 实现而非继承

我们已经知道，所有的 enum 都继承自 Java.lang.Enum 类。由于 Java 不支持多重继承，所以你的 enum 不能再继承其他类：

```java
e


temperature);

	for i = 0, (g_iW * g_iH) - 1, 1 do
		pPlot = Map.GetPlotByIndex(i);
		if (plotTypes[i] == g_PLOT_TYPE_HILLS) then
			terrainTypes[i] = terrainTypes[i] + 1;
		end
		TerrainBuilder.SetTerrainType(pPlot, terrainTypes[i]);
	end
	--]]

	-- Temp
	AreaBuilder.Recalculate();
	local biggest_area = Areas.FindBiggestArea(false);
	print("After Adding Hills: ", biggest_area:GetPlotCount());

	---[[
	for iX = 0, g_iW - 1 do
		for iY = 0, g_iH - 1 do
			local index = (iY * g_iW) + iX;
			pPlot = Map.GetPlotByIndex(index)
			if (pPlot:GetTerrainType() == g_TERRAIN_TYPE_OCEAN) then
				if IsAdjacentToLandPlot(iX, iY) then
					TerrainBuilder.SetTerrainType(pPlot, g_TERRAIN_TYPE_COAST)
				end
			end
		end
	end
	--]]

	TerrainBuilder.StampContinents();
	if GetContinentBoundaryPlotCount then

		-- to do : only get world age once
		local world_age_new = 3;
		local world_age_normal = 2;
		local world_age_old = 1;

		--	local world_age
		local world_age = MapConfiguration.GetValue("world_age");
		if (world_age == 1) then
			world_age = world_age_new;
		elseif (world_age == 2) then
			world_age = world_age_normal;
		elseif (world_age == 3) then
			world_age = world_age_old;
		else
			world_age = 1 + TerrainBuilder.GetRandomNumber(3, "Random World Age - Lua");
		end

		local iContinentBoundaryPlots = GetContinentBoundaryPlotCount(g_iW, g_iH);
		AddTerrainFromContinents(plotTypes, terrainTypes, world_age, g_iW, g_iH, iContinentBoundaryPlots);
	end

	-- River generation is affected by plot types, originating from highlands and preferring to traverse lowlands.
	AddRivers();

	-- Lakes would interfere with rivers, causing them to stop and not reach the ocean, if placed any sooner.
	if bAddLargeLakes then
		local numLargeLakes = math.ceil(GameInfo.Maps[Map.GetMapSize()].Continents / 2);
		AddLakes(numLargeLakes);
	end

	if bImportRealWorldTerrain then
		ImportRealWorldTerrain()
	end

	AddFeatures();

	if bImportRealWorldFeatures then
		ImportRealWorldFeatures()
	end

	-- NW placement is affected by rivers, but when importing placement can be forced
	if not (bImportNaturalWonders or bNoNaturalWonders)  then
		local args = {
			numberToPlace = GameInfo.Maps[Map.GetMapSize()].NumNaturalWonders,
		};
		local nwGen = NaturalWonderGenerator.Create(args);
	end
	if bImportNaturalWonders then
		local NaturalWonders = GetNaturalWonders()
		PlaceRealNaturalWonders(NaturalWonders)
	end

	---[[
	for iX = 0, g_iW - 1 do
		for iY = 0, g_iH - 1 do
			local index = (iY * g_iW) + iX;
			pPlot = Map.GetPlotByIndex(index)
			if (pPlot:GetTerrainType() == g_TERRAIN_TYPE_OCEAN) then
				if IsAdjacentToLandPlot(iX, iY) then
					TerrainBuilder.SetTerrainType(pPlot, g_TERRAIN_TYPE_COAST)
				end
			end
		end
	end
	--]]

	AreaBuilder.Recalculate();

	print("Adding cliffs");
	AddCliffs(plotTypes, terrainTypes);

	--
	AddFeaturesFromContinents()

	-- Low lands
	if MarkCoastalLowlands then
		MarkCoastalLowlands()
	end

	TerrainBuild


d_data;

@$core.Deprecated('Use internedDataDescriptor instead')
const InternedData$json = {
  '1': 'InternedData',
  '2': [
    {
      '1': 'event_categories',
      '3': 1,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.EventCategory',
      '10': 'eventCategories'
    },
    {
      '1': 'event_names',
      '3': 2,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.EventName',
      '10': 'eventNames'
    },
    {
      '1': 'debug_annotation_names',
      '3': 3,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.DebugAnnotationName',
      '10': 'debugAnnotationNames'
    },
    {
      '1': 'mapping_paths',
      '3': 17,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.InternedString',
      '10': 'mappingPaths'
    },
    {
      '1': 'function_names',
      '3': 5,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.InternedString',
      '10': 'functionNames'
    },
    {
      '1': 'mappings',
      '3': 19,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.Mapping',
      '10': 'mappings'
    },
    {
      '1': 'frames',
      '3': 6,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.Frame',
      '10': 'frames'
    },
    {
      '1': 'callstacks',
      '3': 7,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.Callstack',
      '10': 'callstacks'
    },
    {
      '1': 'debug_annotation_string_values',
      '3': 29,
      '4': 3,
      '5': 11,
      '6': '.perfetto.protos.InternedString',
      '10': 'debugAnnotationStringValues'
    },
  ],
};

/// Descriptor for `InternedData`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List internedDataDescriptor = $convert.base64Decode(
    'CgxJbnRlcm5lZERhdGESSQoQZXZlbnRfY2F0ZWdvcmllcxgBIAMoCzIeLnBlcmZldHRvLnByb3'
    'Rvcy5FdmVudENhdGVnb3J5Ug9ldmVudENhdGVnb3JpZXMSOwoLZXZlbnRfbmFtZXMYAiADKAsy'
    'Gi5wZXJmZXR0by5wcm90b3MuRXZlbnROYW1lUgpldmVudE5hbWVzEloKFmRlYnVnX2Fubm90YX'
    'Rpb25fbmFtZXMYAyADKAsyJC5wZXJmZXR0by5wcm90b3MuRGVidWdBbm5vdGF0aW9uTmFtZVIU'
    'ZGVidWdBbm5vdGF0aW9uTmFtZXMSRAoNbWFwcGluZ19wYXRocxgRIAMoCzIfLnBlcmZldHRvLn'
    'Byb3Rvcy5JbnRlcm5lZFN0cmluZ1IMbWFwcGluZ1BhdGhzEkYKDmZ1bmN0aW9uX25hbWVzGAUg'
    'AygLMh8ucGVyZmV0dG8ucHJvdG9zLkludGVybmVkU3RyaW5nUg1mdW5jdGlvbk5hbWVzEjQKCG'
    '1hcHBpbmdzGBMgAygLMhgucGVyZmV0dG8ucHJvdG9zLk1hcHBpbmdSCG1hcHBpbmdzEi4KBmZy'
    'YW1lcxgGIAMoCzIWLnBlcmZldHRvLnByb3Rvcy5GcmFtZVIGZnJhbWVzEjoKCmNhbGxzdGFja3'
    'MYByADKAsyGi5wZXJmZXR0by5wcm90b3MuQ2FsbHN0YWNrUgpjYWxsc3RhY2tzEmQKHmRlYnVn'
    'X2Fubm90