 контекстного меню - ESC.'},{name:"Редактор списка",
legend:'Внутри окна списка, переход к следующему пункту списка - TAB или стрелкой "ВНИЗ". Переход к предыдущему пункту списка - SHIFT + TAB или стрелкой "ВВЕРХ". Нажмите SPACE, или ENTER, чтобы задействовать опцию списка. Нажмите ESC, чтобы закрыть окно списка.'},{name:"Путь к элементу",legend:'Нажмите ${elementsPathFocus}, чтобы перейти к панели пути элементов. Переход к следующей кнопке элемента - TAB или стрелкой "ВПРАВО". Переход к предыдущей кнопку - SHIFT+TAB или стрелкой "ВЛЕВО". Нажмите SPACE, или ENTER, чтобы выбрать элемент в редакторе.'}]},
{name:"Команды",items:[{name:"Отменить",legend:"Нажмите ${undo}"},{name:"Повторить",legend:"Нажмите ${redo}"},{name:"Полужирный",legend:"Нажмите ${bold}"},{name:"Курсив",legend:"Нажмите ${italic}"},{name:"Подчеркнутый",legend:"Нажмите ${underline}"},{name:"Гиперссылка",legend:"Нажмите ${link}"},{name:"Свернуть панель инструментов",legend:"Нажмите ${toolbarCollapse}"},{name:"Команды доступа к предыдущему фокусному пространству",legend:'Нажмите ${accessPreviousSpace}, чтобы обратиться к ближайшему недостижимому фокусному пространству перед символом "^", например: два смежных HR элемента. Повторите комбинацию клавиш, чтобы достичь отдаленных фокусных пространств.'},
{name:"Команды доступа к следующему фокусному пространству",legend:"Press ${accessNextSpace} to access the closest unreachable focus space after the caret, for example: two adjacent HR elements. Repeat the key combination to reach distant focus spaces."},{name:"Справка по горячим клавишам",legend:"Нажмите ${a11yHelp}"}]}]});/*
 Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
 For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang("a11yhelp","gu",{title:"એક્ક્ષેબિલિટી ની વિગતો",contents:"હેલ્પ. આ બંધ કરવા ESC દબાવો.",legend:[{name:"જનરલ",items:[{name:"એડિટર ટૂલબાર",legend:"Press ${toolbarFocus} to navigate to the toolbar. Move to the next and previous toolbar group with TAB and SHIFT-TAB. Move to the next and previous toolbar button with RIGHT ARROW or LEFT ARROW. Press SPACE or ENTER to activate the toolbar button."},{name:"એડિટર ડાયલોગ",legend:"Inside a dialog, press TAB to navigate to next dialog field, press SHIFT + TAB to move to previous field, press ENTER to submit dialog, press ESC to cancel dialog. For dialogs that have multiple tab pages, press ALT + F10 to navigate to tab-list. Then move to next tab with TAB OR RIGTH ARROW. Move to previous tab with SHIFT + TAB or LEFT ARROW. Press SPACE or ENTER to select the tab page."},
{name:"Editor Con


 }

        /// <summary>
        /// 按处理时间范围进行查询：时间范围的下界，取值单位为秒
        /// </summary>
        [XmlElement("gmt_process_start")]
        public string GmtProcessStart { get; set; }

        /// <summary>
        /// 分页查询每次查询的数据量，不传则默认为10，取值单位为条
        /// </summary>
        [XmlElement("page_size")]
        public long PageSize { get; set; }

        /// <summary>
        /// 查询条件：投诉状态列表
        /// </summary>
        [XmlArray("status_list")]
        [XmlArrayItem("string")]
        public List<string> StatusList { get; set; }

        /// <summary>
        /// 投诉单号
        /// </summary>
        [XmlElement("task_id")]
        public string TaskId { get; set; }

        /// <summary>
        /// 查询条件：投诉单号列表
        /// </summary>
        [XmlArray("task_id_list")]
        [XmlArrayItem("string")]
        public List<string> TaskIdList { get; set; }

        /// <summary>
        /// 支付宝订单号
        /// </summary>
        [XmlElement("trade_no")]
        public string TradeNo { get; set; }
    }
}


 0.5) *
        radius *
        Math.sin((pos + this.length / 2) * (Math.PI / this.length)) ** 2
    );
  };

  next = () => {
    for (var step = 0; step < this.anchors.length; step++) {
      let p = this.anchors[step];
      let pos =
        step * (this.length / this.state.anchorpoints) - this.length / 2;
      p.y += this.myspread(pos, this.state.jitterY);
      p.z += this.myspread(pos, this.state.colorspread);
      p.x += this.myspread(pos, this.state.jitterX);
    }
    this.anchors.forEach(p => {});
  };

  /**
   * creates a initial set of anchor points spanning across the width of the canvas.
   * slight wiggle in both y location (tapering off to either end) and the degree
   * of color spread in each point (z)
   *
   * @param {number} amplitude amplitude of maximum spread of color in a singular point
   */

  basepoints = () => {
    let points = Array<THREE.Vector3>();

    return points;
  };
}

export { FuzzyWobble };
import { Injectable } from '@angular/core';
import { Http } from '@angular/http';
import 'rxjs/add/operator/map';

@Injectable()
export class TarefasService {

  tarefas = [
    {
      codigo: 1, projeto: 1, descricao: 'Tarefa 1',
      data: new Date(2017, 2, 29), prioridade: 1
    },
    {
      codigo: 2, projeto: 1, descricao: 'Tarefa 2',
      data: new Date(2017, 5, 17), prioridade: 2
    },
    {
      codigo: 3, projeto: 2, descricao: 'Tarefa 3',
      data: new Date(2017, 2, 10), prioridade: 1
    },
    {
      codigo: 4, projeto: 3, descricao: 'Tarefa 4',
      data: new Date(2017, 3, 2), prioridade: 3
    },
    {
      codigo: 5, projeto: 3, descricao: 'Tarefa 5',
      data: new Date(2017, 2, 28), prioridade: 1
    }
  ];
  ultimoCodigo = 5;

  constructor(public http: Http) { }

  getTarefas(): any[] {
    return this.tarefas;
  }

  getTarefa(codigoTarefa){
    for (let i = 0; i < this.tarefas.length; i++) {
      if (this.tarefas[i].codigo == codigoTarefa) {
        return this.tarefas[i];
        }
      }
  }

  editTarefa(c, prj, desc, dat, prior) {
    for (let i = 0; i < this.tarefas.length; i++) {
      if (this.tarefas[i].codigo == c) {
        this.tarefas[i].projeto = prj;
        this.tarefas[i].descricao = desc;
        this.tarefas[i].data = dat;
        this.tarefas[i].prioridade = prior;
        break;
      }
    }
  }

  addTarefa(prj, desc, dat, prior) {
    this.ultimoCodigo++;
    this.tarefas.push({
      codigo: this.ultimoCodigo,
      projeto: prj,
      descricao: desc,
      data: dat,
      prioridade: prior
    })
  }

  deleteTarefa(c) {
    for (let i = 0; i < this.tarefas.length; i++) {
      if (this.tarefas[i].codigo == c) {
        this.tarefas.splice(


atia":"Хърватска","Haiti":"Хаити","Hungary":"Унгария","Indonesia":"Индонезия","Ireland":"Ирландия","Israel":"Израел","Isle of Man":"Острови Ман","India":"Индия","British Indian Ocean Territory":"Британски територии в Индийския океан","Iraq":"Ирак","Iran":"Иран, Ислямска република","Iceland":"Исландия","Italy":"Италия","Jersey":"о. Джързи","Jamaica":"Ямайка","Jordan":"Йордания","Japan":"Япония","Kenya":"Кения","Kyrgyzstan":"Киргизстан","Cambodia":"Камбоджа","Kiribati":"Кирибати","Comoros":"Комори","Saint Kitts and Nevis":"Сейнт Китс и Невис","North Korea":"Корея, Северна","South Korea":"Корея, Южна","Kuwait":"Кувейт","Cayman Islands":"Кайманови острови","Kazakhstan":"Казахстан","Lao People's Democratic Republic":"Народна демократична република Лаос","Lebanon":"Ливан","Saint Lucia":"Сейнт Лусия","Liechtenstein":"Лихтенщайн","Sri Lanka":"Шри Ланка","Liberia":"Либерия","Lesotho":"Лесото","Lithuania":"Литва","Luxembourg":"Люксембург","Latvia":"Латвия","Libya":"Либийска арабска джамахирия","Morocco":"Мароко","Monaco":"Монако","Moldova":"Молдова, Република","Montenegro":"Черна гора","Saint Martin":"Сейнт Мартин","Madagascar":"Мадагаскар","Marshall Islands":"Маршалови острови","Macedonia":"Македония, Република","Mali":"Мали","Myanmar":"Мианмар","Mongolia":"Монголия","Macau":"Макао О.А.Р. на Китай","Northern Mariana Islands":"Северни Мариански Острови","Martinique":"Мартиника","Mauritania":"Мавритания","Montserrat":"Монсерат","Malta":"Малта","Mauritius":"Мавриций","Maldives":"Малдиви","Malawi":"Малави","Mexico":"Мексико","Malaysia":"Малайзия","Mozambique":"Мозамбик","Namibia":"Намибия","New Caledonia":"Нова Каледония","Niger":"Нигер","Norfolk Island":"Остров Норфолк","Nigeria":"Нигерия","Nicaragua":"Никарагуа","Netherlands":"Холандия","Norway":"Норвегия","Nepal":"Непал","Nauru":"Науру","Niue":"Ниуе","New Zealand":"Нова Зеландия","Oman":"Оман","Panama":"Панама","Peru":"Перу","French Polynesia":"Френска Полинезия","Papua New Guinea":"Папуа Нова Гвинея","Philippines":"Филипини","Pakistan":"Пакистан","Poland":"Полша","Saint Pierre and Miquelon":"Сен Пиер и Мигелон","Pitcairn Islands":"Питкайрн","Puerto Rico":"Пуерто Рико","Palestinian Territories":"Палестински територии","Portugal":"Португалия","Palau":"Палау","Paraguay


 initVertexBuffer();
	void initPipeline();
	void initPipelineLayout();

	void imageMemoryBarrier(VkCommandBuffer cmd, VkImage image, VkAccessFlags srcAccessMask,
	                        VkAccessFlags dstAccessMask, VkPipelineStageFlags srcStageMask,
	                        VkPipelineStageFlags dstStageMask, VkImageLayout oldLayout, VkImageLayout newLayout);

	float accumulatedTime = 0.0f;
};

// To create a buffer, both the device and application have requirements from the buffer object.
// Vulkan exposes the different types of buffers the device can allocate, and we have to find a suitable one.
// deviceRequirements is a bitmask expressing which memory types can be used for a buffer object.
// The different memory types' properties must match with what the application wants.
uint32_t Multisampling::findMemoryTypeFromRequirements(uint32_t deviceRequirements, uint32_t hostRequirements)
{
	const VkPhysicalDeviceMemoryProperties &props = pContext->getPlatform().getMemoryProperties();
	for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
	{
		if (deviceRequirements & (1u << i))
		{
			if ((props.memoryTypes[i].propertyFlags & hostRequirements) == hostRequirements)
			{
				return i;
			}
		}
	}

	LOGE("Failed to obtain suitable memory type.\n");
	abort();
}

uint32_t Multisampling::findMemoryTypeFromRequirementsWithFallback(uint32_t deviceRequirements,
                                                                   uint32_t hostRequirements)
{
	const VkPhysicalDeviceMemoryProperties &props = pContext->getPlatform().getMemoryProperties();
	for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++)
	{
		if (deviceRequirements & (1u << i))
		{
			if ((props.memoryTypes[i].propertyFlags & hostRequirements) == hostRequirements)
			{
				return i;
			}
		}
	}

	// If we cannot find the particular memory type we're looking for, just pick the first one available.
	if (hostRequirements != 0)
		return findMemoryTypeFromRequirements(deviceRequirements, 0);
	else
	{
		LOGE("Failed to obtain suitable memory type.\n");
		abort();
	}
}

RenderTarget Multisampling::createMultisampledRenderTarget(unsigned width, unsigned height, VkFormat format)
{
	VkDevice device = pContext->getDevice();

	VkImageCreateInfo info = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
	info.imageType = VK_IMAGE_TYPE_2D;
	info.format = format;
	info.extent.width = width;
	info.extent.height = height;
	info.extent.depth = 1;
	info.mipLevels = 1;
	info.arrayLayers = 1;
	// Use 4x MSAA. This is the best performance vs. quality tradeoff on Mali GPUs.
	// Beyond 4x MSAA, there is less fill-rate. 4x MSAA has same throughput as no multisampling.
	info.samples = VK_SAMPLE_COUNT_4_BIT;
	info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	info.tiling = VK_IMAGE_TILING_OPTIMAL;

	// This image will only be used as a transient render target.
	// Its purpose is only to hold the multisampled data before resolving the render pass.
	info.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
	info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

	// Create texture.


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

#ifndef _GDEMAOCFORCEFIELDCOPY_H_
#define _GDEMAOCFORCEFIELDCOPY_H_

#include "../gdeBaseMAOCSubObject.h"

/**
 * \brief Menu action copy object class.
 */
class gdeMAOCForceFieldCopy : public gdeBaseMAOCSubObject{
public:
	/** \name Constructors and Destructors */
	/*@{*/
	/** \brief Create menu actions. */
	gdeMAOCForceFieldCopy( gdeWindowMain &windowMain );
	/*@}*/

	/** \name Management */
	/*@{*/
	/** \brief Run action if game definition is not NULL. */
	virtual igdeUndo *OnActionSubObject( gdeGameDefinition &gameDefinition, gdeObjectClass &objectClass );

	/** \brief Request update of action parameters if required. */
	virtual void Update();
	/*@}*/
};

#endif


 = new NetworkMessage("All Good! 🌿");
                returnMessage.Sign(this);
                await Mediator.Broadcast(returnMessage);
            }

            if (payload.Contains("where are you")) {
                await SignalLocation();
            }
        }

        public override async Task Send(ICommunicates receiver, NetworkMessage message) {
            await Task.Delay(500);
            message.Sign(this);
            await Mediator.DeliverPayload(receiver.Handle, message);
        }

        public override void SetMediator(IMediator mediator) {
            Logger.LogInfo($"[{Handle}] Registering with Fleet.", ConsoleColor.DarkYellow);
            Mediator = mediator;
        }
    }
}


