active, "interactive", "i", false, "interactive mode")
	cmd.Flags().StringArrayVarP(&env, "env", "e", []string{}, "environment variables (key=value)")

	return cmd
}// Package compression provides compression utilities for Phantom Fragment
package compression

// AdvancedCompressor handles advanced compression operations
type AdvancedCompressor struct {
	// Add fields as needed
}

// AdvancedDecompressor handles advanced decompression operations
type AdvancedDecompressor struct {
	// Add fields as needed
}

// SmartCompressor handles intelligent compression with content awareness
type SmartCompressor struct {
	// Add fields as needed
}

// NewAdvancedCompressor creates a new advanced compressor
func NewAdvancedCompressor() *AdvancedCompressor {
	return &AdvancedCompressor{}
}

// NewAdvancedDecompressor creates a new advanced decompressor
func NewAdvancedDecompressor() *AdvancedDecompressor {
	return &AdvancedDecompressor{}
}

// NewSmartCompressor creates a new smart compressor
func NewSmartCompressor() *SmartCompressor {
	return &SmartCompressor{}
}

// Compress compresses data using the specified algorithm
func (ac *AdvancedCompressor) Compress(data []byte, algorithm string) ([]byte, error) {
	// Placeholder implementation
	return data, nil
}

// Decompress decompresses data using the specified algorithm
func (ad *AdvancedDecompressor) Decompress(data []byte, algorithm string) ([]byte, error) {
	// Placeholder implementation
	return data, nil
}

// SmartCompress performs content-aware compression
func (sc *SmartCompressor) SmartCompress(data []byte) ([]byte, error) {
	// Placeholder implementation
	return data, nil
}//go:build linux
// +build linux

package io

import (
	"context"
	"fmt"
	"sync"
	"syscall"
	"time"
	"unsafe"

	"golang.org/x/sys/unix"
)

// io_uring system call numbers
const (
	SYS_IO_URING_SETUP    = 425
	SYS_IO_URING_ENTER    = 426
	SYS_IO_URING_REGISTER = 427
)

// io_uring operation codes
const (
	IORING_OP_NOP         = 0
	IORING_OP_READV       = 1
	IORING_OP_WRITEV      = 2
	IORING_OP_FSYNC       = 3
	IORING_OP_READ_FIXED  = 4
	IORING_OP_WRITE_FIXED = 5
	IORING_OP_POLL_ADD    = 6
	IORING_OP_POLL_REMOVE = 7
	IORING_OP_SYNC_FILE_RANGE = 8
	IORING_OP_SENDMSG     = 9
	IORING_OP_RECVMSG     = 10
	IORING_OP_TIMEOUT     = 11
	IORING_OP_ACCEPT      = 13
	IORING_OP_ASYNC_CANCEL = 14
	IORING_OP_LINK_TIMEOUT = 15
	IORING_OP_CONNECT     = 16
	IORING_OP_FALLOCATE   = 17
	IORING_OP_OPENAT      = 18
	IORING_OP_CLOSE       = 19
	IORING_OP_READ        = 22
	IORING_OP_WRITE       = 23
	IORING_OP_STATX       = 24

	// Kernel 6.11+ atomic operations
	IORING_OP_WRITE_ATOMIC = 50 // Hypothetical opcode for atomic writes
)

// io_uring setup flags
const (
	IORING_SETUP_IOPOLL     = 1 << 0
	IORING_SETUP_SQPOLL     = 1 << 1
	IORING_SETUP_SQ_AFF     = 1 << 2
	IORING_SETUP_CQSIZE     = 1 << 3
	IORING_SETUP_CLAMP      = 1 << 4
	IORING_SETUP_ATTACH_WQ  = 1 << 5
	IORING_SETUP_R_DISABLED = 1 << 6
)

// io_uring submission queue entry flags
const (
	IOSQE_FIXED_FILE   = 1 << 0
	I


>

                    <svg
                    xmlns="http://www.w3.org/2000/svg"
                    viewBox="0 0 24 24"
                    fill="currentColor"
                    className="h-4 w-4">
                    <path
                        fill-rule="evenodd"
                        d="M6.75 2.25A.75.75 0 017.5 3v1.5h9V3A.75.75 0 0118 3v1.5h.75a3 3 0 013 3v11.25a3 3 0 01-3 3H5.25a3 3 0 01-3-3V7.5a3 3 0 013-3H6V3a.75.75 0 01.75-.75zm13.5 9a1.5 1.5 0 00-1.5-1.5H5.25a1.5 1.5 0 00-1.5 1.5v7.5a1.5 1.5 0 001.5 1.5h13.5a1.5 1.5 0 001.5-1.5v-7.5z"
                        clip-rule="evenodd" />
                    </svg>

Unisuam

Agosto 2022 - Setembro 2022

                Durante meu estágio em uma empresa, desempenhei um papel integral na equipe, concentrando-me na análise de requisitos para projetos específicos. Minha responsabilidade incluiu a elaboração de documentação técnica detalhada, fornecendo uma base clara para o desenvolvimento e manutenção de sistemas. Além disso, contribuí ativamente para a implementação e otimização das funcionalidades de gestão no GLPI, fornecendo suporte essencial na aplicação prática dessas ferramentas. Essas experiências me permitiram desenvolver habilidades sólidas em análise, documentação e suporte técnico, refletindo meu compromisso em impulsionar a eficiência e a inovação no ambiente de trabalho.

        </>
    )

}

export default Timelineimport { SecretNetworkClient, Wallet, coinsFromString } from "secretjs";
import * as fs from "fs";
import dotenv from "dotenv"
dotenv.config()

const wallet = new Wallet(process.env.MNEMONIC);

const contract_wasm = fs.readFileSync(
  "../contract.wasm.gz"
);

const secretjs = new SecretNetworkClient({
  chainId: "pulsar-3",
  url: "https://lcd.testnet.secretsaturn.net",
  wallet: wallet,
  walletAddress: wallet.address,
});

// Declare global variables
let codeId;
let contractCodeHash;
let contractAddress;


16\n" +
	"\x06totals\x18\a \x01(\bR\x06totals\"\xdf\x04\n" +
	"\x12GetMetricsResponse\x12A\n" +
	"\ametrics\x18\x03 \x03(\v2'.qan.v1.GetMetricsResponse.MetricsEntryR\ametrics\x12N\n" +
	"\ftext_metrics\x18\a \x03(\v2+.qan.v1.GetMetricsResponse.TextMetricsEntryR\vtextMetrics\x12+\n" +
	"\tsparkline\x18\x04 \x03(\v2\r.qan.v1.PointR\tsparkline\x12>\n" +
	"\x06totals\x18\x05 \x03(\v2&.qan.v1.GetMetricsResponse.TotalsEntryR\x06totals\x12 \n" +
	"\vfingerprint\x18\x06 \x01(\tR\vfingerprint\x12D\n" +
	"\bmetadata\x18\b \x01(\v2(.qan.v1.GetSelectedQueryMetadataResponseR\bmetadata\x1aP\n" +
	"\fMetricsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.qan.v1.MetricValuesR\x05value:\x028\x01\x1a>\n" +
	"\x10TextMetricsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1aO\n" +
	"\vTotalsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.qan.v1.MetricValuesR\x05value:\x028\x01\"\xb8\x01\n" +
	"\fMetricValues\x12\x12\n" +
	"\x04rate\x18\x01 \x01(\x02R\x04rate\x12\x10\n" +
	"\x03cnt\x18\x02 \x01(\x02R\x03cnt\x12\x10\n" +
	"\x03sum\x18\x03 \x01(\x02R\x03sum\x12\x10\n" +
	"\x03min\x18\x04 \x01(\x02R\x03min\x12\x10\n" +
	"\x03max\x18\x05 \x01(\x02R\x03max\x12\x10\n" +
	"\x03avg\x18\x06 \x01(\x02R\x03avg\x12\x10\n" +
	"\x03p99\x18\a \x01(\x02R\x03p99\x12(\n" +
	"\x10percent_of_total\x18\b \x01(\x02R\x0epercentOfTotal\"\x1e\n" +
	"\x06Labels\x12\x14\n" +
	"\x05value\x18\x01 \x03(\tR\x05value\"\xa1\x02\n" +
	"\x16GetQueryExampleRequest\x12F\n" +
	"\x11period_start_from\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x0fperiodStartFrom\x12B\n" +
	"\x0fperiod_start_to\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\rperiodStartTo\x12\x1b\n" +
	"\tfilter_by\x18\x03 \x01(\tR\bfilterBy\x12\x19\n" +
	"\bgroup_by\x18\x04 \x01(\tR\agroupBy\x12-\n" +
	"\x06labels\x18\x05 \x03(\v2\x15.qan.v1.MapFieldEntryR\x06labels\x12\x14\n" +
	"\x05limit\x18\x06 \x01(\rR\x05limit\"V\n" +
	"\x17GetQueryExampleResponse\x


reverse].Op == OpConstBool && v.Args[1-reverse].AuxInt == 0 {
				if tmp := v.Args[reverse]; f.sdom.isAncestorEq(tmp.Block, b) {
					v.reset(OpAndB)
					v.SetArgs2(b0.Control, tmp)
					if f.pass.debug > 0 {
						f.Config.Warnl(b.Line, "converted OpPhi to %v", v.Op)
					}
					continue
				}
			}
		}
	}

}
// autogenerated from gen/dec.rules: do not edit!
// generated with: cd gen; go run *.go

package ssa

import "math"

var _ = math.MinInt8 // in case not otherwise used
func rewriteValuedec(v *Value, config *Config) bool {
	switch v.Op {
	case OpComplexImag:
		return rewriteValuedec_OpComplexImag(v, config)
	case OpComplexReal:
		return rewriteValuedec_OpComplexReal(v, config)
	case OpIData:
		return rewriteValuedec_OpIData(v, config)
	case OpITab:
		return rewriteValuedec_OpITab(v, config)
	case OpLoad:
		return rewriteValuedec_OpLoad(v, config)
	case OpSliceCap:
		return rewriteValuedec_OpSliceCap(v, config)
	case OpSliceLen:
		return rewriteValuedec_OpSliceLen(v, config)
	case OpSlicePtr:
		return rewriteValuedec_OpSlicePtr(v, config)
	case OpStore:
		return rewriteValuedec_OpStore(v, config)
	case OpStringLen:
		return rewriteValuedec_OpStringLen(v, config)
	case OpStringPtr:
		return rewriteValuedec_OpStringPtr(v, config)
	}
	return false
}
func rewriteValuedec_OpComplexImag(v *Value, config *Config) bool {
	b := v.Block
	_ = b
	// match: (ComplexImag (ComplexMake _ imag ))
	// cond:
	// result: imag
	for {
		v_0 := v.Args[0]
		if v_0.Op != OpComplexMake {
			break
		}
		imag := v_0.Args[1]
		v.reset(OpCopy)
		v.Type = imag.Type
		v.AddArg(imag)
		return true
	}
	return false
}
func rewriteValuedec_OpComplexReal(v *Value, config *Config) bool {
	b := v.Block
	_ = b
	// match: (ComplexReal (ComplexMake real _  ))
	// cond:
	// result: real
	for {
		v_0 := v.Args[0]
		if v_0.Op != OpComplexMake {
			break
		}
		real := v_0.Args[0]
		v.reset(OpCopy)
		v.Type = real.Type
		v.AddArg(real)
		return true
	}
	return false
}
func rewriteValuedec_OpIData(v *Value, config *Config) bool {
	b := v.Block
	_ = b
	// match: (IData (IMake _ data))
	// cond:
	// result: data
	for {
		v_0 := v.Args[0]
		if v_0.Op != OpIMake {
			break
		}
		data := v_0.Args[1]
		v.reset(OpCopy)
		v.Type = data.Type
		v.AddArg(data)
		return true
	}
	return false
}
func rewriteValuedec_OpITab(v *Value, config *Config) bool {
	b := v.B


AuNjcyLDEuNSwxLjVTNTAuODI5LDg1LjI1LDUwLDg1LjI1eiI+PC9wYXRoPjwvc3ZnPg==",
              unit = "L",
              quantity = 0
            },
            {
              id = 5,
              name = "ELECTRIQUE",
              type = "electric",
              price = 0.25,
              tax = 0,
              color = "#449cf7",
              bgColorSelected = "#cdecf9",
              fuelColor = "#449cf7",
              iconUrl = "data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9JzMwMHB4JyB3aWR0aD0nMzAwcHgnICBmaWxsPSIjMDAwMDAwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2ZXJzaW9uPSIxLjEiIHg9IjBweCIgeT0iMHB4IiB2aWV3Qm94PSIwIDAgMzAgMzAiIHhtbDpzcGFjZT0icHJlc2VydmUiPjxnIHRyYW5zZm9ybT0idHJhbnNsYXRlKC00NTAgLTQ0MCkiPjxnIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiPjxwYXRoIGQ9Ik00NTUsNDU1YzAtNS4zMSw0LjE2Ni05LjY1Niw5LjQtOS45NzFsMS41MTctMS45ODJDNDY1LjYxMyw0NDMuMDIzLDQ2NS4zMSw0NDMsNDY1LDQ0M2MtNi42MjcsMC0xMiw1LjM3My0xMiwxMiAgICBjMCw0LjM5MSwyLjM2NSw4LjIxOSw1Ljg4NCwxMC4zMWwwLjUyMS0yLjAyN0M0NTYuNzQ5LDQ2MS40ODQsNDU1LDQ1OC40NDEsNDU1LDQ1NXoiPjwvcGF0aD48cGF0aCBkPSJNNDcxLjA3NCw0NDQuNjY0bC0wLjU0OSwyLjAwOEM0NzMuMjIsNDQ4LjQ2Nyw0NzUsNDUxLjUyNyw0NzUsNDU1YzAsNS4zMS00LjE2Niw5LjY1Ni05LjQsOS45NjlsLTEuNTE4LDEuOTg0ICAgIEM0NjQuMzg3LDQ2Ni45NzcsNDY0LjY5LDQ2Nyw0NjUsNDY3YzYuNjI3LDAsMTItNS4zNzMsMTItMTJDNDc3LDQ1MC41OTIsNDc0LjYxNiw0NDYuNzUsNDcxLjA3NCw0NDQuNjY0eiI+PC9wYXRoPjxwb2x5Z29uIHBvaW50cz0iNDczLDQ1MiA0NjcsNDU


ne
            AddLiquidPlaneZLevel(ZoneLiquidType.Water, "t75_agua1", 199.293900f, -199.563965f, 177.719742f, -224.856445f, -0.999970f, 250f); // Well
        }
    }
}


wiki/Token_coin">token coins[137] with a private key accessible under a security hologram in a recess struck on the reverse side.[138]:38 The security hologram self-destructs when removed from the token, showing that the private key has been accessed.[139] Originally, these tokens were struck in brass and other base metals, but later used precious metals as bitcoin grew in value and popularity.[138]:80 Coins with stored face value as high as ₿1000 have been struck in gold.[138]:102–104 The British Museum's coin collection includes four specimens from the earliest series[138]:83 of funded bitcoin tokens; one is currently on display in the museum's money gallery.[140] In 2013, a Utahn manufacturer of these tokens was ordered by the Financial Crimes Enforcement Network (FinCEN) to register as a money services business before producing any more funded bitcoin tokens.[137][138]:80\n' +
    '

Another type of physical wallet called a har


_readahead
ENDPROC(sys_oabi_readahead)

/*
 * Let's declare a second syscall table for old ABI binaries
 * using the compatibility syscall entries.
 */
#define ABI(native, compat) compat
#define OBSOLETE(syscall) syscall

	.type	sys_oabi_call_table, #object
ENTRY(sys_oabi_call_table)
#include "calls.S"
#undef ABI
#undef OBSOLETE

#endif


ce-splitbtn .mce-open.mce-active{background-color:#dbdbdb;outline:1px solid #ccc}.mce-splitbtn.mce-btn-small .mce-open{padding:0 3px 0 3px}.mce-rtl .mce-splitbtn{direction:rtl;text-align:right}.mce-rtl .mce-splitbtn button{padding-right:4px;padding-left:4px}.mce-rtl .mce-splitbtn .mce-open{border-left:0}.mce-stack-layout-item{display:block}.mce-tabs{display:block;border-bottom:1px solid #c5c5c5}.mce-tabs,.mce-tabs+.mce-container-body{background:#FFF}.mce-tab{display:inline-block;*display:inline;*zoom:1;border:1px solid #c5c5c5;border-width:0 1px 0 0;background:#ffffff;padding:8px;text-shadow:0 1px 1px rgba(255,255,255,0.75);height:13px;cursor:pointer}.mce-tab:hover{background:#FDFDFD}.mce-tab.mce-active{background:#FDFDFD;border-bottom-color:transparent;margin-bottom:-1px;height:14px}.mce-rtl .mce-tabs{text-align:right;direction:rtl}.mce-rtl .mce-tab{border-width:0 0 0 1px}.mce-textbox{background:#fff;border:1px solid #c5c5c5;display:inline-block;-webkit-transition:border linear .2s, box-shadow linear .2s;transition:border linear .2s, box-shadow linear .2s;height:28px;resize:none;padding:0 4px 0 4px;white-space:pre-wrap;*white-space:pre;color:#333}.mce-textbox:focus,.mce-textbox.mce-focus{border-color:#3498db}.mce-placeholder .mce-textbox{color:#aaa}.mce-textbox.mce-multiline{padding:4px;height:auto}.mce-textbox.mce-disabled{color:#adadad}.mce-rtl .mce-textbox{text-align:right;direction:rtl}@font-face{font-family:'tinymce';src:url('fonts/tinymce.eot');src:url('fonts/tinymce.eot?#iefix') format('embedded-opentype'),url('fonts/tinymce.woff') format('woff'),url('fonts/tinymce.ttf') format('truetype'),url('fonts/tinymce.svg#tinymce') format('svg');font-weight:normal;font-style:normal}@font-face{font-family:'tinymce-small';src:url('fonts/tinymce-small.eot');src:url('fonts/tinymce-small.eot?#iefix') format('embedded-opentype'),url('fonts/tinymce-small.woff') format('woff'),url('fonts/tinymce-small.ttf') format('truetype'),url('fonts/tinymce-small.svg#tinymce') format('svg');font-weight:normal;font-style:normal}.mce-ico{font-family:'tinymce',Arial;font-style:normal;font-weight:normal;font-variant:normal;font-size:16px;line-height:16px;speak:none;vertical-align:text-top;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;display:inline-block;background:transparent center center;background-size:cover;width:16px;height:16px;color:#333}.mce-btn-small .mce-ico{font-family:'tinymce-small',Arial}.mce-i-save:before{content:"\e0


知病情真相和如何实现洛拉看电影愿望的两难。她向温蒂倾诉了自己的恐惧和离开罗德岛的计划。在罗德岛干员温蒂、蜜莓等人的帮助下，她在多媒体室组织了一场特殊的电影放映会，实现了洛拉的愿望。随后，她坦诚告知洛拉失明的事实，并被洛拉的坚强和对记忆的珍视所打动，这帮助她面对了自己对遗忘的恐惧。活动结尾，她接受了罗宾参加下一场电影放映会的邀请，暗示其在罗德岛的故事可能并未结束，她也开始尝试与人建立更深的联系。
-   **[合作](../stories/story_phatom_set_1.md)**：在此活动中，絮雨在罗德岛舰船的偏僻角落为受伤的特种干员傀影进行了初步的伤口处理。随后，医疗部干员亚叶前来，指出私下治疗不符合规范，并主导对傀影进行正式诊疗，絮雨协助了亚叶的工作，并提供了自己的医疗意见。在傀影被强制休息后，絮雨与他有短暂交流，分享了观影这一放松方式，并一同看到了Miss.Christine叼来的多媒体密室传单，引发了关于这个项目的讨论。在此过程中，絮雨表现出对密外的兴趣以及在亚叶面前的紧张。
## trivia
*   絮雨的名字（絮雨）可能与活动“雨落之前”以及活动中提及的电影/书中的雨景元素有关联。
*   她的种族“阿戈尔”是一个神秘的海洋文明族群，而她是其中极为罕见、拥有特殊体质的一个分支。
*   絮雨的特殊体质是“返老还童”并遗失记忆，并非传统意义上的长生不老。
*   她非常害怕与人建立联系，因为担心失忆会伤害到身边的人，但又渴望被理解和接纳。
*   观影和写影评是她重要的爱好和情感寄托方式，她的影评在罗德岛受到欢迎。
*   她收集电影票根的习惯，与她害怕遗忘的体质形成了微妙的对照。
*   尽管身体脆弱且没有战斗经验，她依然具备高超的医疗急救能力。
*   在“雨落之前”活动中，她被洛拉


oBox combo, bool canbeSorted, bool readOnly, string[] values, string current)
        {
            combo.Clear();
            if (values != null) {
                combo.AddRange(values, canbeSorted);
            }
            combo.Text = current;
            combo.ReadOnly = readOnly;
        }

        public void SendData(string signature, string data)
        {
            if (signature == "event_year" && !string.IsNullOrEmpty(data)) {
                var dateControl = fView.Date;
                dateControl.PasteValue(data);
            }
        }

        private void dateCtl_DateChanged(object sender, System.EventArgs e)
        {
            UpdatePlace(false);
        }

        public override void SetLocale()
        {
            fView.SetTitle(LangMan.LS(LSID.Event));

            GetControl<IButton>("btnAccept").Text = LangMan.LS(LSID.DlgAccept);
            GetControl<IButton>("btnCancel").Text = LangMan.LS(LSID.DlgCancel);
            GetControl<IButton>("btnAddress").Text = LangMan.LS(LSID.Address) + @"...";
            GetControl<ITabPage>("pageCommon").Text = LangMan.LS(LSID.Common);
            GetControl<ITabPage>("pageNotes").Text = LangMan.LS(LSID.RPNotes);
            GetControl<ITabPage>("pageMultimedia").Text = LangMan.LS(LSID.RPMultimedia);
            GetControl<ITabPage>("pageSources").Text = LangMan.LS(LSID.RPSources);
            GetControl<ILabel>("lblEvent").Text = LangMan.LS(LSID.Event);
            GetControl<ILabel>("lblAttrValue").Text = LangMan.LS(LSID.Value);
            GetControl<ILabel>("lblPlace").Text = LangMan.LS(LSID.Place);
            GetControl<ILabel>("lblDate").Text = LangMan.LS(LSID.Date);
            GetControl<ILabel>("lblCause").Text = LangMan.LS(LSID.Cause);
            GetControl<ILabel>("lblOrg").Text = LangMan.LS(LSID.Agency);
            GetControl<IButton>("btnAge").Text = LangMan.LS(LSID.Age);
            GetControl<ILabel>("lblAge").Text = LangMan.LS(LSID.Age);

            SetToolTip("btnPlaceAdd", LangMan.LS(LSID.PlaceAddTip));
            SetToolTip("btnPlaceDelete", LangMan.LS(LSID.PlaceDeleteTip));
        }

        public override void ApplyTheme()
        {
            if (!AppHost.Instance.HasFeatureSupport(Feature.Themes)) return;

            GetControl<IButton>("btnAccept").Glyph = AppHost.ThemeManager.GetThemeImage(ThemeElement.Glyph_Accept);
            GetControl<IButton>("btnCancel").Glyph = AppHost.ThemeManager.GetThemeImage(ThemeElement.Glyph_Cancel);

            GetControl<IButton>("btnPlaceAdd").Glyph = AppHost.ThemeManager.GetThemeImage(ThemeElement.Glyph_Attach, true);
            GetControl<IButton>("btnPlaceDelete").Glyph = AppHost.ThemeManager.GetThemeImage(ThemeElement.Glyph_Detach, true);
        }
    }
}


z: 1,
  }
}))
`
	conf := defaultCombinedConf
	conf.ArrayElementNewline = 0
	conf.ArrayBracketNewline = 0
	conf.ObjectCurlyNewline = 1
	conf.ObjectPropertyNewline = 1
	runPrettifyCase(t, conf, src, want)
}

func TestPrettify_Combined_Map(t *testing.T) {
	src := `
export const LOAD_DOCS = 'load docs'
export const loadDocs = (language, identifier) => ({
  meta: {
    props: {language: language}
  }
})
`
	want := `
export const LOAD_DOCS = 'load docs'
export const loadDocs = (language, identifier) => ({
  meta: {
    props: { language: language }
  }
})
`
	runPrettifyCase(t, defaultCombinedConf, src, want)
}

func TestPrettify_Combined_Empty_For(t *testing.T) {
	src := `
for(;;){}
`
	want := `
for (;;) {}
`
	runPrettifyCase(t, defaultCombinedConf, src, want)
}

func TestPrettify_Combined_JSX_Element(t *testing.T) {
	src := `
render( < Provider store = { store } > < Router history = { history } > < Route path="/" component = { App } / >  < / Router > < / Provider > , document . getElementById('root'));
`
	want := `
render(
  <Provider store={store}>
    <Router history={history}>
      <Route path="/" component={App}/>
    </Router>
  </Provider>,
  document.getElementById('root')
);
`
	conf := defaultCombinedConf
	runPrettifyCase(t, conf, src, want)
}

func TestPrettify_Combined_JSX_SelfClosing(t *testing.T) {
	src := `
< Route path = "/settings" name = "name" / >
`
	want := `
<Route path="/settings" name="name"/>
`
	conf := defaultCombinedConf
	runPrettifyCase(t, conf, src, want)
}

func TestPrettify_Combined_JSX_Fragment(t *testing.T) {
	src := `
<>

Q. What is React?

A. A JavaScript library for building user interfaces

Q. How do I render sibling elements?

A. Use Fragments

</>;
`
	want := `
<>

Q. What is React?

A. A JavaScript library for building user interfaces

Q. How do I render sibling elements?

A. Use Fragments

</>;
`
	conf := defaultCombinedConf
	runPrettifyCase(t, conf, src, want)
}

func TestPrettify_Combined_JSX_Element_2(t *testing.T) {
	src := `
render (
 The user is  { isLoggedIn ? 'currently' : 'not' }  logged in.
 );
`
	want := `
render(

    The user is

      {isLoggedIn ? 'currently' : 'not'}

    logged in.

);
`
	conf := defaultCombinedConf
	conf.JsxElementChildrenNewline = 1
	runPrettifyCase(t, conf, src, want)
}

func TestPrettify_Combined_Regex(t *testing.T) {
	src := `
Object.keys(meta.dependencies || {}).filter(key => /^d3-/.test(key))
`
	want := `