"Japanese localization by: {C:green}koukichi_kkc",
				},
			}
		}
	},
	misc = {
		dictionary = {
			jdis_enabled = "已啟用",
			jdis_hide_by_default = "預設隱藏",
			jdis_hide_empty = "隱藏空白",
			jdis_shift_to_hide = "Shift + 右鍵隱藏",
			jdis_disable_collapse = "停止折疊",
			jdis_disable_perishable = "停止非保久",
			jdis_disable_rental = "停止租賃",
			jdis_modifiers = "修飾符",
			jdis_reminders = "提醒事項",
			jdis_extras = "額外的",
			jdis_default_display = "預設",
			jdis_small_display = "折疊了",
			jdis_active = "活躍!",
			jdis_inactive = "不活躍",
			jdis_all_suits = "所有花色"
		},
		v_dictionary = {
			jdis_odds = "#1#/#2#",
			jdis_rank_of_suit = "#1# 的#2#"
		}
	},
}


 memory::Typed};
use gfx_device_gl;
use ggez::{event, filesystem, graphics, timer, Context};
use imgui::{self, im_str, Condition, FontId, FontSource, ImString, StyleColor, Window};
use imgui_gfx_renderer::{Renderer, Shaders};

use crate::{global::Global, utils};

#[derive(Default)]
struct MouseState {
    pos: (i32, i32),
    pressed: (bool, bool, bool),
    wheel: f32,
}

#[derive(Default)]
pub struct ImGuiState {
    pub paused: bool,
    pub debug_click_to_place: bool,
    pub restart: bool,
    pub game_over: bool,
    pub debug_t_spin_tower: bool,
    pub debug_tetris_tower: bool,
    pub update_last: Duration,
    pub draw_last: Duration,
    pub update: Vec<Duration>,
    pub draw: Vec<Duration>,
    pub game_over_window: bool,
    pub save_replay: bool,
    pub replay_score: i32,
}

pub struct ImGuiWrapper {
    pub imgui: imgui::Context,
    pub renderer: Renderer<gfx_core::format::Rgba8, gfx_device_gl::Resources>,
    regular_font: FontId,
    bold_font: FontId,
    last_frame: Instant,
    mouse_state: MouseState,
    show_debug_window: bool,
}

impl ImGuiWrapper {
    fn load_font(imgui: &mut imgui::Context, ctx: &mut Context, path: &str) -> Option<FontId> {
        let regular = filesystem::open(ctx, utils::path(ctx, path));

        let mut regular_font = None;

        if let Ok(mut regular) = regular {
            let mut regular_bytes = vec![];
            if regular.read_to_end(&mut regular_bytes).is_ok() {
                regular_font = Some(imgui.fonts().add_font(&[FontSource::TtfData {
                    data: &regular_bytes,
                    size_pixels: 16.0,
                    config: None,
                }]));
            }
        }

        if regular_font.is_none() {
            log::error!("Unable to load fonts");
        }

        regular_font
    }

    pub fn new(ctx: &mut Context) -> ImGuiWrapper {
        let mut imgui = imgui::Context::create();

        let regular_font = ImGuiWrapper::load_font(&mut imgui, ctx, "fonts/regular.ttf").unwrap();
        let bold_font = ImGuiWrapper::load_font(&mut imgui, ctx, "fonts/bold.ttf").unwrap();
        let (factory, gfx_device, _, _, _) = graphics::gfx_objects(ctx);

        let shaders = {
            let version = gfx_device.get_info().shading_language;
            if version.is_embedded {
                if version.major >= 3 {
                    Shaders::GlSlEs300
                } else {
                    Shaders::GlSlEs100
                }
            } else if version.major >= 4 {
                Shaders::GlSl400
            } else if version.major >= 3 {
                Shaders::GlSl130
            } else {
                Shaders::GlSl110
            }


aw_ptr = not not type.count("$")
            ptr_decl = "*"*(type.count("*") + (1 if is_raw_ptr else 0))

            name_dna = ptr_decl+name_canonical #+array_part

            #required  = "false"
            policy = map_policy[policy]
            destcast = "(int&)" if type in enums else ""

            # POINTER
            if is_raw_ptr:
                type = type.replace('$','')
                s += Structure_Convert_rawptrdecl.format(**locals())
            elif ptr_decl:
                s += Structure_Convert_ptrdecl.format(**locals())
            # ARRAY MEMBER
            elif name.count('[')==1:
                s += Structure_Convert_arraydecl.format(**locals())
            elif name.count('[')==2:
                s += Structure_Convert_arraydecl2d.format(**locals())
            # NORMAL MEMBER
            else:
                s += Structure_Convert_normal.format(**locals())

        s += "\n\n\tdb.reader->IncPtr(size);\n}\n\n"

    # -----------------------------------------------------------------------
    # DNA::RegisterConverters - collect all available converter functions
    # in a std::map<name,converter_proc>
    #s += "#if 0\n"
    s += "//" + "-"*80 + DNA_RegisterConverters_decl + "{\n"
    for k,v in hits.items():
        s += DNA_RegisterConverters_add.format(a=k)

    s += "\n}\n"
    #s += "#endif\n"

    output.write(templt.replace("<HERE>",s))

    # we got here, so no error
    return 0

if __name__ == "__main__":
    sys.exit(main())


1 should be up to date even though its input is dirty, because its
  // order-only dependency has nothing to do.
  string err;
  EXPECT_TRUE(builder_.AddTarget("out1", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.AlreadyUpToDate());

  // out2 should still be out of date though, because its input is dirty.
  err.clear();
  command_runner_.commands_ran_.clear();
  state_.Reset();
  EXPECT_TRUE(builder_.AddTarget("out2", &err));
  ASSERT_EQ("", err);
  EXPECT_TRUE(builder_.Build(&err));
  EXPECT_EQ("", err);
  ASSERT_EQ(1u, command_runner_.commands_ran_.size());
}

TEST_F(BuildTest, DepsGccWithEmptyDepfileErrorsOut) {
  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
"rule cc\n"
"  command = cc\n"
"  deps = gcc\n"
"build out: cc\n"));
  Dirty("out");

  string err;
  EXPECT_TRUE(builder_.AddTarget("out", &err));
  ASSERT_EQ("", err);
  EXPECT_FALSE(builder_.AlreadyUpToDate());

  EXPECT_FALSE(builder_.Build(&err));
  ASSERT_EQ("subcommand failed", err);
  ASSERT_EQ(1u, command_runner_.commands_ran_.size());
}

TEST_F(BuildTest, StatusFormatElapsed_e) {
  status_.BuildStarted();
  // Before any task is done, the elapsed time must be zero.
  EXPECT_EQ("[%/e0.000]", status_.FormatProgressStatus("[%%/e%e]", 0));
}

TEST_F(BuildTest, StatusFormatElapsed_w) {
  status_.BuildStarted();
  // Before any task is done, the elapsed time must be zero.
  EXPECT_EQ("[%/e00:00]", status_.FormatProgressStatus("[%%/e%w]", 0));
}

TEST_F(BuildTest, StatusFormatETA) {
  status_.BuildStarted();
  // Before any task is done, the ETA time must be unknown.
  EXPECT_EQ("[%/E?]", status_.FormatProgressStatus("[%%/E%E]", 0));
}

TEST_F(BuildTest, StatusFormatTimeProgress) {
  status_.BuildStarted();
  // Before any task is done, the percentage of elapsed time must be zero.
  EXPECT_EQ("[%/p  0%]", status_.FormatProgressStatus("[%%/p%p]", 0));
}

TEST_F(BuildTest, StatusFormatReplacePlaceholder) {
  EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
            status_.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]", 0));
}

TEST_F(BuildTest, FailedDepsParse) {
  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
"build bad_deps.o: cat in1\n"
"  deps = gcc\n"
"  depfile = in1.d\n"));

  string err;
  EXPECT_TRUE(builder_.AddTarget("bad_deps.o", &err));
  ASSERT_EQ("", err);

  // These deps will fail to parse, as they should only have one
  // path to the left of the colon.
  fs_.Create("in1.d", "AAA BBB");

  EXPECT_FALSE(builder_.Build(&err));
  EXPECT_EQ("subcommand failed", err);
}

struct BuildWithQueryDepsLogTest : public BuildTest {
  BuildWithQueryDepsLogTest()
      : BuildTest(&log_), deps_log_file_("ninja_de


// untriaged
  String get name native "SharedWorkerGlobalScope_name_Getter";

  /// Stream of `connect` events handled by this [SharedWorkerGlobalScope].
  @DomName('SharedWorkerGlobalScope.onconnect')
  @DocsEditable()
  @Experimental() // untriaged
  Stream<Event> get onConnect => connectEvent.forTarget(this);

}
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// WARNING: Do not edit - generated code.

@DocsEditable()
@DomName('SourceBuffer')
// https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#sourcebuffer
@Experimental()
class SourceBuffer extends EventTarget {
  // To suppress missing implicit constructor warnings.
  factory SourceBuffer._() { throw new UnsupportedError("Not supported"); }

  @DomName('SourceBuffer.appendWindowEnd')
  @DocsEditable()
  @Experimental() // untriaged
  num get appendWindowEnd native "SourceBuffer_appendWindowEnd_Getter";

  @DomName('SourceBuffer.appendWindowEnd')
  @DocsEditable()
  @Experimental() // untriaged
  void set appendWindowEnd(num value) native "SourceBuffer_appendWindowEnd_Setter";

  @DomName('SourceBuffer.appendWindowStart')
  @DocsEditable()
  @Experimental() // untriaged
  num get appendWindowStart native "SourceBuffer_appendWindowStart_Getter";

  @DomName('SourceBuffer.appendWindowStart')
  @DocsEditable()
  @Experimental() // untriaged
  void set appendWindowStart(num value) native "SourceBuffer_appendWindowStart_Setter";

  @DomName('SourceBuffer.buffered')
  @DocsEditable()
  TimeRanges get buffered native "SourceBuffer_buffered_Getter";

  @DomName('SourceBuffer.timestampOffset')
  @DocsEditable()
  num get timestampOffset native "SourceBuffer_timestampOffset_Getter";

  @DomName('SourceBuffer.timestampOffset')
  @DocsEditable()
  void set timestampOffset(num value) native "SourceBuffer_timestampOffset_Setter";

  @DomName('SourceBuffer.updating')
  @DocsEditable()
  @Experimental() // untriaged
  bool get updating native "SourceBuffer_updating_Getter";

  @DomName('SourceBuffer.abort')
  @DocsEditable()
  void abort() native "SourceBuffer_abort_Callback";

  @DomName('SourceBuffer.appendBuffer')
  @DocsEditable()
  @Experimental() // untriaged
  void appendBuffer(ByteBuffer data) native "SourceBuffer_appendBuffer_Callback";

  void appendStream(FileStream stream, [int maxSize]) {
    if (maxSize != null) {
      _appendStream_1(stream, maxSize);
      return;
    }
    _appendStream_2(stream);
    return;
  }

  void _appendStream_1(stream, maxSize) native "SourceBuffer__appendStream_1_Callback";

  void _appendStream_2(stream) native "SourceBuffer__appendStream_2_Callback";

  @DomName('SourceBuffer.appendTypedData')
  @DocsEditable()
  @Experimental() // untriaged
  void appendTypedData(TypedData data) native "SourceBuffer_appendTypedData_Callback";

  @DomName('SourceBuffer.remove')
  @DocsEditable()
  @Experimental() // untriaged
  void remove(num start, num end) native "SourceBuffer_remove_Callback";

  @DomName('SourceBuffer.addEventListener')
  @DocsEditable()
  @Experimental() // untriaged
  void addEventListener(String type, EventListener listener, [bool useCapture]) native "SourceBuffer_addEventListener_Callback";

  @DomName('SourceBuffer.dispatchEvent')
  @DocsEditable()
  @Experimental() // untriaged
  bool dispatchEvent(Event event) native "SourceBuffer_dispatchEvent


 huu wa biashara na usitume vitambulisho vya miamala ya malipo nje ya gumzo hili la biashara! Tunapendekeza pia uweke mawasiliano yote katika gumzo hili la biashara.';

  @override
  String get chat250Sbmitm8722Sbwarning250Sb0 => '⚠ PSA: kuna utapeli mpya anayefanya kazi kama mwanamume katikati. Mtapeli huwasiliana nawe nje ya jukwaa akijifanya kuwa muuzaji kwenye jukwaa akikupa kununua XMR kutoka kwao ili kubadilishana na BTC kwa bei iliyopunguzwa (k.m. lipa 8 XMR ya BTC ili kununua XMR 10). Wakati huo wanafungua biashara na muuzaji ambayo wanaiga kwenye jukwaa kwa kiasi kilichopunguzwa.';

  @override
  String get chat250Sbmitm8722Sbwarning250Sb1 => '<p>Mlaghai kisha humwambia mnunuzi aanze biashara kwa kamili na alipe kiasi kilichopunguzwa, wakati huo-huo anafuatilia anwani ya kupokea ya muuzaji kwenye blockchain na kuangalia muamala uliopunguzwa wa mnunuzi halali. Kisha mlaghai huchukua txid ya mnunuzi halali na kumpa muuzaji kama uthibitisho wa malipo. Muuzaji hutoa sarafu kwa mlaghai kwa vile wana biashara mbili wazi, mmoja kwa kiasi kamili kutoka kwa mnunuzi halali na mmoja kwa kiasi kilichopunguzwa kutoka kwa utapeli, akifikiri kuwa ni tapeli ndiye aliyelipa kwa sababu kiasi hicho kinalingana na kiasi cha biashara zao. </p>\n\n<p> <strong> USIENDE BIASHARA NJE YA JUKWAA. MTU AKIKARIBIA NJE YA JUKWAA FUNGUA BIASHARA PAMOJA NAYE KWENYE JUKWAA NA UTHIBITISHE KUWA NDIO AMBAO WANASEMA WAKO NA DUMISHA MAWASILIANO YOTE HAPO. </strong> </p>\n\n<p> <strong> WAUZAJI WANAOKUBALI MALIPO KWENYE MIFUGO YA KRYPTO INAYOWAZIA: HAKIKISHA UNAFANYA UTOFAUTI WA MALIPO YA KUTOSHA KATI YA WATEJA WAKO NA BIASHARA ILI KUEPUKA MADHUBUTI WA HILI. </strong> </p>\n\n<p> Kila mara tumia anwani tofauti kwa kila biashara kwenye sarafu-fiche inayoweza kutafutwa hadharani kama vile BTC. </p>';

  @override
  String get chat250Sbno8722Sbmessages => 'Hakuna ujumbe bado';

  @override
  String chat250Sbsecurity8722Sbwarning(Object appName) {
    return 'Usifungue viungo vyovyote vya nje unavyopokea kwenye gumzo au kupakua faili zozote zilizopokelewa kutoka kwa watumiaji wengine nje. Ni bora kutumia kivinjari tofauti kwa shughuli zako zote za $appName.';
  }

  @override
  String get chat250Sbselect8722Sbfile => 'Chagua Faili...';

  @override
  String get chat250Sbsend => 'Tuma';

  @override
  String get chat250Sbshortcuts => 'Ingiza: laini mpya, Alt+Enter: tuma';

  @override
  String chat250Sbtitle(Object user) {
    return 'Tuma ujumbe kwa $user';
  }

  @override
  String get chat250Sbupload8722Sberror8722Sbdialog8722Sbtext => 'Faili zilizoambatishwa lazima ziwe .jpg au .png na upeo wa 5MB.';


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

using System;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using EventFlow.Commands;
using EventFlow.Core;
using EventFlow.Exceptions;
using EventFlow.Logs;
using Microsoft.AspNetCore.Http;

namespace EventFlow.AspNetCore.Middlewares
{
    public class CommandPublishMiddleware
    {
        private static readonly Regex CommandPath = new Regex(
            @"/*commands/(?<name>[a-z]+)/(?<version>\d+)/{0,1}",
            RegexOptions.Compiled | RegexOptions.IgnoreCase);

        private readonly RequestDelegate _next;
        private readonly ILog _log;
        private readonly IJsonSerializer _jsonSerializer;
        private readonly ISerializedCommandPublisher _serializedCommandPublisher;

        public CommandPublishMiddleware(
            RequestDelegate next,
            ILog log,
            IJsonSerializer jsonSerializer,
            ISerializedCommandPublisher serializedCommandPublisher)
        {
            _next = next;
            _log = log;
            _jsonSerializer = jsonSerializer;
            _serializedCommandPublisher = serializedCommandPublisher;
        }