Object.keys(meta.dependencies || {}).filter(
  key => /^d3-/.test(key)
)
`
	runPrettify


已另有文件。关于专业侦察部门与厂、矿党委的关系问题要分别情况：不能规定侦察工作情况一律不告诉，也不能规定统统都告诉，但一律要报告市委，归省直接领导 的企业，则应一律报告省委。专业侦察部门的专案与机关党组的关系，也要分别情况：有的可告诉党组，有的只告诉党组书记，但一律要报告相应的党委。

   六、关于“今后从严”

   在讨论中有同志提出一个问题：今后从严是否还有宽大？对反革命的基本政策有无改变？鉴于每次全国公安会议的方针确定之后，下面工作同志总要发生类似的问题，因而有加以回答的必要。回答是：“今后从严”是处理反革命的方针，即是对解放之后仍然进行破坏活动的，或经过宽大处置之后继续进行破坏活动的，要从严办罪 。所谓从严，即是说对于同样的罪行解放之后犯的要比解放之前犯的办得重，经过宽大处置之后犯的要比宽大处置之前犯的办得重，根据从严原则有些过去不判死刑者，现在要判死刑，有些过去判短期徒刑的，现在要判长期徒刑。那末，是不是今后统统不讲宽大了呢？不是的，还有宽大的一面，应该宽大的还是要宽大。例如我在报告中所列举的几项政策，虽然主要的体现了今后从严的原则，但同时也体现有应该宽大还是宽大的一面。我们对待反革命的基本政策的原则过去是，现在是，将来也还是镇压与宽大相结合的政策，这是任何时候也不应改变的。但是对于具体政策的规定，则必须依照具体情况的变化，依据对敌斗争和保护国家和人民利益的需要来加以规定。就总的需要总的趋势来看，愈往后是愈加应该从严一些的。

   七、关于镇反遗留问题

   这次会议，不少同志提出对镇压反革命运动彻底的情况不能估计过高，对镇反遗留问题必须有足够的估计。例如西南地区镇反虽


        Title = $"{projectDefinition.Name} - Project Properties";
        selectedProjectType = projectDefinition.ProjectType;
        StartupObjects = projectDefinition.Forms.Select(x => new ProjectStartupObjectViewModel(x)).ToList();
        selectedStartupObject = StartupObjects.FirstOrDefault(x => x.Form == projectDefinition.StartupForm);
        projectName = projectDefinition.Name;
        projectDescription = projectDefinition.Description;

        OkCommand = new DelegateCommand(() => CloseRequested?.Invoke(true), () => !string.IsNullOrEmpty(projectName));
        CancelCommand = new DelegateCommand(() => CloseRequested?.Invoke(false), () => true);
    }

    public void Apply(ProjectDefinition projectDefinition)
    {
        projectDefinition.Name = projectName;
        projectDefinition.Description = projectDescription;
        projectDefinition.ProjectType = SelectedProjectType;
        projectDefinition.StartupForm = selectedStartupObject?.Form;
    }

    private void OnProjectNameChanged()
    {
        OkCommand.RaiseCanExecutedChanged();
    }
}


f, 45.87742f)
    cubicTo(3.9008825f, 44.15077f, 3.6415462f, 39.267033f, 6.5594354f, 34.965595f)
    cubicTo(9.475807f, 30.664165f, 14.463925f, 28.572945f, 17.700394f, 30.286934f)
    close()
    moveTo(15.845268f, 33.02908f)
    cubicTo(14.408745f, 32.26545f, 11.33781f, 33.5696f, 9.378926f, 36.463108f)
    cubicTo(7.4160166f, 39.356613f, 7.5560293f, 42.376625f, 8.991202f, 43.13795f)
    cubicTo(10.426348f, 43.90618f, 13.499985f, 42.59743f, 15.458868f, 39.703926f)
    cubicTo(17.42313f, 36.81042f, 17.281765f, 33.79271f, 15.845268f, 33.02908f)
    close()
}
shape = Outline.Generic(generalPath!!)
drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode)
alpha = alphaStack.removeAt(0)
blendMode = blendModeStack.removeAt(0)
alphaStack.add(0, alpha)
alpha *= 1.0f
blendModeStack.add(0, BlendMode.SrcOver)
blendMode = BlendMode.SrcOver
// _0_0_9
if (generalPath == null) {
   generalPath = Path()
} else {
   generalPath!!.reset()
}
generalPath?.run {
    moveTo(14.3255f, 30.583288f)
    cubicTo(12.400369f, 30.97051f, 10.691041f, 32.037308f, 9.278593f, 33.06453f)
    cubicTo(8.52683f, 33.759434f, 8.035029f, 34.514454f, 7.362945f, 35.31874f)
    cubicTo(5.654618f, 37.670807f, 4.938707f, 40.76217f, 6.290107f, 43.38841f)
    cubicTo(6.90956f, 44.841515f, 8.932742f, 45.435852f, 10.658323f, 45.067543f)
    cubicTo(12.110236f, 44.819077f, 13.339639f, 43.90647f, 14.470735f, 43.268642f)
    cubicTo(15.391637f, 42.47786f, 16.02475f, 41.64213f, 16.803625f, 40.677364f)
    cubicTo(18.612986f, 38.20296f, 19.595537f, 34.928688f, 18.101604f, 32.16508f)
    cubicTo(17.377897f, 31.022951f, 15.866963f, 30.41829f, 14.3255f, 30.583288f)
    close()
    moveTo(14.797513f, 31.54477f)
    cubicTo(16.814016f, 31.795124f, 18.154488f, 33.577583f, 17.92006f, 35.266636f)
    cubicTo(17.940832f, 37.553574f, 16.774038f, 39.710728f, 15.196909f, 41.500755f)
    cubicTo(13.779705f, 42.902737f, 11.848294f, 44.229027f, 9.532754f, 44.137077f)
    cubicTo(8.1739f, 44.13421f, 7.100179f,


ListViewLayout.html">flower.widget.ListViewLayout

flower.widget.MsgBox

flower.widget.Panel

flower.widget.PanelView

flower.widget.ScrollGroup

flower.widget.ScrollView

flower.widget.SheetButton

flower.widget.SheetImageLabelItemRenderer

flower.widget.Slider

flower.widget.Spacer

flower.widget.TextAlign

flower.widget.TextBox

flower.widget.TextInput

flower.widget.TextView

flower.widget.ThemeMgr

flower.widget.UIComponent

flower.widget.UIEvent

flower.widget.UIGroup

flower.widget.UILabel

flower.widget.UILayer

flower.widget.UILayout

flower.widget.UIView

flower.widget.WidgetItemRenderer

Module flower.SceneMgr

This is a singleton class to manage the scene object.

Extends:

EventDispatcher<l/i>

Info:

Release: V3.0.0

Author: Makoto

Functions

	SceneMgr:initialize ()
	Initialize.

	SceneMgr:gotoScene (sceneName, params)


e: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\Simulating Erosion.html
Status: WOULD COPY TO TARGET

## Sample #443
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\1160353682-indie_compiled.js.download
Size: 0.13 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\1160353682-indie_compiled.js.download
Status: WOULD COPY TO TARGET

## Sample #444
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\2129073323-widgets.js.download
Size: 0.14 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\2129073323-widgets.js.download
Status: WOULD COPY TO TARGET

## Sample #445
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\4235886812-comment_from_post_iframe.js.download
Size: 0.02 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\4235886812-comment_from_post_iframe.js.download
Status: WOULD COPY TO TARGET

## Sample #446
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\7219141595206747297.html
Size: 0.09 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\7219141595206747297.html
Status: WOULD COPY TO TARGET

## Sample #447
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads(1).html
Size: 0.07 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads(1).html
Status: WOULD COPY TO TARGET

## Sample #448
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads(2).html
Size: 0.01 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads(2).html
Status: WOULD COPY TO TARGET

## Sample #449
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads.html
Size: 0.07 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\ads.html
Status: WOULD COPY TO TARGET

## Sample #450
Source: G:\Lab\_In\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\aframe.html
Size: 0.01 MB
Canonical Name: <pending-implementation>
Target: G:\Lab\_Open\GitHub\ff_lua_scripts-main\_erosion_ref\simulating erosion_files\aframe.html
Status: WOULD COPY TO TARGET

## Sample #451
Source: G:\Lab


# %for.end12
	addq	$8, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	.cfi_def_cfa %rsp, 8
	retq
.Lfunc_end1:
	.size	print_array, .Lfunc_end1-print_array
	.cfi_endproc
                                        # -- End function
	.globl	main                    # -- Begin function main
	.p2align	4, 0x90
	.type	main,@function
main:                                   # @main
	.cfi_startproc
# %bb.0:                                # %entry
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	pushq	%r14
	pushq	%rbx
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	callq	init_array
	leaq	C(%rip), %rbx
	xorl	%r14d, %r14d
	xorl	%esi, %esi
	movl	$9437184, %edx          # imm = 0x900000
	movq	%rbx, %rdi
	callq	memset@PLT
	leaq	B(%rip), %rax
	leaq	A(%rip), %rcx
	.p2align	4, 0x90
.LBB2_1:                                # %polly.loop_header8
                                        # =>This Loop Header: Depth=1
                                        #     Child Loop BB2_2 Depth 2
                                        #       Child Loop BB2_3 Depth 3
	movq	%rax, %rdx
	xorl	%esi, %esi
	.p2align	4, 0x90
.LBB2_2:                                # %polly.loop_header14
                                        #   Parent Loop BB2_1 Depth=1
                                        # =>  This Loop Header: Depth=2
                                        #       Child Loop BB2_3 Depth 3
	leaq	(%r14,%r14,2), %rdi
	shlq	$11, %rdi
	addq	%rcx, %rdi
	movss	(%rdi,%rsi,4), %xmm0    # xmm0 = mem[0],zero,zero,zero
	shufps	$0, %xmm0, %xmm0        # xmm0 = xmm0[0,0,0,0]
	movl	$12, %edi
	.p2align	4, 0x90
.LBB2_3:                                # %vector.body
                                        #   Parent Loop BB2_1 Depth=1


n emotional['subcategories'].values():
                for tag in sub_data.get('active_tags', []):
                    if any(word in tag.get('tag_name', '') for word in ['敏感', '焦虑', '紧张']):
                        requirements.append("**特别注意**: 用词谨慎，避免可能引起情绪波动的表达")
                        break

        # 如果用户有学习相关兴趣
        interests = dimensions.get("interests_hobbies", {})
        if interests.get('subcategories', {}).get('knowledge_learning', {}).get('active_tags'):
            requirements.append("**知识性**: 适当提供有价值的知识点，满足用户的学习需求")

        return "\n".join(requirements)

    def _get_profile_snapshot(self, user_tags: Dict) -> Dict:
        """获取用户画像快照 - 增强版，包含冲突处理信息"""
        metrics = user_tags.get("computed_metrics", {})
        dimensions = user_tags.get("tag_dimensions", {})

        snapshot = {
            "emotional_health_index": metrics.get("emotional_health_index", 0.5),
            "profile_maturity": metrics.get("overall_profile_maturity", 0.0),
            "active_dimensions": [],
            "global_conflict_summary": self._get_global_conflict_summary(user_tags)
        }

        for dim_key, dim_data in dimensions.items():
            if dim_data.get("overall_weight", dim_data.get("dimension_weight", 0)) > 0.1:
                all_tags = []

                # 处理新的二级标签结构
                if dim_data.get('subcategories'):
                    for sub_key, subcategory_data in dim_data['subcategories'].items():
                        active_tags = subcategory_data.get("active_tags", [])
                        all_tags.extend(active_tags)
                elif dim_data.get("active_tags"):
                    # 兼容旧的一级标签结构
                    all_tags = dim_data.get("active_tags", [])

                # 获取该维度的前8个最重要标签（增加数量）
                sorted_tags = sorted(all_tags, key=lambda x: x.get("current_weight", 0), reverse=True)[:8]

                # 🆕 分类标签：当前标签、历史标签、上下文标签
                current_tags = []
                historical_tags = []
                contextual_tags = []

                for tag in sorted_tags:
                    tag_info = {
                        "name": tag["tag_name"],
                        "weight": tag.get("current_weight", 0),
                        "confidence": tag.get("avg_confidence", 0),
                        "evidence_count": tag.get("evidence_count", 0),
                        "first_detected": tag.get("first_detected", ""),
                        "last_reinforced": tag.get("last_reinforced", ""),
                        "evidence": tag.get("evidence", "")[:100] + "..." if len(tag.get("evidence", "")) > 100 else tag.get("evidence", ""),
                        "is_historical": tag.get("is_historical", False),
                        "is_contextual": tag.get("is_contextual", False),
                        "conflict_resolved": tag.get("conflict_resolved", False)
                    }

                    if tag.get("is_historical", False):
                        historical_tags.append(tag_info)
                    elif tag.get("is_contextual", False):
                        contextual_tags.append(tag_info)
                    else:
                        current_tags.append(tag_info)

                # 🆕 获取最近的冲突历史
                recent_conflicts = dim_data.get("conflict_history", [])[-3:]

                # 🆕 计算标签变化趋势
                tag_trend = self._calculate_tag_trend(all_tags)

                snapshot["active_dimensions"].append({
                    "dimension": dim_data.get("dimension_name", dim_key),
                    "dimension_key": dim_key,
                    "dominant_tag": dim_data.get("dominant_tag"),
                    "dimension_weight": dim_data.get("overall_weight", dim_data.get("dimension_weight", 0)),
                    "stability_score": dim_data.get("overall_stability", dim_data.get("stability_score", 0)),

                    # 🆕 增强的标签分类
                    "current_tags": current_tags,
                    "historical_tags": historical_tags,
                    "contextual_tags": contextual_tags,

                    # 🆕 冲突和变化信息
                    "recent_conflicts": recent_conflicts,
                    "tag_trend": tag_trend,
                    "total_tags": len(all_tags),
                    "conflict_count": len(dim_da


locations of non-zero pixels.
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaed7df59a3539b4cc0fe5c9c8d7586190
func FindNonZero(src Mat, idx *Mat) {
	C.Mat_FindNonZero(src.p, idx.p)
}

// Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaca7be533e3dac7feb70fc60635adf441
func Flip(src Mat, dst *Mat, flipCode int) {
	C.Mat_Flip(src.p, dst.p, C.int(flipCode))
}

// Gemm performs generalized matrix multiplication.
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#gacb6e64071dffe36434e1e7ee79e7cb35
func Gemm(src1, src2 Mat, alpha float64, src3 Mat, beta float64, dst *Mat, flags int) {
	C.Mat_Gemm(src1.p, src2.p, C.double(alpha), src3.p, C.double(beta), dst.p, C.int(flags))
}

// GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size
// for a given vector size.
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6577a2e59968936ae02eb2edde5de299
func GetOptimalDFTSize(vecsize int) int {
	return int(C.Mat_GetOptimalDFTSize(C.int(vecsize)))
}

// Hconcat applies horizontal concatenation to given matrices.
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaab5ceee39e0580f879df645a872c6bf7
func Hconcat(src1, src2 Mat, dst *Mat) {
	C.Mat_Hconcat(src1.p, src2.p, dst.p)
}

// Vconcat applies vertical concatenation to given matrices.
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#gaab5ceee39e0580f879df645a872c6bf7
func Vconcat(src1, src2 Mat, dst *Mat) {
	C.Mat_Vconcat(src1.p, src2.p, dst.p)
}

// RotateFlag for image rotation
//
// For further details please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6f45d55c0b1cc9d97f5353a7c8a7aac2
type RotateFlag int

const (
	// Rotate90Clockwise allows to rotate image 90 degrees clockwise
	Rotate90Clockwise RotateFlag = 0
	// Rotate180Clockwise allows to rotate image 180 degrees clockwise
	Rotate180Clockwise RotateFlag = 1
	// Rotate90CounterClockwise allows to rotate 270 degrees clockwise
	Rotate90CounterClockwise RotateFlag = 2
)

// Rotate rotates a 2D array in multiples of 90 degrees
//
// For further details, please see:
// https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4ad01c0978b0ce64baa246811deeac24
func Rotate(src Mat, dst *Mat, code RotateFlag) {
	C.Rotate(


from django.db import models
from django.utils import timezone

#class abstraite qui définie les champs et méthodes pour le soft delete
class SoftDeleteModel(models.Model):
    is_deleted = models.BooleanField(default=False)
    deleted_at = models.DateTimeField(null=True, blank=True)

    class Meta:
        abstract = True

    def delete(self, using=None, keep_parents=False):
        self.is_deleted = True
        self.deleted_at = timezone.now()
        self.save()

    def restore(self):
        self.is_deleted = False
        self.deleted_at = None
        self.save()


dices = torch.randint(0, N, (B, n_clusters), device=x.device)
        centroids = torch.gather(
            x_norm,
            dim=1,
            index=indices[..., None].expand(-1, -1, D)
        ) # (B, n_clusters, D)
    else:
        centroids = init_centroids

    centroids = centroids.view(B, n_clusters, D)
    centroids = F.normalize(centroids, p=2, dim=-1)  # Ensure centroids are normalized

    for it in range(max_iters):
        # ---- compiled single iteration ----
        centroids_new, center_shift, cluster_ids = _cosine_iter_compiled(x_norm, centroids)

        # 4. Check for convergence
        if verbose:
            print(f"Iter {it}, center shift: {center_shift.item():.6f}")
        if center_shift < tol:
            break
        centroids = centroids_new.clone()

    return cluster_ids, centroids, it + 1

def batch_kmeans_Dot(x, n_clusters, max_iters=100, tol=0.0, init_centroids=None, verbose=False):
    """
    Batched KMeans clustering in PyTorch using raw dot-product as similarity.

    """
    B, N, D = x.shape

    if init_centroids is None:
        # 随机初始化中心
        indices = torch.randint(0, N, (B, n_clusters), device=x.device)
        centroids = torch.gather(
            x,
            dim=1,
            index=indices[..., None].expand(-1, -1, D)
        )
    else:
        centroids = init_centroids

    centroids = centroids.view(B, n_clusters, D)

    for it in range(max_iters):
        # ---- compiled single iteration ----
        centroids_new, center_shift, cluster_ids = _dot_iter_compiled(x, centroids)

        # 4. Check for convergence
        if verbose:
            print(f"Iter {it} (dot), center shift: {center_shift.item():.6f}")
        if center_shift < tol:
            break
        centroids = centroids_new.clone()

    return cluster_ids, centroids, it + 1

if __name__ == "__main__":
    # 用法示例
    B, N, D = 32, 74256, 128  # 32 个 batch，每个 batch 10 万点，128 维
    dtype = torch.float16
    x = torch.randn(B, N, D, device="cuda", dtype=dtype)  # 大 batch 用 GPU 跑
    n_clusters = 1000
    max_iters = 2

    print("=== Testing Euclidean Distance K-Means ===")
    cluster_ids_euclid, centroids_euclid, n_iters_euclid = batch_kmeans_Euclid(x, n_clusters, max_iters=max_iters, verbose=True)
    print(f"Euclidean - cluster_ids shape: {cluster_ids_euclid.shape}, centroids shape: {centroids_euclid.shape}")

    print("\n=== Testing Cosine Similarity K-Means ===")
    cluster_ids_cosine, centroids_cosine, n_iters_cosine = batch_kmeans_Cosine(x, n_clusters, max_iters=max_iters, verbose=True)
    print(f"Cosine - cluster_ids shape: {cluster_ids_cosine.shape}, centroids shape: {centroids_cosine.shape}")

    print("\n=== Testing Dot-Product K-Means ===")
    cluster_ids_dot, centroids_dot, n_iters_dot = batch_kmeans_Dot(x, n_clusters, max_iters=max_iters, verbose=True)
    print(f"Dot - cluster_ids shape: {cluster_ids_dot.shape}, centroids shape: {centroids_dot.shape}")

    # Profile the time cost with rounds=100
    rounds = 200
    import time

    print(f"\n=== Speed Comparison (averaged over {rounds} rounds) ===")

    # Test Euclidean Distance K-Means
    euclid_start = torch.cuda.Event(enable_timing=True)
    euclid_end = torch.cuda.Event(enable_timing=True)
    euclid_start.record()
    for i in range(rounds):
        cluster_ids_euclid, centroids_euclid, n_iters_euclid = batch_kmeans_Euclid(x, n_clusters, init_centroids=centroids_euclid, max_iters=max_iters, verbose=False)
    euclid_end.record(); torch.cuda.synchronize()
    euclid_time = euclid_start.elapsed_time(euclid_end) / rounds
    euclid_time_per_iter = euclid_time / n_iters_euclid
    print(f"Euclidean Distance K-Means: {euclid_time:.2f} ms per run, total {n_iters_euclid} iterations, {euclid_time_per_iter:.2f} ms per iter")
    print(f"Euclidean Distance TFLOPS: {2 * B * N * D * n_clusters * n_iters_euclid / euclid_time / 1e12:.2f}")

    # Test Cosine Similarity K-Means
    cosine_start = torch.cuda.Event(enable_timing=True)
    cosine_end = torch.cuda.Event(enable_timing=True)
    cosine_start.record()
    for i in range(rounds):
        cluster_ids_cosine, centroids_cosine, n_iters_cosine = batch_kmeans_Cosine(x, n_clusters, max_iters=max_iters, init_centroids=centroids_cosine, verbose=False)
    cosine_end.record(); torch.cuda.synchronize()
    cosine_time = cosine_start.elapsed_time(cosine_end) / rounds
    cosine_time_per_iter = cosine_time / n_iters_cosine
    print(f"Cosine Similarity K-Means: {cosine_time:


or r15,r19
	eor r15,r16
	mov r24,r18
	eor r24,r20
	mov r21,r25
	and r21,r16
	eor r21,r24
	std Y+16,r21
	mov r21,r15
	and r21,r24
	eor r21,r25
	subi r28,176
	sbci r29,255
	st Y,r21
	subi r28,80
	sbc r29,r1
	std Y+33,r14
	std Y+34,r15
	std Y+35,r26
	std Y+36,r27
	std Y+37,r2
	std Y+38,r3
	std Y+39,r4
	std Y+40,r5
	std Y+41,r6
	std Y+42,r7
	std Y+43,r8
	std Y+44,r9
	std Y+45,r10
	std Y+46,r11
	std Y+47,r12
	std Y+48,r13
	subi r28,191
	sbci r29,255
	ld r26,Y+
	ld r27,Y+
	ld r2,Y+
	ld r3,Y+
	ld r4,Y+
	ld r5,Y+
	ld r6,Y+
	ld r7,Y+
	ld r8,Y+
	ld r9,Y+
	ld r10,Y+
	ld r11,Y+
	ld r12,Y+
	ld r13,Y+
	ld r14,Y+
	ld r15,Y
	subi r28,80
	sbc r29,r1
	lsl r26
	rol r27
	rol r2
	rol r3
	rol r4
	rol r5
	rol r6
	rol r7
	rol r8
	rol r9
	rol r10
	rol r11
	rol r12
	rol r13
	rol r14
	rol r15
	adc r26,r1
	std Y+17,r26
	std Y+18,r27
	std Y+19,r2
	std Y+20,r3
	std Y+21,r4
	std Y+22,r5
	std Y+23,r6
	std Y+24,r7
	std Y+25,r8
	std Y+26,r9
	std Y+27,r10
	std Y+28,r11
	std Y+29,r12
	std Y+30,r13
	std Y+31,r14
	std Y+32,r15
	subi r28,175
	sbci r29,255
	ld r26,Y+
	ld r27,Y+
	ld r2,Y+
	ld r3,Y+
	ld r4,Y+
	ld r5,Y+
	ld r6,Y+
	ld r7,Y+
	ld r8,Y+
	ld r9,Y+
	ld r10,Y+
	ld r11,Y+
	ld r12,Y+
	ld r13,Y+
	ld r14,Y+
	ld r15,Y
	subi r28,96
	sbc r29,r1
	lsl r26
	rol r27
	rol r2
	rol r3
	rol r4
	rol r5
	rol r6
	rol r7
	rol r8
	rol r9
	rol r10
	rol r11
	rol r12
	rol r13
	rol r14
	rol r15
	adc r26,r1
	adiw r28,49
	st Y+,r13
	st Y+,r14
	st Y+,r15
	st Y+,r26
	st Y+,r27
	st Y+,r2
	st Y+,r3
	st Y+,r4
	st Y+,r5
	st Y+,r6
	st Y+,r7
	st Y+,r8
	st Y+,r9
	st Y+,r10
	st Y+,


"""
    def __init__(self, suit: SuitType, value: int):
        self.suit = suit
        self.value = value  # 1-9
        self.id = self._calculate_id()

    def _calculate_id(self) -> int:
        """计算牌的唯一ID (0-26)"""
        base = {'m': 0, 's': 9, 'p': 18}
        return base[self.suit.value] + (self.value - 1)

    def __str__(self) -> str:
        return f"{self.value}{self.suit.value}"

    def __eq__(self, other) -> bool:
        return isinstance(other, Tile) and self.id == other.id

    def __hash__(self) -> int:
        return hash(self.id)
```

### 1.2 TilesConverter 牌的格式转换器

参考日本库的 `TilesConverter`，实现多种数据格式的转换：

```python
from typing import List, Union

class TilesConverter:
    """牌的格式转换器 - 支持多种表示方法"""

    @staticmethod
    def string_to_27_array(tiles_string: str) -> List[int]:
        """
        字符串转27位频率数组
        例: "123m456s789p" -> [1,1,1,0,0,0,0,0,0, 1,1,1,0,0,0,0,0,0, 1,1,1,0,0,0,0,0,0]
        """
        tiles_array = [0] * 27
        current_suit = None
        numbers = []

        for char in tiles_string:
            if char.isdigit():
                numbers.append(int(char))
            elif char in ['m', 's', 'p']:
                current_suit = char
                for num in numbers:
                    tile_id = TilesConverter._get_tile_id(current_suit, num)
                    tiles_array[tile_id] += 1
                numbers = []

        return tiles_array

    @staticmethod
    def array_27_to_string(tiles_array: List[int]) -> str:
        """27位数组转字符串表示"""
        result = []
        suits = [('m', 0), ('s', 9), ('p', 18)]

        for suit_char, offset in suits:
            suit_tiles = []
            for i in range(9):
                count = tiles_array[offset + i]
                suit_tiles.extend([str(i + 1)] * count)

            if suit_tiles:
                result.append(''.join(suit_tiles) + suit_char)

        return ''.join(result)

    @staticmethod
    def array_27_to_108_array(tiles_array: List[int]) -> List[int]:
        """27位频率数组转108位详细数组（血战到底每种牌4张）"""
        tiles_108 = [0] * 108
        for i, count in enumerate(tiles_array):
            for j in range(min(count, 4)):  # 最多4张
                tiles_108[i * 4 + j] = 1
        return tiles_108

    @staticmethod
    def _get_tile_id(suit: str, value: int) -> int:
        """获取牌的ID"""
        base = {'m': 0, 's': 9, 'p': 18}


#pragma once

#include <windows.h>
#include <tchar.h>
#include <iostream>

/**
\example:
\code
void main()
{
	// make a ConsoleUtility, set title
	ConsoleUtility console(_T("console window title"));

	for(int i=1;i<1000;i++)
	{
		// do some job

		// before print, roll the cursor to top-left corner
		console.RolltoTop();

		// printf something, allways begin at top-left of the console screen
	}
}
\endcode
*/

class ConsoleUtility{
public:
	ConsoleUtility(){
		Set();
	}
	ConsoleUtility(TCHAR* title){
		Set();
		SetConsoleTitle(title);
	}
	~ConsoleUtility(){}
	// 滚动到开头
	void RolltoTop(){
		cursorPos.X = 0;
		cursorPos.Y = 0;
		SetConsoleCursorPosition(hStdOut, cursorPos);
	}
	// 滚动到某一行
	void Rollto(SHORT row){
		cursorPos.X = 0;
		cursorPos.Y = row;
		SetConsoleCursorPosition(hStdOut, cursorPos);
	}
	// 跳到某个特定光标位置
	void JumpTo(SHORT x,SHORT y){
		cursorPos.X = x;
		cursorPos.Y = y;
		SetConsoleCursorPosition(hStdOut, cursorPos);
	}
	// 初始设置
	void Set(){
#ifdef _MSC_VER
		//////////////////////////////////////////////////////////////////////////
		//  DOS 窗口设置
		hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);	// 获取标准输出设备句柄
		cursorPos.X = 0;
		cursorPos.Y = 0;
		COORD a;
		a.X = 120; a.Y = 300;
		//if(!SetConsoleScreenBufferSize(hStdOut,a))
		//	std::cout << "failed to Set Console Screen Buffer Size\n";
		SMALL_RECT rect;
		rect.Top = 0; rect.Left = 10;
		rect.Right = a.X-1;   rect.Bottom = a.Y-190;
		if(!SetConsoleWindowInfo(hStdOut,TRUE,&rect))
			std::cout << "failed to set console window info\n";
		//////////////////////////////////////////////////////////////////////////
#endif // _MSC_VER;
	}

	// 设置标题
	void SetTitle(TCHAR* title){
		SetConsoleTitle(title);
	}
	// 在原有标题的后面增加字符
	void SetTitle2(TCHAR* title){
		//TCHAR oldtile[128];
		//int len = GetConsoleTitle(oldtile,128);
		//wcscpy(oldtile+len,title);
		//SetConsoleTitle(oldtile);
	}
private:
#ifdef _MSC_VER
	HANDLE hStdOut;
	COORD cursorPos;
#endif // _MSC_VER
};


ord.SetRaw(f.Name, f.normalizeValue(raw))
}

func (f *SelectField) appendValue(record *Record, modifierValue any) {
	val := record.GetRaw(f.Name)

	val = append(
		list.ToUniqueStringSlice(val),
		list.ToUniqueStringSlice(modifierValue)...,
	)

	f.setValue(record, val)
}

func (f *SelectField) prependValue(record *Record, modifierValue any) {
	val := record.GetRaw(f.Name)

	val = append(
		list.ToUniqueStringSlice(modifierValue),
		list.ToUniqueStringSlice(val)...,
	)

	f.setValue(record, val)
}

func (f *SelectField) subtractValue(record *Record, modifierValue any) {
	val := record.GetRaw(f.Name)

	val = list.SubtractSlice(
		list.ToUniqueStringSlice(val),
		list.ToUniqueStringSlice(modifierValue),
	)

	f.setValue(record, val)
}
package tests

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"maps"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/pocketbase/pocketbase/apis"
	"github.com/pocketbase/pocketbase/core"
	"github.com/pocketbase/pocketbase/tools/hook"
)

// ApiScenario defines a single api request test case/scenario.
type ApiScenario struct {
	// Name is the test name.
	Name string

	// Method is the HTTP method of the test request to use.
	Method string

	// URL is the url/path of the endpoint you want to test.
	URL string

	// Body specifies the body to send with the request.
	//
	// For example:
	//
	//	strings.NewReader(`{"title":"abc"}`)
	Body io.Reader

	// Headers specifies the headers to send with the request (e.g. "Authorization": "abc")
	Headers map[string]string

	// Delay adds a delay before checking the expectations usually
	// to ensure that all fired non-awaited go routines have finished
	Delay time.Duration

	// Timeout specifies how long to wait before cancelling the request context.
	//
	// A zero or negative value means that there will be no timeout.
	Timeout time.Duration

	// expectations
	// ---------------------------------------------------------------

	// ExpectedStatus specifies the expected response HTTP status code.
	ExpectedStatus int

	// List of keywords that MUST exist in the response body.
	//
	// Either ExpectedContent or NotExpectedContent must be set if the response body is non-empty.
	// Leave both fields empty if you want to ensure that the response didn't have any body (e.g. 204).
	ExpectedContent []string

	// List of keywords that MUST NOT exist in the response body.
	//
	// Either ExpectedContent or NotExpectedContent must be set if the response body is non-empty.
	// Leave both fields empty if you want to ensure that the response didn't have any body (e.g. 204).
	NotExpectedContent []string

	// List of hook events to check whether they were fired or not.
	//
	// You can use the wildcard "*" event key if you want to ensure
	// that no other hook events except those listed have been fired.
	//
	// For example:
	//
	//	map[string]int{ "*": 0 } // no hook events were fired
	//	map[string]int{ "*": 0, "EventA": 2 } // no hook events, except EventA were fired
	//	map[string]int{ "EventA": 2, "EventB": 0 } // ensures that EventA was fired exactly 2 times and EventB exactly 0 times.
	ExpectedEvents map[string]int

	// test hooks
	// ---------------------------------------------------------------

	Test


Handler(-1);
    while(!selectionMade) await sleep(100);

    emitter.off(keypressEventName, keypressHandler);
    return devices[devIndex];
}

export async function sleep(ms: number) : Promise<void> {
    const _setTimeout = promisify(setTimeout);
    return _setTimeout(ms);
}

async function waitForEvent(eventName : string, value : number, checkIntervalms : number = 250) : Promise<void> {
    let terminate: boolean = false;
    function timetogo(eventVal : number) {
        if (eventVal == value) terminate = true;
    }
    emitter.on(eventName, timetogo);
    while(!terminate) await sleep(checkIntervalms)
    emitter.off(eventName, timetogo);
}

export async function emitKeypress(key : enumKbPresses) : Promise<void> {
    emitter.emit(keypressEventName, key);
}

export async function waitForKeypress(key : enumKbPresses) : Promise<void> {
    return waitForEvent(keypressEventName, key);
}
import * as vscode from 'vscode';
import * as fs from 'fs';

export function activate(context: vscode.ExtensionContext) {
	let disposable = vscode.commands.registerCommand('ts-react-component-generator.generate-ts-component', (e : any) => {

		if(!e){
			vscode.window.showInformationMessage("Just right click on Explorer and Create TS Component!");
			return;
		}

		let rootPath = e.fsPath;

		vscode.window.showInputBox().then(function(componentName1) {

			function replaceAll(string : string, search : string, replace :string) : string {
				return string.split(search).join(replace);
			}

			var componentName : string = "";

			if(componentName1){
				//Trim Whitespaces
				componentName = replaceAll(componentName1," ",'');}
			else{
				//Some Error Occured
				vscode.window.showInformationMessage("[ " +componentName + " ]"+' is a wrong Component Name');
				return;
			}

			//Check Regex for accepted ComponentName
			if(/^[a-zA-Z_$][*a-zA-Z0-9_$]/.test(componentName) == false){
				vscode.window.showInformationMessage("[ " +componentName + " ]"+' is a wrong Component Name! Component starts with [a-zA-Z_$]');
				return;
			}

			//Check if folder already exists
			if (fs.existsSync(rootPath + '/' + componentName)) {
				vscode.window.showInformationMessage("[ " +componentName + " ]"+' folder already exists!');
				return;
			}else{
				//Perfect! Lets create our folder
				fs.mkdirSync(rootPath + '/' + componentName);
			}

			var component_tsx : string = `import React, { Component } from 'react';