        public async Task Invoke(HttpContext context)
        {
            var path = context.Request.Path;
            if (context.Request.Method == "POST" && path.HasValue)
            {
                var match = CommandPath.Match(path.Value);
                if (match.Success)
                {
                    await PublishCommandAsync(


    }

    public AuthenticateByLarkPublicDto getLarkPublicPayload() {
        return larkPublicPayload;
    }
    public void setLarkPublicPayload(AuthenticateByLarkPublicDto larkPublicPayload) {
        this.larkPublicPayload = larkPublicPayload;
    }

    public AuthenticateByLarkInternalDto getLarkInternalPayload() {
        return larkInternalPayload;
    }
    public void setLarkInternalPayload(AuthenticateByLarkInternalDto larkInternalPayload) {
        this.larkInternalPayload = larkInternalPayload;
    }

    public AuthenticateByYidunDto getYidunPayload() {
        return yidunPayload;
    }
    public void setYidunPayload(AuthenticateByYidunDto yidunPayload) {
        this.yidunPayload = yidunPayload;
    }

    public AuthenticateByWechatMiniProgramCodeDto getWechatMiniProgramCodePayload() {
        return wechatMiniProgramCodePayload;
    }
    public void setWechatMiniProgramCodePayload(AuthenticateByWechatMiniProgramCodeDto wechatMiniProgramCodePayload) {
        this.wechatMiniProgramCodePayload = wechatMiniProgramCodePayload;
    }

    public AuthenticateByWechatMiniProgramPhoneDto getWechatMiniProgramPhonePayload() {
        return wechatMiniProgramPhonePayload;
    }
    public void setWechatMiniProgramPhonePayload(AuthenticateByWechatMiniProgramPhoneDto wechatMiniProgramPhonePayload) {
        this.wechatMiniProgramPhonePayload = wechatMiniProgramPhonePayload;
    }

    public SignInByMobileOptionsDto getOptions() {
        return options;
    }
    public void setOptions(SignInByMobileOptionsDto options) {
        this.options = options;
    }

    /**
     * 移动端社会化登录类型：
     * - `wechat`: 微信移动应用
     * - `alipay`: 支付宝移动应用
     * - `wechatwork`: 企业微信移动应用
     * - `wechatwork_agency`: 企业微信移动应用（代开发模式）
     * - `lark_internal`: 飞书移动端企业自建应用
     * - `lark_public`: 飞书移动端应用商店应用
     * - `yidun`: 网易易盾一键登录
     * - `wechat_mini_program_code`: 微信小程序使用 code 登录
     * - `wechat_mini_program_phone `: 微信小程序使用手机号登录
     *
     */
    public static enum Connection {

        @JsonProperty("wechat")
        WECHAT("wechat"),

        @JsonProperty("alipay")
        ALIPAY("alipay"),

        @JsonProperty("wechatwork")
        WECHATWORK("wechatwork"),

        @JsonProperty("wechatwork_agency")
        WECHATWORK_AGENCY("wechatwork_agency"),

        @JsonProperty("lark_internal")
        LARK_INTERNAL("lark_internal"),

        @JsonProperty("lark_public")
        LARK_PUBLIC("lark_public"),

        @JsonProperty("yidun")
        YIDUN("yidun"),

        @JsonProperty("wechat_mini_program_code")
        WECHAT_MINI_PROGRAM_CODE("wechat_mini_program_code"),

        @JsonProperty("wechat_mini_program_phone")
        WECHAT_MINI_PROGRAM_PHONE("wechat_mini_program_phone"),
        ;

        private String value;

        Connection(


垃圾回收算法，该算法中有一个标记初始的 root 区域，以及一个受控堆区。root 区域主要是程序运行到当前时刻的栈和全局数据区域。在受控堆区中，很多数据是程序以后不需要用到的，这类数据就可以被当作垃圾回收了。判断一个对象是否为垃圾，就是看从 root 区域的对象是否有直接或间接的引用到这个对象。如果没有任何对象引用到它，则说明它没有被使用，因此可以安全地当作垃圾回收掉。

标记清扫算法分为两阶段：标记阶段和清扫阶段。标记阶段，从 root 区域出发，扫描所有 root 区域的对象直接或间接引用到的对象，将这些对上全部加上标记。在回收阶段，扫描整个堆区，对所有无标记的对象进行回收。(补图)

## 位图标记和内存布局

既然垃圾回收算法要求给对象加上垃圾回收的标记，显然是需要有标记位的。一般的做法会将对象结构体中加上一个标记域，一些优化的做法会利用对象指针的低位进行标记，这都只是些奇技淫巧罢了。Go 没有这么做，它的对象和 C 的结构体对象完全一致，使用的是非侵入式的标记位，我们看看它是怎么实现的。

堆区域对应了一个标记位图区域，堆中每个字(不是 byte，而是 word)都会在标记位区域中有对应的标记位。每个机器字(32 位或 64 位)会对应 4 位的标记位。因此，64 位系统中相当于每个标记位图的字节对应 16 个堆中的字节。

虽然是一个堆字节对应 4 位标记位，但标记位图区域的内存布局并不是按 4 位一组，而是 16 个堆字节为一组，将它们的标记位信息打包存储的。每组 64 位的标记位图从上到下依次包括：

    16位的 特殊位 标记位
    16位的 垃圾回收 标记位
    16位的 无指针/块边界 的标记位
    16位的 已分配 标记位

这样设计使得对一个类型的相应的位进行遍历很容易。

前面提到堆区域和堆地址的标记位图区域是分开存储的，其实它们是以 mheap.arena_start 地址为边界，向上是实际使用的堆地址空间，向下则是标记位图区域。以 64 位系统为例，计算堆中某个地址的标记位的公式如下：

    偏移 = 地址 - mheap.arena_start
    标记位地址 = mheap.arena_start - 偏移


; active, canceled, or filled.

These orders will not be found:

order status is CANCELED or EXPIRED AND order has NO filled trade AND created time + 3 days < current time

order create time + 90 days < current time

HTTP Request

GET /fapi/v1/allOrders

Request Weight

5

Request Parameters

Name	Type	Mandatory	Description

symbol	STRING	YES

orderId	LONG	NO

startTime	LONG	NO

endTime	LONG	NO

limit	INT	NO	Default 500; max 1000.

recvWindow	LONG	NO

timestamp	LONG	YES

Notes:

If orderId is set, it will get orders >= that orderId. Otherwise most recent orders are returned.

The query time period must be less then 7 days( default as the recent 7 days).

Response Example

[
  {</span


diffusion).

## Requirements
A suitable [conda](https://conda.io/) environment named `ldm` can be created
and activated with:

```
conda env create -f environment.yaml
conda activate ldm
```

You can also update an existing [latent diffusion](https://github.com/CompVis/latent-diffusion) environment by running

```
conda install pytorch torchvision -c pytorch
pip install transformers==4.19.2 diffusers invisible-watermark
pip install -e .
```

## Stable Diffusion v1

Stable Diffusion v1 refers to a specific configuration of the model
architecture that uses a downsampling-factor 8 autoencoder with an 860M UNet
and CLIP ViT-L/14 text encoder for the diffusion model. The model was pretrained on 256x256 images and
then finetuned on 512x512 images.

*Note: Stable Diffusion v1 is a general text-to-image diffusion model and therefore mirrors biases and (mis-)conceptions that are present
in its training data.
Details on the training procedure and data, as well as the intended use of the model can be found in the corresponding [model card](Stable_Diffusion_v1_Model_Card.md).*

The weights are available via [the CompVis organization at Hugging Face](https://huggingface.co/CompVis) under [a license which contains specific use-based restrictions to prevent misuse and harm as informed by the model card, but otherwise remains permissive](LICENSE). While commercial use is permitted under the terms of the license, **we do not recommend using the provided weights for services or products without additional safety mechanisms and considerations**, since there are [known limitations and biases](Stable_Diffusion_v1_Model_Card.md#limitations-and-bias) of the weights, and research on safe and ethical deployment of general text-to-image models is an ongoing effort. **The weights are research artifacts and should be treated as such.**

[The CreativeML OpenRAIL M license](LICENSE) is an [Open RAIL M license](https://www.licenses.ai/blog/2022/8/18/naming-convention-of-responsible-ai-licenses), adapted from the work that [BigScience](https://bigscience.huggingface.co/) and [the RAIL Initiative](https://www.licenses.ai/) are jointly carrying in the area of responsible AI licensing. See also [the article about the BLOOM Open RAIL license](https://bigscience.huggingface.co/blog/the-bigscience-rail-license) on which our license is based.

### Weights

We currently provide the following checkpoints:

- `sd-v1-1.ckpt`: 237k steps at resolution `256x256` on [laion2B-en](https://huggingface.co/datasets/laion/laion2B-en).
  194k steps at resolution `512x512` on [laion-high-resolution](https://huggingface.co/datasets/laion/laion-high-resolution) (170M examples from LAION-5B with resolution `>= 1024x1024`).
- `sd-v1-2.ckpt`: Resumed from `sd-v1-1.ckpt`.
  515k steps at resolution `512x512` on [laion-aesthetics v2 5+](https://laion.ai/blog/laion-aesthetics/) (a subset of laion2B-en with estimated aesthetics score `> 5.0`, and additionally


 8-bytes aligned */
aligned:cbz	x1, x1_zero
	bfi	w1, w1, #8, #8		/* propagate 'val' */
	bfi	w1, w1, #16, #16
	bfi	x1, x1, #32, #32

x1_zero:ands	x4, x2, #~0x3f
	b.eq	less_64

write_64:
	.rept	4
	stp	x1, x1, [x3], #16	/* write 64 bytes in a loop */
	.endr
	subs	x4, x4, #64
	b.ne	write_64
less_64:tbz	w2, #5, less_32		/* < 32 bytes */
	stp	x1, x1, [x3], #16	/* write 32 bytes */
	stp	x1, x1, [x3], #16
less_32:tbz	w2, #4, less_16		/* < 16 bytes */
	stp	x1, x1, [x3], #16	/* write 16 bytes */
less_16:tbz	w2, #3, less_8		/* < 8 bytes */
	str	x1, [x3], #8		/* write 8 bytes */
less_8:	tbz	w2, #2, less_4		/* < 4 bytes */
	str	w1, [x3], #4		/* write 4 bytes */
less_4:	tbz	w2, #1, less_2		/* < 2 bytes */
	strh	w1, [x3], #2		/* write 2 bytes */
less_2:	tbz	w2, #0, exit
	strb	w1, [x3]		/* write 1 byte */
exit:	ret

endfunc	memset


/www.openssl.org/source/license.html">https://www.openssl.org/source/license.html.

<?xml version="1.0" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<title>openssl-prime</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<link rev="made" href="mailto:root@w9fw4.p1s.plx.sd.apple.com" />

NAME

SYNOPSIS

DESCRIPTION

OPTIONS

COPYRIGHT

NAME

openssl-prime - compute prime numbers

SYNOPSIS

openssl prime [-help] [-hex] [-generate] [-bits num] [-safe] [-provider name] [-provider-path path] [-propquery propq] [-checks num] [number ...]

DESCRIPTION

This command checks if the specified numbers are prime.

If no numbers are given on the command line, the -generate flag should be used to generate primes according to the requirements specified by the rest of the flags.

OPTIONS

-help

Display an option summary.

-hex

Generate hex output.

-generate

Generate a prime number.

-bits num

Generate a prime with num bits.

-safe

When used with -generate, generates a "safe" prime. If the number generated is n, then check that (n-1)/2 is also prime.

-provider name

-provider-path path

-propquery propq

See "Provider Options" in openssl(1), provider(7), and property(7).

-checks num

This parameter is


LinkerProvider.Type.GNU, new ConstantToolProvider(commandToolBuilder.build()), true);
    return CxxPlatform.builder()
        .setFlavor(DEFAULT_PLATFORM_FLAVOR)
        .setAs(defaultCompilerProvider(ToolType.AS))
        .setAspp(defaultPreprocessorProvider(ToolType.ASPP))
        .setCc(defaultCompilerProvider(ToolType.CC))
        .setCpp(defaultPreprocessorProvider(ToolType.CPP))
        .setCxx(defaultCompilerProvider(ToolType.CXX))
        .setCxxpp(defaultPreprocessorProvider(ToolType.CXXPP))
        .setCuda(defaultCompilerProvider(ToolType.CUDA))
        .setCudapp(defaultPreprocessorProvider(ToolType.CUDAPP))
        .setAsm(defaultCompilerProvider(ToolType.ASM))
        .setAsmpp(defaultPreprocessorProvider(ToolType.ASMPP))
        .setLd(linkerProvider)
        .setStrip(DEFAULT_TOOL)
        .setAr(ArchiverProvider.from(new GnuArchiver(DEFAULT_TOOL)))
        .setArchiveContents(ArchiveContents.NORMAL)
        .setRanlib(new ConstantToolProvider(DEFAULT_TOOL))
        .setSymbolNameTool(new PosixNmSymbolNameTool(new ConstantToolProvider(DEFAULT_TOOL)))
        .setSharedLibraryExtension("so")
        .setSharedLibraryVersionedExtensionFormat("so.%s")
        .setStaticLibraryExtension("a")
        .setObjectFileExtension("o")
        .setCompilerDebugPathSanitizer(DEFAULT_COMPILER_DEBUG_PATH_SANITIZER)
        .setHeaderVerification(DEFAULT_CONFIG.getHeaderVerificationOrIgnore())
        .setPublicHeadersSymlinksEnabled(true)
        .setPrivateHeadersSymlinksEnabled(true)
        .build();
  }

  public static final UnresolvedCxxPlatform DEFAULT_UNRESOLVED_PLATFORM =
      new StaticUnresolvedCxxPlatform(DEFAULT_PLATFORM);

  public static final FlavorDomain<UnresolvedCxxPlatform> DEFAULT_PLATFORMS =
      FlavorDomain.of("C/C++ Platform", DEFAULT_UNRESOLVED_PLATFORM);

  public static CxxPlatform build(CxxBuckConfig config) {
    return DefaultCxxPlatforms.build(Platform.detect(), config);
  }

  private static CxxPlatform getDefaultPlatform(Path root) throws IOException {
    Config rawConfig = Configs.createDefaultConfig(root);
    BuckConfig buckConfig =
        FakeBuckConfig.builder()
            .setSections(rawConfig.getRawConfig())
            .setFilesystem(TestProjectFilesystems.createProjectFilesystem(root))
            .setEnvironment(ImmutableMap.of())
            .build();
    return DefaultCxxPlatforms.build(Platform.detect(), new CxxBuckConfig(buckConfig));
  }

  public static HeaderMode getHeaderModeForDefaultPlatform(Path root) throws IOException {
    BuildRuleResolver ruleResolver = new TestActionGraphBuilder();
    CxxPlatform defaultPlatform = getDefaultPlatform(root);
    return defaultPlatform
            .getCpp()
            .resolve(ruleResolver, UnconfiguredTargetConfiguration.INSTANCE)
            .supportsHeaderMaps()
        ? HeaderMode.SYMLINK_TREE_WITH_HEADER_MAP
        : HeaderMode.SYMLINK_TREE_ONLY;
  }
}
/*
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific langua


("refund", "￥" + map.get("amount"),"red"));
        data.add(new WxMpTemplateData("reason", "取消订单"));
        data.add(new WxMpTemplateData("remark", "\n\n备注：如有疑问，请致电13260695888联系我们，或回复M来了解详情。"));
        templateMessage.setData(data);
        try {
            wxMpService.getTemplateMsgService().sendTemplateMsg(templateMessage);
        }catch (WxErrorException e) {
        	logger.error("【微信模版消息】发送失败, {}", e);
        }
	}

	/**
	 * 发送新订单通知
	 *
	 * 您收到了一条新的订单。

		提交时间：02月18日 01时05分
		订单类型：询价订单
		客户信息：广州 王俊
		兴趣车型：骐达 2011款 1.6 CVT 舒适版

		截止24日09:39分,您尚有10个订单未处理。
		详情

		{{first.DATA}}

		提交时间：{{tradeDateTime.DATA}}
		订单类型：{{orderType.DATA}}
		客户信息：{{customerInfo.DATA}}
		{{orderItemName.DATA}}：{{orderItemData.DATA}}
		{{remark.DATA}}
	 */
	@Override
	public void pushNewOrderNotification(String jsonStr) {
		WxMpTemplateMessage templateMessage = new WxMpTemplateMessage();
		WeixinTemplate  weixinTemplate = weixinTemplateMapper.selectWeixinTemplateByTemplateKey(NEW_ORDER_NOTIFICATION);
        //模板ID
		templateMessage.setTemplateId(weixinTemplate.getTemplateId());

		Map<String, String> map = WeiXinJsonUtil.jsonToMap(jsonStr);

		//接收消息openId
        templateMessage.setToUser(map.get("openId"));

        List<WxMpTemplateData> data = new ArrayList<WxMpTemplateData>();
        data.add(new WxMpTemplateData("first", "您收到了一条新的订单,请及时处理!"));
        data.add(new WxMpTemplateData("tradeDateTime", map.get("tradeDateTime")));
        data.add(new WxMpTemplateData("orderType", map.get("orderType")));
        data.add(new WxMpTemplateData("customerInfo", map.get("customerInfo")));
        data.add(new WxMpTemplateData("orderItemName", map.get("orderItemName")));
        data.add(new WxMpTemplateData("orderItemData", map.get("orderItemData")));
        data.add(new WxMpTemplateData("remark", "\n\n截止"+map.get("tradeDateTime")+",您尚有"+map.get("orderNum")+"个订单未处理"));
        templateMessage.setData(data);
        try {
            wxMpService.getTemplateMsgService().sendTemplateMsg(templateMessage);
        }catch (WxErrorException e) {
        	logger.error("【微信模版消息】发送失败, {}", e);
        }

	}

	/**
	 * 商品已发出通知
	 * 亲，宝贝已经启程了，好想快点来到你身边

	      快递公司：顺丰快递
	     快递单号：3291987391
	     备注：如果疑问，请在微信服务号中输入“KF”，**将在第一时间为您服务！

	     {{first.DATA}}

		快递公司：{{delivername.DATA}}
		快递单号：{{ordername.DATA}}
		{{remark.DATA}}
	 */
	@Override
	public void pushCommoditHasBeenNotified(String jsonStr) {
		WxMpTemplateMessage templateMessage = n


g/struct.String.html#examples",
        "https://doc.rust-lang.org/nightly/std/string/struct.String.html#method.drain",
    ];

    for &valid in VALID_FAVORED {
        let link = Path::new(valid);
        assert_eq!(
            link_parts(link, &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            favored_parts(link, &crate::OPTS_KRATE_DIS_AND_FAV).unwrap()
        )
    }

    const VALID_ASSOCIATED: &[&str] = &["#struct.Item", "./#struct.Item", "././#struct.Item"];

    for &valid in VALID_ASSOCIATED {
        let link = Path::new(valid);
        assert_eq!(
            link_parts(link, &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            associated_item_parts(link).unwrap()
        )
    }

    const VALID_SECTION: &[&str] = &[
        "#section-a",
        "#section-1",
        "#section-A",
        "#section_a",
        "#section.a",
        "#Section.a",
        "#rection.a",
        "#0ection.a",
        "#_ection.a",
        "krate/#section",
        "../krate/#section",
        "mod1/#section",
        "mod1/mod2/#section",
        "../../mod1/mod2/#section",
    ];

    for &valid in VALID_SECTION {
        let link = Path::new(valid);
        assert_eq!(
            link_parts(link, &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            section_parts(link, &crate::OPTS_KRATE_DIS_AND_FAV.krate).unwrap()
        )
    }

    let mut rust_item = String::with_capacity(40);

    for &item in crate::ALL_ITEM_TYPES {
        rust_item.clear();
        rust_item.push_str(item);
        rust_item.push_str(".Type.html");
        assert_eq!(
            link_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            item_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV.krate).unwrap(),
        );

        rust_item.clear();
        rust_item.push_str(item);
        rust_item.push_str(".Type.html#method.call");
        assert_eq!(
            link_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            item_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV.krate).unwrap(),
        );

        rust_item.clear();
        rust_item.push_str(item);
        rust_item.push_str(".Type.html#section-name");
        assert_eq!(
            link_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            item_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV.krate).unwrap(),
        );

        rust_item.clear();
        rust_item.push_str("./");
        rust_item.push_str(item);
        rust_item.push_str(".Type.html");
        assert_eq!(
            link_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV).unwrap(),
            item_parts(Path::new(&rust_item), &crate::OPTS_KRATE_DIS_AND_FAV.k


liceCmd {
	args := []string{"ZRANGEBYSCORE", key, opt.Min, opt.Max}
	if withScores {
		args = append(args, "WITHSCORES")
	}
	if opt.Offset != 0 || opt.Count != 0 {
		args = append(
			args,
			"LIMIT",
			strconv.FormatInt(opt.Offset, 10),
			strconv.FormatInt(opt.Count, 10),
		)
	}
	cmd := NewStringSliceCmd(args...)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRangeByScore(key string, opt ZRangeByScore) *StringSliceCmd {
	return c.zRangeByScore(key, opt, false)
}

func (c *commandable) ZRangeByScoreWithScores(key string, opt ZRangeByScore) *ZSliceCmd {
	args := []string{"ZRANGEBYSCORE", key, opt.Min, opt.Max, "WITHSCORES"}
	if opt.Offset != 0 || opt.Count != 0 {
		args = append(
			args,
			"LIMIT",
			strconv.FormatInt(opt.Offset, 10),
			strconv.FormatInt(opt.Count, 10),
		)
	}
	cmd := NewZSliceCmd(args...)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRank(key, member string) *IntCmd {
	cmd := NewIntCmd("ZRANK", key, member)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRem(key string, members ...string) *IntCmd {
	args := append([]string{"ZREM", key}, members...)
	cmd := NewIntCmd(args...)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRemRangeByRank(key string, start, stop int64) *IntCmd {
	cmd := NewIntCmd(
		"ZREMRANGEBYRANK",
		key,
		strconv.FormatInt(start, 10),
		strconv.FormatInt(stop, 10),
	)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRemRangeByScore(key, min, max string) *IntCmd {
	cmd := NewIntCmd("ZREMRANGEBYSCORE", key, min, max)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRevRange(key string, start, stop int64) *StringSliceCmd {
	cmd := NewStringSliceCmd("ZREVRANGE", key, formatInt(start), formatInt(stop))
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRevRangeWithScores(key string, start, stop int64) *ZSliceCmd {
	cmd := NewZSliceCmd("ZREVRANGE", key, formatInt(start), formatInt(stop), "WITHSCORES")
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRevRangeByScore(key string, opt ZRangeByScore) *StringSliceCmd {
	args := []string{"ZREVRANGEBYSCORE", key, opt.Max, opt.Min}
	if opt.Offset != 0 || opt.Count != 0 {
		args = append(
			args,
			"LIMIT",
			strconv.FormatInt(opt.Offset, 10),
			strconv.FormatInt(opt.Count, 10),
		)
	}
	cmd := NewStringSliceCmd(args...)
	c.Process(cmd)
	return cmd
}

func (c *commandable) ZRevRangeByScoreWithScores(key string, opt ZRangeByScore) *ZSliceCmd {
	args := []string{"ZREVRANGEBYSCORE", key, opt.Max, opt.Min, "WITHSCORES"}
	if opt.Offset != 0 || opt.Count != 0 {
		args = append(
			args,
			"LIMIT",
			strconv.FormatInt(opt.Offset, 10),
			strconv.FormatInt(opt.Count, 10),
		)
	}
	cmd


_, 2
	octave 4
	note C_, 2
	note D_, 2
	octave 3
	note G_, 2
	octave 4
	note D_, 2
	volume_envelope 11, 5
	octave 3
	note B_, 2
	octave 4
	note D_, 2
	octave 3
	note B_, 2
	octave 4
	note D_, 4
	octave 3
	note G_, 2
	note B_, 2
	octave 4
	note D_, 2
	sound_loop 0, gbs_route30_Ch1.mainloop

gbs_route30_Ch2:
	gbs_switch 1
	duty_cycle 3
	vibrato 18, 3, 6
	stereo_panning FALSE, TRUE
	note_type 12, 12, 2
	octave 3
	note G_, 6
	note G_, 1
	note G_, 1
	note G_, 2
	note G_, 2
	note G_, 4
	note G_, 6
	note G_, 1
	note G_, 1
	note G_, 2
	note G_, 2
	volume_envelope 12, 4
	note D_, 1
	note E_, 1
	note F_, 1
	note Fs, 1
gbs_route30_Ch2.mainloop:
	volume_envelope 12, 7
	note G_, 10
	octave 4
	note D_, 2
	octave 3
	note B_, 2
	note G_, 2
	octave 4
	note F_, 10
	note E_, 2
	note D_, 2
	note C_, 2
	note D_, 1
	note E_, 1
	note D_, 1
	note E_, 1
	volume_envelope 11, 0
	note D_, 4
	volume_envelope 11, 7
	note D_, 8
	volume_envelope 3, -7
	note D_, 8
	volume_envelope 11, 7
	note D_, 8
	volume_envelope 12, 7
	note C_, 10
	note C_, 2
	octave 3
	note A_, 2
	note F_, 2
	octave 4
	note F_, 10
	note E_, 2
	note D_, 2
	note C_, 2
	octave 3
	note B_, 6
	note G_, 2
	octave 4
	note D_, 8
	octave 3
	note G_, 6
	note D_, 2
	note B_, 8
	note C_, 2
	note A_, 4
	note B_, 4
	octave 4
	note C_, 4
	note D_, 2
	note F_, 8
	note A_, 8
	note G_, 2
	volume_envelope 11, 0
	note D_, 4
	volume_envelope 11, 7
	note D_, 10
	volume_envelope 12, 7
	note C_, 4
	octave 3
	note B_, 4
	note A_, 4
	note G_, 4
	note A_, 4
	note B_, 4
	octave 4
	note C_, 4
	note D_, 4
	note F_, 8
	octave 5
	note C_, 8
	octave 4
	note B_, 2
	volume_envelope 11, 0
	note G_, 6
	volume_envelope 11, 7
	note G_, 8
	volume_envelope 12, 7
	note B_, 2
	volume_envelope 11, 0
	note G_, 4
	volume_envelope 11, 7
	note G_, 8
	volume_envelope 10, 7
	octave 3
	note Fs, 2
	sound_loop 0, gbs_route30_Ch2.mainloop

gbs_route30_Ch3:
	gbs_switch 2
	note_type 12, 2, 7
	octave 2
	note G_, 1
	rest 5
	note G_, 1
	note G_, 1
	note G_, 1
	rest 1
	note G_, 1
	rest 1
	note G_, 1
	rest 3
	note G_, 1
	rest 5
	note G_, 1
	note G_, 1
	note G_, 1
	rest 1
	note


/ Extract the one scalar element that is actually being stored.
  SDLoc DL(MS);
  SDValue Value = MS->getValue();
  EVT VT = Value.getValueType();
  EVT EltVT = VT.getVectorElementType();
  if (EltVT == MVT::i64 && !Subtarget.is64Bit()) {
    EltVT = MVT::f64;
    EVT CastVT = VT.changeVectorElementType(EltVT);
    Value = DAG.getBitcast(CastVT, Value);
  }
  SDValue Extract =
      DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, Value, VecIndex);

  // Store that element at the appropriate offset from the base pointer.
  return DAG.getStore(MS->getChain(), DL, Extract, Addr,
                      MS->getPointerInfo().getWithOffset(Offset),
                      Alignment, MS->getMemOperand()->getFlags());
}

static SDValue combineMaskedStore(SDNode *N, SelectionDAG &DAG,
                                  TargetLowering::DAGCombinerInfo &DCI,
                                  const X86Subtarget &Subtarget) {
  MaskedStoreSDNode *Mst = cast<MaskedStoreSDNode>(N);
  if (Mst->isCompressingStore())
    return SDValue();

  EVT VT = Mst->getValue().getValueType();
  SDLoc dl(Mst);
  const TargetLowering &TLI = DAG.getTargetLoweringInfo();

  if (Mst->isTruncatingStore())
    return SDValue();

  if (SDValue ScalarStore = reduceMaskedStoreToScalarStore(Mst, DAG, Subtarget))
    return ScalarStore;

  // If the mask value has been legalized to a non-boolean vector, try to
  // simplify ops leading up to it. We only demand the MSB of each lane.
  SDValue Mask = Mst->getMask();
  if (Mask.getScalarValueSizeInBits() != 1) {
    APInt DemandedBits(APInt::getSignMask(VT.getScalarSizeInBits()));
    if (TLI.SimplifyDemandedBits(Mask, DemandedBits, DCI)) {
      if (N->getOpcode() != ISD::DELETED_NODE)
        DCI.AddToWorklist(N);
      return SDValue(N, 0);
    }
    if (SDValue NewMask =
            TLI.SimplifyMultipleUseDemandedBits(Mask, DemandedBits, DAG))
      return DAG.getMaskedStore(Mst->getChain(), SDLoc(N), Mst->getValue(),
                                Mst->getBasePtr(), Mst->getOffset(), NewMask,
                                Mst->getMemoryVT(), Mst->getMemOperand(),
                                Mst->getAddressingMode());
  }

  SDValue Value = Mst->getValue();
  if (Value.getOpcode() == ISD::TRUNCATE && Value.getNode()->hasOneUse() &&
      TLI.isTruncStoreLegal(Value.getOperand(0).getValueType(),
                            Mst->getMemoryVT())) {
    return DAG.getMaskedStore(Mst->getChain(), SDLoc(N), Value.getOperand(0),
                              Mst->getBasePtr(), Mst->getOffset(), Mask,
                              Mst->getMemoryVT(), Mst->getMemOperand(),
                              Mst->getAddressingMode(), true);
  }

  return SDValue();
}

static SDValue combineStore(SDNode *N, SelectionDAG &DAG,
                            TargetLowering::DAGCombinerInfo &DCI,
                            const X86Subtarget &Subtarget) {
  StoreSDNode *St = cast<StoreSDNode>(N);
  EVT StVT = St->getMemoryVT();
  SDLoc dl(St);
  SDValue StoredVal = St->getValue();
  EVT VT = StoredVal.getValueType();
  const TargetLowering &TLI = DAG.getTargetLoweringInfo();

  // Convert a store of vXi1 into a store of iX and a bitcast.
  if (!Subtarget.hasAVX512() && VT


ash>, DispatchError> {
		match r {
			ReferendumInfo::Ongoing(s) => Ok(s),
			_ => Err(Error::<T>::ReferendumIsOver.into()),
		}
	}

	/// Internal finalization of referendum voting
	fn finalize_vote(
		metaverse_id: MetaverseId,
		referendum_id: ReferendumId,
		referendum_status: ReferendumStatus<T::BlockNumber, BalanceOf<T>, T::Hash>,
	) -> DispatchResult {
		// Check if referendum passes
		let total_issuance = T::Currency::total_issuance();
		let is_referendum_approved = referendum_status
			.threshold
			.is_referendum_approved(referendum_status.tally.clone(), total_issuance);

		// Update referendum info
		<ReferendumInfoOf<T>>::try_mutate(metaverse_id, referendum_id, |referendum_info| -> DispatchResult {
			*referendum_info = Some(ReferendumInfo::Finished {
				title: referendum_status.title.clone(),
				passed: is_referendum_approved,
				end: referendum_status.end,
			});

			Ok(())
		});

		// Enact proposal if it passed the threshold
		if is_referendum_approved {
			let mut when = referendum_status.end;
			match Self::referendum_parameters(referendum_status.metaverse) {
				Some(current_params) => when += current_params.enactment_period,
				None => when += ReferendumParameters::default().enactment_period,
			}

			if T::Scheduler::schedule_named(
				(GOVERNANCE_ID, referendum_id).encode(),
				DispatchTime::At(when),
				None,
				63,
				frame_system::RawOrigin::Root.into(),
				Call::enact_proposal {
					proposal: referendum_status.proposal,
					metaverse_id: referendum_status.metaverse,
					referendum_id: referendum_id,
					proposal_hash: referendum_status.proposal_hash,
				}
				.into(),
			)
			.is_err()
			{
				frame_support::print("LOGIC ERROR: is_referendum_approved/schedule_named failed");
			} else {
				Self::deposit_event(Event::ReferendumPassed(referendum_id));
			}
		} else {
			let preimage = <Preimages<T>>::take(&metaverse_id, &referendum_status.proposal_hash);
			if let Some(PreimageStatus::Available {
				data,
				provider,
				deposit,
				..
			}) = preimage
			{
				T::Currency::unreserve(&provider, deposit);
			}
			Self::deposit_event(Event::ReferendumNotPassed(referendum_id));
		}

		Ok(())
	}

	/// Internal enacting of successfully passed proposal
	fn do_enact_proposal(
		proposal_id: ProposalId,
		metaverse_id: MetaverseId,
		referendum_id: ReferendumId,
		proposal_hash: T::Hash,
	) -> DispatchResult {
		let preimage = <Preimages<T>>::take(&metaverse_id, &proposal_hash);
		if let Some(PreimageStatus::Available {
			data,
			provider,
			deposit,
			..
		}) = preimage
		{
			if let Ok(proposal) = T::Proposal::decode(&mut &data[..]) {
				let proposal_type = T::ProposalType::default();
				if !proposal_type.filter(&proposal) {
					T::Slash::on_unbalanced(T::Currency::slash_reserved(&provider, deposit).0);
					Self::deposit_event(Event::<T>::PreimageInvalid(metaverse_id, proposal_hash


4480F26 */  lhu     $t0, 0x0F26($v0)           ## 8015F586
/* 0051C 809E304C 35090100 */  ori     $t1, $t0, 0x0100           ## $t1 = 00000100
/* 00520 809E3050 A4490F26 */  sh      $t1, 0x0F26($v0)           ## 8015F586
.L809E3054:
/* 00524 809E3054 8FBF0014 */  lw      $ra, 0x0014($sp)
/* 00528 809E3058 27BD0020 */  addiu   $sp, $sp, 0x0020           ## $sp = 00000000
/* 0052C 809E305C 00601025 */  or      $v0, $v1, $zero            ## $v0 = 00000000
/* 00530 809E3060 03E00008 */  jr      $ra
/* 00534 809E3064 00000000 */  nop


  private:
    // Indicates which slice is in the segment
    uInt16 myCurrentSlice[2];

    // Indicates which 256 byte bank of RAM is being used
    uInt16 myCurrentRAM;

    // The 16K ROM image of the cartridge
    uInt8 myImage[16384];

    // The 2048 bytes of RAM
    uInt8 myRAM[2048];
};

#endif
//============================================================================
//
//   SSSS    tt          lll  lll
//  SS  SS   tt           ll   ll
//  SS     tttttt  eeee   ll   ll   aaaa
//   SSSS    tt   ee  ee  ll   ll      aa
//      SS   tt   eeeeee  ll   ll   aaaaa  --  "An Atari 2600 VCS Emulator"
//  SS  SS   tt   ee      ll   ll  aa  aa
//   SSSS     ttt  eeeee llll llll  aaaaa
//
// Copyright (c) 1995-2007 by Bradford W. Mott and the Stella team
//
// See the file "license" for information on usage and redistribution of
// this file, and for a DISCLAIMER OF ALL WARRANTIES.
//
// $Id: CartF8SC.cxx,v 1.13 2007/01/14 16:17:54 stephena Exp $
//============================================================================

#include <cassert>

#include "Random.hxx"
#include "System.hxx"
#include "Serializer.hxx"
#include "Deserializer.hxx"
#include "CartF8SC.hxx"
using namespace std;

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CartridgeF8SC::CartridgeF8SC(const uInt8* image)
{
  // Copy the ROM image into my buffer
  for(uInt32 addr = 0; addr < 8192; ++addr)
  {
    myImage[addr] = image[addr];
  }

  // Initialize RAM with random values
  class Random& random = Random::getInstance();

  for(uInt32 i = 0; i < 128; ++i)
  {
    myRAM[i] = random.next();
  }
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CartridgeF8SC::~CartridgeF8SC()
{
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
const char* CartridgeF8SC::name() const
{
  return "CartridgeF8SC";
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeF8SC::reset()
{
  // Upon reset we switch to bank 1
  bank(1);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CartridgeF8SC::install(System& system)
{
  mySystem = &system;
  uInt16 shift = mySystem->pageShift();
  uInt16 mask = mySystem->pageMask();

  // Make sure the system we're being installed in has a page size that'll work
  assert(((0x1080 & mask) == 0) && ((0x1100 & mask) == 0));

  // Set the page accessing methods for the hot spots
  System::PageAccess access;
  for(uInt32 i = (0x1FF8 & ~mask); i < 0x2000; i += (1 << shift))
  {
    access.directPeekBase = 0;
    access.directPokeBase = 0;
    access.device = this;
    mySystem->setPageAccess(i >> shift, access);
  }

  // Set the page accessing method for the RAM writing pages
  for(uInt32 j = 0x1000; j < 0x1080; j += (1 << shift))
  {
    access.device = this;
    access.directPeekBase = 0;
    access.directPokeBase = &myRAM[j & 0x007F];
    mySystem->setPageAccess(j >> shift, access);
  }

  // Set the page accessing method for the RAM reading pages
  for(uInt32 k = 0x1080; k < 0x1100; k += (1 << shift))
  {
    access.device = this;
    access.directPeekBase = &myRAM


92 0 26.73-9.157 30.75-23.22l128-448c.85-2.97 1.25-5.93 1.25-8.84zM176 143.1c0-18.28-14.95-32-32-32-8.188 0-16.38 3.125-22.62 9.376l-112 112C3.125 239.6 0 247.8 0 255.1s3.125 17.3 9.375 23.5l112 112c6.225 6.3 14.425 8.5 22.625 8.5 17.05 0 32-13.73 32-32 0-8.188-3.125-16.38-9.375-22.63L77.25 255.1l89.38-89.38c6.27-5.42 9.37-13.52 9.37-22.62zm464 112c0-8.188-3.125-16.38-9.375-22.63l-112-112C512.4 115.1 504.2 111.1 496 111.1c-17.05 0-32 13.73-32 32 0 8.188 3.125 16.38 9.375 22.63l89.38 89.38-89.38 89.38C467.1 351.6 464 359.8 464 367.1c0 18.28 14.95 32 32 32 8.188 0 16.38-3.125 22.62-9.376l112-112C636.9 272.4 640 264.2 640 255.1z'/%3E%3C/svg%3E")
}

.EasyMDEContainer .editor-toolbar .unordered-list:before {
    -webkit-mask-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Cpath d='M16 96c0-26.51 21.49-48 48-48s48 21.49 48 48c0 26.5-21.49 48-48 48s-48-21.5-48-48zm464-32c17.7 0 32 14.33 32 32 0 17.7-14.3 32-32 32H192c-17.7 0-32-14.3-32-32 0-17.67 14.3-32 32-32h288zm0 160c17.7 0 32 14.3 32 32s-14.3 32-32 32H192c-17.7 0-32-14.3-32-32s14.3-32 32-32h288zm0 160c17.7 0 32 14.3 32 32s-14.3 32-32 32H192c-17.7 0-32-14.3-32-32s14.3-32 32-32h288zM16 416c0-26.5 21.49-48 48-48s48 21.5 48 48-21.49 48-48 48-48-21.5-48-48zm96-160c0 26.5-21.49 48-48 48s-48-21.5-48-48 21.49-48 48-48 48 21.5 48 48z'/%3E%3C/svg%3E");
    mask-image: url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Cpath d='M16 96c0-26.51 21.49-48 48-48s48 21.49 48 48c0 26.5-21.49 48-48 48s-48-21.5-48-48zm464-32c17.7 0 32 14.33 32 32 0 17.7-14.3 32-32 32H192c-17.7 0-32-14.3-32-32 0-17.67 14.3-32 32-32h288zm0 160c17.7 0 32 14.3 32 32s-14.3 32-32 32H192c-


w->_briefScreen.CurrTime = 2500 * (yw->_briefScreen.ActiveElementID + 1) + yw->_briefScreen.StartTime;
                    break;
                default:
                    break;
                }

                yw->_briefScreen.TimerStatus = TBriefengScreen::TIMER_NORMAL;
            }
            break;

        case TBriefengScreen::TIMER_RESTART:
            yw->_briefScreen.TimerStatus = TBriefengScreen::TIMER_NORMAL;
            yw->_briefScreen.Stage = 29;
            break;

        default:
            break;
        }

        switch ( yw->_briefScreen.Stage )
        {
        case TBriefengScreen::STAGE_LOADED:
            ypaworld_func158__sub4__sub1__sub4__sub3(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_SCALING:
            ypaworld_func158__sub4__sub1__sub4__sub4(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_SCALEEND:
            ypaworld_func158__sub4__sub1__sub4__sub5(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_PLAYER_ST:
            ypaworld_func158__sub4__sub1__sub4__sub6(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_PLAYER_RN:
            if ( yw->_briefScreen.SelectedObjID == -1 )
                ypaworld_func158__sub4__sub1__sub4__sub7(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_PLAYER_END:
            yw->_briefScreen.Stage = TBriefengScreen::STAGE_GATE_ST;
            break;
        case TBriefengScreen::STAGE_KEYS_ST:
            yw_BriefSetupKeySectors(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_KEYS_RN:
            if ( yw->_briefScreen.SelectedObjID == -1 )
                yw_BriefUpdateKeySectors(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_KEYS_END:
            yw->_briefScreen.Stage = TBriefengScreen::STAGE_TECH_ST;
            break;
        case TBriefengScreen::STAGE_TECH_ST:
            ypaworld_func158__sub4__sub1__sub4__sub10(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_TECH_RN:
            if ( yw->_briefScreen.SelectedObjID == -1 )
                ypaworld_func158__sub4__sub1__sub4__sub11(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_TECH_END:
            yw->_briefScreen.Stage = TBriefengScreen::STAGE_ENMHS_ST;
            break;
        case TBriefengScreen::STAGE_ENMHS_ST:
            ypaworld_func158__sub4__sub1__sub4__sub12(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_ENMHS_RN:
            if ( yw->_briefScreen.SelectedObjID == -1 )
                ypaworld_func158__sub4__sub1__sub4__sub13(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_ENMHS_END:
            yw->_briefScreen.Stage = TBriefengScreen::STAGE_ENMFRC_ST;
            break;
        case TBriefengScreen::STAGE_ENMFRC_ST:
            ypaworld_func158__sub4__sub1__sub4__sub14(yw, inpt, brf);
            break;
        case TBriefengScreen::STAGE_ENMFRC_RN:
            if ( yw->_briefScreen.SelectedObjID == -1 )


  }

        public string GetLastNota()
        {
            return _context.GetLastNota(new GajiKaryawan().GetTableName());
        }

        public GajiKaryawan GetByID(string id)
        {
            GajiKaryawan obj = null;

            try
            {
                _sql = SQL_TEMPLATE.Replace("{WHERE}", "WHERE t_gaji_karyawan.gaji_karyawan_id = @id");
                _sql = _sql.Replace("{ORDER BY}", "");

                obj = MappingRecordToObject(_sql, new { id }).SingleOrDefault();
            }
            catch (Exception ex)
            {
                _log.Error("Error:", ex);
            }

            return obj;
        }

        public IList<GajiKaryawan> GetByName(string name)
        {
            throw new NotImplementedException();
        }

        public IList<GajiKaryawan> GetByBulanAndTahun(int bulan, int tahun)
        {
            IList<GajiKaryawan> oList = new List<GajiKaryawan>();

            try
            {
                _sql = SQL_TEMPLATE.Replace("{WHERE}", "WHERE t_gaji_karyawan.bulan = @bulan AND t_gaji_karyawan.tahun = @tahun");
                _sql = _sql.Replace("{ORDER BY}", "ORDER BY m_karyawan.nama_karyawan");

                oList = MappingRecordToObject(_sql, new { bulan, tahun }).ToList();

                IPembayaranKasbonRepository pembayaranKasbonRepo = new PembayaranKasbonRepository(_context, _log);

                foreach (var gaji in oList)
                {
                    gaji.item_pembayaran_kasbon = pembayaranKasbonRepo.GetByGajiKaryawan(gaji.gaji_karyawan_id).ToList();
                }

            }
            catch (Exception ex)
            {
                _log.Error("Error:", ex);
            }

            return oList;
        }

        public IList<GajiKaryawan> GetAll()
        {
            throw new NotImplementedException();
        }

        private bool IsExist(string karyawanId, int bulan, int tahun)
        {
            var count = _context.db.GetAll<GajiKaryawan>()
                                .Where(f => f.karyawan_id == karyawanId && f.bulan == bulan && f.tahun == tahun)
                                .Count();

            return count > 0;
        }

        public int Save(GajiKaryawan obj)
        {
            var result = 0;

            try
            {
                if (IsExist(obj.karyawan_id, obj.bulan, obj.tahun)) // data gaji karyawan sudah diinputkan
                {
                    return 0;
                }

                _context.BeginTransaction();

                var transaction = _context.transaction;

                if (obj.gaji_karyawan_id == null)
                    obj.gaji_karyawan_id = _context.GetGUID();

                // insert header
                _context.db.Insert<GajiKaryawan>(obj, transaction);

                // insert detail
                foreach (var item in obj.item_pembayaran_kasbon.Where(f => f.Kasbon != null))
                {
                    if (item.kasbon_id.Length > 0)
                    {
                        item.pembayaran_kasbon_id = _context.GetGUID();
                        item.pengguna_id = obj.pengguna_id;
                        item.gaji_karyawan_id = obj.g


t this test utilizes the slightly modified version of `HelperConfig.s.sol` shown in the diff at the bottom of this submission, which creates mock tokens with differing decimals.
```solidity
// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

import {DeployDSC} from "../../script/DeployDSC.s.sol";
import {DSCEngine} from "../../src/DSCEngine.sol";
import {DecentralizedStableCoin} from "../../src/DecentralizedStableCoin.sol";
import {HelperConfig} from "../../script/HelperConfig.s.sol";
import {ERC20DecimalsMock} from "@openzeppelin/contracts/mocks/ERC20DecimalsMock.sol";
import {MockV3Aggregator} from "../mocks/MockV3Aggregator.sol";
import {Test, console} from "forge-std/Test.sol";
import {StdCheats} from "forge-std/StdCheats.sol";

contract TokenDecimalExploit is StdCheats, Test {
    DSCEngine public dsce;
    DecentralizedStableCoin public dsc;
    HelperConfig public helperConfig;

    address public ethUsdPriceFeed;
    address public btcUsdPriceFeed;
    address public weth;
    address public wbtc;
    uint256 public wethDecimals;
    uint256 public wbtcDecimals;
    uint256 public feedDecimals;
    uint256 public deployerKey;

    address public user = address(1);
    address public exploiter = address(2);

    uint256 public constant STARTING_USER_BALANCE = 10 ether;
    uint256 public constant MIN_HEALTH_FACTOR = 1e18;
    uint256 public constant LIQUIDATION_BONUS = 10;
    uint256 public constant LIQUIDATION_THRESHOLD = 50;
    uint256 public constant LIQUIDATION_PRECISION = 100;

    function setUp() external {
        DeployDSC deployer = new DeployDSC();
        (dsc, dsce, helperConfig) = deployer.run();
        (ethUsdPriceFeed, btcUsdPriceFeed, weth, wbtc, deployerKey) = helperConfig.activeNetworkConfig();
        if (block.chainid == 31337) {
            vm.deal(user, STARTING_USER_BALANCE);
        }
        ERC20DecimalsMock(weth).mint(user, STARTING_USER_BALANCE);
        ERC20DecimalsMock(wbtc).mint(user, STARTING_USER_BALANCE);
        ERC20DecimalsMock(weth).mint(exploiter, STARTING_USER_BALANCE);
        // The exploiter is not given any WBTC.

        wethDecimals = ERC20DecimalsMock(weth).decimals();
        wbtcDecimals = ERC20DecimalsMock(wbtc).decimals();
        feedDecimals = helperConfig.FEED_DECIMALS();
    }

    /**
     * @notice This test is based on a very real possible scenario involving WETH and WBTC.
     *
     * On Ethereum mainnet, WETH and WBTC have 18 and 8 decimals, respectively.
     * The current prices of WETH and WBTC are close to $2,000 and $30,000, respectively.
     * The `DSCEngine` allows a user to borrow up to the liquidation threshold.
     * The `DSCEngine` fails to account for token decimals when computing USD prices.
     */
    function testExploitTokenDecimals() public {
        // Set initial prices.
        MockV3Aggregator(ethUsdPriceFeed).updateAnswer(int256(2_000 * 10**feedDecimals)); // $2,000
        MockV3Aggregator(btcUsdPriceFeed).updateAnswer(int256(30_000 * 10**feedDecimals)); // $30,000

        // A user borrow


2, %zmm2 {%k2}

// CHECK: vunpcklps (%edx){1to16}, %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0x6c,0xda,0x14,0x12]
vunpcklps (%edx){1to16}, %zmm2, %zmm2 {%k2} {z}

// CHECK: vunpcklps (%edx), %zmm2, %zmm2
// CHECK: encoding: [0x62,0xf1,0x6c,0x48,0x14,0x12]
vunpcklps (%edx), %zmm2, %zmm2

// CHECK: vunpcklps (%edx), %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0x6c,0x4a,0x14,0x12]
vunpcklps (%edx), %zmm2, %zmm2 {%k2}

// CHECK: vunpcklps (%edx), %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0x6c,0xca,0x14,0x12]
vunpcklps (%edx), %zmm2, %zmm2 {%k2} {z}

// CHECK: vunpcklps %zmm2, %zmm2, %zmm2
// CHECK: encoding: [0x62,0xf1,0x6c,0x48,0x14,0xd2]
vunpcklps %zmm2, %zmm2, %zmm2

// CHECK: vunpcklps %zmm2, %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0x6c,0x4a,0x14,0xd2]
vunpcklps %zmm2, %zmm2, %zmm2 {%k2}

// CHECK: vunpcklps %zmm2, %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0x6c,0xca,0x14,0xd2]
vunpcklps %zmm2, %zmm2, %zmm2 {%k2} {z}


e visibility":"изменение видимости линии {toolName}","change {toolName} line width":"изменение толщины линии {toolName}","change {toolName} line style":"изменение стиля линии {toolName}","change {toolName} line color":"изменение цвета линии {toolName}","change {toolName} line extending left":"изменение: продление влево линии {toolName}","change {toolName} line left end":"изменение левой части линии {toolName}","change {toolName} line extending right":"изменение: продление вправо линии {toolName}","change {toolName} line right end":"изменение правой части линии {toolName}","Extend left line":"Продолжить левую линию","Extend right line":"Продолжить правую линию","change {toolName} text visibility":"изменение видимости текста: {toolName}","change {toolName} text color":"изменение цвета текста: {toolName}","change {toolName} text font size":"изменение размера шрифта {toolName}","change {toolName} text font bold":"изменение шрифта {toolName} на жирный","change {toolName} text font italic":"изменение шрифта {toolName} на курсив","change {toolName} text":"изменение текста: {toolName}","change {toolName} labels alignment vertical":"изменение: выравнивание меток по вертикали ({toolName})","change {toolName} labels alignment horizontal":"изменение: выравнивание меток по горизонтали ({toolName})","change {toolName} labels direction":"изменение направления меток: {toolName}","change {toolName} text background visibility":"изменение видимости фона текста: {toolName}","change {toolName} text background color":"изменение цвета фона текста: {toolName}","change {toolName} text border visibility":"изменение видимости границ текста: {toolName}","change {toolName} text border width":"изменение толщины границ текста: {toolName}","change {toolName} text border color":"изменение цвета границ текста: {toolName}","change {toolName} text wrap":"изменение переноса строк: {toolName}","Text wrap":"Перенос строк","change arrow color":"изменение цвета стрелки","change {title} color":"изменение цвета {title}","change {title} mode":"изменение режима {title}","change {title} mirrored":"изменение: отражение по вертикали ({title})","change {title} flipped":"изменение: отражение по горизонтали ({title})",Mode:"Режим",Mirrored:"Отобразить по вертикали",Flipped:"Отразить по горизонтали","HL bars":"МаксМин бары","OC bars":"ОткрЗакр бары","Line - close":"Линия — Цена закр.","Line - open":"Линия — Цена откр.","Line - high":"Линия — Макс.","Line - low":"Линия — Мин.","Line - HL/2":"Линия — Макс.Мин./2","change {title} background visibility":"изменение видимости фона {title}","change {title} background color":"изменение цвета фона {title}","change {title} degree":"изменение угла {title}",Wave:"Волна",Degree


*  playing or stopped).
   *
   *  @method  isPaused
   *  @return {Boolean}
   */
  p5.SoundFile.prototype.isPaused = function () {
    return this._paused;
  };
  /**
   * Stop soundfile playback.
   *
   * @method stop
   * @param {Number} [startTime] (optional) schedule event to occur
   *                             in seconds from now
   */
  p5.SoundFile.prototype.stop = function (timeFromNow) {
    var time = timeFromNow || 0;
    if (this.mode == 'sustain') {
      this.stopAll(time);
      this._playing = false;
      this.pauseTime = 0;
      this._paused = false;
    } else if (this.buffer && this.bufferSourceNode) {
      var now = p5sound.audiocontext.currentTime;
      var t = time || 0;
      this.pauseTime = 0;
      this.bufferSourceNode.stop(now + t);
      this._counterNode.stop(now + t);
      this._playing = false;
      this._paused = false;
    }
  };
  /**
   *  Stop playback on all of this soundfile's sources.
   *  @private
   */
  p5.SoundFile.prototype.stopAll = function (_time) {
    var now = p5sound.audiocontext.currentTime;
    var time = _time || 0;
    if (this.buffer && this.bufferSourceNode) {
      for (var i = 0; i < this.bufferSourceNodes.length; i++) {
        if (typeof this.bufferSourceNodes[i] != undefined) {
          try {
            this.bufferSourceNodes[i].stop(now + time);
          } catch (e) {
          }
        }
      }
      this._counterNode.stop(now + time);
    }
  };
  /**
   *  Multiply the output volume (amplitude) of a sound file
   *  between 0.0 (silence) and 1.0 (full volume).
   *  1.0 is the maximum amplitude of a digital sound, so multiplying
   *  by greater than 1.0 may cause digital distortion. To
   *  fade, provide a rampTime parameter. For more
   *  complex fades, see the Env class.
   *
   *  Alternately, you can pass in a signal source such as an
   *  oscillator to modulate the amplitude with an audio signal.
   *
   *  @method  setVolume
   *  @param {Number|Object} volume  Volume (amplitude) between 0.0
   *                                     and 1.0 or modulating signal/oscillator
   *  @param {Number} [rampTime]  Fade for t seconds
   *  @param {Number} [timeFromNow]  Schedule this event to happen at
   *                                 t seconds in the future
   */
  p5.SoundFile.prototype.setVolume = function (vol, rampTime, tFromNow) {
    if (typeof vol === 'number') {
      var rampTime = rampTime || 0;
      var tFromNow = tFromNow || 0;
      var now = p5sound.audiocontext.currentTime;
      var currentVol = this.output.gain.value;
      this.output.gain.cancelScheduledValues(now + tFromNow);
      this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);
      this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);
    } else if (vol) {
      vol.connect(this.output.gain);
    } else {
      // return the Gain Node
      return this.output.gain;
    }
  };
  // same as setVolume, to match Processing Sound
  p5.SoundFile.prototype.amp = p5.SoundFile.prototype.setVolume;


ly, err = QueryStorageByKey(stateDB, kvdb, txhash, cfg)
	assert.Nil(t, err)
	assert.Equal(t, common.Sha256(contents[0]), reply.GetLinkStorage().Hash)

	//加密存储
	aes := des.NewAES(keys[2], ivs[0])
	crypted, err := aes.Encrypt(contents[0])
	assert.Nil(t, err)
	tx, err = CreateTx("EncryptStorage", &oty.EncryptNotaryStorage{ContentHash: common.Sha256(contents[0]), EncryptContent: crypted, Nonce: ivs[0]}, PrivKeyA, cfg)
	assert.Nil(t, err)
	Exec_Block(t, stateDB, kvdb, env, tx)
	txhash = common.ToHex(tx.Hash())
	reply, err = QueryStorageByKey(stateDB, kvdb, txhash, cfg)
	assert.Nil(t, err)
	assert.Equal(t, common.Sha256(contents[0]), reply.GetEncryptStorage().ContentHash)
	assert.Equal(t, crypted, reply.GetEncryptStorage().EncryptContent)
	assert.Equal(t, ivs[0], reply.GetEncryptStorage().Nonce)

	// 同态加密
	c1, _ := common.FromHex("010076833cbc35c9b7a87eda9aab7aafec45bd7eb8c0e9306141e7d1e84ecd87a5cb9f80343551bd9b0d04669fd74d020fca8837d9b3b471e3e13c125a06663d820cabb36c243747a11ea2601a9cb32e61c697dcdc846c492d954fa8c3ca2be662e8c0142138b647ce5d9e7c4c4d2ace8ba3c5699fbec98beef24e3c740967ec0b72b1626ecd4a7ce54960ae9bc1e2ea5594b05778f4f772aa213a06421744ed8dd775fb8f212bcc7e0da5fe4949051e6aa09d47db7e8d5028ecc41cea2aed4e23aefd80714519662fae980e3a6ca3defc0dd5596cb7e90da29e1bdd84db82603aed78fb8f98687898cd675da74452052ff1761446bf2ee922fc8c56b7e1beb2d4b91042742837052b340e4afce1836badf4a56ef775bb6a94fd91686a44122543fdab3ee90488160068769fbce2e74ffd5e052bb4c651969c4755f6eb5d7ea0cee3e7fa58f4b38b1722535909bd0f325a0b8d0797c15300ab06095b305f46497bbd75c3682d379387f55f638cd10639db1f050090bfd5d291718cee9fc6894d04ba6ef0acb477184512984f435b13e9bffe630bbc8ceade6d269487bf219e25b3beecc46afb98fb8e1fec1a9ad0af0a16e70611f9a4337af05a2ff82d7c9dcebeea9d8e2070413e49e29ff564e6dcee5696e39dc590ff8f8f553834c66c5ae730d05441e3fcc59de0d6efb12fd8852e19f2e309e4ac4cbf0634655fcaab5a70b4eab49829190ea2862c2568e8b69ff0324055f92275de05f2de1d6a8a78333370da754708f7a827f5e9bbe2e58d58294cafef37898a5a5a4866678b6e07941a3bfcb3c3f2d150f830a12d8e0dd20d756099be48f10d51521b3ba0c49f2ab139724ae3962999d75b88bf572fbfd86b6eef3bad5a446b97949d95f9e742500f8609ecfe189d2b4d5a47ea997164f48b3872ec


ce face, bool isHorizontal = true, int32_t loadFlags = 0, const KoSvgText::TextRendering rendering = KoSvgText::RenderingAuto);
private Q_SLOTS:
    /**
     * Update the config and reset the FontChangeListener.
     */
    void updateConfig();
private:
    class Private;

    friend class TestSvgText;
    friend class SvgTextCursorTest;

    /**
     * @brief addFontFilePathToRegistery
     * This adds a font file to the registery. Right now only used by unittests.
     *
     * @param path the path of the font file.
     * @return Whether adding the font file was succesful.
     */
    bool addFontFilePathToRegistery(const QString &path);

    /**
     * @brief addFontFileDirectoryToRegistery
     * This adds a directory of font files to the registery. Right now only used by unittests.
     * @param path the path of the directory.
     * @return whether it was succesful.
     */
    bool addFontFileDirectoryToRegistery(const QString &path);

    QScopedPointer<Private> d;

    Q_DISABLE_COPY(KoFontRegistry);
};

#endif // KOFONTREGISTRY_H


/*============================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

============================================================================*/

#ifndef mitkPlanarFigureToPlanarFigureFilter_h
#define mitkPlanarFigureToPlanarFigureFilter_h

#include "mitkCommon.h"
#include "mitkPlanarFigure.h"
#include "mitkPlanarFigureSource.h"
#include <MitkPlanarFigureExports.h>

namespace mitk
{
  /**
   * @brief Base class for all filters which have an object of type
   * mitk::PlanarFigure as input and output
   *
   * Base class for all filters which have an object of type mitk::PlanarFigure
   * as input and output.
   * @ingroup MitkPlanarFigureModule
   */
  class MITKPLANARFIGURE_EXPORT PlanarFigureToPlanarFigureFilter : public mitk::PlanarFigureSource
  {
  public:
    mitkClassMacro(PlanarFigureToPlanarFigureFilter, PlanarFigureSource);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);

      typedef PlanarFigure InputType;
    typedef InputType::Pointer InputTypePointer;
    typedef itk::DataObject::Pointer DataObjectPointer;

    using Superclass::SetInput;

    virtual void SetInput(const InputType *figure);

    virtual void SetInput(unsigned int idx, const InputType *figure);

    virtual const InputType *GetInput();

    virtual const InputType *GetInput(unsigned int idx);

    virtual void CreateOutputsForAllInputs();

  protected:
    PlanarFigureToPlanarFigureFilter();
    ~PlanarFigureToPlanarFigureFilter() override;
  };
} // namespace mitk
#endif


#!/usr/bin/env python
# -*- coding: UTF-8 -*-

"""
@project: PyCharm
@file: excel_func.py
@author: Shengqiang Zhang
@time: 2020/4/11 21:14
@mail: sqzhang77@gmail.com
"""

import xlrd
import xlwt
from xlutils.copy import copy

def write_excel_xls(path, sheet_name_list, value):
    # 新建一个工作簿
    workbook = xlwt.Workbook()

    # 获取需要写入数据的行数
    index = len(value)

    for sheet_name in sheet_name_list:

        # 在工作簿中新建一个表格
        sheet = workbook.add_sheet(sheet_name)

        # 往这个工作簿的表格中写入数据
        for i in range(0, index):
            for j in range(0, len(value[i])):
                sheet.write(i, j, value[i][j])

    # 保存工作簿
    workbook.save(path)

def write_excel_xls_append(path, sheet_name, value):
    index = len(value)  # 获取需要写入数据的行数
    workbook = xlrd.open_workbook(path)  # 打开工作簿
    worksheet = workbook.sheet_by_name(sheet_name)  # 获取工作簿中所有表格中的的第一个表格
    rows_old = worksheet.nrows  # 获取表格中已存在的数据的行数
    new_workbook = copy(workbook)  # 将xlrd对象拷贝转化为xlwt对象
    new_worksheet = new_workbook.get_sheet(sheet_name)  # 获取转化后工作簿中的第一个表格
    for i in range(0, index):
        for j in range(0, len(value[i])):
            new_worksheet.write(i + rows_old, j, value[i][j])  # 追加写入数据，注意是从i+rows_old行开始写入
    new_workbook.save(path)  # 保存工作簿
    print("{}【追加】写入【{}】数据成功！".format(path, sheet_name))


ble=autofish.isEnabled
        }

    }
    self:refresh_data()
end

function get_count_pen(val, min, max)
    if val <= min then return COLOR_RED end
    if val <= max then return COLOR_YELLOW end
    return COLOR_GREEN
end

function get_count_text(val, min, max)
    return {text=tostring(val), pen=get_count_pen(val, min, max)}
end

function get_fishing_text(val)
    if not val then return {text="not ", pen=COLOR_RED} end
    return ""
end

function Autofish:refresh_data()
    self.subviews.enable_toggle:setOption(autofish.isEnabled())

    --self.subviews.minimum:setText(tostring(autofish.set_minFish))
    self.subviews.maximum:setText(tostring(autofish.s_maxFish))
    self.subviews.useRawFish:setOption(autofish.s_useRaw)

    local prep, raw = autofish.count_fish()
    local total = prep+raw
    local counts_text = {
        "Fish: ",
        get_count_text(total, autofish.s_minFish, autofish.s_maxFish),
        " (",
        {text=tostring(prep), pen=COLOR_GREY}, " prepared, ",
        {text=tostring(raw), pen=COLOR_GREY}, " raw)"
    }
    self.subviews.fish_count:setText(counts_text)
    local fishingText = {
        "Currently ",
        get_fishing_text(autofish.isFishing),
        "fishing."
    }
    self.subviews.current_mode:setText(fishingText)
    self.next_refresh_ms = dfhack.getTickCount() + REFRESH_MS
end

function Autofish:render(dc)
    if self.next_refresh_ms <= dfhack.getTickCount() then
        self:refresh_data()
    end
    Autofish.super.render(self, dc)
end

---
-- AutofishScreen
---
AutofishScreen = defclass(AutofishScreen, gui.ZScreen)
AutofishScreen.ATTRS{focus_path = "autofish"}

function AutofishScreen:init()
    self:addviews{Autofish{}}
end

function AutofishScreen:onDismiss()
    view = nil
end
if not dfhack.isMapLoaded then
    qerror("autofish requires a map to be loaded")
end

view = view and view:raise() or AutofishScreen{}:show()


stack(&mut self) -> [u32; 8] {
        self.cv_stack_len -= 1;
        self.cv_stack[self.cv_stack_len as usize]
    }

    fn add_chunk_chaining_value(&mut self, mut new_cv: [u32; 8], mut total_chunks: u64) {
        // This chunk might complete some subtrees. For each completed subtree,
        // its left child will be the current top entry in the CV stack, and
        // its right child will be the current value of `new_cv`. Pop each left
        // child off the stack, merge it with `new_cv`, and overwrite `new_cv`
        // with the result. After all these merges, push the final value of
        // `new_cv` onto the stack. The number of completed subtrees is given
        // by the number of trailing 0-bits in the new total number of chunks.
        while total_chunks & 1 == 0 {
            new_cv = parent_cv(self.pop_stack(), new_cv, self.key, self.flags);
            total_chunks >>= 1;
        }
        self.push_stack(new_cv);
    }

    /// Add input to the hash state. This can be called any number of times.
    pub fn update(&mut self, mut input: &[u8]) {
        while !input.is_empty() {
            // If the current chunk is complete, finalize it and reset the
            // chunk state. More input is coming, so this chunk is not ROOT.
            if self.chunk_state.len() == CHUNK_LEN {
                let chunk_cv = self.chunk_state.output().chaining_value();
                let total_chunks = self.chunk_state.chunk_counter + 1;
                self.add_chunk_chaining_value(chunk_cv, total_chunks);
                self.chunk_state = ChunkState::new(self.key, total_chunks, self.flags);
            }

            // Compress input bytes into the current chunk state.
            let want = CHUNK_LEN - self.chunk_state.len();
            let take = min(want, input.len());
            self.chunk_state.update(&input[..take]);
            input = &input[take..];
        }
    }

    /// Finalize the hash and write any number of output bytes.
    pub fn finalize(&self, out_slice: &mut [u8]) {
        // Starting with the Output from the current chunk, compute all the
        // parent chaining values along the right edge of the tree, until we
        // have the root Output.
        let mut output = self.chunk_state.output();
        let mut parent_nodes_remaining = self.cv_stack_len as usize;
        while parent_nodes_remaining > 0 {
            parent_nodes_remaining -= 1;
            output = parent_output(
                self.cv_stack[parent_nodes_remaining],
                output.chaining_value(),
                self.key,
                self.flags,
            );
        }
        output.root_output_bytes(out_slice);
    }
}
use std::marker::Unsize;
use wasm_bindgen::closure::WasmClosure;
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;

// Adapted from https://github.com/rustwasm/gloo/blob/2c9e776701ecb90c53e62dec1abd19c2b70e47c7/crates/events/src/lib.rs#L232-L582
#[must_use = "event listener will never be called after being dropped"]
pub struct EventListener<'a, F: ?Sized> {
    target: &'a web_extensions_sys::EventTarget,
    callback: Option<Closure<


 play with all the properties.
    var particles = GSimpleParticleSystem();
    particles.texture = particle;
    particles.emission = 80;
    particles.emissionTime = .9;
    particles.emit = true;
    particles.energy = 1.2;
    // _particleSystem.burst=true;
    // _particleSystem.initialAngularVelocity=.004;
    particles.initialAngle = -Math.PI;
    particles.dispersionAngleVariance = Math.PI / 4;
    particles.dispersionAngle = -Math.PI / 1.5;
    particles.initialVelocity = 20;
    particles.initialVelocityVariance = 20;
    // _particleSystem.initialVelocity = 40;
    // _particleSystem.initialVelocityVariance = 80;
    // _particleSystem.particlePivotX = 50.0;
    // _particleSystem.particlePivotY = 10.0;

    // _particleSystem.dispersionXVariance = 200;
    // _particleSystem.dispersionYVariance = 200;
    // _particleSystem.initialAngleVariance = 3;
    // _particleSystem.initialScaleVariance = .2;
    particles.endAlpha = 0;
    // _particleSystem.endBlue = 1;
    // _particleSystem.endRed = .4;
    // _particleSystem.initialRed = .2;
    particles.initialAlpha = .4;
    particles.initialAlphaVariance = .6;
    particles.initialScale = .25;
    particles.initialScaleVariance = .53;
    particles.endScale = .13;
    particles.endScaleVariance = .23;
    particles.useWorldSpace = true;
    particles.dispersionXVariance = tubeW / 2;
    tubeContainer.addChild(particles);
    particles.x = tubeW / 2;
    particles.y = tubeH;
    // var isUp = false ;
    // tweenUP(){
    //   isUp=!isUp;
    //   particles.tween(duration: 1, y:isUp?'-80':'80', onComplete: tweenUP);
    // }
    // tweenUP();
  }
}
import 'package:flutter/material.dart';
import 'package:graphx/graphx.dart';

class MyButton extends GSprite {
  double w, h;
  late GShape bg, border1, border2;
  late GIcon successIco;

  late GText label;
  final Color mainColor = const Color(0xff58A993);
  final Color greyColor = const Color(0xffE3E3E3);
  final tweenWidth = 0.0.twn;
  double? currentW;
  double? percentLoaded = 0.0;
  double lineThickness = 4;

  MyButton(this.w, this.h) {
    _init();
  }

  void _init() {
    currentW = w;
    useCursor = true;
    bg = GShape();
    border1 = GShape();
    border2 = GShape();
    addChild(bg);
    addChild(border1);
    addChild(border2);
    bg.setPosition(w / 2, h / 2);
    border1.setPosition(w / 2, h / 2);
    border2.setPosition(w / 2, h / 2);
    label = GText.build(
      text: 'Submit',
      color: mainColor,
      fontSize: 25,
      letterSpacing: .1,
      fontWeight: FontWeight.w500,
    );
    label.alignPivot();
    label.setPosition(w / 2, h / 2);
    addChild(label);
    successIco = GIcon(Icons.check, Colors.white, 48);
    addChild(successIco);
    successIco.alignPivot();
    successIco.setPosition(w / 2, h / 2);
    successIco.setProps(scale: .5, alpha: 0);
    draw();
    onMouseDown.add(_onMous


import pytest

import webview

from .util import run_test

@pytest.fixture
def window():
    return webview.create_window('Run JS test', html='
TEST
')

def test_string(window):
    run_test(webview, window, string_test)

def test_int(window):
    run_test(webview, window, int_test)

def test_numeric(window):
    run_test(webview, window, numeric_test)

def test_stringify(window):
    run_test(webview, window, stringify_test)

def string_test(window):
    result = window.run_js(
    """
    "this is only a test"
    """
    )
    assert result == 'this is only a test'

def int_test(window):
    result = window.run_js(
    """
    420
    """
    )
    assert result == 420

def numeric_test(window):
    result = window.run_js(
    """
    '420'
    """
    )
    assert result == '420'

def stringify_test(window):
    window.events.loaded.wait()
    result = window.run_js(
    """
    var obj = {a: 420};
    var value = pywebview.stringify(obj);
    value;
    """
    )
    assert result == '{"a":420}'


.allocate(24L)
				.let { WGPUSurfaceDescriptor(it) }
		}

		actual fun allocateArray(allocator: MemoryAllocator, size: UInt, provider: (UInt,  WGPUSurfaceDescriptor) -> Unit): ArrayHolder<WGPUSurfaceDescriptor> {
			return allocator.allocate(24 * size.toLong())
				.also {
					(0u until size).forEach { index ->
						it.handler.asSlice(index.toLong() * 24L)
							.let(::NativeAddress)
							.let { WGPUSurfaceDescriptor(it) }
							.let { provider(index, it) }
					}
				}
				.let(::ArrayHolder)
		}

		internal val LAYOUT = structLayout(
			ffi.C_POINTER.withName("nextInChain"),
			WGPUStringView.LAYOUT.withName("label"),
		).withName("WGPUSurfaceDescriptor")

		val nextInChainOffset = 0L
		val nextInChainLayout = ffi.C_POINTER
		val labelOffset = 8L
		val labelLayout = WGPUStringView.LAYOUT
	}
}
actual interface WGPUSurfaceSourceAndroidNativeWindow : CStructure {

	@JvmInline
	value class ByReference(override val handler: NativeAddress) : WGPUSurfaceSourceAndroidNativeWindow {
		override val chain: WGPUChainedStruct
			get() = handler.handler.asSlice(chainOffset, 16L).let(::NativeAddress).let { WGPUChainedStruct(it) }
		override var window: NativeAddress?
			get() = get(windowLayout, windowOffset)
			set(newValue) = set(windowLayout, windowOffset, newValue)
	}

	actual val chain: WGPUChainedStruct
	actual var window: NativeAddress?

	actual companion object {
		actual operator fun invoke(address: NativeAddress): WGPUSurfaceSourceAndroidNativeWindow {
			return ByReference(address)
		}

		actual fun allocate(allocator: MemoryAllocator): WGPUSurfaceSourceAndroidNativeWindow {
			return allocator.allocate(24L)
				.let { WGPUSurfaceSourceAndroidNativeWindow(it) }
		}

		actual fun allocateArray(allocator: MemoryAllocator, size: UInt, provider: (UInt,  WGPUSurfaceSourceAndroidNativeWindow) -> Unit): ArrayHolder<WGPUSurfaceSourceAndroidNativeWindow> {
			return allocator.allocate(24 * size.toLong())
				.also {
					(0u until size).forEach { index ->
						it.handler.asSlice(index.toLong() * 24L)
							.let(::NativeAddress)
							.let { WGPUSurfaceSourceAndroidNativeWindow(it) }
							.let { provider(index, it) }
					}
				}
				.let(::ArrayHolder)
		}

		internal val LAYOUT = structLayout(
			WGPUChainedStruct.LAYOUT.withName("chain"),
			ffi.C_POINTER.withName("window"),
		).withName("WGPUSurfaceSourceAndroidNativeWindow")

		val chainOffset = 0L
		val chainLayout = WGPUChainedStruct.LAYOUT
		val windowOffset = 16L
		val windowLayout = ffi.C_POINTER
	}
}
actual interface WGPUSurfaceSourceMetalLayer : CStructure {

	@JvmInline
	value class ByReference(override val handler: NativeAddress) : WGPUSurfaceSourceMetalLayer {
		override val chain: WGPUChainedStruct
			get() = handler.handler.asSlice(chainOffset, 16L).let(::NativeAddress).let { WGPUChainedStruct(it) }
		override var layer: NativeAddress?
			get() = get(layerLayout, layerOffset)
			set(newValue) = set(layerLayout, layerOffset, newValue)
	}

	actual val chain: WGPUChainedStruct
	actual var layer: NativeAddress?

	actual companion object {
		actual operator fun invoke(address: NativeAddress): WGPUSurfaceSourceMetalLayer {
			return ByReference(address)
		}

		actual fun allocate(allocator: MemoryAl