import './index.css';

export interface I-component-Props {
	//Here we pass the Props Interface
}

export interface I-component-State {
	//here we pass the State Interface
}

//class ComponentName Component<PropsInterface, StateInterface>
class -component- extends Component<I-component-Props, I-component-State> {

	constructor(props:I-component-Props){
		super(props)

		this.state = {

		}
	}

	//Add style here
	style = {
	};

	// Before the component mounts, we initialise our state
	componentWillMount() {
	 }

	// After the component did mount, we set the state.
	componentDidMount() {
	}

	render() {
		return (
			<div className="-component-" style={this.style}>
			</div>
		);
	}
}

export default -component-;`;

			var component_css : string = `.-component- {\r\n\r\n}`;

			//Replace Component


.map(|q| 3 * q * q + 3 * q + 1)
        .take_while(|&p| p <= limit)
        .filter(|&p| ps.contains(p))
        .count()
}

fn solve() -> String {
    compute(1000000).to_string()
}

problem!("173", solve);

#[cfg(test)]
mod tests {
    #[test]
    fn hundred() {
        assert_eq!(4, super::compute(100));
    }
}
#![cfg(feature = "osu")]

extern crate rosu_pp;

use rosu_pp::Beatmap;

struct MapResult {
    map_id: u32,
    mods: u32,
    stars: f32,
    pp: f32,
}

macro_rules! assert_result {
    ($kind:expr => $result:expr, $margin:expr, $expected:ident, $map_id:ident, $mods:ident) => {
        assert!(
            ($result - $expected).abs() < $margin * $expected,
            "\n{kind}:\n\
                Calculated: {calculated} | Expected: {expected}\n \
                => {margin} margin ({allowed} allowed)\n\
                [map {map} | mods {mods}]\n",
            kind = $kind,
            calculated = $result,
            expected = $expected,
            margin = ($result - $expected).abs(),
            allowed = $margin * $expected,
            map = $map_id,
            mods = $mods
        );
    };
}

fn margin() -> f32 {
    if cfg!(feature = "no_sliders_no_leniency") {
        0.0075
    } else if cfg!(feature = "no_leniency") {
        0.0025
    } else if cfg!(feature = "all_included") {
        0.001
    } else {
        unreachable!()
    }
}

fn osu_test(map: Beatmap, result: &MapResult) {
    let margin = margin();

    let star_margin = margin;
    let pp_margin = margin;

    let MapResult {
        map_id,
        mods,
        stars,
        pp,
    } = result;

    let result = rosu_pp::OsuPP::new(&map).mods(*mods).calculate();

    assert_result!("Stars" => result.stars(), star_margin, stars, map_id, mods);
    assert_result!("PP" => result.pp(), pp_margin, pp, map_id, mods);
}

#[cfg(not(any(feature = "async_std", feature = "async_tokio")))]
#[test]
fn osu_sync() {
    for result in RESULTS {
        let file = match std::fs::File::open(format!("./maps/{}.osu", result.map_id)) {
            Ok(file) => file,
            Err(why) => panic!("Could not open file {}.osu: {}", result.map_id, why),
        };

        let map = match Beatmap::parse(file) {
            Ok(map) => map,
            Err(why) => panic!("Error while parsing map {}: {}", result.map_id, why),
        };

        osu_test(map, result);
    }
}

#[cfg(feature = "async_tokio")]
#[test]
fn osu_async_tokio() {
    tokio::runtime::Builder::new_current_thread()
        .build()
        .expect("could not start runtime")
        .block_on(async {
            for result in RESULTS {
                let file =
                    match tokio::fs::File::open(format!("./maps/{}.osu", result.map_id)).await {
                        Ok(file) => file,
                        Err(why) => panic!("Could not open file {}.osu: {}", result


rules.addToken("RETURN", "RETURN");
    rules.addToken("SEG", "SEG");
    rules.addToken("SELECT", "SELECT");
    rules.addToken("SHARED", "SHARED");
    rules.addToken("STATIC", "STATIC");
    rules.addToken("STEP", "STEP");
    rules.addToken("SUB", "SUB");
    rules.addToken("TAB", "TAB");
    rules.addToken("THEN", "THEN");
    rules.addToken("TO", "TO");
    rules.addToken("TYPE", "TYPE");
    rules.addToken("UNTIL", "UNTIL");
    rules.addToken("USING", "USING");
    rules.addToken("VIEW", "VIEW");
    rules.addToken("WEND", "WEND");
    rules.addToken("WHILE", "WHILE");
    rules.addToken("XOR", "XOR");
    rules.addToken("minus", "\\-");
    rules.addToken("endl", "\\n");
    rules.addToken("comment", "'.*$");
    rules.addToken("hexconstant", "\\&H[\\da-fA-F]+");
    rules.addToken("floatconstant", "\\d*\\.\\d+");
    rules.addToken("intconstant", "\\d+");
    rules.addToken("stringconstant", "\"[^\"]*\"");
    rules.addToken("label", "^([a-zA-Z][a-zA-Z0-9_]*:|\\d+)");
    rules.addToken("identifier", "[a-zA-Z_][a-zA-Z0-9_]*(\\$|%|#|&|!)?");

    rules.addRule("program: statements", onProgram);
    rules.addRule("program: repl_expr endl", onExpressionProgram);
    rules.addRule("statements: statement*");
    // Line number:
    //rules.addRule( "statement: intconstant istatement separator" );
    rules.addRule("statement: label istatement separator",
                  function (args, locus) {
      var label = args[0];
      if (label.substr(-1) == ':') {
        label = label.substr(0, label.length - 1);
      }
      return [new QBasic.AstLabel(locus, label), args[1]];
    });
    rules.addRule("statement: label", function (args, locus) {
      var label = args[0];
      if (label.substr(-1) == ':') {
        label = label.substr(0, label.length - 1);
      }
      return new QBasic.AstLabel(locus, label);
    });

    rules.addRule("statement: istatement ? separator");
    rules.addRule("istatement: CONST identifier '=' expr",
                  function (args, locus) {
      return new QBasic.AstConstStatement(locus, args[1], args[3]);
    });
    rules.addRule("istatement: DECLARE FUNCTION identifier ArgList",
                  function (args, locus) {
      return new QBasic.AstDeclareFunction(locus, args[2], args[3], true);
    });
    rules.addRule("istatement: DECLARE SUB identifier ArgList",
                  function (args, locus) {
      return new QBasic.AstDeclareFunction(locus, args[2], args[3], false);
    });
    rules.addRule("istatement: SUB identifier ArgList STATIC? statements END SUB",
                  function (args, locus) {
      return new QBasic.AstSubroutine(
          locus, args[1], args[2], args[4], false, args[3] !== null);
    });
    rules.addRule("istatement: FUNCTION identifier ArgList statements END FUNCTION",
                  function (symbols, locus) {
      return new QBasic.AstSubroutine(
          locus, symbols[1], symbols[2], symbols[3], true);
    });
    rules.addRule("istatement: DEF SEG ('=' expr)?", function (args, locus) {
      return new QBasic.AstNullStatement(locus);
    });
    rules.addRule("istatement: DEF identifier ArgList '=' expr",
                  function (args, locus) {
      return new QBasic.AstNullStatement(locus);


e>

   ℓ-adic and mod ℓ data for ℓ=
        {% for i in info.l_adic %}
             {{i}}{% if not loop.last %}, {% endif %}
        {% endfor %}

    {% endfor %}
{% endif %}

{% endif %}

{% endblock %}
{% extends 'homepage.html' %}

{% block content %}

  {{info.stats.short_summary| safe}}

 Browse

    By {{ KNOWL('ec.q.conductor',title = "conductor")}}:
    {% for r,q in info.conductor_list.items() %} {{r}}   {% endfor %}

    By {{ KNOWL('ec.rank', title="rank")}}:
    {% for r in info.rank_list: %} {{r}}  {% endfor %}

    By {{ KNOWL('ec.torsion_order', torsion=t,title="torsion order") }}:
    {% for t in info.torsion_list: %} {{t}}  {% endfor %}

    Some interesting elliptic curves or a random elliptic curve

 {{ KNOWL('intro.search', 'Search') }} <button id="advancedtoggle" href="#">Advanced search options</button>

<form class='search'>
  {{ info.search_array.html() | safe }}
</form>

 Find

<form>
  {{ info.search_array.jump_box(info) | safe }}
</form>

{% endblock %}
{% extends 'homepage.html' %}
{% block content %}

  Data for the first 1,000,000 {{ KNOWL('ec.congruent_number_curve',
  'congruent number curves') }} is available, provided by
  Randall L. Rathbun.  For each of the first 1,000,000 positive
  integers $n$, this includes information about the $n$th {{
  KNOWL('ec.congruent_number_curve', 'congruent number curve') }}
  $E_n$, from which it can be determined whether or not $n$ is a {{
  KNOWL('ec.congruent_number', 'congruent number') }}, and a solution
  to the {{ KNOWL('ec.congruent_number_problem', 'congruent number
  problem') }} when it is.

Congruence property of specific integers

Enter an integer between 1 and 1,000,000 to see if it is a {{
  KNOWL('ec.congruent_number', 'congruent number') }} or not:
<form>
<input type='text' name='lookup' placeholder='6' size='6'>
e.g. 6
<button type='submit'>Look up $n$</button>
</form>

{#

Congruent numbers, the congruent number problem, and congruent number curves

{{ KNOWL_INC('ec.congruent_number') }}

{{ KNOWL_INC('ec.congruent_number_problem') }}

{{ KNOWL_INC('ec.congruent_number_curve') }}

#}


;* write sprites posY		12
		add.l	d4, d3						;* next spr			8
		move.l	d5, (a5)+					;* write sprites posX		12
		add.l	(a2)+, d5					;* next spr
		add.w	#16<<7, d5					;* +16 px
	.endr
		move.l	d3, (a5)+					;* write last sprite posY	12
		move.l	d5, (a5)+					;* write sprites posX		12

		move.l	a5, SC234ptr					;* save SC234ptr
		move.l	SC1ptr, a5					;* a5=SC1ptr

		swap	d0  						;* posY

_checkRefills:
		move.w	d0, SC_POSY(a0)					;* update posY
		bpl.s	0f
		clr.w	d0						;* map index 0 if y<0
0:		lsr.w	#4, d0						;* d0= top data index ======

		cmp.w	SC_RANGEMIN(a0), d0
		blo.s	_refillUp					;* unsigned compares
		cmp.w	SC_RANGEMAX(a0), d0
		bhs.w	_refillDown					;* bhs?
	;* d0= top data index
	;* d1= refill size

	;* staying in same range ******************
_noRefill:
		moveq	#0, d1
		move.w	d1, CFG_REFILL_DATALENGTH(a0)
		move.w	d1, CFG_REFILL_DATALENGTH2(a0)
		bra.w	_refillConfigDone

	;* upward partial refill ******************
_refillUp:
		move.w	SC_RANGEMIN(a0), d1
		sub.w	d0, d1						;* d1 = refill size
		cmp.w	#31, d1
		bpl.w	_fullRefill
		sub.w	d1, SC_RANGEMIN(a0)
		sub.w	d1, SC_RANGEMAX(a0)

		move.w	CFG_TILEINDEX(a0), d2
		sub.w	d1, d2
		bmi.s	0f	;* ****adjust value?
		move.w	#0, CFG_REFILL_DATALENGTH2(a0)
		move.w	d2, CFG_REFILL_TILEINDEX(a0)
		move.w	d0, CFG_REFILL_DATAINDEX(a0)
		move.w	d1, CFG_REFILL_DATALENGTH(a0)

		;* update raw config
		sub.w	d1, CFG_DATAINDEX(a0)
		add.w	d1, CFG_DATALENGTH(a0)
		sub.w	d1, CFG_TILEINDEX(a0)
		bra.w	_refillConfigDone

0:		;*split section
		move.w	d0, CFG_DATAINDEX(a0)
		move.w	d0, CFG_REFILL_DATAINDEX(a0)
		moveq	#32, d3
		add.w	d2, d3
		move.w	d3, CFG_TILEINDEX(a0)				;* also is CFG_DATALENGTH2
		move.w	d3, CFG_REFILL_TILEINDEX(a0)
		neg.w	d2
		move.w	d2, CFG_DATALENGTH(a0)
		move.w	d2, CFG_REFILL_DATALENGTH(a0)
		sub.w	d2, d1
		move.w	d1, CFG_REFILL_DATALENGTH2(a0)
		add.w	d0, d2
		move.w	d2, CFG_DATAINDEX2(a0)
		move.w


/****************************************************************************
 *
 * Copyright (c) 2014 - 2016 Samsung Electronics Co., Ltd. All rights reserved
 *
 ****************************************************************************/

#include "slsi_kic_internal.h"

int slsi_kic_bt_ops_register(void *priv, struct slsi_kic_bt_ops *bt_ops)
{
	struct slsi_kic_pdata *kic_inst = slsi_kic_core_get_context();

	if (!kic_inst)
		return -EFAULT;

	mutex_lock(&kic_inst->bt_ops_tuple.ops_mutex);
	memcpy(&kic_inst->bt_ops_tuple.bt_ops, bt_ops, sizeof(struct slsi_kic_bt_ops));
	kic_inst->bt_ops_tuple.priv = priv;
	mutex_unlock(&kic_inst->bt_ops_tuple.ops_mutex);
	return 0;
}
EXPORT_SYMBOL(slsi_kic_bt_ops_register);

void slsi_kic_bt_ops_unregister(struct slsi_kic_bt_ops *bt_ops)
{
	struct slsi_kic_pdata *kic_inst = slsi_kic_core_get_context();

	OS_UNUSED_PARAMETER(bt_ops);

	if (!kic_inst)
		return;

	mutex_lock(&kic_inst->bt_ops_tuple.ops_mutex);
	memset(&kic_inst->bt_ops_tuple.bt_ops, 0, sizeof(struct slsi_kic_bt_ops));
	kic_inst->bt_ops_tuple.priv = NULL;
	mutex_unlock(&kic_inst->bt_ops_tuple.ops_mutex);
}
EXPORT_SYMBOL(slsi_kic_bt_ops_unregister);


   这里只说一下，在这次选举工作中着重抓了的三个问题。

   （一）把选举作为社会主义教育的重要一段来进行。他们一方面向干部、社员进行为人民服务的教育，民主集中制的教育，社员权利与义务的教育。同时，强调把这次选举办成社员行使民主权利的示范。对候选人反复酝酿，认真评比。把百分之九十九的工作做在选举之前，防止把选举简单的当成“划Ｏ、打Ｘ”的事。

   （二）注意了全面安排，新老结合，提拔新生力量。对这个问题有两个片面的看法：一是有些人对原有干部的功过，缺乏全面地认识，盲目地要求多换，大换；一是有些人认为，要团结百分之九十五以上干部，就要把他们都重新选上，不注意，看不起或者不敢大胆提拔和使用新生力量。由于克服了上述偏向，选举的结果，原有干部继续任职的，大队占百分之七十，生产队占百分之六十二。只要错误不大、深刻检讨、决心改正、群众谅解，做到了尽量适当安排。新选出的二十五岁左右的青年干部，占百分之二十六。这些人多是劳动好、觉悟高、公道能干、群众拥护的积极分子。

   （三）“交印”、“竞选”和找不到第一把手的适当人选，这是在选举中部分队遇到的三个问题。有一些干部，群众要选他，本人却不愿干。其中多数是假，少数是真。主要原因是教育不透，思想上还有疙瘩，或者有坏人在背后挑唆。四出“竞选”的，往往是少数有缺点的积极分子，动机不纯，选不上就大发牢骚。只有把“交印”、“竞选”的问题，交给群众讨论，并对这些人进行细致的思想工作之后，才能选出一个群众满意的班子。

   有两个大队在选举中，物色不到支部书记的人选。原因是，长期以来，党的基层工作薄弱，现有的党员很少，大都又犯有错误或不能胜任，群众中有新的积极分子，但不是党员。因此，就派了工作队的人去担任政治指导员。一面巩固成果，一面进一步整顿和发展党的组织，帮助培养出本地�


12, zmm12, zmm10
      vmulps zmm14, zmm14, zmm10
      vmulps zmm15, zmm15, zmm10
      vmulps zmm16, zmm16, zmm10
      vmulps zmm17, zmm17, zmm10
      vmulps zmm18, zmm18, zmm10
      vminps zmm5, zmm5, zmm1
      vminps zmm12, zmm12, zmm1
      vminps zmm14, zmm14, zmm1
      vminps zmm15, zmm15, zmm1
      vminps zmm16, zmm16, zmm1
      vminps zmm17, zmm17, zmm1
      vminps zmm18, zmm18, zmm1
      vcvtps2dq zmm5, zmm5
      vcvtps2dq zmm12, zmm12
      vcvtps2dq zmm14, zmm14
      vcvtps2dq zmm15, zmm15
      vcvtps2dq zmm16, zmm16
      vcvtps2dq zmm17, zmm17
      vcvtps2dq zmm18, zmm18
      vpaddd zmm5, zmm5, zmm31
      vpaddd zmm12, zmm12, zmm31
      vpaddd zmm14, zmm14, zmm31
      vpaddd zmm15, zmm15, zmm31
      vpaddd zmm16, zmm16, zmm31
      vpaddd zmm17, zmm17, zmm31
      vpaddd zmm18, zmm18, zmm31
      vpmovsdb xmm5, zmm5
      vpmovsdb xmm12, zmm12
      vpmovsdb xmm14, zmm14
      vpmovsdb xmm15, zmm15
      vpmovsdb xmm16, zmm16
      vpmovsdb xmm17, zmm17
      vpmovsdb xmm18, zmm18
      vpmaxsb xmm5, xmm5, xmm0
      vpmaxsb xmm12, xmm12, xmm0
      vpmaxsb xmm14, xmm14, xmm0
      vpmaxsb xmm15, xmm15, xmm0
      vpmaxsb xmm16, xmm16, xmm0
      vpmaxsb xmm17, xmm17, xmm0
      vpmaxsb xmm18, xmm18, xmm0

      # Pop output pointers from the stack.
      mov rcx, [rsp + 24]
      mov rax, [rsp + 40]
      mov r15, [rsp + 56]
      mov r14, [rsp + 72]
      mov r12, [rsp + 88]
      mov r10, [rsp + 104]
      mov r13, [rsp + 120]

      # Check whether full or partial store.
      cmp rsi, 16
      jl .Ltail

      vmovups  [rcx], xmm5
      vmovups  [rax], xmm12
      vmovups  [r15], xmm14
      vmovups  [r14], xmm15
      vmovups  [r12], xmm16
      vmovups  [r10], xmm17
      vmovups  [r13], xmm18
      add rcx, 16
      add


g_state_s;

#ifdef __cplusplus
extern "C" {
#endif

void lwm2m_fota_state_init(lwm2m_fota_state_s *thi, lwm2m_fota_manager_s *manager);

void lwm2m_fota_idle_state_init(lwm2m_fota_idle_state_s *thi, lwm2m_fota_manager_s *manager);
int lwm2m_fota_idle_state_int_report_result(lwm2m_fota_idle_state_s *thi);

void lwm2m_fota_downloading_state_init(lwm2m_fota_downloading_state_s *thi, lwm2m_fota_manager_s *manager);

void lwm2m_fota_downloaded_state_init(lwm2m_fota_downloaded_state_s *thi, lwm2m_fota_manager_s *manager);

void lwm2m_fota_updating_state_init(lwm2m_fota_updating_state_s *thi, lwm2m_fota_manager_s *manager);

#ifdef __cplusplus
}
#endif

#endif /* ATINY_FOTA_STATE_H_ */


import re
import pytest

from net_inspect.plugins.input_plugin_with_console import (
    InputPluginWithConsole,
    simialr_huawei_reg,
    similar_cisco_reg,
)
from net_inspect.plugins.input_plugin_with_smartone import InputPluginWithSmartOne
from net_inspect import exception

def test_input_plugin_with_console_simalr_huawei_reg():

    test_list = [
        ('<device>display version', 'device'),
        ('[device] dis version', 'device'),
        ('<GZ-24F-SN1-248.16>display version', 'GZ-24F-SN1-248.16'),
    ]

    for (line, refer_hostname) in test_list:
        match = re.match(simialr_huawei_reg, line)
        assert match.group('device_name') == refer_hostname
        assert re.match(r'\s*dis.*ver', match.group('cmd'))

def test_input_pulgin_with_console_simalr_cisco_reg():

    test_list = [
        ('device>show version', 'device'),
        ('device(config)# sh version', 'device'),
        ('device-1(config-if)# sh version', 'device-1'),
    ]

    for (line, refer_hostname) in test_list:
        match = re.match(similar_cisco_reg, line)
        assert match.group('device_name') == refer_hostname
        assert re.match(r'\s*sh.*ver', match.group('cmd'))

def test_input_plugin_with_lower_commands():
    """保证cmd_dict.keys()是小写的"""

    input_plugin = InputPluginWithConsole()
    stream = """\
<YY_XX_YH_AR01>DIS version
Huawei Versatile Routing Platform Software
VRP (R) software, Version 5.170 (AR2200 V200R009C00SPC500)
Copyright (C) 2011-2018 HUAWEI TECH CO., LTD
Huawei AR2204-51GE-P Router uptime is 104 weeks, 4 days, 21 hours, 46 minutes

MPU 0(Master) : uptime is 104 weeks, 4 days, 21 hours, 44 minutes
SDRAM Memory Size    : 512     M bytes
Flash 0 Memory Size  : 512     M bytes
MPU version information :
1. PCB      Version  : AR-SRU2204C VER.B
2. MAB      Version  : 0
3. Board    Type     : AR2204-51GE-P
4. CPLD0    Version  : 100
5. BootROM  Version  : 1
"""
    res = input_plugin.main('', stream)
    assert res.cmd_dict.get('dis version')

def test_console_plugin_with_prompt():
    """测试console plugin的命令提示符切割方法"""

    input_plugin = InputPluginWithConsole()
    stream = """\
<device>display version
Huawei Versatile Routing Platform Software
VRP (R) software, Version 5.170 (AR2200 V200R009C00SPC500)
Copyright (C) 2011-2018 HUAWEI TECH CO., LTD
Huawei AR2204-51GE-P Router uptime is 104 weeks, 4 days, 21 hours, 46 minutes
<device>!
        ^
Error: Unrecognized command found at '^' position.
"""
    res = input_plugin.main('', stream)
    assert not re.search(r'Error:', res.cmd_dict.get('display version'))

def test_console_plugin_with_file(shared_datadir):
    """测试console plugin的比较复杂的文件"""

    input_plugin = InputPluginWithConsole()
    res = input_plugin.run(shared_datadir / 'console_input.log')
    # 文件中的是 DIS version , 要求改为小写
    assert res.cmd_dict.get('dis version')

    # 文件中有两个dis cpu-usage, 其中一个被截断了，只保留最长的那个
    assert len(res.cmd_dict.get('dis cpu-usage').split("\n")) > 20

def test_smartone_plugin_state_1(shared_datadir):
    """测试 smartone plugin 情况一"""

    input_plugin = InputPluginWithSmartOne()
    result = input_plugin.run(
        shared_datadir / 'B_FOO_BAR_DS02_21.2.3.4_20220221170516.diag'
    )
    cmd_dict = result.cmd_dict
    device_info = result._device_info
    assert device_info.name == 'B_FOO_BAR_DS02'
    assert device_info.ip == '21.2.3.4'
    assert len(cmd_dict) == 13
    assert len(cmd_dict['dis version'].split('\n')) > 6  # 判断是有内容的

def test_smartone_plugin_state_2(shared_datadir):
    """测试 smartone plugin 情况二"""

    input_plugin = InputPluginWithSmartOne()
    result = input_plugin.run(shared_datadir / 'B_FOO_BAR_AR01_21.1.1.1.diag')
    cmd_dict = result.cmd_dict
    device_info = result._device_info
    assert device_info.name == 'B_FOO_BAR_AR01'
    assert device_info.ip == '21.1.1.1'
    assert len(cmd_dict) == 16
    assert len(cmd_dict['dis version'].split('\n')) > 6  # 判断是有内容的

def test_smartone_plugin_error_file(shared_datadir):
    """测试 smartone plugin 错误文件"""

    input_plugin = InputPluginWithSmartOne()
    with pytest.raises(exception.InputFileTypeError):
        input_plugin.run(shared_datadir / 'console_input.log')


        ~ScopedCanvas()
        {
            if(canvas_)
            {
                canvas_->Restore();
            }
        }
        void SetCanvas(gfx::Canvas* canvas)
        {
            if(canvas_)
            {
                canvas_->Restore();
            }
            canvas_ = canvas;
            canvas_->Save();
        }

    private:
        gfx::Canvas* canvas_;

        DISALLOW_COPY_AND_ASSIGN(ScopedCanvas);
    };

}

namespace view
{

    // static
    ViewDelegate* ViewDelegate::view_delegate = NULL;

    // static
    char View::kViewClassName[] = "view/View";

    ////////////////////////////////////////////////////////////////////////////////
    // View, public:

    // TO BE MOVED -----------------------------------------------------------------

    void View::SetHotTracked(bool flag) {}

    bool View::IsHotTracked() const
    {
        return false;
    }

    // Creation and lifetime -------------------------------------------------------

    View::View()
        : parent_owned_(true),
        id_(0),
        group_(-1),
        parent_(NULL),
        visible_(true),
        enabled_(true),
        painting_enabled_(true),
        registered_for_visible_bounds_notification_(false),
        clip_x_(0.0),
        clip_y_(0.0),
        needs_layout_(true),
        flip_canvas_on_paint_for_rtl_ui_(false),
        accelerator_registration_delayed_(false),
        accelerator_focus_manager_(NULL),
        registered_accelerator_count_(0),
        next_focusable_view_(NULL),
        previous_focusable_view_(NULL),
        focusable_(false),
        accessibility_focusable_(false),
        context_menu_controller_(NULL),
        drag_controller_(NULL) {}

    View::~View()
    {
        if(parent_)
        {
            parent_->RemoveChildView(this);
        }

        for(Views::const_iterator i(children_.begin()); i!=children_.end(); ++i)
        {
            (*i)->parent_ = NULL;
            if((*i)->parent_owned())
            {
                delete *i;
            }
        }

        if(native_view_accessibility_win_.get())
        {
            native_view_accessibility_win_->set_view(NULL);
        }
    }

    // Tree operations -------------------------------------------------------------

    const Widget* View::GetWidget() const
    {
        // The root view holds a reference to this view hierarchy's Widget.
        return parent_ ? parent_->GetWidget() : NULL;
    }

    Widget* View::GetWidget()
    {
        return const_cast<Widget*>(const_cast<const View*>(this)->GetWidget());
    }

    void View::AddChildView(View* view)
    {
        AddChildViewAt(view, child_count());
    }

    void View::AddChildViewAt(View* view, int index)
    {
        CHECK_NE(view, this) << "You cannot add a view as its own child";

        // If |view| has a parent, remove it from its parent.
        View* parent = view->parent_;
        if(parent)
        {
            parent->RemoveChildView(view);
        }

        // Sets the prev/next focus views.
        InitFocusSiblings(view, index);

        // Let's insert the view.
        view->parent_ = this;
        children_.insert(children_.begin()+index, view);

        if(GetWidget())
        {
            // Sending out notification of insert may result in adding other views.
            // Invoke this first to make sure we know the layer is created (if needed).
            view->CreateLayerIfNecessary();
        }

        for(View* v=this; v; v=v->parent_)
        {
            v->ViewHierarchyChangedImpl(false, true, this, view);
        }

        view->PropagateAddNotifications(this, view);


 (xTerm, yTerm) by reference.
    // It is much more efficient to keep (xTerm, yTerm) at object scope,
    // and allow term() to overwrite their values.
    // Callers know that each time they call term(), they must
    // access the output through (xTerm, yTerm) before calling term() again.

    var xTerm = Double.NaN
    var yTerm = Double.NaN
    private fun term(p: Int, q: Int, r: Int, s: Int) {
        xTerm = 1.0
        yTerm = 0.0
        if (p != 0) addTheta(CO[p, 1], SI[p, 1])
        if (q != 0) addTheta(CO[q, 2], SI[q, 2])
        if (r != 0) addTheta(CO[r, 3], SI[r, 3])
        if (s != 0) addTheta(CO[s, 4], SI[s, 4])
    }

    private fun addTheta(c2: Double, s2: Double) {
        val c1 = xTerm
        val s1 = yTerm
        xTerm = c1*c2 - s1*s2
        yTerm = s1*c2 + c1*s2
    }

    fun addSol(
        coeffl: Double,
        coeffs: Double,
        coeffg: Double,
        coeffp: Double,
        p: Int,
        q: Int,
        r: Int,
        s: Int
    ) {
        term(p, q, r, s)
        DLAM  += coeffl * yTerm
        DS    += coeffs * yTerm
        GAM1C += coeffg * xTerm
        SINPI += coeffp * xTerm
    }

    fun addn(coeffn: Double, p: Int, q: Int, r: Int, s: Int) {
        term(p, q, r, s)
        N += (coeffn * yTerm)
    }

    private fun solarN() {
        N = 0.0
        addn(-526.069,  0, 0, 1, -2)
        addn(  -3.352,  0, 0, 1, -4)
        addn( +44.297, +1, 0, 1, -2)
        addn(  -6.000, +1, 0, 1, -4)
        addn( +20.599, -1, 0, 1,  0)
        addn( -30.598, -1, 0, 1, -2)
        addn( -24.649, -2, 0, 1,  0)
        addn(  -2.000, -2, 0, 1, -2)
        addn( -22.571,  0,+1, 1, -2)
        addn( +10.985,  0,-1, 1, -2)
    }

    private fun planetary() {
        DLAM += (
            +0.82*sine(0.7736   -62.5512*T) + 0.31*sine(0.0466  -125.1025*T)
            +0.35*sine(0.5785   -25.1042*T) + 0.66*sine(0.4591 +1335.8075*T)
            +0.64*sine(0.3130   -91.5680*T) + 1.14*sine(0.1480 +1331.2898*T)
            +0.21*sine(0.5918 +1056.5859*T) + 0.44*sine(0.5784 +1322.8595*T)
            +0.24*sine(0.2275    -5.7374*T) + 0.28*sine(0.2965    +2.6929*T)
            +0.33*sine(0.3132    +6.3368*T)
        )
    }

    fun calcMoon(): Spherical {
        addSolarTerms(this)
        solarN()
        planetary()
        val S = F + DS/ARC
        val latSeconds = (1.000002708 + 139.978*DGAM)*(18518.511+1.189+GAM1C)*sin(S)-6.24*sin(3*S) + N
        return Spherical(
            latSeconds / 3600.0,
            360.0 * frac((L0+DLAM/ARC) / PI2),
            (ARC * EARTH_EQU


 {
    name: "Perl",
    aliases: [
      "pl",
      "pm"
    ],
    keywords: i,
    contains: p
  };
}
function _D(e) {
  const t = e.regex, n = /(?![A-Za-z0-9])(?![$])/, r = t.concat(
    /[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,
    n
  ), i = t.concat(
    /(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,
    n
  ), o = {
    scope: "variable",
    match: "\\$+" + r
  }, a = {
    scope: "meta",
    variants: [
      { begin: /<\?php/, relevance: 10 },
      // boost for obvious PHP
      { begin: /<\?=/ },
      // less relevant per PSR-1 which says not to use short-tags
      { begin: /<\?/, relevance: 0.1 },
      { begin: /\?>/ }
      // end php tag
    ]
  }, s = {
    scope: "subst",
    variants: [
      { begin: /\$\w+/ },
      {
        begin: /\{\$/,
        end: /\}/
      }
    ]
  }, l = e.inherit(e.APOS_STRING_MODE, { illegal: null }), c = e.inherit(e.QUOTE_STRING_MODE, {
    illegal: null,
    contains: e.QUOTE_STRING_MODE.contains.concat(s)
  }), d = {
    begin: /<<<[ \t]*(?:(\w+)|"(\w+)")\n/,
    end: /[ \t]*(\w+)\b/,
    contains: e.QUOTE_STRING_MODE.contains.concat(s),
    "on:begin": (V, G) => {
      G.data._beginMatch = V[1] || V[2];
    },
    "on:end": (V, G) => {
      G.data._beginMatch !== V[1] && G.ignoreMatch();
    }
  }, u = e.END_SAME_AS_BEGIN({
    begin: /<<<[ \t]*'(\w+)'\n/,
    end: /[ \t]*(\w+)\b/
  }), p = `[
]`, m = {
    scope: "string",
    variants: [
      c,
      l,
      d,
      u
    ]
  }, _ = {
    scope: "number",
    variants: [
      { begin: "\\b0[bB][01]+(?:_[01]+)*\\b" },
      // Binary w/ underscore support
      { begin: "\\b0[oO][0-7]+(?:_[0-7]+)*\\b" },
      // Octals w/ underscore support
      { begin: "\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b" },
      // Hex w/ underscore support
      // Decimals w/ underscore support, with optional fragments and scientific exponent (e) suffix.
      { begin: "(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?" }
    ],
    relevance: 0
  }, h = [
    "false",
    "null",
    "true"
  ], g = [
    // Magic constants:
    // <https://www.php.net/manual/en/language.constants.predefined.php>
    "__CLASS__",
    "__DIR__",
    "__FILE__",
    "__FUNCTION__",
    "__COMPILER_HALT_OFFSET__",
    "__LINE__",
    "__METHOD__",
    "__NAMESPACE__",
    "__TRAIT__",
    // Function that look like language construct or language construct that look like function:
    // List of keywords that may not require parenthesis
    "die",
    "echo",
    "exit",
    "include",
    "include_once",
    "print",
    "require",
    "require_once",
    // These are not language construct (function) but operate on the cur


/* **********************************************************
 * Copyright (c) 2019-2023 Google, Inc.  All rights reserved.
 * **********************************************************/

/*
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * * Neither the name of Google, Inc. nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */

/*
 * snappy_file_writer: writes small buffers to a snappy-compressed
 * file in a safe way for use during live tracing.
 *
 * Does not split up large buffers!  Will only write buffers guaranteed
 * to have a compressed size <= 64K: so a maximum uncompressed size
 * of ~53K, based on snappy::MaxCompressedLength.
 *
 * Files are written in the snappy framing format:
 *   https://github.com/google/snappy/blob/master/framing_format.txt
 *
 * This class it not thread-safe and the intent is for the user to create a
 * separate instance per thread.
 *
 * The snappy library allocates memory without parameterizing the allocator, meaning we
 * can't support it for static linking.  We give a warning in drmemtrace_client_main()
 * about this.  We could try to override the global allocator for some uses cases, but
 * that is not workable for statically linking into large C++ applications, and it can
 * be unsafe and seems to cause droption crashes in release build.
 * XXX: Send a patch to libsnappy to parameterize the allocator.
 */

#ifndef _SNAPPY_FILE_WRITER_H_
#define _SNAPPY_FILE_WRITER_H_ 1

#include <snappy.h>
#include "snappy_consts.h"
#include "dr_api.h"

namespace dynamorio {
namespace drmemtrace {

class snappy_file_writer_t : snappy_consts_t {
public:
    snappy_file_writer_t(file_t f,
                         ssize_t (*write_file)(file_t file, const void *data,
                                               size_t count),
                         bool include_checksums = true)
        : fd_(f)
        , write_func_(write_file)
        , include_checksums_(include_checksums)
    {
    }

    bool
    write_file_header();

    // Returns the count of uncompressed data written (i.e., returning anything
    // less than "count" indicates an error).
    ssize_t
    compress_and_write(const void *buf, size_t count);

private:
    file_t fd_;
    char compressed_buf_[header_size_ + checksum_size_ + max_compressed_size_];
    ssize_t (*write_func_)(file_t file, const void *data, size_t count);
    bool include_checksums_;
};

} // namespace drmemtrace
} // namespace dynamorio

#endif /* _SNAPPY_FILE_WRITER_H_ */


from %1). Your content will be preserved across the upgrade.

Note that core upgrades have been known to interfere with older plugins. If you run into problems with the upgraded file, see http://www.tiddlywiki.org/wiki/CoreUpgrades",
	errorCantUpgrade: "Unable to upgrade this TiddlyWiki. You can only perform upgrades on TiddlyWiki files stored locally",
	errorNotSaved: "You must save changes before you can perform an upgrade",
	step2Title: "Confirm the upgrade details",
	step2Html_downgrade: "You are about to downgrade to TiddlyWiki version %0 from %1.

Downgrading to an earlier version of the core code is not recommended",
	step2Html_restore: "This TiddlyWiki appears to be already using the latest version of the core code (%0).

You can continue to upgrade anyway to ensure that the core code hasn't been corrupted or damaged",
	step2Html_upgrade: "You are about to upgrade to TiddlyWiki version %0 from %1",
	upgradeLabel: "upgrade",
	upgradePrompt: "Prepare for the upgrade process",
	statusPreparingBackup: "Preparing backup",
	statusSavingBackup: "Saving backup file",
	errorSavingBackup: "There was a problem saving the backup file",
	statusLoadingCore: "Loading core code",
	errorLoadingCore: "Error loading the core code",
	errorCoreFormat: "Error with the new core code",
	statusSavingCore: "Saving the new core code",
	statusReloadingCore: "Reloading the new core code",
	startLabel: "start",
	startPrompt: "Start the upgrade process",
	cancelLabel: "cancel",
	cancelPrompt: "Cancel the upgrade process",
	step3Title: "Upgrade cancelled",
	step3Html: "You have cancelled the upgrade process"
	});

merge(config.macros.sync,{
	listViewTemplate: {
		columns: [
			{name: 'Selected', field: 'selected', rowName: 'title', type: 'Selector'},
			{name: 'Tiddler', field: 'tiddler', title: "Tiddler", type: 'Tiddler'},
			{name: 'Server Type', field: 'serverType', title: "Server type", type: 'String'},
			{name: 'Server Host', field: 'serverHost', title: "Server host", type: 'String'},
			{name: 'Server Workspace', field: 'serverWorkspace', title: "Server workspace", type: 'String'},
			{name: 'Status', field: 'status', title: "Synchronisation status", type: 'String'},
			{name: 'Server URL', field: 'serverUrl', title: "Server URL", text: "View", type: 'Link'}
			],
		rowClasses: [
			],
		buttons: [
			{caption: "Sync these tiddlers", name: 'sync'}
			]},
	wizardTitle: "Synchronize with external servers and files",
	step1Title: "Choose the tiddlers you want to synchronize",
	step1Html: "<input type='hidden' name='markList'></input>", // DO NOT TRANSLATE
	syncLabel: "sync",
	syncPrompt: "Sync these tiddlers",
	hasChanged: "Changed while unplugged",
	hasNotChanged: "Unchanged while unplugged",
	syncStatusList: {
		none: {text: "...", display:'none', className:'notChanged'},
		changedServer: {text: "Changed on server", display:null, className:'changedServer'},
		changedLocally: {text: "Changed while unplugged", display:null, className:'changedLocally'},
		changedBoth: {text: "Changed while unplugged and on server", display:null, className:'changedBoth'},


primary5, $lightness: 10%);

// custom one-off colours
$color_contest_ranking_disqualified: #ffa8a8;

$color_martor_resize_dragger: #e8e8e8;

$color_rating_none: #999;
$color_rating_newbie: #808080;
$color_rating_pupil: #008000;
$color_rating_specialist: #03a89e;
$color_rating_expert: #0000ff;
$color_rating_candidate_master: #aa00aa;
$color_rating_master: #ff8c00;
$color_rating_grandmaster: #ff0000;

$color_select2_search_dropdown: $color_primary0;

$color_user_submission_activity0: #ddd;
$color_user_submission_activity1: #9be9a8;
$color_user_submission_activity2: #40c463;
$color_user_submission_activity3: #2f9c4c;
$color_user_submission_activity4: #216e39;

$color_info25: #def;
$color_info50: #bdf;
$color_info100: #368;
$color_success25: #ded;
$color_success50: #adb;
$color_success100: #173;
$color_warning25: #ffd;
$color_warning50: #feb;
$color_warning100: #863;
$color_danger25: #edd;
$color_danger50: #dbb;
$color_danger100: #944;

$color_problem_submit_select2: #757575;

$color_voted_mark: #0000ff;

$path_to_root: '.';     // relative path from style.css to STATIC_ROOT

@mixin vars-img {}
@forward "vars-common";

$is_light_theme: false;

$color_primary0: #0f0f0f;
$color_primary5: #111;      // light background
$color_primary10: #181818;  // background
$color_primary25: #3b3b3b;  // border
$color_primary33: #555;     // widget
$color_primary50: #808080;
$color_primary66: #aaa;     // tabs
$color_primary75: #ccc;     // widget
$color_primary90: #eee;
$color_primary100: #f8f8f8;

$color_link50: #06d;    // default (title)
$color_link75: #6bf;    // default
$color_link100: #49e;   // hover
$color_link200: #d83;   // active

$color_pageBg: #222;    // #222 because some elements should be darker than pageBg

// custom one-off colours
$color_contest_ranking_disqualified: #622;

$color_martor_resize_dragger: #232323;

$color_rating_none: #aaa;
$color_rating_newbie: #988f81;
$color_rating_pupil: #72ff72;
$color_rating_specialist: #57fcf2;
$color_rating_expert: #337dff;
$color_rating_candidate_master: #ff55ff;
$color_rating_master: #ff981a;
$color_rating_grandmaster: #ff1a1a;

$color_select2_search_dropdown: $color_primary10;

$color_user_submission_activity0: #3b3b3b;
$color_user_submission_activity1: #0e4429;
$color_user_submission_activity2: #006d32;
$color_user_submission_activity3: #26a641;
$color_user_submission_activity4: #39d353;

$color_info25: #023;
$color_info50: #068;
$color_info100: #7df;
$color_success25: #031;
$color_success50: #172;
$color_success100: #6f8;
$color_warning25: #320;
$color_warning50: #960;


/*
 * TOD (Time Of Day) clock
 *
 * Copyright 2018 Red Hat, Inc.
 * Author(s): David Hildenbrand <david@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#ifndef HW_S390_TOD_H
#define HW_S390_TOD_H

#include "hw/qdev-core.h"
#include "target/s390x/s390-tod.h"
#include "qom/object.h"

typedef struct S390TOD {
    uint8_t high;
    uint64_t low;
} S390TOD;

#define TYPE_S390_TOD "s390-tod"
OBJECT_DECLARE_TYPE(S390TODState, S390TODClass, S390_TOD)
#define TYPE_KVM_S390_TOD TYPE_S390_TOD "-kvm"
#define TYPE_QEMU_S390_TOD TYPE_S390_TOD "-qemu"

struct S390TODState {
    /* private */
    DeviceState parent_obj;

    /*
     * Used by TCG to remember the time base. Used by KVM to backup the TOD
     * while the TOD is stopped.
     */
    S390TOD base;
    /* Used by KVM to remember if the TOD is stopped and base is valid. */
    bool stopped;
};

struct S390TODClass {
    /* private */
    DeviceClass parent_class;
    void (*parent_realize)(DeviceState *dev, Error **errp);

    /* public */
    void (*get)(const S390TODState *td, S390TOD *tod, Error **errp);
    void (*set)(S390TODState *td, const S390TOD *tod, Error **errp);
};

void s390_init_tod(void);
S390TODState *s390_get_todstate(void);

#endif


this.showTimer(message);
        break;
      case "!locations":
        this.showLocations(message);
        break;
    }
  }

  async vote(message: Message) {
    if (this.sessionConfig.activeVote) {
      Tools.handleUserError(message, "There is already a vote going on!");
      return;
    }

    if (message.channel.type === "dm") {
      Tools.handleUserError(
        message,
        "Voting must be done in the main channel: <#" + this.channel.id + ">"
      );
      return;
    }

    const voted = message.mentions.members.first();
    if (!voted) {
      Tools.handleUserError(
        message,
        "you have to mention the user you suspect to be the spy"
      );
      return;
    }

    const playerIds = this.sessionConfig.players.map((player) => player.id);

    if (!playerIds.includes(message.author.id)) {
      Tools.handleUserError(
        message,
        "you are not in the game and cannot start a vote!"
      );
      return;
    }

    if (!playerIds.includes(voted.id)) {
      await Tools.handleUserError(message, "that user is not in the game!");
      return;
    }

    this.sessionConfig.activeVote = true;

    const votedIndex = playerIds.indexOf(voted.id);
    if (votedIndex > -1) {
      playerIds.splice(votedIndex, 1);
    }

    const thumbsDown = "👎";
    const thumbsUp = "👍";
    await this.channel.send(`Vote within the next ${voteTime / 1000} seconds!`);
    const voting = await Tools.addUniqueVote(
      message,
      [thumbsUp, thumbsDown],
      playerIds,
      voteTime,
      true
    );

    this.sessionConfig.activeVote = false;

    const upvotes = voting[thumbsUp];
    const isCounted =
      this.sessionConfig.spyIds.length === 1
        ? upvotes.length === playerIds.length
        : upvotes.length >= Math.floor(playerIds.length / 2);

    const isCorrect = this.sessionConfig.spyIds.includes(voted.id);

    if (isCounted) {
      // In either case, the player is indicted and removed from the list of players
      this.sessionConfig.players = this.sessionConfig.players.filter(
        (player) => player.id !== voted.id
      );

      await this.channel.send(
        `You decided! You guess that ${
          voted.displayName
        } is the spy and you were${isCorrect ? "" : " not"} correct!`
      );

      if (
        (!isCorrect && this.sessionConfig.endOnWrongVote) ||
        (isCorrect &&
          (this.sessionConfig.numberOfSpies === 1 ||
            this.sessionConfig.endAfterFirstSpy))
      ) {
        await this.end();
        return;
      }

      if (isCorrect) {
        const spies = this.sessionConfig.spyIds;
        const index = spies.indexOf(voted.id);
        if (index > -1) {
          this.sessionConfig.spyIds.splice(index, 1);
        }

        if (spies.length > 0) {
          await this.channel.send(
            "There are still spies remaining; the game continues."
          );
        } else {
          await this.channel.send("That was the last spy! You win!");
          await this.end();
        }
      } else if (
        this.sessionConfig.players.length / 2 <=
        this.sessionConfig.spyIds.length
      ) {
        await this.channel.send(
          "The spies managed to get the upper hand! The spies win!"
        );
        await this.end();
      }

      return;
    }

    const ignoredReason =
      this.sessionConfig.numberOfSpies === 1
        ? "was


toxins spread in the body and lead to complications like HUS.

Back

Main page

<!DOCTYPE html>

		<title>HIV</title>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
		<link rel="stylesheet" href="../css/presentaball.css">

			Main page  > HIV I > HIV II

The Human Immunodeficiency Virus

Once a binding pocket of an enzyme, which is important for the progress of a disease, is identified, researcher try to find a small drug molecule that fits both, chemically as well as geometrically, into this detected binding pocket. A good example in the case of HIV is the drug Efavirenz.

				The drug molecule Efavirenz (Source: Wikipedia)

				Click on the structure shown above to place Efavirenz into the binding pocket! Use the mouse to examine how Efavirenz fits into the binding pocket.

What is the main difference of HIV to other viruses?

HIV differs from many viruses in that it has very high genetic variability, which means that it is able to adapt to the pharmaceutical treatment very fast. The enzyme reverse transcriptase is able to mutate, which induces resistency for drugs like Efavirenz.

For example if at amino acid position 103 of the reverse transcriptase the amino acid lysine is mutated to another amino acid called asparagine.

				The amino acids lysine and asparagine (Source: Wikipedia)

				What is the difference of the two amino acids?

				Click here, to see position 103 of the amino acid sequence!

The amino acid position 103 is one of the amino acid positions involved in the acitivity of the reverse transcriptase. Since the amino acids lysine and asparagine have different chemical properties, the drug molecule is prevented from binding when lysine is substituted by asparagine. Consequently, the drug is without effect.

				Compare both binding pockets with and without mutation.

<a href="hiv.html?action=loadProject&module=view_utils&filename=PresentaBALL/projects/2HMI_DNA.bvp